This graph shows which files directly or indirectly include this file:

Macros
#define	WINGDIPAPI __stdcall

#define	GDIPCONST const

Functions
GpStatus WINGDIPAPI	GdipCreateAdjustableArrowCap (REAL, REAL, BOOL, GpAdjustableArrowCap **)

GpStatus WINGDIPAPI	GdipGetAdjustableArrowCapFillState (GpAdjustableArrowCap , BOOL )

GpStatus WINGDIPAPI	GdipGetAdjustableArrowCapHeight (GpAdjustableArrowCap , REAL )

GpStatus WINGDIPAPI	GdipGetAdjustableArrowCapMiddleInset (GpAdjustableArrowCap , REAL )

GpStatus WINGDIPAPI	GdipGetAdjustableArrowCapWidth (GpAdjustableArrowCap , REAL )

GpStatus WINGDIPAPI	GdipSetAdjustableArrowCapFillState (GpAdjustableArrowCap *, BOOL)

GpStatus WINGDIPAPI	GdipSetAdjustableArrowCapHeight (GpAdjustableArrowCap *, REAL)

GpStatus WINGDIPAPI	GdipSetAdjustableArrowCapMiddleInset (GpAdjustableArrowCap *, REAL)

GpStatus WINGDIPAPI	GdipSetAdjustableArrowCapWidth (GpAdjustableArrowCap *, REAL)

GpStatus WINGDIPAPI	GdipBitmapApplyEffect (GpBitmap , CGpEffect , RECT , BOOL, VOID , INT )

GpStatus WINGDIPAPI	GdipBitmapCreateApplyEffect (GpBitmap *, INT, CGpEffect , RECT , RECT , GpBitmap , BOOL, VOID , INT *)

GpStatus WINGDIPAPI	GdipBitmapGetHistogram (GpBitmap , HistogramFormat, UINT, UINT , UINT , UINT , UINT *)

GpStatus WINGDIPAPI	GdipBitmapGetHistogramSize (HistogramFormat, UINT *)

GpStatus WINGDIPAPI	GdipBitmapGetPixel (GpBitmap , INT, INT, ARGB )

GpStatus WINGDIPAPI	GdipBitmapLockBits (GpBitmap , GDIPCONST GpRect , UINT, PixelFormat, BitmapData *)

GpStatus WINGDIPAPI	GdipBitmapSetPixel (GpBitmap *, INT, INT, ARGB)

GpStatus WINGDIPAPI	GdipBitmapSetResolution (GpBitmap *, REAL, REAL)

GpStatus WINGDIPAPI	GdipBitmapUnlockBits (GpBitmap , BitmapData )

GpStatus WINGDIPAPI	GdipCloneBitmapArea (REAL, REAL, REAL, REAL, PixelFormat, GpBitmap , GpBitmap *)

GpStatus WINGDIPAPI	GdipCloneBitmapAreaI (INT, INT, INT, INT, PixelFormat, GpBitmap , GpBitmap *)

GpStatus WINGDIPAPI	GdipCreateBitmapFromFile (GDIPCONST WCHAR , GpBitmap *)

GpStatus WINGDIPAPI	GdipCreateBitmapFromFileICM (GDIPCONST WCHAR , GpBitmap *)

GpStatus WINGDIPAPI	GdipCreateBitmapFromGdiDib (GDIPCONST BITMAPINFO , VOID , GpBitmap **)

GpStatus WINGDIPAPI	GdipCreateBitmapFromGraphics (INT, INT, GpGraphics , GpBitmap *)

GpStatus WINGDIPAPI	GdipCreateBitmapFromHBITMAP (HBITMAP, HPALETTE, GpBitmap **)

GpStatus WINGDIPAPI	GdipCreateBitmapFromHICON (HICON, GpBitmap **)

GpStatus WINGDIPAPI	GdipCreateBitmapFromResource (HINSTANCE, GDIPCONST WCHAR , GpBitmap *)

GpStatus WINGDIPAPI	GdipCreateBitmapFromScan0 (INT, INT, INT, PixelFormat, BYTE , GpBitmap *)

GpStatus WINGDIPAPI	GdipCreateBitmapFromStream (IStream , GpBitmap *)

GpStatus WINGDIPAPI	GdipCreateBitmapFromStreamICM (IStream , GpBitmap *)

GpStatus WINGDIPAPI	GdipCreateHBITMAPFromBitmap (GpBitmap , HBITMAP , ARGB)

GpStatus WINGDIPAPI	GdipCreateHICONFromBitmap (GpBitmap , HICON )

GpStatus WINGDIPAPI	GdipDeleteEffect (CGpEffect *)

GpStatus WINGDIPAPI	GdipSetEffectParameters (CGpEffect , const VOID , const UINT)

GpStatus WINGDIPAPI	GdipCloneBrush (GpBrush , GpBrush *)

GpStatus WINGDIPAPI	GdipDeleteBrush (GpBrush *)

GpStatus WINGDIPAPI	GdipGetBrushType (GpBrush , GpBrushType )

GpStatus WINGDIPAPI	GdipCreateCachedBitmap (GpBitmap , GpGraphics , GpCachedBitmap **)

GpStatus WINGDIPAPI	GdipDeleteCachedBitmap (GpCachedBitmap *)

GpStatus WINGDIPAPI	GdipDrawCachedBitmap (GpGraphics , GpCachedBitmap , INT, INT)

GpStatus WINGDIPAPI	GdipCloneCustomLineCap (GpCustomLineCap , GpCustomLineCap *)

GpStatus WINGDIPAPI	GdipCreateCustomLineCap (GpPath , GpPath , GpLineCap, REAL, GpCustomLineCap **)

GpStatus WINGDIPAPI	GdipDeleteCustomLineCap (GpCustomLineCap *)

GpStatus WINGDIPAPI	GdipGetCustomLineCapBaseCap (GpCustomLineCap , GpLineCap )

GpStatus WINGDIPAPI	GdipSetCustomLineCapBaseCap (GpCustomLineCap *, GpLineCap)

GpStatus WINGDIPAPI	GdipGetCustomLineCapBaseInset (GpCustomLineCap , REAL )

GpStatus WINGDIPAPI	GdipSetCustomLineCapBaseInset (GpCustomLineCap *, REAL)

GpStatus WINGDIPAPI	GdipSetCustomLineCapStrokeCaps (GpCustomLineCap *, GpLineCap, GpLineCap)

GpStatus WINGDIPAPI	GdipGetCustomLineCapStrokeJoin (GpCustomLineCap , GpLineJoin )

GpStatus WINGDIPAPI	GdipSetCustomLineCapStrokeJoin (GpCustomLineCap *, GpLineJoin)

GpStatus WINGDIPAPI	GdipGetCustomLineCapWidthScale (GpCustomLineCap , REAL )

GpStatus WINGDIPAPI	GdipSetCustomLineCapWidthScale (GpCustomLineCap *, REAL)

GpStatus WINGDIPAPI	GdipGetCustomLineCapType (GpCustomLineCap , CustomLineCapType )

GpStatus WINGDIPAPI	GdipCloneFont (GpFont , GpFont *)

GpStatus WINGDIPAPI	GdipCreateFont (GDIPCONST GpFontFamily , REAL, INT, Unit, GpFont *)

GpStatus WINGDIPAPI	GdipCreateFontFromDC (HDC, GpFont **)

GpStatus WINGDIPAPI	GdipCreateFontFromLogfontA (HDC, GDIPCONST LOGFONTA , GpFont *)

GpStatus WINGDIPAPI	GdipCreateFontFromLogfontW (HDC, GDIPCONST LOGFONTW , GpFont *)

GpStatus WINGDIPAPI	GdipDeleteFont (GpFont *)

GpStatus WINGDIPAPI	GdipGetLogFontA (GpFont , GpGraphics , LOGFONTA *)

GpStatus WINGDIPAPI	GdipGetLogFontW (GpFont , GpGraphics , LOGFONTW *)

GpStatus WINGDIPAPI	GdipGetFamily (GpFont , GpFontFamily *)

GpStatus WINGDIPAPI	GdipGetFontUnit (GpFont , Unit )

GpStatus WINGDIPAPI	GdipGetFontSize (GpFont , REAL )

GpStatus WINGDIPAPI	GdipGetFontStyle (GpFont , INT )

GpStatus WINGDIPAPI	GdipGetFontHeight (GDIPCONST GpFont , GDIPCONST GpGraphics , REAL *)

GpStatus WINGDIPAPI	GdipGetFontHeightGivenDPI (GDIPCONST GpFont , REAL, REAL )

GpStatus WINGDIPAPI	GdipNewInstalledFontCollection (GpFontCollection **)

GpStatus WINGDIPAPI	GdipNewPrivateFontCollection (GpFontCollection **)

GpStatus WINGDIPAPI	GdipDeletePrivateFontCollection (GpFontCollection **)

GpStatus WINGDIPAPI	GdipPrivateAddFontFile (GpFontCollection , GDIPCONST WCHAR )

GpStatus WINGDIPAPI	GdipPrivateAddMemoryFont (GpFontCollection , GDIPCONST void , INT)

GpStatus WINGDIPAPI	GdipGetFontCollectionFamilyCount (GpFontCollection , INT )

GpStatus WINGDIPAPI	GdipGetFontCollectionFamilyList (GpFontCollection , INT, GpFontFamily [], INT *)

GpStatus WINGDIPAPI	GdipCloneFontFamily (GpFontFamily , GpFontFamily *)

GpStatus WINGDIPAPI	GdipCreateFontFamilyFromName (GDIPCONST WCHAR , GpFontCollection , GpFontFamily **)

GpStatus WINGDIPAPI	GdipDeleteFontFamily (GpFontFamily *)

GpStatus WINGDIPAPI	GdipGetFamilyName (GDIPCONST GpFontFamily , WCHAR , LANGID)

GpStatus WINGDIPAPI	GdipGetCellAscent (GDIPCONST GpFontFamily , INT, UINT16 )

GpStatus WINGDIPAPI	GdipGetCellDescent (GDIPCONST GpFontFamily , INT, UINT16 )

GpStatus WINGDIPAPI	GdipGetEmHeight (GDIPCONST GpFontFamily , INT, UINT16 )

GpStatus WINGDIPAPI	GdipGetGenericFontFamilySansSerif (GpFontFamily **)

GpStatus WINGDIPAPI	GdipGetGenericFontFamilySerif (GpFontFamily **)

GpStatus WINGDIPAPI	GdipGetGenericFontFamilyMonospace (GpFontFamily **)

GpStatus WINGDIPAPI	GdipGetLineSpacing (GDIPCONST GpFontFamily , INT, UINT16 )

GpStatus WINGDIPAPI	GdipIsStyleAvailable (GDIPCONST GpFontFamily , INT, BOOL )

GpStatus WINGDIPAPI	GdipFlush (GpGraphics *, GpFlushIntention)

GpStatus WINGDIPAPI	GdipBeginContainer (GpGraphics , GDIPCONST GpRectF , GDIPCONST GpRectF , GpUnit, GraphicsContainer )

GpStatus WINGDIPAPI	GdipBeginContainer2 (GpGraphics , GraphicsContainer )

GpStatus WINGDIPAPI	GdipBeginContainerI (GpGraphics , GDIPCONST GpRect , GDIPCONST GpRect , GpUnit, GraphicsContainer )

GpStatus WINGDIPAPI	GdipEndContainer (GpGraphics *, GraphicsContainer)

GpStatus WINGDIPAPI	GdipComment (GpGraphics , UINT, GDIPCONST BYTE )

GpStatus WINGDIPAPI	GdipCreateFromHDC (HDC, GpGraphics **)

GpStatus WINGDIPAPI	GdipCreateFromHDC2 (HDC, HANDLE, GpGraphics **)

GpStatus WINGDIPAPI	GdipCreateFromHWND (HWND, GpGraphics **)

GpStatus WINGDIPAPI	GdipCreateFromHWNDICM (HWND, GpGraphics **)

HPALETTE WINGDIPAPI	GdipCreateHalftonePalette (void)

GpStatus WINGDIPAPI	GdipDeleteGraphics (GpGraphics *)

GpStatus WINGDIPAPI	GdipDrawArc (GpGraphics , GpPen , REAL, REAL, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawArcI (GpGraphics , GpPen , INT, INT, INT, INT, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawBezier (GpGraphics , GpPen , REAL, REAL, REAL, REAL, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawBezierI (GpGraphics , GpPen , INT, INT, INT, INT, INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipDrawBeziers (GpGraphics , GpPen , GDIPCONST GpPointF *, INT)

GpStatus WINGDIPAPI	GdipDrawBeziersI (GpGraphics , GpPen , GDIPCONST GpPoint *, INT)

GpStatus WINGDIPAPI	GdipDrawClosedCurve (GpGraphics , GpPen , GDIPCONST GpPointF *, INT)

GpStatus WINGDIPAPI	GdipDrawClosedCurveI (GpGraphics , GpPen , GDIPCONST GpPoint *, INT)

GpStatus WINGDIPAPI	GdipDrawClosedCurve2 (GpGraphics , GpPen , GDIPCONST GpPointF *, INT, REAL)

GpStatus WINGDIPAPI	GdipDrawClosedCurve2I (GpGraphics , GpPen , GDIPCONST GpPoint *, INT, REAL)

GpStatus WINGDIPAPI	GdipDrawCurve (GpGraphics , GpPen , GDIPCONST GpPointF *, INT)

GpStatus WINGDIPAPI	GdipDrawCurveI (GpGraphics , GpPen , GDIPCONST GpPoint *, INT)

GpStatus WINGDIPAPI	GdipDrawCurve2 (GpGraphics , GpPen , GDIPCONST GpPointF *, INT, REAL)

GpStatus WINGDIPAPI	GdipDrawCurve2I (GpGraphics , GpPen , GDIPCONST GpPoint *, INT, REAL)

GpStatus WINGDIPAPI	GdipDrawCurve3 (GpGraphics , GpPen , GDIPCONST GpPointF *, INT, INT, INT, REAL)

GpStatus WINGDIPAPI	GdipDrawCurve3I (GpGraphics , GpPen , GDIPCONST GpPoint *, INT, INT, INT, REAL)

GpStatus WINGDIPAPI	GdipDrawDriverString (GpGraphics , GDIPCONST UINT16 , INT, GDIPCONST GpFont , GDIPCONST GpBrush , GDIPCONST PointF , INT, GDIPCONST GpMatrix )

GpStatus WINGDIPAPI	GdipDrawEllipse (GpGraphics , GpPen , REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawEllipseI (GpGraphics , GpPen , INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipDrawImage (GpGraphics , GpImage , REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawImageI (GpGraphics , GpImage , INT, INT)

GpStatus WINGDIPAPI	GdipDrawImagePointRect (GpGraphics , GpImage , REAL, REAL, REAL, REAL, REAL, REAL, GpUnit)

GpStatus WINGDIPAPI	GdipDrawImagePointRectI (GpGraphics , GpImage , INT, INT, INT, INT, INT, INT, GpUnit)

GpStatus WINGDIPAPI	GdipDrawImagePoints (GpGraphics , GpImage , GDIPCONST GpPointF *, INT)

GpStatus WINGDIPAPI	GdipDrawImagePointsI (GpGraphics , GpImage , GDIPCONST GpPoint *, INT)

GpStatus WINGDIPAPI	GdipDrawImagePointsRect (GpGraphics , GpImage , GDIPCONST GpPointF , INT, REAL, REAL, REAL, REAL, GpUnit, GDIPCONST GpImageAttributes , DrawImageAbort, VOID *)

GpStatus WINGDIPAPI	GdipDrawImagePointsRectI (GpGraphics , GpImage , GDIPCONST GpPoint , INT, INT, INT, INT, INT, GpUnit, GDIPCONST GpImageAttributes , DrawImageAbort, VOID *)

GpStatus WINGDIPAPI	GdipDrawImageRect (GpGraphics , GpImage , REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawImageRectI (GpGraphics , GpImage , INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipDrawImageRectRect (GpGraphics , GpImage , REAL, REAL, REAL, REAL, REAL, REAL, REAL, REAL, GpUnit, GDIPCONST GpImageAttributes , DrawImageAbort, VOID )

GpStatus WINGDIPAPI	GdipDrawImageRectRectI (GpGraphics , GpImage , INT, INT, INT, INT, INT, INT, INT, INT, GpUnit, GDIPCONST GpImageAttributes , DrawImageAbort, VOID )

GpStatus WINGDIPAPI	GdipDrawLine (GpGraphics , GpPen , REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawLineI (GpGraphics , GpPen , INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipDrawLines (GpGraphics , GpPen , GDIPCONST GpPointF *, INT)

GpStatus WINGDIPAPI	GdipDrawLinesI (GpGraphics , GpPen , GDIPCONST GpPoint *, INT)

GpStatus WINGDIPAPI	GdipDrawPath (GpGraphics , GpPen , GpPath *)

GpStatus WINGDIPAPI	GdipDrawPie (GpGraphics , GpPen , REAL, REAL, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawPieI (GpGraphics , GpPen , INT, INT, INT, INT, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawPolygon (GpGraphics , GpPen , GDIPCONST GpPointF *, INT)

GpStatus WINGDIPAPI	GdipDrawPolygonI (GpGraphics , GpPen , GDIPCONST GpPoint *, INT)

GpStatus WINGDIPAPI	GdipDrawRectangle (GpGraphics , GpPen , REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipDrawRectangleI (GpGraphics , GpPen , INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipDrawRectangles (GpGraphics , GpPen , GDIPCONST GpRectF *, INT)

GpStatus WINGDIPAPI	GdipDrawRectanglesI (GpGraphics , GpPen , GDIPCONST GpRect *, INT)

GpStatus WINGDIPAPI	GdipDrawString (GpGraphics , GDIPCONST WCHAR , INT, GDIPCONST GpFont , GDIPCONST RectF , GDIPCONST GpStringFormat , GDIPCONST GpBrush )

GpStatus WINGDIPAPI	GdipEnumerateMetafileDestPoint (GpGraphics , GDIPCONST GpMetafile , GDIPCONST GpPointF , EnumerateMetafileProc, VOID , GDIPCONST GpImageAttributes *)

GpStatus WINGDIPAPI	GdipEnumerateMetafileDestPointI (GpGraphics , GDIPCONST GpMetafile , GDIPCONST GpPoint , EnumerateMetafileProc, VOID , GDIPCONST GpImageAttributes *)

GpStatus WINGDIPAPI	GdipEnumerateMetafileDestRect (GpGraphics , GDIPCONST GpMetafile , GDIPCONST GpRectF , EnumerateMetafileProc, VOID , GDIPCONST GpImageAttributes *)

GpStatus WINGDIPAPI	GdipEnumerateMetafileDestRectI (GpGraphics , GDIPCONST GpMetafile , GDIPCONST GpRect , EnumerateMetafileProc, VOID , GDIPCONST GpImageAttributes *)

GpStatus WINGDIPAPI	GdipEnumerateMetafileSrcRectDestPoints (GpGraphics , GDIPCONST GpMetafile , GDIPCONST GpPointF , INT, GDIPCONST GpRectF , Unit, EnumerateMetafileProc, VOID , GDIPCONST GpImageAttributes )

GpStatus WINGDIPAPI	GdipFillClosedCurve2 (GpGraphics , GpBrush , GDIPCONST GpPointF *, INT, REAL, GpFillMode)

GpStatus WINGDIPAPI	GdipFillClosedCurve2I (GpGraphics , GpBrush , GDIPCONST GpPoint *, INT, REAL, GpFillMode)

GpStatus WINGDIPAPI	GdipFillClosedCurve (GpGraphics , GpBrush , GDIPCONST GpPointF *, INT)

GpStatus WINGDIPAPI	GdipFillClosedCurveI (GpGraphics , GpBrush , GDIPCONST GpPoint *, INT)

GpStatus WINGDIPAPI	GdipFillEllipse (GpGraphics , GpBrush , REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipFillEllipseI (GpGraphics , GpBrush , INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipFillPath (GpGraphics , GpBrush , GpPath *)

GpStatus WINGDIPAPI	GdipFillPie (GpGraphics , GpBrush , REAL, REAL, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipFillPieI (GpGraphics , GpBrush , INT, INT, INT, INT, REAL, REAL)

GpStatus WINGDIPAPI	GdipFillPolygon (GpGraphics , GpBrush , GDIPCONST GpPointF *, INT, GpFillMode)

GpStatus WINGDIPAPI	GdipFillPolygonI (GpGraphics , GpBrush , GDIPCONST GpPoint *, INT, GpFillMode)

GpStatus WINGDIPAPI	GdipFillPolygon2 (GpGraphics , GpBrush , GDIPCONST GpPointF *, INT)

GpStatus WINGDIPAPI	GdipFillPolygon2I (GpGraphics , GpBrush , GDIPCONST GpPoint *, INT)

GpStatus WINGDIPAPI	GdipFillRectangle (GpGraphics , GpBrush , REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipFillRectangleI (GpGraphics , GpBrush , INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipFillRectangles (GpGraphics , GpBrush , GDIPCONST GpRectF *, INT)

GpStatus WINGDIPAPI	GdipFillRectanglesI (GpGraphics , GpBrush , GDIPCONST GpRect *, INT)

GpStatus WINGDIPAPI	GdipFillRegion (GpGraphics , GpBrush , GpRegion *)

GpStatus WINGDIPAPI	GdipGetClip (GpGraphics , GpRegion )

GpStatus WINGDIPAPI	GdipGetClipBounds (GpGraphics , GpRectF )

GpStatus WINGDIPAPI	GdipGetClipBoundsI (GpGraphics , GpRect )

GpStatus WINGDIPAPI	GdipGetCompositingMode (GpGraphics , CompositingMode )

GpStatus WINGDIPAPI	GdipGetCompositingQuality (GpGraphics , CompositingQuality )

GpStatus WINGDIPAPI	GdipGetDC (GpGraphics , HDC )

GpStatus WINGDIPAPI	GdipGetDpiX (GpGraphics , REAL )

GpStatus WINGDIPAPI	GdipGetDpiY (GpGraphics , REAL )

GpStatus WINGDIPAPI	GdipGetEncoderParameterListSize (GpImage , GDIPCONST CLSID , UINT *)

GpStatus WINGDIPAPI	GdipGetImageDecoders (UINT, UINT, ImageCodecInfo *)

GpStatus WINGDIPAPI	GdipGetImageDecodersSize (UINT , UINT )

GpStatus WINGDIPAPI	GdipGetImageGraphicsContext (GpImage , GpGraphics *)

GpStatus WINGDIPAPI	GdipGetInterpolationMode (GpGraphics , InterpolationMode )

GpStatus WINGDIPAPI	GdipGetNearestColor (GpGraphics , ARGB )

GpStatus WINGDIPAPI	GdipGetPageScale (GpGraphics , REAL )

GpStatus WINGDIPAPI	GdipGetPageUnit (GpGraphics , GpUnit )

GpStatus WINGDIPAPI	GdipGetPixelOffsetMode (GpGraphics , PixelOffsetMode )

GpStatus WINGDIPAPI	GdipGetRenderingOrigin (GpGraphics , INT , INT *)

GpStatus WINGDIPAPI	GdipGetSmoothingMode (GpGraphics , SmoothingMode )

GpStatus WINGDIPAPI	GdipGetTextContrast (GpGraphics , UINT )

GpStatus WINGDIPAPI	GdipGetTextRenderingHint (GpGraphics , TextRenderingHint )

GpStatus WINGDIPAPI	GdipGetWorldTransform (GpGraphics , GpMatrix )

GpStatus WINGDIPAPI	GdipGraphicsClear (GpGraphics *, ARGB)

GpStatus WINGDIPAPI	GdipGraphicsSetAbort (GpGraphics , GdiplusAbort )

GpStatus WINGDIPAPI	GdipGetVisibleClipBounds (GpGraphics , GpRectF )

GpStatus WINGDIPAPI	GdipGetVisibleClipBoundsI (GpGraphics , GpRect )

GpStatus WINGDIPAPI	GdipInitializePalette (ColorPalette , PaletteType, INT, BOOL, GpBitmap )

GpStatus WINGDIPAPI	GdipIsClipEmpty (GpGraphics , BOOL )

GpStatus WINGDIPAPI	GdipIsVisibleClipEmpty (GpGraphics , BOOL )

GpStatus WINGDIPAPI	GdipIsVisiblePoint (GpGraphics , REAL, REAL, BOOL )

GpStatus WINGDIPAPI	GdipIsVisiblePointI (GpGraphics , INT, INT, BOOL )

GpStatus WINGDIPAPI	GdipIsVisibleRect (GpGraphics , REAL, REAL, REAL, REAL, BOOL )

GpStatus WINGDIPAPI	GdipIsVisibleRectI (GpGraphics , INT, INT, INT, INT, BOOL )

GpStatus WINGDIPAPI	GdipMeasureCharacterRanges (GpGraphics , GDIPCONST WCHAR , INT, GDIPCONST GpFont , GDIPCONST RectF , GDIPCONST GpStringFormat , INT, GpRegion *)

GpStatus WINGDIPAPI	GdipMeasureDriverString (GpGraphics , GDIPCONST UINT16 , INT, GDIPCONST GpFont , GDIPCONST PointF , INT, GDIPCONST GpMatrix , RectF )

GpStatus WINGDIPAPI	GdipMeasureString (GpGraphics , GDIPCONST WCHAR , INT, GDIPCONST GpFont , GDIPCONST RectF , GDIPCONST GpStringFormat , RectF , INT , INT )

GpStatus WINGDIPAPI	GdipMultiplyWorldTransform (GpGraphics , GDIPCONST GpMatrix , GpMatrixOrder)

GpStatus WINGDIPAPI	GdipRecordMetafileFileName (GDIPCONST WCHAR , HDC, EmfType, GDIPCONST GpRectF , MetafileFrameUnit, GDIPCONST WCHAR , GpMetafile *)

GpStatus WINGDIPAPI	GdipRecordMetafileFileNameI (GDIPCONST WCHAR , HDC, EmfType, GDIPCONST GpRect , MetafileFrameUnit, GDIPCONST WCHAR , GpMetafile *)

GpStatus WINGDIPAPI	GdipRecordMetafileI (HDC, EmfType, GDIPCONST GpRect , MetafileFrameUnit, GDIPCONST WCHAR , GpMetafile **)

GpStatus WINGDIPAPI	GdipReleaseDC (GpGraphics *, HDC)

GpStatus WINGDIPAPI	GdipResetClip (GpGraphics *)

GpStatus WINGDIPAPI	GdipResetWorldTransform (GpGraphics *)

GpStatus WINGDIPAPI	GdipRestoreGraphics (GpGraphics *, GraphicsState)

GpStatus WINGDIPAPI	GdipRotateWorldTransform (GpGraphics *, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipSaveAdd (GpImage , GDIPCONST EncoderParameters )

GpStatus WINGDIPAPI	GdipSaveGraphics (GpGraphics , GraphicsState )

GpStatus WINGDIPAPI	GdipScaleWorldTransform (GpGraphics *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipSetClipHrgn (GpGraphics *, HRGN, CombineMode)

GpStatus WINGDIPAPI	GdipSetClipGraphics (GpGraphics , GpGraphics , CombineMode)

GpStatus WINGDIPAPI	GdipSetClipPath (GpGraphics , GpPath , CombineMode)

GpStatus WINGDIPAPI	GdipSetClipRect (GpGraphics *, REAL, REAL, REAL, REAL, CombineMode)

GpStatus WINGDIPAPI	GdipSetClipRectI (GpGraphics *, INT, INT, INT, INT, CombineMode)

GpStatus WINGDIPAPI	GdipSetClipRegion (GpGraphics , GpRegion , CombineMode)

GpStatus WINGDIPAPI	GdipSetCompositingMode (GpGraphics *, CompositingMode)

GpStatus WINGDIPAPI	GdipSetCompositingQuality (GpGraphics *, CompositingQuality)

GpStatus WINGDIPAPI	GdipSetInterpolationMode (GpGraphics *, InterpolationMode)

GpStatus WINGDIPAPI	GdipSetPageScale (GpGraphics *, REAL)

GpStatus WINGDIPAPI	GdipSetPageUnit (GpGraphics *, GpUnit)

GpStatus WINGDIPAPI	GdipSetPixelOffsetMode (GpGraphics *, PixelOffsetMode)

GpStatus WINGDIPAPI	GdipSetRenderingOrigin (GpGraphics *, INT, INT)

GpStatus WINGDIPAPI	GdipSetSmoothingMode (GpGraphics *, SmoothingMode)

GpStatus WINGDIPAPI	GdipSetTextContrast (GpGraphics *, UINT)

GpStatus WINGDIPAPI	GdipSetTextRenderingHint (GpGraphics *, TextRenderingHint)

GpStatus WINGDIPAPI	GdipSetWorldTransform (GpGraphics , GpMatrix )

GpStatus WINGDIPAPI	GdipTransformPoints (GpGraphics , GpCoordinateSpace, GpCoordinateSpace, GpPointF , INT)

GpStatus WINGDIPAPI	GdipTransformPointsI (GpGraphics , GpCoordinateSpace, GpCoordinateSpace, GpPoint , INT)

GpStatus WINGDIPAPI	GdipTranslateClip (GpGraphics *, REAL, REAL)

GpStatus WINGDIPAPI	GdipTranslateClipI (GpGraphics *, INT, INT)

GpStatus WINGDIPAPI	GdipTranslateWorldTransform (GpGraphics *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipAddPathArc (GpPath *, REAL, REAL, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipAddPathArcI (GpPath *, INT, INT, INT, INT, REAL, REAL)

GpStatus WINGDIPAPI	GdipAddPathBezier (GpPath *, REAL, REAL, REAL, REAL, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipAddPathBezierI (GpPath *, INT, INT, INT, INT, INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipAddPathBeziers (GpPath , GDIPCONST GpPointF , INT)

GpStatus WINGDIPAPI	GdipAddPathBeziersI (GpPath , GDIPCONST GpPoint , INT)

GpStatus WINGDIPAPI	GdipAddPathClosedCurve (GpPath , GDIPCONST GpPointF , INT)

GpStatus WINGDIPAPI	GdipAddPathClosedCurveI (GpPath , GDIPCONST GpPoint , INT)

GpStatus WINGDIPAPI	GdipAddPathClosedCurve2 (GpPath , GDIPCONST GpPointF , INT, REAL)

GpStatus WINGDIPAPI	GdipAddPathClosedCurve2I (GpPath , GDIPCONST GpPoint , INT, REAL)

GpStatus WINGDIPAPI	GdipAddPathCurve (GpPath , GDIPCONST GpPointF , INT)

GpStatus WINGDIPAPI	GdipAddPathCurveI (GpPath , GDIPCONST GpPoint , INT)

GpStatus WINGDIPAPI	GdipAddPathCurve2 (GpPath , GDIPCONST GpPointF , INT, REAL)

GpStatus WINGDIPAPI	GdipAddPathCurve2I (GpPath , GDIPCONST GpPoint , INT, REAL)

GpStatus WINGDIPAPI	GdipAddPathCurve3 (GpPath , GDIPCONST GpPointF , INT, INT, INT, REAL)

GpStatus WINGDIPAPI	GdipAddPathCurve3I (GpPath , GDIPCONST GpPoint , INT, INT, INT, REAL)

GpStatus WINGDIPAPI	GdipAddPathEllipse (GpPath *, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipAddPathEllipseI (GpPath *, INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipAddPathLine (GpPath *, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipAddPathLineI (GpPath *, INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipAddPathLine2 (GpPath , GDIPCONST GpPointF , INT)

GpStatus WINGDIPAPI	GdipAddPathLine2I (GpPath , GDIPCONST GpPoint , INT)

GpStatus WINGDIPAPI	GdipAddPathPath (GpPath , GDIPCONST GpPath , BOOL)

GpStatus WINGDIPAPI	GdipAddPathPie (GpPath *, REAL, REAL, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipAddPathPieI (GpPath *, INT, INT, INT, INT, REAL, REAL)

GpStatus WINGDIPAPI	GdipAddPathPolygon (GpPath , GDIPCONST GpPointF , INT)

GpStatus WINGDIPAPI	GdipAddPathPolygonI (GpPath , GDIPCONST GpPoint , INT)

GpStatus WINGDIPAPI	GdipAddPathRectangle (GpPath *, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipAddPathRectangleI (GpPath *, INT, INT, INT, INT)

GpStatus WINGDIPAPI	GdipAddPathRectangles (GpPath , GDIPCONST GpRectF , INT)

GpStatus WINGDIPAPI	GdipAddPathRectanglesI (GpPath , GDIPCONST GpRect , INT)

GpStatus WINGDIPAPI	GdipAddPathString (GpPath , GDIPCONST WCHAR , INT, GDIPCONST GpFontFamily , INT, REAL, GDIPCONST RectF , GDIPCONST GpStringFormat *)

GpStatus WINGDIPAPI	GdipAddPathStringI (GpPath , GDIPCONST WCHAR , INT, GDIPCONST GpFontFamily , INT, REAL, GDIPCONST Rect , GDIPCONST GpStringFormat *)

GpStatus WINGDIPAPI	GdipClearPathMarkers (GpPath *)

GpStatus WINGDIPAPI	GdipClonePath (GpPath , GpPath *)

GpStatus WINGDIPAPI	GdipClosePathFigure (GpPath *)

GpStatus WINGDIPAPI	GdipClosePathFigures (GpPath *)

GpStatus WINGDIPAPI	GdipCreatePath (GpFillMode, GpPath **)

GpStatus WINGDIPAPI	GdipCreatePath2 (GDIPCONST GpPointF , GDIPCONST BYTE , INT, GpFillMode, GpPath **)

GpStatus WINGDIPAPI	GdipCreatePath2I (GDIPCONST GpPoint , GDIPCONST BYTE , INT, GpFillMode, GpPath **)

GpStatus WINGDIPAPI	GdipDeletePath (GpPath *)

GpStatus WINGDIPAPI	GdipFlattenPath (GpPath , GpMatrix , REAL)

GpStatus WINGDIPAPI	GdipIsOutlineVisiblePathPoint (GpPath , REAL, REAL, GpPen , GpGraphics , BOOL )

GpStatus WINGDIPAPI	GdipIsOutlineVisiblePathPointI (GpPath , INT, INT, GpPen , GpGraphics , BOOL )

GpStatus WINGDIPAPI	GdipIsVisiblePathPoint (GpPath , REAL, REAL, GpGraphics , BOOL *)

GpStatus WINGDIPAPI	GdipIsVisiblePathPointI (GpPath , INT, INT, GpGraphics , BOOL *)

GpStatus WINGDIPAPI	GdipGetPathData (GpPath , GpPathData )

GpStatus WINGDIPAPI	GdipGetPathFillMode (GpPath , GpFillMode )

GpStatus WINGDIPAPI	GdipGetPathLastPoint (GpPath , GpPointF )

GpStatus WINGDIPAPI	GdipGetPathPoints (GpPath , GpPointF , INT)

GpStatus WINGDIPAPI	GdipGetPathPointsI (GpPath , GpPoint , INT)

GpStatus WINGDIPAPI	GdipGetPathTypes (GpPath , BYTE , INT)

GpStatus WINGDIPAPI	GdipGetPathWorldBounds (GpPath , GpRectF , GDIPCONST GpMatrix , GDIPCONST GpPen )

GpStatus WINGDIPAPI	GdipGetPathWorldBoundsI (GpPath , GpRect , GDIPCONST GpMatrix , GDIPCONST GpPen )

GpStatus WINGDIPAPI	GdipGetPointCount (GpPath , INT )

GpStatus WINGDIPAPI	GdipResetPath (GpPath *)

GpStatus WINGDIPAPI	GdipReversePath (GpPath *)

GpStatus WINGDIPAPI	GdipSetPathFillMode (GpPath *, GpFillMode)

GpStatus WINGDIPAPI	GdipSetPathMarker (GpPath *)

GpStatus WINGDIPAPI	GdipStartPathFigure (GpPath *)

GpStatus WINGDIPAPI	GdipTransformPath (GpPath , GpMatrix )

GpStatus WINGDIPAPI	GdipWarpPath (GpPath , GpMatrix , GDIPCONST GpPointF *, INT, REAL, REAL, REAL, REAL, WarpMode, REAL)

GpStatus WINGDIPAPI	GdipWidenPath (GpPath , GpPen , GpMatrix *, REAL)

GpStatus WINGDIPAPI	GdipWindingModeOutline (GpPath , GpMatrix , REAL)

GpStatus WINGDIPAPI	GdipCreateHatchBrush (GpHatchStyle, ARGB, ARGB, GpHatch **)

GpStatus WINGDIPAPI	GdipGetHatchBackgroundColor (GpHatch , ARGB )

GpStatus WINGDIPAPI	GdipGetHatchForegroundColor (GpHatch , ARGB )

GpStatus WINGDIPAPI	GdipGetHatchStyle (GpHatch , GpHatchStyle )

GpStatus WINGDIPAPI	GdipCloneImage (GpImage , GpImage *)

GpStatus WINGDIPAPI	GdipCloneImageAttributes (GDIPCONST GpImageAttributes , GpImageAttributes *)

GpStatus WINGDIPAPI	GdipDisposeImage (GpImage *)

GpStatus WINGDIPAPI	GdipEmfToWmfBits (HENHMETAFILE, UINT, LPBYTE, INT, INT)

GpStatus WINGDIPAPI	GdipFindFirstImageItem (GpImage , ImageItemData )

GpStatus WINGDIPAPI	GdipFindNextImageItem (GpImage , ImageItemData )

GpStatus WINGDIPAPI	GdipGetAllPropertyItems (GpImage , UINT, UINT, PropertyItem )

GpStatus WINGDIPAPI	GdipGetImageBounds (GpImage , GpRectF , GpUnit *)

GpStatus WINGDIPAPI	GdipGetImageDimension (GpImage , REAL , REAL *)

GpStatus WINGDIPAPI	GdipGetImageFlags (GpImage , UINT )

GpStatus WINGDIPAPI	GdipGetImageHeight (GpImage , UINT )

GpStatus WINGDIPAPI	GdipGetImageHorizontalResolution (GpImage , REAL )

GpStatus WINGDIPAPI	GdipGetImageItemData (GpImage , ImageItemData )

GpStatus WINGDIPAPI	GdipGetImagePalette (GpImage , ColorPalette , INT)

GpStatus WINGDIPAPI	GdipGetImagePaletteSize (GpImage , INT )

GpStatus WINGDIPAPI	GdipGetImagePixelFormat (GpImage , PixelFormat )

GpStatus WINGDIPAPI	GdipGetImageRawFormat (GpImage , GUID )

GpStatus WINGDIPAPI	GdipGetImageThumbnail (GpImage , UINT, UINT, GpImage , GetThumbnailImageAbort, VOID )

GpStatus WINGDIPAPI	GdipGetImageType (GpImage , ImageType )

GpStatus WINGDIPAPI	GdipGetImageVerticalResolution (GpImage , REAL )

GpStatus WINGDIPAPI	GdipGetImageWidth (GpImage , UINT )

GpStatus WINGDIPAPI	GdipGetPropertyCount (GpImage , UINT )

GpStatus WINGDIPAPI	GdipGetPropertyIdList (GpImage , UINT, PROPID )

GpStatus WINGDIPAPI	GdipGetPropertyItem (GpImage , PROPID, UINT, PropertyItem )

GpStatus WINGDIPAPI	GdipGetPropertyItemSize (GpImage , PROPID, UINT )

GpStatus WINGDIPAPI	GdipGetPropertySize (GpImage , UINT , UINT *)

GpStatus WINGDIPAPI	GdipImageForceValidation (GpImage *)

GpStatus WINGDIPAPI	GdipImageGetFrameCount (GpImage , GDIPCONST GUID , UINT *)

GpStatus WINGDIPAPI	GdipImageGetFrameDimensionsCount (GpImage , UINT )

GpStatus WINGDIPAPI	GdipImageGetFrameDimensionsList (GpImage , GUID , UINT)

GpStatus WINGDIPAPI	GdipImageRotateFlip (GpImage *, RotateFlipType)

GpStatus WINGDIPAPI	GdipImageSelectActiveFrame (GpImage , GDIPCONST GUID , UINT)

GpStatus WINGDIPAPI	GdipImageSetAbort (GpImage , GdiplusAbort )

GpStatus WINGDIPAPI	GdipLoadImageFromFile (GDIPCONST WCHAR , GpImage *)

GpStatus WINGDIPAPI	GdipLoadImageFromFileICM (GDIPCONST WCHAR , GpImage *)

GpStatus WINGDIPAPI	GdipLoadImageFromStream (IStream , GpImage *)

GpStatus WINGDIPAPI	GdipLoadImageFromStreamICM (IStream , GpImage *)

GpStatus WINGDIPAPI	GdipRemovePropertyItem (GpImage *, PROPID)

GpStatus WINGDIPAPI	GdipSaveImageToFile (GpImage , GDIPCONST WCHAR , GDIPCONST CLSID , GDIPCONST EncoderParameters )

GpStatus WINGDIPAPI	GdipSaveImageToStream (GpImage , IStream , GDIPCONST CLSID , GDIPCONST EncoderParameters )

GpStatus WINGDIPAPI	GdipSetImagePalette (GpImage , GDIPCONST ColorPalette )

GpStatus WINGDIPAPI	GdipSetPropertyItem (GpImage , GDIPCONST PropertyItem )

GpStatus WINGDIPAPI	GdipCreateImageAttributes (GpImageAttributes **)

GpStatus WINGDIPAPI	GdipDisposeImageAttributes (GpImageAttributes *)

GpStatus WINGDIPAPI	GdipGetImageAttributesAdjustedPalette (GpImageAttributes , ColorPalette , ColorAdjustType)

GpStatus WINGDIPAPI	GdipSetImageAttributesCachedBackground (GpImageAttributes *, BOOL)

GpStatus WINGDIPAPI	GdipSetImageAttributesColorKeys (GpImageAttributes *, ColorAdjustType, BOOL, ARGB, ARGB)

GpStatus WINGDIPAPI	GdipSetImageAttributesColorMatrix (GpImageAttributes , ColorAdjustType, BOOL, GDIPCONST ColorMatrix , GDIPCONST ColorMatrix *, ColorMatrixFlags)

GpStatus WINGDIPAPI	GdipSetImageAttributesGamma (GpImageAttributes *, ColorAdjustType, BOOL, REAL)

GpStatus WINGDIPAPI	GdipSetImageAttributesNoOp (GpImageAttributes *, ColorAdjustType, BOOL)

GpStatus WINGDIPAPI	GdipSetImageAttributesOutputChannel (GpImageAttributes *, ColorAdjustType, BOOL, ColorChannelFlags)

GpStatus WINGDIPAPI	GdipSetImageAttributesOutputChannelColorProfile (GpImageAttributes , ColorAdjustType, BOOL, GDIPCONST WCHAR )

GpStatus WINGDIPAPI	GdipSetImageAttributesRemapTable (GpImageAttributes , ColorAdjustType, BOOL, UINT, GDIPCONST ColorMap )

GpStatus WINGDIPAPI	GdipSetImageAttributesThreshold (GpImageAttributes *, ColorAdjustType, BOOL, REAL)

GpStatus WINGDIPAPI	GdipSetImageAttributesToIdentity (GpImageAttributes *, ColorAdjustType)

GpStatus WINGDIPAPI	GdipSetImageAttributesWrapMode (GpImageAttributes *, WrapMode, ARGB, BOOL)

GpStatus WINGDIPAPI	GdipResetImageAttributes (GpImageAttributes *, ColorAdjustType)

GpStatus WINGDIPAPI	GdipCreateLineBrush (GDIPCONST GpPointF , GDIPCONST GpPointF , ARGB, ARGB, GpWrapMode, GpLineGradient **)

GpStatus WINGDIPAPI	GdipCreateLineBrushI (GDIPCONST GpPoint , GDIPCONST GpPoint , ARGB, ARGB, GpWrapMode, GpLineGradient **)

GpStatus WINGDIPAPI	GdipCreateLineBrushFromRect (GDIPCONST GpRectF , ARGB, ARGB, LinearGradientMode, GpWrapMode, GpLineGradient *)

GpStatus WINGDIPAPI	GdipCreateLineBrushFromRectI (GDIPCONST GpRect , ARGB, ARGB, LinearGradientMode, GpWrapMode, GpLineGradient *)

GpStatus WINGDIPAPI	GdipCreateLineBrushFromRectWithAngle (GDIPCONST GpRectF , ARGB, ARGB, REAL, BOOL, GpWrapMode, GpLineGradient *)

GpStatus WINGDIPAPI	GdipCreateLineBrushFromRectWithAngleI (GDIPCONST GpRect , ARGB, ARGB, REAL, BOOL, GpWrapMode, GpLineGradient *)

GpStatus WINGDIPAPI	GdipGetLineColors (GpLineGradient , ARGB )

GpStatus WINGDIPAPI	GdipGetLineGammaCorrection (GpLineGradient , BOOL )

GpStatus WINGDIPAPI	GdipGetLineRect (GpLineGradient , GpRectF )

GpStatus WINGDIPAPI	GdipGetLineRectI (GpLineGradient , GpRect )

GpStatus WINGDIPAPI	GdipGetLineWrapMode (GpLineGradient , GpWrapMode )

GpStatus WINGDIPAPI	GdipSetLineBlend (GpLineGradient , GDIPCONST REAL , GDIPCONST REAL *, INT)

GpStatus WINGDIPAPI	GdipGetLineBlend (GpLineGradient , REAL , REAL *, INT)

GpStatus WINGDIPAPI	GdipGetLineBlendCount (GpLineGradient , INT )

GpStatus WINGDIPAPI	GdipSetLinePresetBlend (GpLineGradient , GDIPCONST ARGB , GDIPCONST REAL *, INT)

GpStatus WINGDIPAPI	GdipGetLinePresetBlend (GpLineGradient , ARGB , REAL *, INT)

GpStatus WINGDIPAPI	GdipGetLinePresetBlendCount (GpLineGradient , INT )

GpStatus WINGDIPAPI	GdipGetLineTransform (GpLineGradient , GpMatrix )

GpStatus WINGDIPAPI	GdipMultiplyLineTransform (GpLineGradient , GDIPCONST GpMatrix , GpMatrixOrder)

GpStatus WINGDIPAPI	GdipResetLineTransform (GpLineGradient *)

GpStatus WINGDIPAPI	GdipRotateLineTransform (GpLineGradient *, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipScaleLineTransform (GpLineGradient *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipSetLineColors (GpLineGradient *, ARGB, ARGB)

GpStatus WINGDIPAPI	GdipSetLineGammaCorrection (GpLineGradient *, BOOL)

GpStatus WINGDIPAPI	GdipSetLineSigmaBlend (GpLineGradient *, REAL, REAL)

GpStatus WINGDIPAPI	GdipSetLineTransform (GpLineGradient , GDIPCONST GpMatrix )

GpStatus WINGDIPAPI	GdipSetLineLinearBlend (GpLineGradient *, REAL, REAL)

GpStatus WINGDIPAPI	GdipSetLineWrapMode (GpLineGradient *, GpWrapMode)

GpStatus WINGDIPAPI	GdipTranslateLineTransform (GpLineGradient *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipCloneMatrix (GpMatrix , GpMatrix *)

GpStatus WINGDIPAPI	GdipCreateMatrix (GpMatrix **)

GpStatus WINGDIPAPI	GdipCreateMatrix2 (REAL, REAL, REAL, REAL, REAL, REAL, GpMatrix **)

GpStatus WINGDIPAPI	GdipCreateMatrix3 (GDIPCONST GpRectF , GDIPCONST GpPointF , GpMatrix **)

GpStatus WINGDIPAPI	GdipCreateMatrix3I (GDIPCONST GpRect , GDIPCONST GpPoint , GpMatrix **)

GpStatus WINGDIPAPI	GdipDeleteMatrix (GpMatrix *)

GpStatus WINGDIPAPI	GdipGetMatrixElements (GDIPCONST GpMatrix , REAL )

GpStatus WINGDIPAPI	GdipInvertMatrix (GpMatrix *)

GpStatus WINGDIPAPI	GdipIsMatrixEqual (GDIPCONST GpMatrix , GDIPCONST GpMatrix , BOOL *)

GpStatus WINGDIPAPI	GdipIsMatrixIdentity (GDIPCONST GpMatrix , BOOL )

GpStatus WINGDIPAPI	GdipIsMatrixInvertible (GDIPCONST GpMatrix , BOOL )

GpStatus WINGDIPAPI	GdipMultiplyMatrix (GpMatrix , GDIPCONST GpMatrix , GpMatrixOrder)

GpStatus WINGDIPAPI	GdipRotateMatrix (GpMatrix *, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipShearMatrix (GpMatrix *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipScaleMatrix (GpMatrix *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipSetMatrixElements (GpMatrix *, REAL, REAL, REAL, REAL, REAL, REAL)

GpStatus WINGDIPAPI	GdipTransformMatrixPoints (GpMatrix , GpPointF , INT)

GpStatus WINGDIPAPI	GdipTransformMatrixPointsI (GpMatrix , GpPoint , INT)

GpStatus WINGDIPAPI	GdipTranslateMatrix (GpMatrix *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipVectorTransformMatrixPoints (GpMatrix , GpPointF , INT)

GpStatus WINGDIPAPI	GdipVectorTransformMatrixPointsI (GpMatrix , GpPoint , INT)

GpStatus WINGDIPAPI	GdipConvertToEmfPlus (const GpGraphics , GpMetafile , INT , EmfType, const WCHAR , GpMetafile **)

GpStatus WINGDIPAPI	GdipConvertToEmfPlusToFile (const GpGraphics , GpMetafile , INT , const WCHAR , EmfType, const WCHAR , GpMetafile *)

GpStatus WINGDIPAPI	GdipConvertToEmfPlusToStream (const GpGraphics , GpMetafile , INT , IStream , EmfType, const WCHAR , GpMetafile *)

GpStatus WINGDIPAPI	GdipCreateMetafileFromEmf (HENHMETAFILE, BOOL, GpMetafile **)

GpStatus WINGDIPAPI	GdipCreateMetafileFromWmf (HMETAFILE, BOOL, GDIPCONST WmfPlaceableFileHeader , GpMetafile *)

GpStatus WINGDIPAPI	GdipCreateMetafileFromWmfFile (GDIPCONST WCHAR , GDIPCONST WmfPlaceableFileHeader , GpMetafile **)

GpStatus WINGDIPAPI	GdipCreateMetafileFromFile (GDIPCONST WCHAR , GpMetafile *)

GpStatus WINGDIPAPI	GdipCreateMetafileFromStream (IStream , GpMetafile *)

GpStatus WINGDIPAPI	GdipGetHemfFromMetafile (GpMetafile , HENHMETAFILE )

GpStatus WINGDIPAPI	GdipPlayMetafileRecord (GDIPCONST GpMetafile , EmfPlusRecordType, UINT, UINT, GDIPCONST BYTE )

GpStatus WINGDIPAPI	GdipSetMetafileDownLevelRasterizationLimit (GpMetafile *, UINT)

GpStatus WINGDIPAPI	GdipRecordMetafile (HDC, EmfType, GDIPCONST GpRectF , MetafileFrameUnit, GDIPCONST WCHAR , GpMetafile **)

GpStatus WINGDIPAPI	GdipRecordMetafileStream (IStream , HDC, EmfType, GDIPCONST GpRectF , MetafileFrameUnit, GDIPCONST WCHAR , GpMetafile *)

GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromEmf (HENHMETAFILE, MetafileHeader *)

GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromFile (GDIPCONST WCHAR , MetafileHeader )

GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromMetafile (GpMetafile , MetafileHeader )

GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromStream (IStream , MetafileHeader )

GpStatus WINGDIPAPI	GdipGetMetafileHeaderFromWmf (HMETAFILE, GDIPCONST WmfPlaceableFileHeader , MetafileHeader )

GpStatus WINAPI	GdiplusNotificationHook (ULONG_PTR *)

void WINAPI	GdiplusNotificationUnhook (ULONG_PTR)

GpStatus WINGDIPAPI	GdipCreatePathGradient (GDIPCONST GpPointF , INT, GpWrapMode, GpPathGradient *)

GpStatus WINGDIPAPI	GdipCreatePathGradientI (GDIPCONST GpPoint , INT, GpWrapMode, GpPathGradient *)

GpStatus WINGDIPAPI	GdipCreatePathGradientFromPath (GDIPCONST GpPath , GpPathGradient *)

GpStatus WINGDIPAPI	GdipGetPathGradientBlend (GpPathGradient , REAL , REAL *, INT)

GpStatus WINGDIPAPI	GdipGetPathGradientBlendCount (GpPathGradient , INT )

GpStatus WINGDIPAPI	GdipGetPathGradientCenterColor (GpPathGradient , ARGB )

GpStatus WINGDIPAPI	GdipGetPathGradientCenterPoint (GpPathGradient , GpPointF )

GpStatus WINGDIPAPI	GdipGetPathGradientCenterPointI (GpPathGradient , GpPoint )

GpStatus WINGDIPAPI	GdipGetPathGradientFocusScales (GpPathGradient , REAL , REAL *)

GpStatus WINGDIPAPI	GdipGetPathGradientGammaCorrection (GpPathGradient , BOOL )

GpStatus WINGDIPAPI	GdipGetPathGradientPath (GpPathGradient , GpPath )

GpStatus WINGDIPAPI	GdipGetPathGradientPresetBlend (GpPathGradient , ARGB , REAL *, INT)

GpStatus WINGDIPAPI	GdipGetPathGradientPresetBlendCount (GpPathGradient , INT )

GpStatus WINGDIPAPI	GdipGetPathGradientPointCount (GpPathGradient , INT )

GpStatus WINGDIPAPI	GdipSetPathGradientPresetBlend (GpPathGradient , GDIPCONST ARGB , GDIPCONST REAL *, INT)

GpStatus WINGDIPAPI	GdipGetPathGradientRect (GpPathGradient , GpRectF )

GpStatus WINGDIPAPI	GdipGetPathGradientRectI (GpPathGradient , GpRect )

GpStatus WINGDIPAPI	GdipGetPathGradientSurroundColorCount (GpPathGradient , INT )

GpStatus WINGDIPAPI	GdipGetPathGradientSurroundColorsWithCount (GpPathGradient , ARGB , INT *)

GpStatus WINGDIPAPI	GdipGetPathGradientTransform (GpPathGradient , GpMatrix )

GpStatus WINGDIPAPI	GdipGetPathGradientWrapMode (GpPathGradient , GpWrapMode )

GpStatus WINGDIPAPI	GdipMultiplyPathGradientTransform (GpPathGradient , GDIPCONST GpMatrix , GpMatrixOrder)

GpStatus WINGDIPAPI	GdipResetPathGradientTransform (GpPathGradient *)

GpStatus WINGDIPAPI	GdipRotatePathGradientTransform (GpPathGradient *, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipScalePathGradientTransform (GpPathGradient *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipSetPathGradientLinearBlend (GpPathGradient *, REAL, REAL)

GpStatus WINGDIPAPI	GdipSetPathGradientBlend (GpPathGradient , GDIPCONST REAL , GDIPCONST REAL *, INT)

GpStatus WINGDIPAPI	GdipSetPathGradientCenterColor (GpPathGradient *, ARGB)

GpStatus WINGDIPAPI	GdipSetPathGradientCenterPoint (GpPathGradient , GpPointF )

GpStatus WINGDIPAPI	GdipSetPathGradientCenterPointI (GpPathGradient , GpPoint )

GpStatus WINGDIPAPI	GdipSetPathGradientFocusScales (GpPathGradient *, REAL, REAL)

GpStatus WINGDIPAPI	GdipSetPathGradientGammaCorrection (GpPathGradient *, BOOL)

GpStatus WINGDIPAPI	GdipSetPathGradientPath (GpPathGradient , GDIPCONST GpPath )

GpStatus WINGDIPAPI	GdipSetPathGradientSigmaBlend (GpPathGradient *, REAL, REAL)

GpStatus WINGDIPAPI	GdipSetPathGradientSurroundColorsWithCount (GpPathGradient , GDIPCONST ARGB , INT *)

GpStatus WINGDIPAPI	GdipSetPathGradientTransform (GpPathGradient , GpMatrix )

GpStatus WINGDIPAPI	GdipSetPathGradientWrapMode (GpPathGradient *, GpWrapMode)

GpStatus WINGDIPAPI	GdipTranslatePathGradientTransform (GpPathGradient *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipCreatePathIter (GpPathIterator *, GpPath )

GpStatus WINGDIPAPI	GdipDeletePathIter (GpPathIterator *)

GpStatus WINGDIPAPI	GdipPathIterCopyData (GpPathIterator , INT , GpPointF , BYTE , INT, INT)

GpStatus WINGDIPAPI	GdipPathIterGetCount (GpPathIterator , INT )

GpStatus WINGDIPAPI	GdipPathIterGetSubpathCount (GpPathIterator , INT )

GpStatus WINGDIPAPI	GdipPathIterEnumerate (GpPathIterator , INT , GpPointF , BYTE , INT)

GpStatus WINGDIPAPI	GdipPathIterHasCurve (GpPathIterator , BOOL )

GpStatus WINGDIPAPI	GdipPathIterIsValid (GpPathIterator , BOOL )

GpStatus WINGDIPAPI	GdipPathIterNextMarker (GpPathIterator , INT , INT , INT )

GpStatus WINGDIPAPI	GdipPathIterNextMarkerPath (GpPathIterator , INT , GpPath *)

GpStatus WINGDIPAPI	GdipPathIterNextPathType (GpPathIterator , INT , BYTE , INT , INT *)

GpStatus WINGDIPAPI	GdipPathIterNextSubpath (GpPathIterator , INT , INT , INT , BOOL *)

GpStatus WINGDIPAPI	GdipPathIterNextSubpathPath (GpPathIterator , INT , GpPath , BOOL )

GpStatus WINGDIPAPI	GdipPathIterRewind (GpPathIterator *)

GpStatus WINGDIPAPI	GdipClonePen (GpPen , GpPen *)

GpStatus WINGDIPAPI	GdipCreatePen1 (ARGB, REAL, GpUnit, GpPen **)

GpStatus WINGDIPAPI	GdipCreatePen2 (GpBrush , REAL, GpUnit, GpPen *)

GpStatus WINGDIPAPI	GdipDeletePen (GpPen *)

GpStatus WINGDIPAPI	GdipGetPenBrushFill (GpPen , GpBrush *)

GpStatus WINGDIPAPI	GdipGetPenColor (GpPen , ARGB )

GpStatus WINGDIPAPI	GdipGetPenCompoundCount (GpPen , INT )

GpStatus WINGDIPAPI	GdipGetPenCustomStartCap (GpPen , GpCustomLineCap *)

GpStatus WINGDIPAPI	GdipGetPenCustomEndCap (GpPen , GpCustomLineCap *)

GpStatus WINGDIPAPI	GdipGetPenDashArray (GpPen , REAL , INT)

GpStatus WINGDIPAPI	GdipGetPenDashCount (GpPen , INT )

GpStatus WINGDIPAPI	GdipGetPenDashOffset (GpPen , REAL )

GpStatus WINGDIPAPI	GdipGetPenDashStyle (GpPen , GpDashStyle )

GpStatus WINGDIPAPI	GdipGetPenMode (GpPen , GpPenAlignment )

GpStatus WINGDIPAPI	GdipGetPenTransform (GpPen , GpMatrix )

GpStatus WINGDIPAPI	GdipMultiplyPenTransform (GpPen , GDIPCONST GpMatrix , GpMatrixOrder)

GpStatus WINGDIPAPI	GdipResetPenTransform (GpPen *)

GpStatus WINGDIPAPI	GdipRotatePenTransform (GpPen *, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipScalePenTransform (GpPen *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipSetPenBrushFill (GpPen , GpBrush )

GpStatus WINGDIPAPI	GdipSetPenColor (GpPen *, ARGB)

GpStatus WINGDIPAPI	GdipSetPenCompoundArray (GpPen , GDIPCONST REAL , INT)

GpStatus WINGDIPAPI	GdipSetPenCustomEndCap (GpPen , GpCustomLineCap )

GpStatus WINGDIPAPI	GdipSetPenCustomStartCap (GpPen , GpCustomLineCap )

GpStatus WINGDIPAPI	GdipSetPenDashArray (GpPen , GDIPCONST REAL , INT)

GpStatus WINGDIPAPI	GdipSetPenDashCap197819 (GpPen *, GpDashCap)

GpStatus WINGDIPAPI	GdipSetPenDashOffset (GpPen *, REAL)

GpStatus WINGDIPAPI	GdipSetPenDashStyle (GpPen *, GpDashStyle)

GpStatus WINGDIPAPI	GdipSetPenEndCap (GpPen *, GpLineCap)

GpStatus WINGDIPAPI	GdipGetPenFillType (GpPen , GpPenType )

GpStatus WINGDIPAPI	GdipSetPenLineCap197819 (GpPen *, GpLineCap, GpLineCap, GpDashCap)

GpStatus WINGDIPAPI	GdipSetPenLineJoin (GpPen *, GpLineJoin)

GpStatus WINGDIPAPI	GdipSetPenMode (GpPen *, GpPenAlignment)

GpStatus WINGDIPAPI	GdipSetPenMiterLimit (GpPen *, REAL)

GpStatus WINGDIPAPI	GdipSetPenStartCap (GpPen *, GpLineCap)

GpStatus WINGDIPAPI	GdipSetPenTransform (GpPen , GpMatrix )

GpStatus WINGDIPAPI	GdipSetPenWidth (GpPen *, REAL)

GpStatus WINGDIPAPI	GdipGetPenDashCap197819 (GpPen , GpDashCap )

GpStatus WINGDIPAPI	GdipGetPenEndCap (GpPen , GpLineCap )

GpStatus WINGDIPAPI	GdipGetPenLineJoin (GpPen , GpLineJoin )

GpStatus WINGDIPAPI	GdipGetPenMiterLimit (GpPen , REAL )

GpStatus WINGDIPAPI	GdipGetPenStartCap (GpPen , GpLineCap )

GpStatus WINGDIPAPI	GdipGetPenUnit (GpPen , GpUnit )

GpStatus WINGDIPAPI	GdipGetPenWidth (GpPen , REAL )

GpStatus WINGDIPAPI	GdipTranslatePenTransform (GpPen *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipCloneRegion (GpRegion , GpRegion *)

GpStatus WINGDIPAPI	GdipCombineRegionPath (GpRegion , GpPath , CombineMode)

GpStatus WINGDIPAPI	GdipCombineRegionRect (GpRegion , GDIPCONST GpRectF , CombineMode)

GpStatus WINGDIPAPI	GdipCombineRegionRectI (GpRegion , GDIPCONST GpRect , CombineMode)

GpStatus WINGDIPAPI	GdipCombineRegionRegion (GpRegion , GpRegion , CombineMode)

GpStatus WINGDIPAPI	GdipCreateRegion (GpRegion **)

GpStatus WINGDIPAPI	GdipCreateRegionPath (GpPath , GpRegion *)

GpStatus WINGDIPAPI	GdipCreateRegionRect (GDIPCONST GpRectF , GpRegion *)

GpStatus WINGDIPAPI	GdipCreateRegionRectI (GDIPCONST GpRect , GpRegion *)

GpStatus WINGDIPAPI	GdipCreateRegionRgnData (GDIPCONST BYTE , INT, GpRegion *)

GpStatus WINGDIPAPI	GdipCreateRegionHrgn (HRGN, GpRegion **)

GpStatus WINGDIPAPI	GdipDeleteRegion (GpRegion *)

GpStatus WINGDIPAPI	GdipGetRegionBounds (GpRegion , GpGraphics , GpRectF *)

GpStatus WINGDIPAPI	GdipGetRegionBoundsI (GpRegion , GpGraphics , GpRect *)

GpStatus WINGDIPAPI	GdipGetRegionData (GpRegion , BYTE , UINT, UINT *)

GpStatus WINGDIPAPI	GdipGetRegionDataSize (GpRegion , UINT )

GpStatus WINGDIPAPI	GdipGetRegionHRgn (GpRegion , GpGraphics , HRGN *)

GpStatus WINGDIPAPI	GdipGetRegionScans (GpRegion , GpRectF , INT , GpMatrix )

GpStatus WINGDIPAPI	GdipGetRegionScansI (GpRegion , GpRect , INT , GpMatrix )

GpStatus WINGDIPAPI	GdipGetRegionScansCount (GpRegion , UINT , GpMatrix *)

GpStatus WINGDIPAPI	GdipIsEmptyRegion (GpRegion , GpGraphics , BOOL *)

GpStatus WINGDIPAPI	GdipIsEqualRegion (GpRegion , GpRegion , GpGraphics , BOOL )

GpStatus WINGDIPAPI	GdipIsInfiniteRegion (GpRegion , GpGraphics , BOOL *)

GpStatus WINGDIPAPI	GdipIsVisibleRegionPoint (GpRegion , REAL, REAL, GpGraphics , BOOL *)

GpStatus WINGDIPAPI	GdipIsVisibleRegionPointI (GpRegion , INT, INT, GpGraphics , BOOL *)

GpStatus WINGDIPAPI	GdipIsVisibleRegionRect (GpRegion , REAL, REAL, REAL, REAL, GpGraphics , BOOL *)

GpStatus WINGDIPAPI	GdipIsVisibleRegionRectI (GpRegion , INT, INT, INT, INT, GpGraphics , BOOL *)

GpStatus WINGDIPAPI	GdipSetEmpty (GpRegion *)

GpStatus WINGDIPAPI	GdipSetInfinite (GpRegion *)

GpStatus WINGDIPAPI	GdipTransformRegion (GpRegion , GpMatrix )

GpStatus WINGDIPAPI	GdipTranslateRegion (GpRegion *, REAL, REAL)

GpStatus WINGDIPAPI	GdipTranslateRegionI (GpRegion *, INT, INT)

GpStatus WINGDIPAPI	GdipCreateSolidFill (ARGB, GpSolidFill **)

GpStatus WINGDIPAPI	GdipGetSolidFillColor (GpSolidFill , ARGB )

GpStatus WINGDIPAPI	GdipSetSolidFillColor (GpSolidFill *, ARGB)

GpStatus WINGDIPAPI	GdipCloneStringFormat (GDIPCONST GpStringFormat , GpStringFormat *)

GpStatus WINGDIPAPI	GdipCreateStringFormat (INT, LANGID, GpStringFormat **)

GpStatus WINGDIPAPI	GdipDeleteStringFormat (GpStringFormat *)

GpStatus WINGDIPAPI	GdipGetStringFormatAlign (GpStringFormat , StringAlignment )

GpStatus WINGDIPAPI	GdipGetStringFormatDigitSubstitution (GDIPCONST GpStringFormat , LANGID , StringDigitSubstitute *)

GpStatus WINGDIPAPI	GdipGetStringFormatFlags (GDIPCONST GpStringFormat , INT )

GpStatus WINGDIPAPI	GdipGetStringFormatHotkeyPrefix (GDIPCONST GpStringFormat , INT )

GpStatus WINGDIPAPI	GdipGetStringFormatLineAlign (GpStringFormat , StringAlignment )

GpStatus WINGDIPAPI	GdipGetStringFormatMeasurableCharacterRangeCount (GDIPCONST GpStringFormat , INT )

GpStatus WINGDIPAPI	GdipGetStringFormatTabStopCount (GDIPCONST GpStringFormat , INT )

GpStatus WINGDIPAPI	GdipGetStringFormatTabStops (GDIPCONST GpStringFormat , INT, REAL , REAL *)

GpStatus WINGDIPAPI	GdipGetStringFormatTrimming (GpStringFormat , StringTrimming )

GpStatus WINGDIPAPI	GdipSetStringFormatAlign (GpStringFormat *, StringAlignment)

GpStatus WINGDIPAPI	GdipSetStringFormatDigitSubstitution (GpStringFormat *, LANGID, StringDigitSubstitute)

GpStatus WINGDIPAPI	GdipSetStringFormatHotkeyPrefix (GpStringFormat *, INT)

GpStatus WINGDIPAPI	GdipSetStringFormatLineAlign (GpStringFormat *, StringAlignment)

GpStatus WINGDIPAPI	GdipSetStringFormatMeasurableCharacterRanges (GpStringFormat , INT, GDIPCONST CharacterRange )

GpStatus WINGDIPAPI	GdipSetStringFormatTabStops (GpStringFormat , REAL, INT, GDIPCONST REAL )

GpStatus WINGDIPAPI	GdipSetStringFormatTrimming (GpStringFormat *, StringTrimming)

GpStatus WINGDIPAPI	GdipSetStringFormatFlags (GpStringFormat *, INT)

GpStatus WINGDIPAPI	GdipStringFormatGetGenericDefault (GpStringFormat **)

GpStatus WINGDIPAPI	GdipStringFormatGetGenericTypographic (GpStringFormat **)

GpStatus WINGDIPAPI	GdipCreateTexture (GpImage , GpWrapMode, GpTexture *)

GpStatus WINGDIPAPI	GdipCreateTexture2 (GpImage , GpWrapMode, REAL, REAL, REAL, REAL, GpTexture *)

GpStatus WINGDIPAPI	GdipCreateTexture2I (GpImage , GpWrapMode, INT, INT, INT, INT, GpTexture *)

GpStatus WINGDIPAPI	GdipCreateTextureIA (GpImage , GDIPCONST GpImageAttributes , REAL, REAL, REAL, REAL, GpTexture **)

GpStatus WINGDIPAPI	GdipCreateTextureIAI (GpImage , GDIPCONST GpImageAttributes , INT, INT, INT, INT, GpTexture **)

GpStatus WINGDIPAPI	GdipGetTextureImage (GpTexture , GpImage *)

GpStatus WINGDIPAPI	GdipGetTextureTransform (GpTexture , GpMatrix )

GpStatus WINGDIPAPI	GdipGetTextureWrapMode (GpTexture , GpWrapMode )

GpStatus WINGDIPAPI	GdipMultiplyTextureTransform (GpTexture , GDIPCONST GpMatrix , GpMatrixOrder)

GpStatus WINGDIPAPI	GdipResetTextureTransform (GpTexture *)

GpStatus WINGDIPAPI	GdipRotateTextureTransform (GpTexture *, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipScaleTextureTransform (GpTexture *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipSetTextureTransform (GpTexture , GDIPCONST GpMatrix )

GpStatus WINGDIPAPI	GdipSetTextureWrapMode (GpTexture *, GpWrapMode)

GpStatus WINGDIPAPI	GdipTranslateTextureTransform (GpTexture *, REAL, REAL, GpMatrixOrder)

GpStatus WINGDIPAPI	GdipCreateStreamOnFile (GDIPCONST WCHAR , UINT, IStream *)

GpStatus WINGDIPAPI	GdipGetImageEncodersSize (UINT numEncoders, UINT size)

GpStatus WINGDIPAPI	GdipGetImageEncoders (UINT numEncoders, UINT size, ImageCodecInfo *encoders)

GpStatus WINGDIPAPI	GdipTestControl (GpTestControlEnum, void *)

Macro Definition Documentation

◆ GDIPCONST

#define GDIPCONST const

Definition at line 24 of file gdiplusflat.h.

◆ WINGDIPAPI

#define WINGDIPAPI __stdcall

Definition at line 22 of file gdiplusflat.h.

Function Documentation

◆ GdipAddPathArc()

GpStatus WINGDIPAPI GdipAddPathArc	(	GpPath *	path,
		REAL	x1,
		REAL	y1,
		REAL	x2,
		REAL	y2,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 195 of file graphicspath.c.

{
    INT count, old_count, i;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
          path, x1, y1, x2, y2, startAngle, sweepAngle);
 
    if(!path)
        return InvalidParameter;
 
    count = arc2polybezier(NULL, x1, y1, x2, y2, startAngle, sweepAngle);
 
    if(count == 0)
        return Ok;
    if(!lengthen_path(path, count))
        return OutOfMemory;
 
    old_count = path->pathdata.Count;
    arc2polybezier(&path->pathdata.Points[old_count], x1, y1, x2, y2,
                   startAngle, sweepAngle);
 
    for(i = 0; i < count; i++){
        path->pathdata.Types[old_count + i] = PathPointTypeBezier;
    }
 
    path->pathdata.Types[old_count] =
        (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
    path->newfigure = FALSE;
    path->pathdata.Count += count;
 
    return Ok;
}

Referenced by GdipAddPathArcI(), GdipDrawArc(), test_arc(), test_flatten(), test_getregiondata(), test_linei(), test_pathpath(), and test_worldbounds().

◆ GdipAddPathArcI()

GpStatus WINGDIPAPI GdipAddPathArcI	(	GpPath *	path,
		INT	x1,
		INT	y1,
		INT	x2,
		INT	y2,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 234 of file graphicspath.c.

{
    TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
          path, x1, y1, x2, y2, startAngle, sweepAngle);
 
    return GdipAddPathArc(path,(REAL)x1,(REAL)y1,(REAL)x2,(REAL)y2,startAngle,sweepAngle);
}

◆ GdipAddPathBezier()

GpStatus WINGDIPAPI GdipAddPathBezier	(	GpPath *	path,
		REAL	x1,
		REAL	y1,
		REAL	x2,
		REAL	y2,
		REAL	x3,
		REAL	y3,
		REAL	x4,
		REAL	y4
	)

Definition at line 243 of file graphicspath.c.

{
    INT old_count;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
          path, x1, y1, x2, y2, x3, y3, x4, y4);
 
    if(!path)
        return InvalidParameter;
 
    if(!lengthen_path(path, 4))
        return OutOfMemory;
 
    old_count = path->pathdata.Count;
 
    path->pathdata.Points[old_count].X = x1;
    path->pathdata.Points[old_count].Y = y1;
    path->pathdata.Points[old_count + 1].X = x2;
    path->pathdata.Points[old_count + 1].Y = y2;
    path->pathdata.Points[old_count + 2].X = x3;
    path->pathdata.Points[old_count + 2].Y = y3;
    path->pathdata.Points[old_count + 3].X = x4;
    path->pathdata.Points[old_count + 3].Y = y4;
 
    path->pathdata.Types[old_count] =
        (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
    path->pathdata.Types[old_count + 1] = PathPointTypeBezier;
    path->pathdata.Types[old_count + 2] = PathPointTypeBezier;
    path->pathdata.Types[old_count + 3] = PathPointTypeBezier;
 
    path->newfigure = FALSE;
    path->pathdata.Count += 4;
 
    return Ok;
}

Referenced by GdipAddPathBezierI().

◆ GdipAddPathBezierI()

GpStatus WINGDIPAPI GdipAddPathBezierI	(	GpPath *	path,
		INT	x1,
		INT	y1,
		INT	x2,
		INT	y2,
		INT	x3,
		INT	y3,
		INT	x4,
		INT	y4
	)

Definition at line 280 of file graphicspath.c.

{
    TRACE("(%p, %d, %d, %d, %d, %d, %d, %d, %d)\n",
          path, x1, y1, x2, y2, x3, y3, x4, y4);
 
    return GdipAddPathBezier(path,(REAL)x1,(REAL)y1,(REAL)x2,(REAL)y2,(REAL)x3,(REAL)y3,
                                  (REAL)x4,(REAL)y4);
}

◆ GdipAddPathBeziers()

GpStatus WINGDIPAPI GdipAddPathBeziers	(	GpPath *	path,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 290 of file graphicspath.c.

{
    INT i, old_count;
 
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(!path || !points || ((count - 1) % 3))
        return InvalidParameter;
 
    if(!lengthen_path(path, count))
        return OutOfMemory;
 
    old_count = path->pathdata.Count;
 
    for(i = 0; i < count; i++){
        path->pathdata.Points[old_count + i].X = points[i].X;
        path->pathdata.Points[old_count + i].Y = points[i].Y;
        path->pathdata.Types[old_count + i] = PathPointTypeBezier;
    }
 
    path->pathdata.Types[old_count] =
        (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
    path->newfigure = FALSE;
    path->pathdata.Count += count;
 
    return Ok;
}

Referenced by GdipAddPathBeziersI(), GdipAddPathClosedCurve2(), GdipAddPathCurve2(), and GdipDrawBeziers().

◆ GdipAddPathBeziersI()

GpStatus WINGDIPAPI GdipAddPathBeziersI	(	GpPath *	path,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 319 of file graphicspath.c.

{
    GpPointF *ptsF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(!points || ((count - 1) % 3))
        return InvalidParameter;
 
    ptsF = heap_alloc_zero(sizeof(GpPointF) * count);
    if(!ptsF)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        ptsF[i].X = (REAL)points[i].X;
        ptsF[i].Y = (REAL)points[i].Y;
    }
 
    ret = GdipAddPathBeziers(path, ptsF, count);
    heap_free(ptsF);
 
    return ret;
}

◆ GdipAddPathClosedCurve()

GpStatus WINGDIPAPI GdipAddPathClosedCurve	(	GpPath *	path,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 346 of file graphicspath.c.

{
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    return GdipAddPathClosedCurve2(path, points, count, 1.0);
}

◆ GdipAddPathClosedCurve2()

GpStatus WINGDIPAPI GdipAddPathClosedCurve2	(	GpPath *	path,
		GDIPCONST GpPointF *	points,
		INT	count,
		REAL	tension
	)

Definition at line 362 of file graphicspath.c.

{
    INT i, len_pt = (count + 1)*3-2;
    GpPointF *pt;
    GpPointF *pts;
    REAL x1, x2, y1, y2;
    GpStatus stat;
 
    TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 
    if(!path || !points || count <= 1)
        return InvalidParameter;
 
    pt = heap_alloc_zero(len_pt * sizeof(GpPointF));
    pts = heap_alloc_zero((count + 1)*sizeof(GpPointF));
    if(!pt || !pts){
        heap_free(pt);
        heap_free(pts);
        return OutOfMemory;
    }
 
    /* copy source points to extend with the last one */
    memcpy(pts, points, sizeof(GpPointF)*count);
    pts[count] = pts[0];
 
    tension = tension * TENSION_CONST;
 
    for(i = 0; i < count-1; i++){
        calc_curve_bezier(&(pts[i]), tension, &x1, &y1, &x2, &y2);
 
        pt[3*i+2].X = x1;
        pt[3*i+2].Y = y1;
        pt[3*i+3].X = pts[i+1].X;
        pt[3*i+3].Y = pts[i+1].Y;
        pt[3*i+4].X = x2;
        pt[3*i+4].Y = y2;
    }
 
    /* points [len_pt-2] and [0] are calculated
       separately to connect splines properly */
    pts[0] = points[count-1];
    pts[1] = points[0]; /* equals to start and end of a resulting path */
    pts[2] = points[1];
 
    calc_curve_bezier(pts, tension, &x1, &y1, &x2, &y2);
    pt[len_pt-2].X = x1;
    pt[len_pt-2].Y = y1;
    pt[0].X = pts[1].X;
    pt[0].Y = pts[1].Y;
    pt[1].X = x2;
    pt[1].Y = y2;
    /* close path */
    pt[len_pt-1].X = pt[0].X;
    pt[len_pt-1].Y = pt[0].Y;
 
    stat = GdipAddPathBeziers(path, pt, len_pt);
 
    /* close figure */
    if(stat == Ok){
        path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
        path->newfigure = TRUE;
    }
 
    heap_free(pts);
    heap_free(pt);
 
    return stat;
}

Referenced by GdipAddPathClosedCurve(), GdipAddPathClosedCurve2I(), GdipDrawClosedCurve2(), GdipFillClosedCurve2(), and test_addclosedcurve().

◆ GdipAddPathClosedCurve2I()

GpStatus WINGDIPAPI GdipAddPathClosedCurve2I	(	GpPath *	path,
		GDIPCONST GpPoint *	points,
		INT	count,
		REAL	tension
	)

Definition at line 432 of file graphicspath.c.

{
    GpPointF *ptf;
    INT i;
    GpStatus stat;
 
    TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 
    if(!path || !points || count <= 1)
        return InvalidParameter;
 
    ptf = heap_alloc_zero(sizeof(GpPointF)*count);
    if(!ptf)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        ptf[i].X = (REAL)points[i].X;
        ptf[i].Y = (REAL)points[i].Y;
    }
 
    stat = GdipAddPathClosedCurve2(path, ptf, count, tension);
 
    heap_free(ptf);
 
    return stat;
}

Referenced by GdipAddPathClosedCurveI().

◆ GdipAddPathClosedCurveI()

GpStatus WINGDIPAPI GdipAddPathClosedCurveI	(	GpPath *	path,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 354 of file graphicspath.c.

{
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    return GdipAddPathClosedCurve2I(path, points, count, 1.0);
}

◆ GdipAddPathCurve()

GpStatus WINGDIPAPI GdipAddPathCurve	(	GpPath *	path,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 460 of file graphicspath.c.

{
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(!path || !points || count <= 1)
        return InvalidParameter;
 
    return GdipAddPathCurve2(path, points, count, 1.0);
}

◆ GdipAddPathCurve2()

GpStatus WINGDIPAPI GdipAddPathCurve2	(	GpPath *	path,
		GDIPCONST GpPointF *	points,
		INT	count,
		REAL	tension
	)

Definition at line 480 of file graphicspath.c.

{
    INT i, len_pt = count*3-2;
    GpPointF *pt;
    REAL x1, x2, y1, y2;
    GpStatus stat;
 
    TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 
    if(!path || !points || count <= 1)
        return InvalidParameter;
 
    pt = heap_alloc_zero(len_pt * sizeof(GpPointF));
    if(!pt)
        return OutOfMemory;
 
    tension = tension * TENSION_CONST;
 
    calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
        tension, &x1, &y1);
 
    pt[0].X = points[0].X;
    pt[0].Y = points[0].Y;
    pt[1].X = x1;
    pt[1].Y = y1;
 
    for(i = 0; i < count-2; i++){
        calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
 
        pt[3*i+2].X = x1;
        pt[3*i+2].Y = y1;
        pt[3*i+3].X = points[i+1].X;
        pt[3*i+3].Y = points[i+1].Y;
        pt[3*i+4].X = x2;
        pt[3*i+4].Y = y2;
    }
 
    calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
        points[count-2].X, points[count-2].Y, tension, &x1, &y1);
 
    pt[len_pt-2].X = x1;
    pt[len_pt-2].Y = y1;
    pt[len_pt-1].X = points[count-1].X;
    pt[len_pt-1].Y = points[count-1].Y;
 
    stat = GdipAddPathBeziers(path, pt, len_pt);
 
    heap_free(pt);
 
    return stat;
}

Referenced by GdipAddPathCurve(), GdipAddPathCurve2I(), GdipAddPathCurve3(), GdipDrawCurve2(), and test_addcurve().

◆ GdipAddPathCurve2I()

GpStatus WINGDIPAPI GdipAddPathCurve2I	(	GpPath *	path,
		GDIPCONST GpPoint *	points,
		INT	count,
		REAL	tension
	)

Definition at line 533 of file graphicspath.c.

{
    GpPointF *ptf;
    INT i;
    GpStatus stat;
 
    TRACE("(%p, %p, %d, %.2f)\n", path, points, count, tension);
 
    if(!path || !points || count <= 1)
        return InvalidParameter;
 
    ptf = heap_alloc_zero(sizeof(GpPointF)*count);
    if(!ptf)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        ptf[i].X = (REAL)points[i].X;
        ptf[i].Y = (REAL)points[i].Y;
    }
 
    stat = GdipAddPathCurve2(path, ptf, count, tension);
 
    heap_free(ptf);
 
    return stat;
}

Referenced by GdipAddPathCurve3I(), and GdipAddPathCurveI().

◆ GdipAddPathCurve3()

GpStatus WINGDIPAPI GdipAddPathCurve3	(	GpPath *	path,
		GDIPCONST GpPointF *	points,
		INT	count,
		INT	offset,
		INT	nseg,
		REAL	tension
	)

Definition at line 561 of file graphicspath.c.

{
    TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path, points, count, offset, nseg, tension);
 
    if(!path || !points || offset + 1 >= count || count - offset < nseg + 1)
        return InvalidParameter;
 
    return GdipAddPathCurve2(path, &points[offset], nseg + 1, tension);
}

Referenced by test_addcurve().

◆ GdipAddPathCurve3I()

GpStatus WINGDIPAPI GdipAddPathCurve3I	(	GpPath *	path,
		GDIPCONST GpPoint *	points,
		INT	count,
		INT	offset,
		INT	nseg,
		REAL	tension
	)

Definition at line 572 of file graphicspath.c.

{
    TRACE("(%p, %p, %d, %d, %d, %.2f)\n", path, points, count, offset, nseg, tension);
 
    if(!path || !points || offset + 1 >= count || count - offset < nseg + 1)
        return InvalidParameter;
 
    return GdipAddPathCurve2I(path, &points[offset], nseg + 1, tension);
}

◆ GdipAddPathCurveI()

GpStatus WINGDIPAPI GdipAddPathCurveI	(	GpPath *	path,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 470 of file graphicspath.c.

{
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(!path || !points || count <= 1)
        return InvalidParameter;
 
    return GdipAddPathCurve2I(path, points, count, 1.0);
}

◆ GdipAddPathEllipse()

GpStatus WINGDIPAPI GdipAddPathEllipse	(	GpPath *	path,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height
	)

Definition at line 583 of file graphicspath.c.

{
    INT old_count, numpts;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
 
    if(!path)
        return InvalidParameter;
 
    if(!lengthen_path(path, MAX_ARC_PTS))
        return OutOfMemory;
 
    old_count = path->pathdata.Count;
    if((numpts = arc2polybezier(&path->pathdata.Points[old_count],  x, y, width,
                               height, 0.0, 360.0)) != MAX_ARC_PTS){
        ERR("expected %d points but got %d\n", MAX_ARC_PTS, numpts);
        return GenericError;
    }
 
    memset(&path->pathdata.Types[old_count + 1], PathPointTypeBezier,
           MAX_ARC_PTS - 1);
 
    /* An ellipse is an intrinsic figure (always is its own subpath). */
    path->pathdata.Types[old_count] = PathPointTypeStart;
    path->pathdata.Types[old_count + MAX_ARC_PTS - 1] |= PathPointTypeCloseSubpath;
    path->newfigure = TRUE;
    path->pathdata.Count += MAX_ARC_PTS;
 
    return Ok;
}

Referenced by GdipAddPathEllipseI(), GdipDrawEllipse(), GdipFillEllipse(), test_combinereplace(), test_ellipse(), test_flatten(), test_hascurve(), test_isvisiblepoint(), test_isvisiblerect(), test_nextpathtype(), test_transform(), and test_translate().

◆ GdipAddPathEllipseI()

GpStatus WINGDIPAPI GdipAddPathEllipseI	(	GpPath *	path,
		INT	x,
		INT	y,
		INT	width,
		INT	height
	)

Definition at line 615 of file graphicspath.c.

{
    TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
 
    return GdipAddPathEllipse(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
}

◆ GdipAddPathLine()

GpStatus WINGDIPAPI GdipAddPathLine	(	GpPath *	path,
		REAL	x1,
		REAL	y1,
		REAL	x2,
		REAL	y2
	)

Definition at line 704 of file graphicspath.c.

{
    INT old_count;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x1, y1, x2, y2);
 
    if(!path)
        return InvalidParameter;
 
    if(!lengthen_path(path, 2))
        return OutOfMemory;
 
    old_count = path->pathdata.Count;
 
    path->pathdata.Points[old_count].X = x1;
    path->pathdata.Points[old_count].Y = y1;
    path->pathdata.Points[old_count + 1].X = x2;
    path->pathdata.Points[old_count + 1].Y = y2;
 
    path->pathdata.Types[old_count] =
        (path->newfigure ? PathPointTypeStart : PathPointTypeLine);
    path->pathdata.Types[old_count + 1] = PathPointTypeLine;
 
    path->newfigure = FALSE;
    path->pathdata.Count += 2;
 
    return Ok;
}

Referenced by GdipAddPathLineI(), GdipAddPathPie(), GdipAddPathRectangle(), test_addcurve(), test_drawpath(), test_fillpath(), test_flatten(), test_getpathdata(), test_getregiondata(), test_getsubpathcount(), test_isvalid(), test_nextmarker(), test_nextmarkerpath(), test_nextpathtype(), test_nextsubpathpath(), test_pen_thickness(), test_polygon(), and test_widen().

◆ GdipAddPathLine2()

GpStatus WINGDIPAPI GdipAddPathLine2	(	GpPath *	path,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 623 of file graphicspath.c.

{
    INT i, old_count;
 
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(!path || !points)
        return InvalidParameter;
 
    if(!lengthen_path(path, count))
        return OutOfMemory;
 
    old_count = path->pathdata.Count;
 
    for(i = 0; i < count; i++){
        path->pathdata.Points[old_count + i].X = points[i].X;
        path->pathdata.Points[old_count + i].Y = points[i].Y;
        path->pathdata.Types[old_count + i] = PathPointTypeLine;
    }
 
    if(path->newfigure){
        path->pathdata.Types[old_count] = PathPointTypeStart;
        path->newfigure = FALSE;
    }
 
    path->pathdata.Count += count;
 
    return Ok;
}

Referenced by GdipAddPathLine2I(), GdipAddPathRectangle(), GdipCreatePathGradient(), GdipDrawLines(), test_ellipse(), test_line2(), test_reverse(), and test_worldbounds().

◆ GdipAddPathLine2I()

GpStatus WINGDIPAPI GdipAddPathLine2I	(	GpPath *	path,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 654 of file graphicspath.c.

{
    GpPointF *pointsF;
    INT i;
    GpStatus stat;
 
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(count <= 0)
        return InvalidParameter;
 
    pointsF = heap_alloc_zero(sizeof(GpPointF) * count);
    if(!pointsF)    return OutOfMemory;
 
    for(i = 0;i < count; i++){
        pointsF[i].X = (REAL)points[i].X;
        pointsF[i].Y = (REAL)points[i].Y;
    }
 
    stat = GdipAddPathLine2(path, pointsF, count);
 
    heap_free(pointsF);
 
    return stat;
}

Referenced by GdipCreatePathGradientI().

◆ GdipAddPathLineI()

GpStatus WINGDIPAPI GdipAddPathLineI	(	GpPath *	path,
		INT	x1,
		INT	y1,
		INT	x2,
		INT	y2
	)

Definition at line 738 of file graphicspath.c.

{
    TRACE("(%p, %d, %d, %d, %d)\n", path, x1, y1, x2, y2);
 
    return GdipAddPathLine(path, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2);
}

Referenced by test_GdipFillPath(), and test_linei().

◆ GdipAddPathPath()

GpStatus WINGDIPAPI GdipAddPathPath	(	GpPath *	path,
		GDIPCONST GpPath *	addingPath,
		BOOL	connect
	)

Definition at line 745 of file graphicspath.c.

{
    INT old_count, count;
 
    TRACE("(%p, %p, %d)\n", path, addingPath, connect);
 
    if(!path || !addingPath)
        return InvalidParameter;
 
    old_count = path->pathdata.Count;
    count = addingPath->pathdata.Count;
 
    if(!lengthen_path(path, count))
        return OutOfMemory;
 
    memcpy(&path->pathdata.Points[old_count], addingPath->pathdata.Points,
           count * sizeof(GpPointF));
    memcpy(&path->pathdata.Types[old_count], addingPath->pathdata.Types, count);
 
    if(path->newfigure || !connect)
        path->pathdata.Types[old_count] = PathPointTypeStart;
    else
        path->pathdata.Types[old_count] = PathPointTypeLine;
 
    path->newfigure = FALSE;
    path->pathdata.Count += count;
 
    return Ok;
}

Referenced by test_pathpath().

◆ GdipAddPathPie()

GpStatus WINGDIPAPI GdipAddPathPie	(	GpPath *	path,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 776 of file graphicspath.c.

{
    GpPointF *ptf;
    GpStatus status;
    INT i, count;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
          path, x, y, width, height, startAngle, sweepAngle);
 
    if(!path)
        return InvalidParameter;
 
    /* on zero width/height only start point added */
    if(width <= 1e-7 || height <= 1e-7){
        if(!lengthen_path(path, 1))
            return OutOfMemory;
        path->pathdata.Points[0].X = x + width  / 2.0;
        path->pathdata.Points[0].Y = y + height / 2.0;
        path->pathdata.Types[0] = PathPointTypeStart | PathPointTypeCloseSubpath;
        path->pathdata.Count = 1;
        return InvalidParameter;
    }
 
    count = arc2polybezier(NULL, x, y, width, height, startAngle, sweepAngle);
 
    if(count == 0)
        return Ok;
 
    ptf = heap_alloc_zero(sizeof(GpPointF)*count);
    if(!ptf)
        return OutOfMemory;
 
    arc2polybezier(ptf, x, y, width, height, startAngle, sweepAngle);
 
    status = GdipAddPathLine(path, x + width/2, y + height/2, ptf[0].X, ptf[0].Y);
    if(status != Ok){
        heap_free(ptf);
        return status;
    }
    /* one spline is already added as a line endpoint */
    if(!lengthen_path(path, count - 1)){
        heap_free(ptf);
        return OutOfMemory;
    }
 
    memcpy(&(path->pathdata.Points[path->pathdata.Count]), &(ptf[1]),sizeof(GpPointF)*(count-1));
    for(i = 0; i < count-1; i++)
        path->pathdata.Types[path->pathdata.Count+i] = PathPointTypeBezier;
 
    path->pathdata.Count += count-1;
 
    GdipClosePathFigure(path);
 
    heap_free(ptf);
 
    return status;
}

Referenced by GdipAddPathPieI(), GdipDrawPie(), GdipFillPie(), and test_addpie().

◆ GdipAddPathPieI()

GpStatus WINGDIPAPI GdipAddPathPieI	(	GpPath *	path,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 835 of file graphicspath.c.

{
    TRACE("(%p, %d, %d, %d, %d, %.2f, %.2f)\n",
          path, x, y, width, height, startAngle, sweepAngle);
 
    return GdipAddPathPie(path, (REAL)x, (REAL)y, (REAL)width, (REAL)height, startAngle, sweepAngle);
}

◆ GdipAddPathPolygon()

GpStatus WINGDIPAPI GdipAddPathPolygon	(	GpPath *	path,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 844 of file graphicspath.c.

{
    INT old_count;
 
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(!path || !points || count < 3)
        return InvalidParameter;
 
    if(!lengthen_path(path, count))
        return OutOfMemory;
 
    old_count = path->pathdata.Count;
 
    memcpy(&path->pathdata.Points[old_count], points, count*sizeof(GpPointF));
    memset(&path->pathdata.Types[old_count + 1], PathPointTypeLine, count - 1);
 
    /* A polygon is an intrinsic figure */
    path->pathdata.Types[old_count] = PathPointTypeStart;
    path->pathdata.Types[old_count + count - 1] |= PathPointTypeCloseSubpath;
    path->newfigure = TRUE;
    path->pathdata.Count += count;
 
    return Ok;
}

Referenced by GdipAddPathPolygonI(), GdipDrawPolygon(), GdipEnumerateMetafileSrcRectDestPoints(), GdipFillPolygon(), and test_polygon().

◆ GdipAddPathPolygonI()

GpStatus WINGDIPAPI GdipAddPathPolygonI	(	GpPath *	path,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 870 of file graphicspath.c.

{
    GpPointF *ptf;
    GpStatus status;
    INT i;
 
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(!points || count < 3)
        return InvalidParameter;
 
    ptf = heap_alloc_zero(sizeof(GpPointF) * count);
    if(!ptf)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        ptf[i].X = (REAL)points[i].X;
        ptf[i].Y = (REAL)points[i].Y;
    }
 
    status = GdipAddPathPolygon(path, ptf, count);
 
    heap_free(ptf);
 
    return status;
}

Referenced by GdipFillPolygonI().

◆ GdipAddPathRectangle()

GpStatus WINGDIPAPI GdipAddPathRectangle	(	GpPath *	path,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height
	)

Definition at line 2296 of file graphicspath.c.

{
    GpPath *backup;
    GpPointF ptf[2];
    GpStatus retstat;
    BOOL old_new;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f)\n", path, x, y, width, height);
 
    if(!path)
        return InvalidParameter;
 
    if (width <= 0.0 || height <= 0.0)
        return Ok;
 
    /* make a backup copy of path data */
    if((retstat = GdipClonePath(path, &backup)) != Ok)
        return retstat;
 
    /* rectangle should start as new path */
    old_new = path->newfigure;
    path->newfigure = TRUE;
    if((retstat = GdipAddPathLine(path,x,y,x+width,y)) != Ok){
        path->newfigure = old_new;
        goto fail;
    }
 
    ptf[0].X = x+width;
    ptf[0].Y = y+height;
    ptf[1].X = x;
    ptf[1].Y = y+height;
 
    if((retstat = GdipAddPathLine2(path, ptf, 2)) != Ok)  goto fail;
    path->pathdata.Types[path->pathdata.Count-1] |= PathPointTypeCloseSubpath;
 
    /* free backup */
    GdipDeletePath(backup);
    return Ok;
 
fail:
    /* reverting */
    heap_free(path->pathdata.Points);
    heap_free(path->pathdata.Types);
    memcpy(path, backup, sizeof(*path));
    heap_free(backup);
 
    return retstat;
}

Referenced by GdipAddPathRectangleI(), GdipAddPathRectangles(), GdipCreateRegionHrgn(), GdipDrawRectangle(), get_region_hrgn(), test_captype(), test_constructor_destructor(), test_empty_rect(), test_GdipFillPath(), test_gethrgn(), test_getregiondata(), test_hascurve(), test_inset(), test_isvisible(), test_lastpoint(), test_linejoin(), test_nextmarker(), test_nextmarkerpath(), test_rect(), test_scale(), and transform_region_element().

◆ GdipAddPathRectangleI()

GpStatus WINGDIPAPI GdipAddPathRectangleI	(	GpPath *	path,
		INT	x,
		INT	y,
		INT	width,
		INT	height
	)

Definition at line 2346 of file graphicspath.c.

{
    TRACE("(%p, %d, %d, %d, %d)\n", path, x, y, width, height);
 
    return GdipAddPathRectangle(path,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
}

Referenced by test_getregiondata().

◆ GdipAddPathRectangles()

GpStatus WINGDIPAPI GdipAddPathRectangles	(	GpPath *	path,
		GDIPCONST GpRectF *	rects,
		INT	count
	)

Definition at line 2354 of file graphicspath.c.

{
    GpPath *backup;
    GpStatus retstat;
    INT i;
 
    TRACE("(%p, %p, %d)\n", path, rects, count);
 
    /* count == 0 - verified condition  */
    if(!path || !rects || count == 0)
        return InvalidParameter;
 
    if(count < 0)
        return OutOfMemory;
 
    /* make a backup copy */
    if((retstat = GdipClonePath(path, &backup)) != Ok)
        return retstat;
 
    for(i = 0; i < count; i++){
        if((retstat = GdipAddPathRectangle(path,rects[i].X,rects[i].Y,rects[i].Width,rects[i].Height)) != Ok)
            goto fail;
    }
 
    /* free backup */
    GdipDeletePath(backup);
    return Ok;
 
fail:
    /* reverting */
    heap_free(path->pathdata.Points);
    heap_free(path->pathdata.Types);
    memcpy(path, backup, sizeof(*path));
    heap_free(backup);
 
    return retstat;
}

Referenced by GdipAddPathRectanglesI(), GdipDrawRectangles(), GdipFillRectangles(), and test_rect().

◆ GdipAddPathRectanglesI()

GpStatus WINGDIPAPI GdipAddPathRectanglesI	(	GpPath *	path,
		GDIPCONST GpRect *	rects,
		INT	count
	)

Definition at line 2392 of file graphicspath.c.

{
    GpRectF *rectsF;
    GpStatus retstat;
    INT i;
 
    TRACE("(%p, %p, %d)\n", path, rects, count);
 
    if(!rects || count == 0)
        return InvalidParameter;
 
    if(count < 0)
        return OutOfMemory;
 
    rectsF = heap_alloc_zero(sizeof(GpRectF)*count);
 
    for(i = 0;i < count;i++){
        rectsF[i].X      = (REAL)rects[i].X;
        rectsF[i].Y      = (REAL)rects[i].Y;
        rectsF[i].Width  = (REAL)rects[i].Width;
        rectsF[i].Height = (REAL)rects[i].Height;
    }
 
    retstat = GdipAddPathRectangles(path, rectsF, count);
    heap_free(rectsF);
 
    return retstat;
}

◆ GdipAddPathString()

GpStatus WINGDIPAPI GdipAddPathString	(	GpPath *	path,
		GDIPCONST WCHAR *	string,
		INT	length,
		GDIPCONST GpFontFamily *	family,
		INT	style,
		REAL	emSize,
		GDIPCONST RectF *	layoutRect,
		GDIPCONST GpStringFormat *	format
	)

Definition at line 1007 of file graphicspath.c.

{
    GpFont *font;
    GpStatus status;
    LOGFONTW lfw;
    HANDLE hfont;
    HDC dc;
    GpGraphics *graphics;
    GpPath *backup;
    struct format_string_args args;
    int i;
    UINT16 native_height;
    RectF scaled_layout_rect;
    TEXTMETRICW textmetric;
 
    TRACE("(%p, %s, %d, %p, %d, %f, %p, %p)\n", path, debugstr_w(string), length, family, style, emSize, layoutRect, format);
    if (!path || !string || !family || !emSize || !layoutRect || !format)
        return InvalidParameter;
 
    status = GdipGetEmHeight(family, style, &native_height);
    if (status != Ok)
        return status;
 
    scaled_layout_rect.X = layoutRect->X;
    scaled_layout_rect.Y = layoutRect->Y;
    scaled_layout_rect.Width = layoutRect->Width * native_height / emSize;
    scaled_layout_rect.Height = layoutRect->Height * native_height / emSize;
 
    if ((status = GdipClonePath(path, &backup)) != Ok)
        return status;
 
    dc = CreateCompatibleDC(0);
    status = GdipCreateFromHDC(dc, &graphics);
    if (status != Ok)
    {
        DeleteDC(dc);
        GdipDeletePath(backup);
        return status;
    }
 
    status = GdipCreateFont(family, native_height, style, UnitPixel, &font);
    if (status != Ok)
    {
        GdipDeleteGraphics(graphics);
        DeleteDC(dc);
        GdipDeletePath(backup);
        return status;
    }
 
    get_log_fontW(font, graphics, &lfw);
    GdipDeleteFont(font);
    GdipDeleteGraphics(graphics);
 
    hfont = CreateFontIndirectW(&lfw);
    if (!hfont)
    {
        WARN("Failed to create font\n");
        DeleteDC(dc);
        GdipDeletePath(backup);
        return GenericError;
    }
 
    SelectObject(dc, hfont);
 
    GetTextMetricsW(dc, &textmetric);
 
    args.path = path;
    args.maxY = 0;
    args.scale = emSize / native_height;
    args.ascent = textmetric.tmAscent * args.scale;
    status = gdip_format_string(dc, string, length, NULL, &scaled_layout_rect,
                                format, TRUE, format_string_callback, &args);
 
    DeleteDC(dc);
    DeleteObject(hfont);
 
    if (status != Ok) /* free backup */
    {
        heap_free(path->pathdata.Points);
        heap_free(path->pathdata.Types);
        *path = *backup;
        heap_free(backup);
        return status;
    }
    if (format && format->line_align == StringAlignmentCenter && layoutRect->Y + args.maxY < layoutRect->Height)
    {
        float inc = layoutRect->Height + layoutRect->Y - args.maxY;
        inc /= 2;
        for (i = backup->pathdata.Count; i < path->pathdata.Count; ++i)
            path->pathdata.Points[i].Y += inc;
    } else if (format && format->line_align == StringAlignmentFar) {
        float inc = layoutRect->Height + layoutRect->Y - args.maxY;
        for (i = backup->pathdata.Count; i < path->pathdata.Count; ++i)
            path->pathdata.Points[i].Y += inc;
    }
    GdipDeletePath(backup);
    return status;
}

Referenced by GdipAddPathStringI().

◆ GdipAddPathStringI()

GpStatus WINGDIPAPI GdipAddPathStringI	(	GpPath *	path,
		GDIPCONST WCHAR *	string,
		INT	length,
		GDIPCONST GpFontFamily *	family,
		INT	style,
		REAL	emSize,
		GDIPCONST Rect *	layoutRect,
		GDIPCONST GpStringFormat *	format
	)

Definition at line 1106 of file graphicspath.c.

{
    if (layoutRect)
    {
        RectF layoutRectF = {
            (REAL)layoutRect->X,
            (REAL)layoutRect->Y,
            (REAL)layoutRect->Width,
            (REAL)layoutRect->Height
        };
        return GdipAddPathString(path, string, length, family, style, emSize, &layoutRectF, format);
    }
    return InvalidParameter;
}

◆ GdipBeginContainer()

GpStatus WINGDIPAPI GdipBeginContainer	(	GpGraphics *	graphics,
		GDIPCONST GpRectF *	dstrect,
		GDIPCONST GpRectF *	srcrect,
		GpUnit	unit,
		GraphicsContainer *	state
	)

Definition at line 5924 of file graphics.c.

{
    GraphicsContainerItem *container;
    GpMatrix transform;
    GpStatus stat;
    GpRectF scaled_srcrect;
    REAL scale_x, scale_y;
 
    TRACE("(%p, %s, %s, %d, %p)\n", graphics, debugstr_rectf(dstrect), debugstr_rectf(srcrect), unit, state);
 
    if(!graphics || !dstrect || !srcrect || unit < UnitPixel || unit > UnitMillimeter || !state)
        return InvalidParameter;
 
    stat = init_container(&container, graphics, BEGIN_CONTAINER);
    if(stat != Ok)
        return stat;
 
    list_add_head(&graphics->containers, &container->entry);
    *state = graphics->contid = container->contid;
 
    scale_x = units_to_pixels(1.0, unit, graphics->xres);
    scale_y = units_to_pixels(1.0, unit, graphics->yres);
 
    scaled_srcrect.X = scale_x * srcrect->X;
    scaled_srcrect.Y = scale_y * srcrect->Y;
    scaled_srcrect.Width = scale_x * srcrect->Width;
    scaled_srcrect.Height = scale_y * srcrect->Height;
 
    transform.matrix[0] = dstrect->Width / scaled_srcrect.Width;
    transform.matrix[1] = 0.0;
    transform.matrix[2] = 0.0;
    transform.matrix[3] = dstrect->Height / scaled_srcrect.Height;
    transform.matrix[4] = dstrect->X - scaled_srcrect.X;
    transform.matrix[5] = dstrect->Y - scaled_srcrect.Y;
 
    GdipMultiplyMatrix(&graphics->worldtrans, &transform, MatrixOrderPrepend);
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile) {
        METAFILE_BeginContainer((GpMetafile*)graphics->image, dstrect, srcrect, unit, container->contid);
    }
 
    return Ok;
}

Referenced by GdipBeginContainerI(), test_container_rects(), and test_containers().

◆ GdipBeginContainer2()

GpStatus WINGDIPAPI GdipBeginContainer2	(	GpGraphics *	graphics,
		GraphicsContainer *	state
	)

Definition at line 5917 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, state);
    return begin_container(graphics, BEGIN_CONTAINER, state);
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), GdipPlayMetafileRecord(), test_BeginContainer2(), test_containers(), and test_save_restore().

◆ GdipBeginContainerI()

GpStatus WINGDIPAPI GdipBeginContainerI	(	GpGraphics *	graphics,
		GDIPCONST GpRect *	dstrect,
		GDIPCONST GpRect *	srcrect,
		GpUnit	unit,
		GraphicsContainer *	state
	)

Definition at line 5968 of file graphics.c.

{
    GpRectF dstrectf, srcrectf;
 
    TRACE("(%p, %p, %p, %d, %p)\n", graphics, dstrect, srcrect, unit, state);
 
    if (!dstrect || !srcrect)
        return InvalidParameter;
 
    dstrectf.X = dstrect->X;
    dstrectf.Y = dstrect->Y;
    dstrectf.Width = dstrect->Width;
    dstrectf.Height = dstrect->Height;
 
    srcrectf.X = srcrect->X;
    srcrectf.Y = srcrect->Y;
    srcrectf.Width = srcrect->Width;
    srcrectf.Height = srcrect->Height;
 
    return GdipBeginContainer(graphics, &dstrectf, &srcrectf, unit, state);
}

◆ GdipBitmapApplyEffect()

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

Definition at line 134 of file image.c.

{
    FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
    /*
     * Note: According to Jose Roca's GDI+ docs, this function is not
     * implemented in Windows's GDI+.
     */
    return NotImplemented;
}

◆ GdipBitmapCreateApplyEffect()

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

Definition at line 145 of file image.c.

{
    FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
    /*
     * Note: According to Jose Roca's GDI+ docs, this function is not
     * implemented in Windows's GDI+.
     */
    return NotImplemented;
}

◆ GdipBitmapGetHistogram()

GpStatus WINGDIPAPI GdipBitmapGetHistogram	(	GpBitmap *	bitmap,
		HistogramFormat	format,
		UINT	num_of_entries,
		UINT *	ch0,
		UINT *	ch1,
		UINT *	ch2,
		UINT *	ch3
	)

Definition at line 5609 of file image.c.

{
    static void (* const set_histogram_point[])(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3) =
    {
        set_histogram_point_argb,
        set_histogram_point_pargb,
        set_histogram_point_rgb,
        set_histogram_point_gray,
        set_histogram_point_b,
        set_histogram_point_g,
        set_histogram_point_r,
        set_histogram_point_a,
    };
    UINT width, height, x, y;
 
    TRACE("(%p, %d, %u, %p, %p, %p, %p)\n", bitmap, format, num_of_entries,
        ch0, ch1, ch2, ch3);
 
    if (!bitmap || num_of_entries != 256)
        return InvalidParameter;
 
    /* Make sure passed channel pointers match requested format */
    switch (format)
    {
    case HistogramFormatARGB:
    case HistogramFormatPARGB:
        if (!ch0 || !ch1 || !ch2 || !ch3)
            return InvalidParameter;
        memset(ch0, 0, num_of_entries * sizeof(UINT));
        memset(ch1, 0, num_of_entries * sizeof(UINT));
        memset(ch2, 0, num_of_entries * sizeof(UINT));
        memset(ch3, 0, num_of_entries * sizeof(UINT));
        break;
    case HistogramFormatRGB:
        if (!ch0 || !ch1 || !ch2 || ch3)
            return InvalidParameter;
        memset(ch0, 0, num_of_entries * sizeof(UINT));
        memset(ch1, 0, num_of_entries * sizeof(UINT));
        memset(ch2, 0, num_of_entries * sizeof(UINT));
        break;
    case HistogramFormatGray:
    case HistogramFormatB:
    case HistogramFormatG:
    case HistogramFormatR:
    case HistogramFormatA:
        if (!ch0 || ch1 || ch2 || ch3)
            return InvalidParameter;
        memset(ch0, 0, num_of_entries * sizeof(UINT));
        break;
    default:
        WARN("Invalid histogram format requested, %d\n", format);
        return InvalidParameter;
    }
 
    GdipGetImageWidth(&bitmap->image, &width);
    GdipGetImageHeight(&bitmap->image, &height);
 
    for (y = 0; y < height; y++)
        for (x = 0; x < width; x++)
        {
            ARGB color;
 
            GdipBitmapGetPixel(bitmap, x, y, &color);
            set_histogram_point[format](color, ch0, ch1, ch2, ch3);
        }
 
    return Ok;
}

◆ GdipBitmapGetHistogramSize()

GpStatus WINGDIPAPI GdipBitmapGetHistogramSize	(	HistogramFormat	format,
		UINT *	num_of_entries
	)

Definition at line 5682 of file image.c.

{
    TRACE("(%d, %p)\n", format, num_of_entries);
 
    if (!num_of_entries)
        return InvalidParameter;
 
    *num_of_entries = 256;
    return Ok;
}

◆ GdipBitmapGetPixel()

GpStatus WINGDIPAPI GdipBitmapGetPixel	(	GpBitmap *	bitmap,
		INT	x,
		INT	y,
		ARGB *	color
	)

Definition at line 288 of file image.c.

{
    BYTE r, g, b, a;
    BYTE index;
    BYTE *row;
 
    if(!bitmap || !color ||
       x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
        return InvalidParameter;
 
    row = bitmap->bits+bitmap->stride*y;
 
    switch (bitmap->format)
    {
        case PixelFormat1bppIndexed:
            getpixel_1bppIndexed(&index,row,x);
            break;
        case PixelFormat4bppIndexed:
            getpixel_4bppIndexed(&index,row,x);
            break;
        case PixelFormat8bppIndexed:
            getpixel_8bppIndexed(&index,row,x);
            break;
        case PixelFormat16bppGrayScale:
            getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat16bppRGB555:
            getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat16bppRGB565:
            getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat16bppARGB1555:
            getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat24bppRGB:
            getpixel_24bppRGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat32bppRGB:
            getpixel_32bppRGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat32bppARGB:
            getpixel_32bppARGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat32bppPARGB:
            getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat48bppRGB:
            getpixel_48bppRGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat64bppARGB:
            getpixel_64bppARGB(&r,&g,&b,&a,row,x);
            break;
        case PixelFormat64bppPARGB:
            getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
            break;
        default:
            FIXME("not implemented for format 0x%x\n", bitmap->format);
            return NotImplemented;
    }
 
    if (bitmap->format & PixelFormatIndexed)
        *color = bitmap->image.palette->Entries[index];
    else
        *color = a<<24|r<<16|g<<8|b;
 
    return Ok;
}

Referenced by alpha_blend_bmp_pixels(), GdipBitmapGetHistogram(), test_clear(), test_clipping(), test_colorkey(), test_colormatrix(), test_containers(), test_emfonly(), test_fillrect(), test_gamma(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipImageGetFrameDimensionsCount(), test_gditransform(), test_getdc(), test_getdc_scaled(), test_getsetpixel(), test_LockBits(), test_LockBits_UserBuf(), test_multiframegif(), test_pagetransform(), test_palette(), test_remaptable(), test_rotateflip(), and test_worldtransform().

◆ GdipBitmapLockBits()

GpStatus WINGDIPAPI GdipBitmapLockBits	(	GpBitmap *	bitmap,
		GDIPCONST GpRect *	rect,
		UINT	flags,
		PixelFormat	format,
		BitmapData *	lockeddata
	)

Definition at line 1030 of file image.c.

{
    INT bitspp = PIXELFORMATBPP(format);
    GpRect act_rect; /* actual rect to be used */
    GpStatus stat;
    BOOL unlock;
 
    TRACE("%p %p %d 0x%x %p\n", bitmap, rect, flags, format, lockeddata);
 
    if(!lockeddata || !bitmap)
        return InvalidParameter;
    if(!image_lock(&bitmap->image, &unlock))
        return ObjectBusy;
 
    if(rect){
        if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
          (rect->Y + rect->Height > bitmap->height) || !flags)
        {
            image_unlock(&bitmap->image, unlock);
            return InvalidParameter;
        }
 
        act_rect = *rect;
    }
    else{
        act_rect.X = act_rect.Y = 0;
        act_rect.Width  = bitmap->width;
        act_rect.Height = bitmap->height;
    }
 
    if(bitmap->lockmode)
    {
        WARN("bitmap is already locked and cannot be locked again\n");
        image_unlock(&bitmap->image, unlock);
        return WrongState;
    }
 
    if (bitmap->bits && bitmap->format == format && !(flags & ImageLockModeUserInputBuf))
    {
        /* no conversion is necessary; just use the bits directly */
        lockeddata->Width = act_rect.Width;
        lockeddata->Height = act_rect.Height;
        lockeddata->PixelFormat = format;
        lockeddata->Reserved = flags;
        lockeddata->Stride = bitmap->stride;
        lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
                            bitmap->stride * act_rect.Y;
 
        bitmap->lockmode = flags | ImageLockModeRead;
 
        image_unlock(&bitmap->image, unlock);
        return Ok;
    }
 
    /* Make sure we can convert to the requested format. */
    if (flags & ImageLockModeRead)
    {
        stat = convert_pixels(0, 0, 0, NULL, format, 0, NULL, bitmap->format, NULL);
        if (stat == NotImplemented)
        {
            FIXME("cannot read bitmap from %x to %x\n", bitmap->format, format);
            image_unlock(&bitmap->image, unlock);
            return NotImplemented;
        }
    }
 
    /* If we're opening for writing, make sure we'll be able to write back in
     * the original format. */
    if (flags & ImageLockModeWrite)
    {
        stat = convert_pixels(0, 0, 0, NULL, bitmap->format, 0, NULL, format, NULL);
        if (stat == NotImplemented)
        {
            FIXME("cannot write bitmap from %x to %x\n", format, bitmap->format);
            image_unlock(&bitmap->image, unlock);
            return NotImplemented;
        }
    }
 
    lockeddata->Width  = act_rect.Width;
    lockeddata->Height = act_rect.Height;
    lockeddata->PixelFormat = format;
    lockeddata->Reserved = flags;
 
    if(!(flags & ImageLockModeUserInputBuf))
    {
        lockeddata->Stride = (((act_rect.Width * bitspp + 7) / 8) + 3) & ~3;
 
        bitmap->bitmapbits = heap_alloc_zero(lockeddata->Stride * act_rect.Height);
 
        if (!bitmap->bitmapbits)
        {
            image_unlock(&bitmap->image, unlock);
            return OutOfMemory;
        }
 
        lockeddata->Scan0  = bitmap->bitmapbits;
    }
 
    if (flags & ImageLockModeRead)
    {
        static BOOL fixme = FALSE;
 
        if (!fixme && (PIXELFORMATBPP(bitmap->format) * act_rect.X) % 8 != 0)
        {
            FIXME("Cannot copy rows that don't start at a whole byte.\n");
            fixme = TRUE;
        }
 
        stat = convert_pixels(act_rect.Width, act_rect.Height,
            lockeddata->Stride, lockeddata->Scan0, format,
            bitmap->stride,
            bitmap->bits + bitmap->stride * act_rect.Y + PIXELFORMATBPP(bitmap->format) * act_rect.X / 8,
            bitmap->format, bitmap->image.palette);
 
        if (stat != Ok)
        {
            heap_free(bitmap->bitmapbits);
            bitmap->bitmapbits = NULL;
            image_unlock(&bitmap->image, unlock);
            return stat;
        }
    }
 
    bitmap->lockmode = flags | ImageLockModeRead;
    bitmap->lockx = act_rect.X;
    bitmap->locky = act_rect.Y;
 
    image_unlock(&bitmap->image, unlock);
    return Ok;
}

Referenced by brush_fill_pixels(), create_optimal_palette(), decode_frame_wic(), DibLoadImage(), encode_image_wic(), GdipCreateBitmapFromHBITMAP(), GdipCreateBitmapFromHICON(), GdipCreateHICONFromBitmap(), GdipDrawImagePointsRect(), GdipImageRotateFlip(), test_ARGB_conversion(), test_bitmapbits(), test_CloneBitmapArea(), test_createhbitmap(), test_image_format(), test_LockBits(), test_LockBits_UserBuf(), and test_pen_thickness().

◆ GdipBitmapSetPixel()

GpStatus WINGDIPAPI GdipBitmapSetPixel	(	GpBitmap *	bitmap,
		INT	x,
		INT	y,
		ARGB	color
	)

Definition at line 494 of file image.c.

{
    BYTE a, r, g, b;
    BYTE *row;
 
    if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
        return InvalidParameter;
 
    a = color>>24;
    r = color>>16;
    g = color>>8;
    b = color;
 
    row = bitmap->bits + bitmap->stride * y;
 
    switch (bitmap->format)
    {
        case PixelFormat16bppGrayScale:
            setpixel_16bppGrayScale(r,g,b,a,row,x);
            break;
        case PixelFormat16bppRGB555:
            setpixel_16bppRGB555(r,g,b,a,row,x);
            break;
        case PixelFormat16bppRGB565:
            setpixel_16bppRGB565(r,g,b,a,row,x);
            break;
        case PixelFormat16bppARGB1555:
            setpixel_16bppARGB1555(r,g,b,a,row,x);
            break;
        case PixelFormat24bppRGB:
            setpixel_24bppRGB(r,g,b,a,row,x);
            break;
        case PixelFormat32bppRGB:
            setpixel_32bppRGB(r,g,b,a,row,x);
            break;
        case PixelFormat32bppARGB:
            setpixel_32bppARGB(r,g,b,a,row,x);
            break;
        case PixelFormat32bppPARGB:
            setpixel_32bppPARGB(r,g,b,a,row,x);
            break;
        case PixelFormat48bppRGB:
            setpixel_48bppRGB(r,g,b,a,row,x);
            break;
        case PixelFormat64bppARGB:
            setpixel_64bppARGB(r,g,b,a,row,x);
            break;
        case PixelFormat64bppPARGB:
            setpixel_64bppPARGB(r,g,b,a,row,x);
            break;
        case PixelFormat8bppIndexed:
            setpixel_8bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
            break;
        case PixelFormat4bppIndexed:
            setpixel_4bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
            break;
        case PixelFormat1bppIndexed:
            setpixel_1bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
            break;
        default:
            FIXME("not implemented for format 0x%x\n", bitmap->format);
            return NotImplemented;
    }
 
    return Ok;
}

Referenced by alpha_blend_bmp_pixels(), test_colorkey(), test_colormatrix(), test_emfonly(), test_fillrect(), test_gamma(), test_GdipCreateBitmapFromHBITMAP(), test_GdipImageGetFrameDimensionsCount(), test_getdc(), test_getsetpixel(), test_histogram(), test_LockBits(), test_multiframegif(), test_palette(), and test_remaptable().

◆ GdipBitmapSetResolution()

GpStatus WINGDIPAPI GdipBitmapSetResolution	(	GpBitmap *	bitmap,
		REAL	xdpi,
		REAL	ydpi
	)

Definition at line 1163 of file image.c.

{
    TRACE("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
 
    if (!bitmap || xdpi == 0.0 || ydpi == 0.0)
        return InvalidParameter;
 
    bitmap->image.xres = xdpi;
    bitmap->image.yres = ydpi;
 
    return Ok;
}

Referenced by create_graphics(), test_DrawImage(), test_DrawImage_scale(), test_GdipDrawImagePointRect(), test_pen_thickness(), and test_resolution().

◆ GdipBitmapUnlockBits()

GpStatus WINGDIPAPI GdipBitmapUnlockBits	(	GpBitmap *	bitmap,
		BitmapData *	lockeddata
	)

Definition at line 1176 of file image.c.

{
    GpStatus stat;
    static BOOL fixme = FALSE;
    BOOL unlock;
 
    TRACE("(%p,%p)\n", bitmap, lockeddata);
 
    if(!bitmap || !lockeddata)
        return InvalidParameter;
    if(!image_lock(&bitmap->image, &unlock))
        return ObjectBusy;
 
    if(!bitmap->lockmode)
    {
        image_unlock(&bitmap->image, unlock);
        return WrongState;
    }
 
    if(!(lockeddata->Reserved & ImageLockModeWrite)){
        bitmap->lockmode = 0;
        heap_free(bitmap->bitmapbits);
        bitmap->bitmapbits = NULL;
        image_unlock(&bitmap->image, unlock);
        return Ok;
    }
 
    if (!bitmap->bitmapbits && !(lockeddata->Reserved & ImageLockModeUserInputBuf))
    {
        /* we passed a direct reference; no need to do anything */
        bitmap->lockmode = 0;
        image_unlock(&bitmap->image, unlock);
        return Ok;
    }
 
    if (!fixme && (PIXELFORMATBPP(bitmap->format) * bitmap->lockx) % 8 != 0)
    {
        FIXME("Cannot copy rows that don't start at a whole byte.\n");
        fixme = TRUE;
    }
 
    stat = convert_pixels(lockeddata->Width, lockeddata->Height,
        bitmap->stride,
        bitmap->bits + bitmap->stride * bitmap->locky + PIXELFORMATBPP(bitmap->format) * bitmap->lockx / 8,
        bitmap->format,
        lockeddata->Stride, lockeddata->Scan0, lockeddata->PixelFormat, NULL);
 
    if (stat != Ok)
    {
        ERR("failed to convert pixels; this should never happen\n");
    }
 
    heap_free(bitmap->bitmapbits);
    bitmap->bitmapbits = NULL;
    bitmap->lockmode = 0;
 
    image_unlock(&bitmap->image, unlock);
    return stat;
}

Referenced by brush_fill_pixels(), create_optimal_palette(), decode_frame_wic(), DibLoadImage(), encode_image_wic(), GdipCreateBitmapFromHBITMAP(), GdipCreateBitmapFromHICON(), GdipCreateHICONFromBitmap(), GdipDrawImagePointsRect(), GdipImageRotateFlip(), test_ARGB_conversion(), test_bitmapbits(), test_CloneBitmapArea(), test_createhbitmap(), test_image_format(), test_LockBits(), test_LockBits_UserBuf(), and test_pen_thickness().

◆ GdipClearPathMarkers()

GpStatus WINGDIPAPI GdipClearPathMarkers ( GpPath * path )

Definition at line 2439 of file graphicspath.c.

{
    INT count;
    INT i;
 
    TRACE("(%p)\n", path);
 
    if(!path)
        return InvalidParameter;
 
    count = path->pathdata.Count;
 
    for(i = 0; i < count - 1; i++){
        path->pathdata.Types[i] &= ~PathPointTypePathMarker;
    }
 
    return Ok;
}

◆ GdipCloneBitmapArea()

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

Definition at line 1237 of file image.c.

{
    Rect area;
    GpStatus stat;
 
    TRACE("(%f,%f,%f,%f,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
 
    if (!srcBitmap || !dstBitmap || srcBitmap->image.type != ImageTypeBitmap ||
        x < 0 || y < 0 ||
        x + width > srcBitmap->width || y + height > srcBitmap->height)
    {
        TRACE("<-- InvalidParameter\n");
        return InvalidParameter;
    }
 
    if (format == PixelFormatDontCare)
        format = srcBitmap->format;
 
    area.X = gdip_round(x);
    area.Y = gdip_round(y);
    area.Width = gdip_round(width);
    area.Height = gdip_round(height);
 
    stat = GdipCreateBitmapFromScan0(area.Width, area.Height, 0, format, NULL, dstBitmap);
    if (stat == Ok)
    {
        stat = convert_pixels(area.Width, area.Height, (*dstBitmap)->stride, (*dstBitmap)->bits, (*dstBitmap)->format,
                              srcBitmap->stride,
                              srcBitmap->bits + srcBitmap->stride * area.Y + PIXELFORMATBPP(srcBitmap->format) * area.X / 8,
                              srcBitmap->format, srcBitmap->image.palette);
 
        if (stat == Ok && srcBitmap->image.palette)
        {
            ColorPalette *src_palette, *dst_palette;
 
            src_palette = srcBitmap->image.palette;
 
            dst_palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * src_palette->Count);
 
            if (dst_palette)
            {
                dst_palette->Flags = src_palette->Flags;
                dst_palette->Count = src_palette->Count;
                memcpy(dst_palette->Entries, src_palette->Entries, sizeof(ARGB) * src_palette->Count);
 
                heap_free((*dstBitmap)->image.palette);
                (*dstBitmap)->image.palette = dst_palette;
            }
            else
                stat = OutOfMemory;
        }
 
        if (stat != Ok)
            GdipDisposeImage(&(*dstBitmap)->image);
    }
 
    if (stat != Ok)
        *dstBitmap = NULL;
 
    return stat;
}

Referenced by GdipCloneBitmapAreaI(), and GdipCreateTextureIA().

◆ GdipCloneBitmapAreaI()

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

Definition at line 1300 of file image.c.

{
    TRACE("(%i,%i,%i,%i,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
 
    return GdipCloneBitmapArea(x, y, width, height, format, srcBitmap, dstBitmap);
}

Referenced by GdipCloneImage(), and test_CloneBitmapArea().

◆ GdipCloneBrush()

GpStatus WINGDIPAPI GdipCloneBrush	(	GpBrush *	brush,
		GpBrush **	clone
	)

Definition at line 70 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, clone);
 
    if(!brush || !clone)
        return InvalidParameter;
 
    switch(brush->bt){
        case BrushTypeSolidColor:
        {
            *clone = heap_alloc_zero(sizeof(GpSolidFill));
            if (!*clone) return OutOfMemory;
            memcpy(*clone, brush, sizeof(GpSolidFill));
            break;
        }
        case BrushTypeHatchFill:
        {
            GpHatch *hatch = (GpHatch*)brush;
 
            return GdipCreateHatchBrush(hatch->hatchstyle, hatch->forecol, hatch->backcol, (GpHatch**)clone);
        }
        case BrushTypePathGradient:{
            GpPathGradient *src, *dest;
            INT count, pcount;
            GpStatus stat;
 
            *clone = heap_alloc_zero(sizeof(GpPathGradient));
            if (!*clone) return OutOfMemory;
 
            src = (GpPathGradient*) brush,
            dest = (GpPathGradient*) *clone;
 
            memcpy(dest, src, sizeof(GpPathGradient));
 
            stat = GdipClonePath(src->path, &dest->path);
 
            if(stat != Ok){
                heap_free(dest);
                return stat;
            }
 
            dest->transform = src->transform;
 
            /* blending */
            count = src->blendcount;
            dest->blendcount = count;
            dest->blendfac = heap_alloc_zero(count * sizeof(REAL));
            dest->blendpos = heap_alloc_zero(count * sizeof(REAL));
            dest->surroundcolors = heap_alloc_zero(dest->surroundcolorcount * sizeof(ARGB));
            pcount = dest->pblendcount;
            if (pcount)
            {
                dest->pblendcolor = heap_alloc_zero(pcount * sizeof(ARGB));
                dest->pblendpos = heap_alloc_zero(pcount * sizeof(REAL));
            }
 
            if(!dest->blendfac || !dest->blendpos || !dest->surroundcolors ||
               (pcount && (!dest->pblendcolor || !dest->pblendpos))){
                GdipDeletePath(dest->path);
                heap_free(dest->blendfac);
                heap_free(dest->blendpos);
                heap_free(dest->surroundcolors);
                heap_free(dest->pblendcolor);
                heap_free(dest->pblendpos);
                heap_free(dest);
                return OutOfMemory;
            }
 
            memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
            memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
            memcpy(dest->surroundcolors, src->surroundcolors, dest->surroundcolorcount * sizeof(ARGB));
 
            if (pcount)
            {
                memcpy(dest->pblendcolor, src->pblendcolor, pcount * sizeof(ARGB));
                memcpy(dest->pblendpos, src->pblendpos, pcount * sizeof(REAL));
            }
 
            break;
        }
        case BrushTypeLinearGradient:{
            GpLineGradient *dest, *src;
            INT count, pcount;
 
            dest = heap_alloc_zero(sizeof(GpLineGradient));
            if(!dest)    return OutOfMemory;
 
            src = (GpLineGradient*)brush;
 
            memcpy(dest, src, sizeof(GpLineGradient));
 
            count = dest->blendcount;
            dest->blendfac = heap_alloc_zero(count * sizeof(REAL));
            dest->blendpos = heap_alloc_zero(count * sizeof(REAL));
            pcount = dest->pblendcount;
            if (pcount)
            {
                dest->pblendcolor = heap_alloc_zero(pcount * sizeof(ARGB));
                dest->pblendpos = heap_alloc_zero(pcount * sizeof(REAL));
            }
 
            if (!dest->blendfac || !dest->blendpos ||
                (pcount && (!dest->pblendcolor || !dest->pblendpos)))
            {
                heap_free(dest->blendfac);
                heap_free(dest->blendpos);
                heap_free(dest->pblendcolor);
                heap_free(dest->pblendpos);
                heap_free(dest);
                return OutOfMemory;
            }
 
            dest->transform = src->transform;
 
            memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
            memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
 
            if (pcount)
            {
                memcpy(dest->pblendcolor, src->pblendcolor, pcount * sizeof(ARGB));
                memcpy(dest->pblendpos, src->pblendpos, pcount * sizeof(REAL));
            }
 
            *clone = &dest->brush;
            break;
        }
        case BrushTypeTextureFill:
        {
            GpStatus stat;
            GpTexture *texture = (GpTexture*)brush;
            GpTexture *new_texture;
            UINT width, height;
 
            stat = GdipGetImageWidth(texture->image, &width);
            if (stat != Ok) return stat;
            stat = GdipGetImageHeight(texture->image, &height);
            if (stat != Ok) return stat;
 
            stat = GdipCreateTextureIA(texture->image, texture->imageattributes, 0, 0, width, height, &new_texture);
 
            if (stat == Ok)
            {
                new_texture->transform = texture->transform;
                *clone = &new_texture->brush;
            }
            else
                *clone = NULL;
 
            return stat;
        }
        default:
            ERR("not implemented for brush type %d\n", brush->bt);
            return NotImplemented;
    }
 
    TRACE("<-- %p\n", *clone);
    return Ok;
}

Referenced by GdipClonePen(), GdipCreatePen2(), GdipGetPenBrushFill(), and GdipSetPenBrushFill().

◆ GdipCloneCustomLineCap()

GpStatus WINGDIPAPI GdipCloneCustomLineCap	(	GpCustomLineCap *	from,
		GpCustomLineCap **	to
	)

Definition at line 34 of file customlinecap.c.

{
    TRACE("(%p, %p)\n", from, to);
 
    if(!from || !to)
        return InvalidParameter;
 
    if (from->type == CustomLineCapTypeDefault)
        *to = heap_alloc_zero(sizeof(GpCustomLineCap));
    else
        *to = heap_alloc_zero(sizeof(GpAdjustableArrowCap));
 
    if (!*to)
        return OutOfMemory;
 
    if (from->type == CustomLineCapTypeDefault)
        **to = *from;
    else
        *(GpAdjustableArrowCap *)*to = *(GpAdjustableArrowCap *)from;
 
    /* Duplicate path data */
    (*to)->pathdata.Points = heap_alloc_zero(from->pathdata.Count * sizeof(PointF));
    (*to)->pathdata.Types = heap_alloc_zero(from->pathdata.Count);
 
    if((!(*to)->pathdata.Types  || !(*to)->pathdata.Points) && (*to)->pathdata.Count){
        heap_free((*to)->pathdata.Points);
        heap_free((*to)->pathdata.Types);
        heap_free(*to);
        return OutOfMemory;
    }
 
    memcpy((*to)->pathdata.Points, from->pathdata.Points, from->pathdata.Count
           * sizeof(PointF));
    memcpy((*to)->pathdata.Types, from->pathdata.Types, from->pathdata.Count);
 
    TRACE("<-- %p\n", *to);
 
    return Ok;
}

Referenced by GdipClonePen(), GdipGetPenCustomEndCap(), GdipGetPenCustomStartCap(), GdipSetPenCustomEndCap(), and GdipSetPenCustomStartCap().

◆ GdipCloneFont()

GpStatus WINGDIPAPI GdipCloneFont	(	GpFont *	font,
		GpFont **	cloneFont
	)

Definition at line 520 of file font.c.

{
    GpStatus stat;
 
    TRACE("(%p, %p)\n", font, cloneFont);
 
    if(!font || !cloneFont)
        return InvalidParameter;
 
    *cloneFont = heap_alloc_zero(sizeof(GpFont));
    if(!*cloneFont)    return OutOfMemory;
 
    **cloneFont = *font;
    stat = GdipCloneFontFamily(font->family, &(*cloneFont)->family);
    if (stat != Ok) heap_free(*cloneFont);
 
    return stat;
}

◆ GdipCloneFontFamily()

GpStatus WINGDIPAPI GdipCloneFontFamily	(	GpFontFamily *	FontFamily,
		GpFontFamily **	clonedFontFamily
	)

Definition at line 803 of file font.c.

{
    GpStatus status;
 
    if (!(FontFamily && clonedFontFamily)) return InvalidParameter;
 
    TRACE("%p (%s), %p\n", FontFamily,
            debugstr_w(FontFamily->FamilyName), clonedFontFamily);
 
    status = clone_font_family(FontFamily, clonedFontFamily);
    if (status != Ok) return status;
 
    TRACE("<-- %p\n", *clonedFontFamily);
 
    return Ok;
}

Referenced by GdipCloneFont(), GdipGetFamily(), GdipGetFontCollectionFamilyList(), and test_fontfamily().

◆ GdipCloneImage()

GpStatus WINGDIPAPI GdipCloneImage	(	GpImage *	image,
		GpImage **	cloneImage
	)

Definition at line 1308 of file image.c.

{
    TRACE("%p, %p\n", image, cloneImage);
 
    if (!image || !cloneImage)
        return InvalidParameter;
 
    if (image->type == ImageTypeBitmap)
    {
        GpBitmap *bitmap = (GpBitmap *)image;
 
        return GdipCloneBitmapAreaI(0, 0, bitmap->width, bitmap->height,
                                    bitmap->format, bitmap, (GpBitmap **)cloneImage);
    }
    else if (image->type == ImageTypeMetafile && ((GpMetafile*)image)->hemf)
    {
        GpMetafile *result, *metafile;
 
        metafile = (GpMetafile*)image;
 
        result = heap_alloc_zero(sizeof(*result));
        if (!result)
            return OutOfMemory;
 
        result->image.type = ImageTypeMetafile;
        result->image.format = image->format;
        result->image.flags = image->flags;
        result->image.frame_count = 1;
        result->image.xres = image->xres;
        result->image.yres = image->yres;
        result->bounds = metafile->bounds;
        result->unit = metafile->unit;
        result->metafile_type = metafile->metafile_type;
        result->hemf = CopyEnhMetaFileW(metafile->hemf, NULL);
        list_init(&result->containers);
 
        if (!result->hemf)
        {
            heap_free(result);
            return OutOfMemory;
        }
 
        *cloneImage = &result->image;
        return Ok;
    }
    else
    {
        WARN("GpImage with no image data (metafile in wrong state?)\n");
        return InvalidParameter;
    }
}

Referenced by GdipCreateCachedBitmap(), GdipGetTextureImage(), load_image(), sync_metafile(), test_emfonly(), and test_GdipCloneImage().

◆ GdipCloneImageAttributes()

GpStatus WINGDIPAPI GdipCloneImageAttributes	(	GDIPCONST GpImageAttributes *	imageattr,
		GpImageAttributes **	cloneImageattr
	)

Definition at line 30 of file imageattributes.c.

{
    GpStatus stat = Ok;
    struct color_remap_table remap_tables[ColorAdjustTypeCount] = {{0}};
    int i;
 
    TRACE("(%p, %p)\n", imageattr, cloneImageattr);
 
    if(!imageattr || !cloneImageattr)
        return InvalidParameter;
 
    for (i=0; i<ColorAdjustTypeCount; i++)
    {
        if (imageattr->colorremaptables[i].enabled)
        {
            remap_tables[i].enabled = TRUE;
            remap_tables[i].mapsize = imageattr->colorremaptables[i].mapsize;
            remap_tables[i].colormap = heap_alloc(sizeof(ColorMap) * remap_tables[i].mapsize);
 
            if (remap_tables[i].colormap)
            {
                memcpy(remap_tables[i].colormap, imageattr->colorremaptables[i].colormap,
                    sizeof(ColorMap) * remap_tables[i].mapsize);
            }
            else
            {
                stat = OutOfMemory;
                break;
            }
        }
    }
 
    if (stat == Ok)
        stat = GdipCreateImageAttributes(cloneImageattr);
 
    if (stat == Ok)
    {
        **cloneImageattr = *imageattr;
 
        memcpy((*cloneImageattr)->colorremaptables, remap_tables, sizeof(remap_tables));
    }
 
    if (stat != Ok)
    {
        for (i=0; i<ColorAdjustTypeCount; i++)
            heap_free(remap_tables[i].colormap);
    }
 
    return stat;
}

Referenced by GdipCreateTextureIA().

◆ GdipCloneMatrix()

GpStatus WINGDIPAPI GdipCloneMatrix	(	GpMatrix *	matrix,
		GpMatrix **	clone
	)

Definition at line 125 of file matrix.c.

{
    TRACE("(%p, %p)\n", matrix, clone);
 
    if(!matrix || !clone)
        return InvalidParameter;
 
    *clone = heap_alloc_zero(sizeof(GpMatrix));
    if(!*clone)    return OutOfMemory;
 
    **clone = *matrix;
 
    return Ok;
}

◆ GdipClonePath()

GpStatus WINGDIPAPI GdipClonePath	(	GpPath *	path,
		GpPath **	clone
	)

Definition at line 1135 of file graphicspath.c.

{
    TRACE("(%p, %p)\n", path, clone);
 
    if(!path || !clone)
        return InvalidParameter;
 
    *clone = heap_alloc_zero(sizeof(GpPath));
    if(!*clone) return OutOfMemory;
 
    **clone = *path;
 
    (*clone)->pathdata.Points = heap_alloc_zero(path->datalen * sizeof(PointF));
    (*clone)->pathdata.Types = heap_alloc_zero(path->datalen);
    if(!(*clone)->pathdata.Points || !(*clone)->pathdata.Types){
        heap_free((*clone)->pathdata.Points);
        heap_free((*clone)->pathdata.Types);
        heap_free(*clone);
        return OutOfMemory;
    }
 
    memcpy((*clone)->pathdata.Points, path->pathdata.Points,
           path->datalen * sizeof(PointF));
    memcpy((*clone)->pathdata.Types, path->pathdata.Types, path->datalen);
 
    return Ok;
}

Referenced by brush_fill_pixels(), clone_element(), GdipAddPathRectangle(), GdipAddPathRectangles(), GdipAddPathString(), GdipCloneBrush(), GdipCreatePathGradientFromPath(), GdipCreateRegionPath(), GdipIsOutlineVisiblePathPoint(), GdipSetClipPath(), GdipWidenPath(), SOFTWARE_GdipDrawPath(), and SOFTWARE_GdipDrawThinPath().

◆ GdipClonePen()

GpStatus WINGDIPAPI GdipClonePen	(	GpPen *	pen,
		GpPen **	clonepen
	)

Definition at line 88 of file pen.c.

{
    GpStatus stat;
 
    TRACE("(%p, %p)\n", pen, clonepen);
 
    if(!pen || !clonepen)
        return InvalidParameter;
 
    *clonepen = heap_alloc_zero(sizeof(GpPen));
    if(!*clonepen)  return OutOfMemory;
 
    **clonepen = *pen;
 
    (*clonepen)->customstart = NULL;
    (*clonepen)->customend = NULL;
    (*clonepen)->brush = NULL;
    (*clonepen)->dashes = NULL;
 
    stat = GdipCloneBrush(pen->brush, &(*clonepen)->brush);
 
    if (stat == Ok && pen->customstart)
        stat = GdipCloneCustomLineCap(pen->customstart, &(*clonepen)->customstart);
 
    if (stat == Ok && pen->customend)
        stat = GdipCloneCustomLineCap(pen->customend, &(*clonepen)->customend);
 
    if (stat == Ok && pen->dashes)
    {
        (*clonepen)->dashes = heap_alloc_zero(pen->numdashes * sizeof(REAL));
        if ((*clonepen)->dashes)
            memcpy((*clonepen)->dashes, pen->dashes, pen->numdashes * sizeof(REAL));
        else
            stat = OutOfMemory;
    }
 
    if (stat != Ok)
    {
        GdipDeletePen(*clonepen);
        *clonepen = NULL;
        return stat;
    }
 
    TRACE("<-- %p\n", *clonepen);
 
    return Ok;
}

◆ GdipCloneRegion()

GpStatus WINGDIPAPI GdipCloneRegion	(	GpRegion *	region,
		GpRegion **	clone
	)

Definition at line 211 of file region.c.

{
    region_element *element;
 
    TRACE("%p %p\n", region, clone);
 
    if (!(region && clone))
        return InvalidParameter;
 
    *clone = heap_alloc_zero(sizeof(GpRegion));
    if (!*clone)
        return OutOfMemory;
    element = &(*clone)->node;
 
    (*clone)->num_children = region->num_children;
    return clone_element(&region->node, &element);
}

Referenced by GdipCombineRegionRegion(), GdipGetClip(), GdipPlayMetafileRecord(), GdipSetClipRegion(), get_clip_hrgn(), get_region_scans_data(), init_container(), restore_container(), and SOFTWARE_GdipFillRegion().

◆ GdipCloneStringFormat()

GpStatus WINGDIPAPI GdipCloneStringFormat	(	GDIPCONST GpStringFormat *	format,
		GpStringFormat **	newFormat
	)

Definition at line 369 of file stringformat.c.

{
    if(!format || !newFormat)
        return InvalidParameter;
 
    *newFormat = heap_alloc_zero(sizeof(GpStringFormat));
    if(!*newFormat)    return OutOfMemory;
 
    **newFormat = *format;
 
    if(format->tabcount > 0){
        (*newFormat)->tabs = heap_alloc_zero(sizeof(REAL) * format->tabcount);
        if(!(*newFormat)->tabs){
            heap_free(*newFormat);
            return OutOfMemory;
        }
        memcpy((*newFormat)->tabs, format->tabs, sizeof(REAL) * format->tabcount);
    }
    else
        (*newFormat)->tabs = NULL;
 
    if(format->range_count > 0){
        (*newFormat)->character_ranges = heap_alloc_zero(sizeof(CharacterRange) * format->range_count);
        if(!(*newFormat)->character_ranges){
            heap_free((*newFormat)->tabs);
            heap_free(*newFormat);
            return OutOfMemory;
        }
        memcpy((*newFormat)->character_ranges, format->character_ranges,
               sizeof(CharacterRange) * format->range_count);
    }
    else
        (*newFormat)->character_ranges = NULL;
 
    TRACE("%p %p\n",format,newFormat);
 
    return Ok;
}

◆ GdipClosePathFigure()

GpStatus WINGDIPAPI GdipClosePathFigure ( GpPath * path )

Definition at line 1163 of file graphicspath.c.

{
    TRACE("(%p)\n", path);
 
    if(!path)
        return InvalidParameter;
 
    if(path->pathdata.Count > 0){
        path->pathdata.Types[path->pathdata.Count - 1] |= PathPointTypeCloseSubpath;
        path->newfigure = TRUE;
    }
 
    return Ok;
}

Referenced by GdipAddPathPie(), test_ellipse(), test_getregiondata(), test_line2(), test_linei(), test_nextpathtype(), test_nextsubpathpath(), test_pen_thickness(), and test_reverse().

◆ GdipClosePathFigures()

GpStatus WINGDIPAPI GdipClosePathFigures ( GpPath * path )

Definition at line 1178 of file graphicspath.c.

{
    INT i;
 
    TRACE("(%p)\n", path);
 
    if(!path)
        return InvalidParameter;
 
    for(i = 1; i < path->pathdata.Count; i++){
        if(path->pathdata.Types[i] == PathPointTypeStart)
            path->pathdata.Types[i-1] |= PathPointTypeCloseSubpath;
    }
 
    path->newfigure = TRUE;
 
    return Ok;
}

◆ GdipCombineRegionPath()

GpStatus WINGDIPAPI GdipCombineRegionPath	(	GpRegion *	region,
		GpPath *	path,
		CombineMode	mode
	)

Definition at line 232 of file region.c.

{
    GpRegion *path_region;
    region_element *left, *right = NULL;
    GpStatus stat;
 
    TRACE("%p %p %d\n", region, path, mode);
 
    if (!(region && path))
        return InvalidParameter;
 
    stat = GdipCreateRegionPath(path, &path_region);
    if (stat != Ok)
        return stat;
 
    /* simply replace region data */
    if(mode == CombineModeReplace){
        delete_element(&region->node);
        memcpy(region, path_region, sizeof(GpRegion));
        heap_free(path_region);
        return Ok;
    }
 
    left = heap_alloc_zero(sizeof(region_element));
    if (left)
    {
        *left = region->node;
        stat = clone_element(&path_region->node, &right);
        if (stat == Ok)
        {
            fuse_region(region, left, right, mode);
            GdipDeleteRegion(path_region);
            return Ok;
        }
    }
    else
        stat = OutOfMemory;
 
    heap_free(left);
    GdipDeleteRegion(path_region);
    return stat;
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), GdipSetClipPath(), test_combinereplace(), test_getregiondata(), test_isvisiblepoint(), test_isvisiblerect(), test_transform(), and test_translate().

◆ GdipCombineRegionRect()

GpStatus WINGDIPAPI GdipCombineRegionRect	(	GpRegion *	region,
		GDIPCONST GpRectF *	rect,
		CombineMode	mode
	)

Definition at line 278 of file region.c.

{
    GpRegion *rect_region;
    region_element *left, *right = NULL;
    GpStatus stat;
 
    TRACE("%p %s %d\n", region, debugstr_rectf(rect), mode);
 
    if (!(region && rect))
        return InvalidParameter;
 
    stat = GdipCreateRegionRect(rect, &rect_region);
    if (stat != Ok)
        return stat;
 
    /* simply replace region data */
    if(mode == CombineModeReplace){
        delete_element(&region->node);
        memcpy(region, rect_region, sizeof(GpRegion));
        heap_free(rect_region);
        return Ok;
    }
 
    left = heap_alloc_zero(sizeof(region_element));
    if (left)
    {
        memcpy(left, &region->node, sizeof(region_element));
        stat = clone_element(&rect_region->node, &right);
        if (stat == Ok)
        {
            fuse_region(region, left, right, mode);
            GdipDeleteRegion(rect_region);
            return Ok;
        }
    }
    else
        stat = OutOfMemory;
 
    heap_free(left);
    GdipDeleteRegion(rect_region);
    return stat;
}

Referenced by GdipCombineRegionRectI(), get_visible_clip_region(), measure_ranges_callback(), SOFTWARE_GdipFillRegion(), test_clipping(), test_clipping_2(), test_combinereplace(), test_excludeinfinite(), test_getbounds(), test_gethrgn(), test_isequal(), test_isvisiblepoint(), test_isvisiblerect(), test_scans(), test_transform(), and test_translate().

◆ GdipCombineRegionRectI()

GpStatus WINGDIPAPI GdipCombineRegionRectI	(	GpRegion *	region,
		GDIPCONST GpRect *	rect,
		CombineMode	mode
	)

Definition at line 325 of file region.c.

{
    GpRectF rectf;
 
    TRACE("%p %p %d\n", region, rect, mode);
 
    if (!rect)
        return InvalidParameter;
 
    rectf.X = (REAL)rect->X;
    rectf.Y = (REAL)rect->Y;
    rectf.Height = (REAL)rect->Height;
    rectf.Width = (REAL)rect->Width;
 
    return GdipCombineRegionRect(region, &rectf, mode);
}

Referenced by test_getregiondata().

◆ GdipCombineRegionRegion()

GpStatus WINGDIPAPI GdipCombineRegionRegion	(	GpRegion *	region1,
		GpRegion *	region2,
		CombineMode	mode
	)

Definition at line 346 of file region.c.

{
    region_element *left, *right = NULL;
    GpStatus stat;
    GpRegion *reg2copy;
 
    TRACE("%p %p %d\n", region1, region2, mode);
 
    if(!(region1 && region2))
        return InvalidParameter;
 
    /* simply replace region data */
    if(mode == CombineModeReplace){
        stat = GdipCloneRegion(region2, &reg2copy);
        if(stat != Ok)  return stat;
 
        delete_element(&region1->node);
        memcpy(region1, reg2copy, sizeof(GpRegion));
        heap_free(reg2copy);
        return Ok;
    }
 
    left  = heap_alloc_zero(sizeof(region_element));
    if (!left)
        return OutOfMemory;
 
    *left = region1->node;
    stat = clone_element(&region2->node, &right);
    if (stat != Ok)
    {
        heap_free(left);
        return OutOfMemory;
    }
 
    fuse_region(region1, left, right, mode);
    region1->num_children += region2->num_children;
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), GdipSetClipGraphics(), GdipSetClipHrgn(), GdipSetClipRect(), GdipSetClipRegion(), get_visible_clip_region(), METAFILE_PlaybackUpdateClip(), metafile_set_clip_region(), test_combinereplace(), and test_getregiondata().

◆ GdipComment()

GpStatus WINGDIPAPI GdipComment	(	GpGraphics *	graphics,
		UINT	sizeData,
		GDIPCONST BYTE *	data
	)

Definition at line 5990 of file graphics.c.

{
    FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
    return NotImplemented;
}

◆ GdipConvertToEmfPlus()

GpStatus WINGDIPAPI GdipConvertToEmfPlus	(	const GpGraphics *	,
		GpMetafile *	,
		INT *	,
		EmfType	,
		const WCHAR *	,
		GpMetafile **
	)

◆ GdipConvertToEmfPlusToFile()

GpStatus WINGDIPAPI GdipConvertToEmfPlusToFile	(	const GpGraphics *	,
		GpMetafile *	,
		INT *	,
		const WCHAR *	,
		EmfType	,
		const WCHAR *	,
		GpMetafile **
	)

◆ GdipConvertToEmfPlusToStream()

GpStatus WINGDIPAPI GdipConvertToEmfPlusToStream	(	const GpGraphics *	,
		GpMetafile *	,
		INT *	,
		IStream *	,
		EmfType	,
		const WCHAR *	,
		GpMetafile **
	)

◆ GdipCreateAdjustableArrowCap()

GpStatus WINGDIPAPI GdipCreateAdjustableArrowCap	(	REAL	height,
		REAL	width,
		BOOL	fill,
		GpAdjustableArrowCap **	cap
	)

Definition at line 329 of file customlinecap.c.

{
    GpPathData pathdata;
    GpStatus stat;
 
    TRACE("(%0.2f,%0.2f,%i,%p)\n", height, width, fill, cap);
 
    if (!cap)
        return InvalidParameter;
 
    *cap = heap_alloc_zero(sizeof(**cap));
    if (!*cap)
        return OutOfMemory;
 
    /* We'll need 4 points at most. */
    pathdata.Count = 4;
    pathdata.Points = NULL;
    pathdata.Types = NULL;
    stat = init_custom_linecap(&(*cap)->cap, &pathdata, fill, LineCapTriangle, width != 0.0 ? height / width : 0.0);
    if (stat != Ok)
    {
        heap_free(*cap);
        return stat;
    }
 
    (*cap)->cap.type = CustomLineCapTypeAdjustableArrow;
    (*cap)->height = height;
    (*cap)->width = width;
    (*cap)->middle_inset = 0.0;
    arrowcap_update_path(*cap);
 
    return Ok;
}

Referenced by test_captype(), and test_create_adjustable_cap().

◆ GdipCreateBitmapFromFile()

GpStatus WINGDIPAPI GdipCreateBitmapFromFile	(	GDIPCONST WCHAR *	filename,
		GpBitmap **	bitmap
	)

Definition at line 1360 of file image.c.

{
    GpStatus stat;
    IStream *stream;
 
    TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
 
    if(!filename || !bitmap)
        return InvalidParameter;
 
    *bitmap = NULL;
 
    stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 
    if(stat != Ok)
        return stat;
 
    stat = GdipCreateBitmapFromStream(stream, bitmap);
 
    IStream_Release(stream);
 
    return stat;
}

Referenced by DibLoadImage(), GdipCreateBitmapFromFileICM(), and test_LoadingImages().

◆ GdipCreateBitmapFromFileICM()

GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM	(	GDIPCONST WCHAR *	filename,
		GpBitmap **	bitmap
	)

Definition at line 1436 of file image.c.

{
    TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
 
    return GdipCreateBitmapFromFile(filename, bitmap);
}

◆ GdipCreateBitmapFromGdiDib()

GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib	(	GDIPCONST BITMAPINFO *	info,
		VOID *	bits,
		GpBitmap **	bitmap
	)

Definition at line 1385 of file image.c.

{
    DWORD height, stride;
    PixelFormat format;
 
    FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
 
    if (!info || !bits || !bitmap)
        return InvalidParameter;
 
    height = abs(info->bmiHeader.biHeight);
    stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
 
    if(info->bmiHeader.biHeight > 0) /* bottom-up */
    {
        bits = (BYTE*)bits + (height - 1) * stride;
        stride = -stride;
    }
 
    switch(info->bmiHeader.biBitCount) {
    case 1:
        format = PixelFormat1bppIndexed;
        break;
    case 4:
        format = PixelFormat4bppIndexed;
        break;
    case 8:
        format = PixelFormat8bppIndexed;
        break;
    case 16:
        format = PixelFormat16bppRGB555;
        break;
    case 24:
        format = PixelFormat24bppRGB;
        break;
    case 32:
        format = PixelFormat32bppRGB;
        break;
    default:
        FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
        *bitmap = NULL;
        return InvalidParameter;
    }
 
    return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
                                     bits, bitmap);
 
}

Referenced by test_drawimage(), test_FromGdiDib(), and test_GdipDrawImagePointsRect().

◆ GdipCreateBitmapFromGraphics()

GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics	(	INT	width,
		INT	height,
		GpGraphics *	target,
		GpBitmap **	bitmap
	)

Definition at line 1542 of file image.c.

{
    GpStatus ret;
 
    TRACE("(%d, %d, %p, %p)\n", width, height, target, bitmap);
 
    if(!target || !bitmap)
        return InvalidParameter;
 
    ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
                                    NULL, bitmap);
 
    if (ret == Ok)
    {
        GdipGetDpiX(target, &(*bitmap)->image.xres);
        GdipGetDpiY(target, &(*bitmap)->image.yres);
    }
 
    return ret;
}

Referenced by test_bitmapfromgraphics(), test_texturewrap(), and test_transform().

◆ GdipCreateBitmapFromHBITMAP()

GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP	(	HBITMAP	hbm,
		HPALETTE	hpal,
		GpBitmap **	bitmap
	)

Definition at line 5152 of file image.c.

{
    BITMAP bm;
    GpStatus retval;
    PixelFormat format;
    BitmapData lockeddata;
 
    TRACE("%p %p %p\n", hbm, hpal, bitmap);
 
    if(!hbm || !bitmap)
        return InvalidParameter;
 
    if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
            return InvalidParameter;
 
    /* TODO: Figure out the correct format for 16, 32, 64 bpp */
    switch(bm.bmBitsPixel) {
        case 1:
            format = PixelFormat1bppIndexed;
            break;
        case 4:
            format = PixelFormat4bppIndexed;
            break;
        case 8:
            format = PixelFormat8bppIndexed;
            break;
        case 16:
            format = get_16bpp_format(hbm);
            if (format == PixelFormatUndefined)
                return InvalidParameter;
            break;
        case 24:
            format = PixelFormat24bppRGB;
            break;
        case 32:
            format = PixelFormat32bppRGB;
            break;
        case 48:
            format = PixelFormat48bppRGB;
            break;
        default:
            FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
            return InvalidParameter;
    }
 
    retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
        format, NULL, bitmap);
 
    if (retval == Ok)
    {
        retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
            format, &lockeddata);
        if (retval == Ok)
        {
            HDC hdc;
            char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors) + 256 * sizeof(RGBQUAD)];
            BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
            INT src_height;
 
            hdc = CreateCompatibleDC(NULL);
 
            pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
            pbmi->bmiHeader.biBitCount = 0;
 
            GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
 
            src_height = abs(pbmi->bmiHeader.biHeight);
            pbmi->bmiHeader.biHeight = -src_height;
 
            GetDIBits(hdc, hbm, 0, src_height, lockeddata.Scan0, pbmi, DIB_RGB_COLORS);
 
            DeleteDC(hdc);
 
            GdipBitmapUnlockBits(*bitmap, &lockeddata);
        }
 
        if (retval == Ok && hpal)
        {
            PALETTEENTRY entry[256];
            ColorPalette *palette=NULL;
            int i, num_palette_entries;
 
            num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry);
            if (!num_palette_entries)
                retval = GenericError;
 
            palette = heap_alloc_zero(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
            if (!palette)
                retval = OutOfMemory;
 
            if (retval == Ok)
            {
                palette->Flags = 0;
                palette->Count = num_palette_entries;
 
                for (i=0; i<num_palette_entries; i++)
                {
                    palette->Entries[i] = 0xff000000 | entry[i].peRed << 16 |
                                          entry[i].peGreen << 8 | entry[i].peBlue;
                }
 
                retval = GdipSetImagePalette(&(*bitmap)->image, palette);
            }
 
            heap_free(palette);
        }
 
        if (retval != Ok)
        {
            GdipDisposeImage(&(*bitmap)->image);
            *bitmap = NULL;
        }
    }
 
    return retval;
}

Referenced by GdipCreateBitmapFromResource(), GdipCreateBitmapFromStream(), and test_GdipCreateBitmapFromHBITMAP().

◆ GdipCreateBitmapFromHICON()

GpStatus WINGDIPAPI GdipCreateBitmapFromHICON	(	HICON	hicon,
		GpBitmap **	bitmap
	)

Definition at line 1564 of file image.c.

{
    GpStatus stat;
    ICONINFO iinfo;
    BITMAP bm;
    int ret;
    UINT width, height, stride;
    GpRect rect;
    BitmapData lockeddata;
    HDC screendc;
    BOOL has_alpha;
    int x, y;
    BITMAPINFOHEADER bih;
    DWORD *src;
    BYTE *dst_row;
    DWORD *dst;
 
    TRACE("%p, %p\n", hicon, bitmap);
 
    if(!bitmap || !GetIconInfo(hicon, &iinfo))
        return InvalidParameter;
 
    /* get the size of the icon */
    ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
    if (ret == 0) {
        DeleteObject(iinfo.hbmColor);
        DeleteObject(iinfo.hbmMask);
        return GenericError;
    }
 
    width = bm.bmWidth;
    height = iinfo.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
    stride = width * 4;
 
    stat = GdipCreateBitmapFromScan0(width, height, stride, PixelFormat32bppARGB, NULL, bitmap);
    if (stat != Ok) {
        DeleteObject(iinfo.hbmColor);
        DeleteObject(iinfo.hbmMask);
        return stat;
    }
 
    rect.X = 0;
    rect.Y = 0;
    rect.Width = width;
    rect.Height = height;
 
    stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
    if (stat != Ok) {
        DeleteObject(iinfo.hbmColor);
        DeleteObject(iinfo.hbmMask);
        GdipDisposeImage(&(*bitmap)->image);
        return stat;
    }
 
    bih.biSize = sizeof(bih);
    bih.biWidth = width;
    bih.biHeight = iinfo.hbmColor ? -height: -height * 2;
    bih.biPlanes = 1;
    bih.biBitCount = 32;
    bih.biCompression = BI_RGB;
    bih.biSizeImage = 0;
    bih.biXPelsPerMeter = 0;
    bih.biYPelsPerMeter = 0;
    bih.biClrUsed = 0;
    bih.biClrImportant = 0;
 
    screendc = CreateCompatibleDC(0);
    if (iinfo.hbmColor)
    {
        GetDIBits(screendc, iinfo.hbmColor, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
 
        if (bm.bmBitsPixel == 32)
        {
            has_alpha = FALSE;
 
            /* If any pixel has a non-zero alpha, ignore hbmMask */
            src = (DWORD*)lockeddata.Scan0;
            for (x=0; x<width && !has_alpha; x++)
                for (y=0; y<height && !has_alpha; y++)
                    if ((*src++ & 0xff000000) != 0)
                        has_alpha = TRUE;
        }
        else has_alpha = FALSE;
    }
    else
    {
        GetDIBits(screendc, iinfo.hbmMask, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
        has_alpha = FALSE;
    }
 
    if (!has_alpha)
    {
        if (iinfo.hbmMask)
        {
            BYTE *bits = heap_alloc(height * stride);
 
            /* read alpha data from the mask */
            if (iinfo.hbmColor)
                GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
            else
                GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
 
            src = (DWORD*)bits;
            dst_row = lockeddata.Scan0;
            for (y=0; y<height; y++)
            {
                dst = (DWORD*)dst_row;
                for (x=0; x<height; x++)
                {
                    DWORD src_value = *src++;
                    if (src_value)
                        *dst++ = 0;
                    else
                        *dst++ |= 0xff000000;
                }
                dst_row += lockeddata.Stride;
            }
 
            heap_free(bits);
        }
        else
        {
            /* set constant alpha of 255 */
            dst_row = lockeddata.Scan0;
            for (y=0; y<height; y++)
            {
                dst = (DWORD*)dst_row;
                for (x=0; x<height; x++)
                    *dst++ |= 0xff000000;
                dst_row += lockeddata.Stride;
            }
        }
    }
 
    DeleteDC(screendc);
 
    DeleteObject(iinfo.hbmColor);
    DeleteObject(iinfo.hbmMask);
 
    GdipBitmapUnlockBits(*bitmap, &lockeddata);
 
    return Ok;
}

Referenced by test_fromhicon().

◆ GdipCreateBitmapFromResource()

GpStatus WINGDIPAPI GdipCreateBitmapFromResource	(	HINSTANCE	hInstance,
		GDIPCONST WCHAR *	lpBitmapName,
		GpBitmap **	bitmap
	)

Definition at line 1444 of file image.c.

{
    HBITMAP hbm;
    GpStatus stat = InvalidParameter;
 
    TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
 
    if(!lpBitmapName || !bitmap)
        return InvalidParameter;
 
    /* load DIB */
    hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
                     LR_CREATEDIBSECTION);
 
    if(hbm){
        stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
        DeleteObject(hbm);
    }
 
    return stat;
}

◆ GdipCreateBitmapFromScan0()

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

Definition at line 1760 of file image.c.

{
    HBITMAP hbitmap=NULL;
    INT row_size, dib_stride;
    BYTE *bits=NULL, *own_bits=NULL;
    REAL xres, yres;
    GpStatus stat;
 
    TRACE("%d %d %d 0x%x %p %p\n", width, height, stride, format, scan0, bitmap);
 
    if (!bitmap) return InvalidParameter;
 
    if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
        *bitmap = NULL;
        return InvalidParameter;
    }
 
    if(scan0 && !stride)
        return InvalidParameter;
 
    stat = get_screen_resolution(&xres, &yres);
    if (stat != Ok) return stat;
 
    row_size = (width * PIXELFORMATBPP(format)+7) / 8;
    dib_stride = (row_size + 3) & ~3;
 
    if(stride == 0)
        stride = dib_stride;
 
    if (format & PixelFormatGDI && !(format & (PixelFormatAlpha|PixelFormatIndexed)) && !scan0)
    {
        char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors) + 256 * sizeof(RGBQUAD)];
        BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
 
        pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
        pbmi->bmiHeader.biWidth = width;
        pbmi->bmiHeader.biHeight = -height;
        pbmi->bmiHeader.biPlanes = 1;
        /* FIXME: use the rest of the data from format */
        pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(format);
        pbmi->bmiHeader.biCompression = BI_RGB;
        pbmi->bmiHeader.biSizeImage = 0;
        pbmi->bmiHeader.biXPelsPerMeter = 0;
        pbmi->bmiHeader.biYPelsPerMeter = 0;
        pbmi->bmiHeader.biClrUsed = 0;
        pbmi->bmiHeader.biClrImportant = 0;
 
        hbitmap = CreateDIBSection(0, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 
        if (!hbitmap) return GenericError;
 
        stride = dib_stride;
    }
    else
    {
        /* Not a GDI format; don't try to make an HBITMAP. */
        if (scan0)
            bits = scan0;
        else
        {
            INT size = abs(stride) * height;
 
            own_bits = bits = heap_alloc_zero(size);
            if (!own_bits) return OutOfMemory;
 
            if (stride < 0)
                bits += stride * (1 - height);
        }
    }
 
    *bitmap = heap_alloc_zero(sizeof(GpBitmap));
    if(!*bitmap)
    {
        DeleteObject(hbitmap);
        heap_free(own_bits);
        return OutOfMemory;
    }
 
    (*bitmap)->image.type = ImageTypeBitmap;
    memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
    (*bitmap)->image.flags = ImageFlagsNone;
    (*bitmap)->image.frame_count = 1;
    (*bitmap)->image.current_frame = 0;
    (*bitmap)->image.palette = NULL;
    (*bitmap)->image.xres = xres;
    (*bitmap)->image.yres = yres;
    (*bitmap)->width = width;
    (*bitmap)->height = height;
    (*bitmap)->format = format;
    (*bitmap)->image.decoder = NULL;
    (*bitmap)->hbitmap = hbitmap;
    (*bitmap)->hdc = NULL;
    (*bitmap)->bits = bits;
    (*bitmap)->stride = stride;
    (*bitmap)->own_bits = own_bits;
    (*bitmap)->metadata_reader = NULL;
    (*bitmap)->prop_count = 0;
    (*bitmap)->prop_item = NULL;
 
    /* set format-related flags */
    if (format & (PixelFormatAlpha|PixelFormatPAlpha|PixelFormatIndexed))
        (*bitmap)->image.flags |= ImageFlagsHasAlpha;
 
    if (format == PixelFormat1bppIndexed ||
        format == PixelFormat4bppIndexed ||
        format == PixelFormat8bppIndexed)
    {
        (*bitmap)->image.palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * (1 << PIXELFORMATBPP(format)));
 
        if (!(*bitmap)->image.palette)
        {
            GdipDisposeImage(&(*bitmap)->image);
            *bitmap = NULL;
            return OutOfMemory;
        }
 
        (*bitmap)->image.palette->Count = 1 << PIXELFORMATBPP(format);
 
        if (format == PixelFormat1bppIndexed)
        {
            (*bitmap)->image.palette->Flags = PaletteFlagsGrayScale;
            (*bitmap)->image.palette->Entries[0] = 0xff000000;
            (*bitmap)->image.palette->Entries[1] = 0xffffffff;
        }
        else
        {
            if (format == PixelFormat8bppIndexed)
                (*bitmap)->image.palette->Flags = PaletteFlagsHalftone;
 
            generate_halftone_palette((*bitmap)->image.palette->Entries,
                (*bitmap)->image.palette->Count);
        }
    }
 
    TRACE("<-- %p\n", *bitmap);
 
    return Ok;
}

Referenced by create_graphics(), decode_frame_wic(), GdipCloneBitmapArea(), GdipCreateBitmapFromGdiDib(), GdipCreateBitmapFromGraphics(), GdipCreateBitmapFromHBITMAP(), GdipCreateBitmapFromHICON(), GdipGetImageThumbnail(), GdipImageRotateFlip(), metafile_deserialize_image(), METAFILE_DrawImagePointsRect(), test_ARGB_conversion(), test_bitmapbits(), test_clear(), test_clipping(), test_CloneBitmapArea(), test_colorkey(), test_colormatrix(), test_containers(), test_createhbitmap(), test_dispose(), test_DrawImage(), test_DrawImage_scale(), test_DrawImage_SourceCopy(), test_emfonly(), test_fillrect(), test_fromMemoryBitmap(), test_gamma(), test_GdipCloneImage(), test_GdipDrawImagePointRect(), test_GdipDrawImagePointsRectOnMemoryDC(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_GdipGetImageFlags(), test_GdipGetNearestColor(), test_GdipImageGetFrameDimensionsCount(), test_GdipInitializePalette(), test_gditransform(), test_getdc(), test_getdc_scaled(), test_GetImageDimension(), test_getsetpixel(), test_getthumbnail(), test_histogram(), test_image_format(), test_imageabort(), test_LockBits(), test_LockBits_UserBuf(), test_pagetransform(), test_palette(), test_pen_thickness(), test_remaptable(), test_resolution(), test_rotateflip(), test_SavingImages(), test_Scan0(), test_supported_encoders(), and test_worldtransform().

◆ GdipCreateBitmapFromStream()

GpStatus WINGDIPAPI GdipCreateBitmapFromStream	(	IStream *	stream,
		GpBitmap **	bitmap
	)

Definition at line 1935 of file image.c.

{
    GpStatus stat;
 
    TRACE("%p %p\n", stream, bitmap);
 
    stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
 
    if(stat != Ok)
        return stat;
 
#ifdef __REACTOS__
    if ((*bitmap)->image.type == ImageTypeMetafile)
    {
        HBITMAP hbm = hbitmap_from_emf(((GpMetafile*)*bitmap)->hemf);
        GdipDisposeImage(&(*bitmap)->image);
        if (!hbm)
            return GenericError; /* FIXME: what error to return? */
 
        GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
        DeleteObject(hbm);
    }
    else
#endif
    if((*bitmap)->image.type != ImageTypeBitmap){
        GdipDisposeImage(&(*bitmap)->image);
        *bitmap = NULL;
        return GenericError; /* FIXME: what error to return? */
    }
 
    return Ok;
}

Referenced by GdipCreateBitmapFromFile(), GdipCreateBitmapFromStreamICM(), metafile_deserialize_image(), and test_multiframegif().

◆ GdipCreateBitmapFromStreamICM()

GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM	(	IStream *	stream,
		GpBitmap **	bitmap
	)

Definition at line 1970 of file image.c.

{
    TRACE("%p %p\n", stream, bitmap);
 
    return GdipCreateBitmapFromStream(stream, bitmap);
}

◆ GdipCreateCachedBitmap()

GpStatus WINGDIPAPI GdipCreateCachedBitmap	(	GpBitmap *	bitmap,
		GpGraphics *	graphics,
		GpCachedBitmap **	cachedbmp
	)

Definition at line 1978 of file image.c.

{
    GpStatus stat;
 
    TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
 
    if(!bitmap || !graphics || !cachedbmp)
        return InvalidParameter;
 
    *cachedbmp = heap_alloc_zero(sizeof(GpCachedBitmap));
    if(!*cachedbmp)
        return OutOfMemory;
 
    stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
    if(stat != Ok){
        heap_free(*cachedbmp);
        return stat;
    }
 
    return Ok;
}

◆ GdipCreateCustomLineCap()

GpStatus WINGDIPAPI GdipCreateCustomLineCap	(	GpPath *	fillPath,
		GpPath *	strokePath,
		GpLineCap	baseCap,
		REAL	baseInset,
		GpCustomLineCap **	customCap
	)

Definition at line 108 of file customlinecap.c.

{
    GpPathData *pathdata;
    GpStatus stat;
 
    TRACE("%p %p %d %f %p\n", fillPath, strokePath, baseCap, baseInset, customCap);
 
    if(!customCap || !(fillPath || strokePath))
        return InvalidParameter;
 
    *customCap = heap_alloc_zero(sizeof(GpCustomLineCap));
    if(!*customCap)    return OutOfMemory;
 
    if (strokePath)
        pathdata = &strokePath->pathdata;
    else
        pathdata = &fillPath->pathdata;
 
    stat = init_custom_linecap(*customCap, pathdata, fillPath != NULL, baseCap, baseInset);
    if (stat != Ok)
    {
        heap_free(*customCap);
        return stat;
    }
 
    TRACE("<-- %p\n", *customCap);
 
    return Ok;
}

Referenced by test_captype(), test_constructor_destructor(), test_inset(), test_linejoin(), and test_scale().

◆ GdipCreateFont()

GpStatus WINGDIPAPI GdipCreateFont	(	GDIPCONST GpFontFamily *	fontFamily,
		REAL	emSize,
		INT	style,
		Unit	unit,
		GpFont **	font
	)

Definition at line 144 of file font.c.

{
    HFONT hfont;
    OUTLINETEXTMETRICW otm;
    LOGFONTW lfw;
    HDC hdc;
    GpStatus stat;
    int ret;
 
    if (!fontFamily || !font || emSize < 0.0)
        return InvalidParameter;
 
    TRACE("%p (%s), %f, %d, %d, %p\n", fontFamily,
            debugstr_w(fontFamily->FamilyName), emSize, style, unit, font);
 
    memset(&lfw, 0, sizeof(lfw));
 
    stat = GdipGetFamilyName(fontFamily, lfw.lfFaceName, LANG_NEUTRAL);
    if (stat != Ok) return stat;
 
    lfw.lfHeight = -units_to_pixels(emSize, unit, fontFamily->dpi);
    lfw.lfWeight = style & FontStyleBold ? FW_BOLD : FW_REGULAR;
    lfw.lfItalic = style & FontStyleItalic;
    lfw.lfUnderline = style & FontStyleUnderline;
    lfw.lfStrikeOut = style & FontStyleStrikeout;
 
    hfont = CreateFontIndirectW(&lfw);
    hdc = CreateCompatibleDC(0);
    SelectObject(hdc, hfont);
    otm.otmSize = sizeof(otm);
    ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
    DeleteDC(hdc);
    DeleteObject(hfont);
 
    if (!ret) return NotTrueTypeFont;
 
    *font = heap_alloc_zero(sizeof(GpFont));
    if (!*font) return OutOfMemory;
 
    (*font)->unit = unit;
    (*font)->emSize = emSize;
    (*font)->otm = otm;
 
    stat = clone_font_family(fontFamily, &(*font)->family);
    if (stat != Ok)
    {
        heap_free(*font);
        return stat;
    }
 
    TRACE("<-- %p\n", *font);
 
    return Ok;
}

Referenced by check_family(), GdipAddPathString(), METAFILE_PlaybackObject(), test_createfont(), test_font_height_scaling(), test_font_metrics(), test_font_substitution(), test_GdipMeasureString(), test_heightgivendpi(), test_long_name(), test_measure_string(), test_measured_extra_space(), and test_string_functions().

◆ GdipCreateFontFamilyFromName()

GpStatus WINGDIPAPI GdipCreateFontFamilyFromName	(	GDIPCONST WCHAR *	name,
		GpFontCollection *	fontCollection,
		GpFontFamily **	FontFamily
	)

Definition at line 746 of file font.c.

{
    GpStatus stat;
    GpFontFamily* ffamily;
    struct font_metrics fm;
 
    TRACE("%s, %p %p\n", debugstr_w(name), fontCollection, FontFamily);
 
    if (!(name && FontFamily))
        return InvalidParameter;
    if (fontCollection)
        FIXME("No support for FontCollections yet!\n");
 
    stat = find_installed_font(name, &fm);
    if (stat != Ok) return stat;
 
    ffamily = heap_alloc_zero(sizeof (GpFontFamily));
    if (!ffamily) return OutOfMemory;
 
    lstrcpyW(ffamily->FamilyName, fm.facename);
    ffamily->em_height = fm.em_height;
    ffamily->ascent = fm.ascent;
    ffamily->descent = fm.descent;
    ffamily->line_spacing = fm.line_spacing;
    ffamily->dpi = fm.dpi;
 
    *FontFamily = ffamily;
 
    TRACE("<-- %p\n", ffamily);
 
    return Ok;
}

Referenced by add_font_proc(), GdipCreateFontFromLogfontW(), GdipGetGenericFontFamilyMonospace(), GdipGetGenericFontFamilySansSerif(), GdipGetGenericFontFamilySerif(), METAFILE_PlaybackObject(), test_createfont(), test_font_height_scaling(), test_font_metrics(), test_font_substitution(), test_fontfamily(), test_fontfamily_properties(), test_GdipMeasureString(), test_heightgivendpi(), test_measure_string(), test_measured_extra_space(), and test_string_functions().

◆ GdipCreateFontFromDC()

GpStatus WINGDIPAPI GdipCreateFontFromDC	(	HDC	hdc,
		GpFont **	font
	)

Definition at line 286 of file font.c.

{
    HFONT hfont;
    LOGFONTW lfw;
 
    TRACE("(%p, %p)\n", hdc, font);
 
    if(!font)
        return InvalidParameter;
 
    hfont = GetCurrentObject(hdc, OBJ_FONT);
    if(!hfont)
        return GenericError;
 
    if(!GetObjectW(hfont, sizeof(LOGFONTW), &lfw))
        return GenericError;
 
    return GdipCreateFontFromLogfontW(hdc, &lfw, font);
}

◆ GdipCreateFontFromLogfontA()

GpStatus WINGDIPAPI GdipCreateFontFromLogfontA	(	HDC	hdc,
		GDIPCONST LOGFONTA *	lfa,
		GpFont **	font
	)

Definition at line 249 of file font.c.

{
    LOGFONTW lfw;
 
    TRACE("(%p, %p, %p)\n", hdc, lfa, font);
 
    if(!lfa || !font)
        return InvalidParameter;
 
    memcpy(&lfw, lfa, FIELD_OFFSET(LOGFONTA,lfFaceName) );
 
    if(!MultiByteToWideChar(CP_ACP, 0, lfa->lfFaceName, -1, lfw.lfFaceName, LF_FACESIZE))
        return GenericError;
 
    return GdipCreateFontFromLogfontW(hdc, &lfw, font);
}

Referenced by test_font_substitution(), test_font_transform(), test_GdipDrawString(), and test_logfont().

◆ GdipCreateFontFromLogfontW()

GpStatus WINGDIPAPI GdipCreateFontFromLogfontW	(	HDC	hdc,
		GDIPCONST LOGFONTW *	logfont,
		GpFont **	font
	)

Definition at line 203 of file font.c.

{
    HFONT hfont, oldfont;
    OUTLINETEXTMETRICW otm;
    WCHAR facename[LF_FACESIZE];
    GpStatus stat;
    int ret;
 
    TRACE("(%p, %p, %p)\n", hdc, logfont, font);
 
    if (!hdc || !logfont || !font)
        return InvalidParameter;
 
    hfont = CreateFontIndirectW(logfont);
    oldfont = SelectObject(hdc, hfont);
    otm.otmSize = sizeof(otm);
    ret = GetOutlineTextMetricsW(hdc, otm.otmSize, &otm);
    GetTextFaceW(hdc, LF_FACESIZE, facename);
    SelectObject(hdc, oldfont);
    DeleteObject(hfont);
 
    if (!ret) return NotTrueTypeFont;
 
    *font = heap_alloc_zero(sizeof(GpFont));
    if (!*font) return OutOfMemory;
 
    (*font)->unit = UnitWorld;
    (*font)->emSize = otm.otmTextMetrics.tmAscent;
    (*font)->otm = otm;
 
    stat = GdipCreateFontFamilyFromName(facename, NULL, &(*font)->family);
    if (stat != Ok)
    {
        heap_free(*font);
        return NotTrueTypeFont;
    }
 
    TRACE("<-- %p\n", *font);
 
    return Ok;
}

Referenced by GdipCreateFontFromDC(), GdipCreateFontFromLogfontA(), and test_font_metrics().

◆ GdipCreateFromHDC()

GpStatus WINGDIPAPI GdipCreateFromHDC	(	HDC	hdc,
		GpGraphics **	graphics
	)

Definition at line 2395 of file graphics.c.

{
    TRACE("(%p, %p)\n", hdc, graphics);
 
    return GdipCreateFromHDC2(hdc, NULL, graphics);
}

Referenced by check_metafile(), GdipAddPathString(), GdipCreateFromHWND(), GdipGetImageGraphicsContext(), get_path_hrgn(), test_alpha_hdc(), test_BeginContainer2(), test_bitmapfromgraphics(), test_clip_xform(), test_cliphrgn_transform(), test_clipping(), test_clipping_2(), test_constructor_destructor(), test_container_rects(), test_font_height_scaling(), test_font_metrics(), test_font_substitution(), test_font_transform(), test_fromhrgn(), test_GdipCreateRegionRgnData(), test_GdipDrawArc(), test_GdipDrawArcI(), test_GdipDrawBezierI(), test_GdipDrawCurve(), test_GdipDrawCurve2(), test_GdipDrawCurve2I(), test_GdipDrawCurve3(), test_GdipDrawCurve3I(), test_GdipDrawCurveI(), test_GdipDrawImagePointsRect(), test_GdipDrawImagePointsRectOnMemoryDC(), test_GdipDrawLineI(), test_GdipDrawLinesI(), test_GdipDrawString(), test_GdipFillClosedCurve(), test_GdipFillClosedCurve2(), test_GdipFillClosedCurve2I(), test_GdipFillClosedCurveI(), test_GdipFillPath(), test_GdipFillRectangles(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_GdipGetNearestColor(), test_GdipGetVisibleClipBounds(), test_GdipGetVisibleClipBounds_memoryDC(), test_GdipGetVisibleClipBounds_screen(), test_GdipGetVisibleClipBounds_window(), test_GdipGraphicsSetAbort(), test_GdipIsVisiblePoint(), test_GdipIsVisibleRect(), test_Get_Release_DC(), test_get_set_clip(), test_get_set_interpolation(), test_get_set_textrenderinghint(), test_getbounds(), test_gethrgn(), test_hdc_caching(), test_isempty(), test_isequal(), test_isinfinite(), test_isvisible(), test_isvisiblepoint(), test_isvisiblerect(), test_logfont(), test_measure_string(), test_measured_extra_space(), test_save_restore(), test_string_functions(), test_textcontrast(), test_texturewrap(), test_transform(), test_transformpoints(), test_translate(), and ZoomWnd_OnDraw().

◆ GdipCreateFromHDC2()

GpStatus WINGDIPAPI GdipCreateFromHDC2	(	HDC	hdc,
		HANDLE	hDevice,
		GpGraphics **	graphics
	)

Definition at line 2416 of file graphics.c.

{
    GpStatus retval;
    HBITMAP hbitmap;
    DIBSECTION dib;
 
    TRACE("(%p, %p, %p)\n", hdc, hDevice, graphics);
 
    if(hDevice != NULL)
        FIXME("Don't know how to handle parameter hDevice\n");
 
    if(hdc == NULL)
        return OutOfMemory;
 
    if(graphics == NULL)
        return InvalidParameter;
 
    *graphics = heap_alloc_zero(sizeof(GpGraphics));
    if(!*graphics)  return OutOfMemory;
 
    GdipSetMatrixElements(&(*graphics)->worldtrans, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
        heap_free(*graphics);
        return retval;
    }
 
    hbitmap = GetCurrentObject(hdc, OBJ_BITMAP);
    if (hbitmap && GetObjectW(hbitmap, sizeof(dib), &dib) == sizeof(dib) &&
        dib.dsBmih.biBitCount == 32 && dib.dsBmih.biCompression == BI_RGB)
    {
        (*graphics)->alpha_hdc = 1;
    }
 
    (*graphics)->hdc = hdc;
    (*graphics)->hwnd = WindowFromDC(hdc);
    (*graphics)->owndc = FALSE;
    (*graphics)->smoothing = SmoothingModeDefault;
    (*graphics)->compqual = CompositingQualityDefault;
    (*graphics)->interpolation = InterpolationModeBilinear;
    (*graphics)->pixeloffset = PixelOffsetModeDefault;
    (*graphics)->compmode = CompositingModeSourceOver;
    (*graphics)->unit = UnitDisplay;
    (*graphics)->scale = 1.0;
    (*graphics)->xres = GetDeviceCaps(hdc, LOGPIXELSX);
    (*graphics)->yres = GetDeviceCaps(hdc, LOGPIXELSY);
    (*graphics)->busy = FALSE;
    (*graphics)->textcontrast = 4;
    list_init(&(*graphics)->containers);
#ifdef __REACTOS__
    (*graphics)->contid = GDIP_GET_NEW_CONTID_FOR(*graphics);
#else
    (*graphics)->contid = 0;
#endif
    get_gdi_transform(*graphics, &(*graphics)->gdi_transform);
 
    (*graphics)->gdi_clip = CreateRectRgn(0,0,0,0);
    if (!GetClipRgn(hdc, (*graphics)->gdi_clip))
    {
        DeleteObject((*graphics)->gdi_clip);
        (*graphics)->gdi_clip = NULL;
    }
 
    TRACE("<-- %p\n", *graphics);
 
    return Ok;
}

Referenced by GdipCreateFromHDC().

◆ GdipCreateFromHWND()

GpStatus WINGDIPAPI GdipCreateFromHWND	(	HWND	hwnd,
		GpGraphics **	graphics
	)

Definition at line 2529 of file graphics.c.

{
    GpStatus ret;
    HDC hdc;
 
    TRACE("(%p, %p)\n", hwnd, graphics);
 
    hdc = GetDC(hwnd);
 
    if((ret = GdipCreateFromHDC(hdc, graphics)) != Ok)
    {
        ReleaseDC(hwnd, hdc);
        return ret;
    }
 
    (*graphics)->hwnd = hwnd;
    (*graphics)->owndc = TRUE;
 
    return Ok;
}

Referenced by GdipCreateFromHWNDICM(), test_constructor_destructor(), and test_transform().

◆ GdipCreateFromHWNDICM()

GpStatus WINGDIPAPI GdipCreateFromHWNDICM	(	HWND	hwnd,
		GpGraphics **	graphics
	)

Definition at line 2551 of file graphics.c.

{
    TRACE("(%p, %p)\n", hwnd, graphics);
 
    return GdipCreateFromHWND(hwnd, graphics);
}

Referenced by test_constructor_destructor().

◆ GdipCreateHalftonePalette()

HPALETTE WINGDIPAPI GdipCreateHalftonePalette ( void )

Definition at line 7011 of file graphics.c.

{
    static int calls;
 
    TRACE("\n");
 
    if (!calls++)
      FIXME("stub\n");
 
    return NULL;
}

◆ GdipCreateHatchBrush()

GpStatus WINGDIPAPI GdipCreateHatchBrush	(	GpHatchStyle	hatchstyle,
		ARGB	forecol,
		ARGB	backcol,
		GpHatch **	brush
	)

Definition at line 276 of file brush.c.

{
    TRACE("(%d, %d, %d, %p)\n", hatchstyle, forecol, backcol, brush);
 
    if(!brush)  return InvalidParameter;
 
    if(hatchstyle < HatchStyleMin || hatchstyle > HatchStyleMax)
        return InvalidParameter;
 
    *brush = heap_alloc_zero(sizeof(GpHatch));
    if (!*brush) return OutOfMemory;
 
    (*brush)->brush.bt = BrushTypeHatchFill;
    (*brush)->forecol = forecol;
    (*brush)->backcol = backcol;
    (*brush)->hatchstyle = hatchstyle;
    TRACE("<-- %p\n", *brush);
 
    return Ok;
}

Referenced by GdipCloneBrush(), metafile_deserialize_brush(), test_createHatchBrush(), and test_getHatchStyle().

◆ GdipCreateHBITMAPFromBitmap()

GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap	(	GpBitmap *	bitmap,
		HBITMAP *	hbmReturn,
		ARGB	background
	)

Definition at line 1479 of file image.c.

{
    GpStatus stat;
    HBITMAP result;
    UINT width, height;
    BITMAPINFOHEADER bih;
    LPBYTE bits;
    BOOL unlock;
 
    TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
 
    if (!bitmap || !hbmReturn) return InvalidParameter;
    if (!image_lock(&bitmap->image, &unlock)) return ObjectBusy;
 
    GdipGetImageWidth(&bitmap->image, &width);
    GdipGetImageHeight(&bitmap->image, &height);
 
    bih.biSize = sizeof(bih);
    bih.biWidth = width;
    bih.biHeight = height;
    bih.biPlanes = 1;
    bih.biBitCount = 32;
    bih.biCompression = BI_RGB;
    bih.biSizeImage = 0;
    bih.biXPelsPerMeter = 0;
    bih.biYPelsPerMeter = 0;
    bih.biClrUsed = 0;
    bih.biClrImportant = 0;
 
    result = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    if (!result)
    {
        image_unlock(&bitmap->image, unlock);
        return GenericError;
    }
 
    stat = convert_pixels(width, height, -width*4,
            bits + (width * 4 * (height - 1)), PixelFormat32bppPARGB,
            bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette);
    if (stat != Ok)
    {
        DeleteObject(result);
        image_unlock(&bitmap->image, unlock);
        return stat;
    }
 
    if (background & 0xffffff)
    {
        DWORD *ptr;
        UINT i;
        for (ptr = (DWORD*)bits, i = 0; i < width * height; ptr++, i++)
        {
            if ((*ptr & 0xff000000) == 0xff000000) continue;
            *ptr = blend_argb_no_bkgnd_alpha(*ptr, background);
        }
    }
 
    *hbmReturn = result;
    image_unlock(&bitmap->image, unlock);
    return Ok;
}

Referenced by GdipDrawImagePointsRect(), test_createhbitmap(), and test_image_format().

◆ GdipCreateHICONFromBitmap()

GpStatus WINGDIPAPI GdipCreateHICONFromBitmap	(	GpBitmap *	bitmap,
		HICON *	hicon
	)

Definition at line 2001 of file image.c.

{
    GpStatus stat;
    BitmapData lockeddata;
    ULONG andstride, xorstride, bitssize;
    LPBYTE andbits, xorbits, androw, xorrow, srcrow;
    UINT x, y;
 
    TRACE("(%p, %p)\n", bitmap, hicon);
 
    if (!bitmap || !hicon)
        return InvalidParameter;
 
    stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead,
        PixelFormat32bppPARGB, &lockeddata);
    if (stat == Ok)
    {
        andstride = ((lockeddata.Width+31)/32)*4;
        xorstride = lockeddata.Width*4;
        bitssize = (andstride + xorstride) * lockeddata.Height;
 
        andbits = heap_alloc_zero(bitssize);
 
        if (andbits)
        {
            xorbits = andbits + andstride * lockeddata.Height;
 
            for (y=0; y<lockeddata.Height; y++)
            {
                srcrow = ((LPBYTE)lockeddata.Scan0) + lockeddata.Stride * y;
 
                androw = andbits + andstride * y;
                for (x=0; x<lockeddata.Width; x++)
                    if (srcrow[3+4*x] >= 128)
                        androw[x/8] |= 1 << (7-x%8);
 
                xorrow = xorbits + xorstride * y;
                memcpy(xorrow, srcrow, xorstride);
            }
 
            *hicon = CreateIcon(NULL, lockeddata.Width, lockeddata.Height, 1, 32,
                andbits, xorbits);
 
            heap_free(andbits);
        }
        else
            stat = OutOfMemory;
 
        GdipBitmapUnlockBits(bitmap, &lockeddata);
    }
 
    return stat;
}

◆ GdipCreateImageAttributes()

GpStatus WINGDIPAPI GdipCreateImageAttributes ( GpImageAttributes ** imageattr )

Definition at line 82 of file imageattributes.c.

{
    if(!imageattr)
        return InvalidParameter;
 
    *imageattr = heap_alloc_zero(sizeof(GpImageAttributes));
    if(!*imageattr)    return OutOfMemory;
 
    (*imageattr)->wrap = WrapModeClamp;
 
    TRACE("<-- %p\n", *imageattr);
 
    return Ok;
}

Referenced by GdipCloneImageAttributes(), GdipCreateTexture(), GdipCreateTexture2(), GdipCreateTexture2I(), GdipCreateTextureIA(), METAFILE_PlaybackObject(), test_colorkey(), test_colormatrix(), test_drawimage(), test_gamma(), test_getadjustedpalette(), test_remaptable(), and ZoomWnd_OnDraw().

◆ GdipCreateLineBrush()

GpStatus WINGDIPAPI GdipCreateLineBrush	(	GDIPCONST GpPointF *	startpoint,
		GDIPCONST GpPointF *	endpoint,
		ARGB	startcolor,
		ARGB	endcolor,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 372 of file brush.c.

{
    GpStatus stat;
    GpRectF rect;
 
    TRACE("(%s, %s, %x, %x, %d, %p)\n", debugstr_pointf(startpoint),
          debugstr_pointf(endpoint), startcolor, endcolor, wrap, line);
 
    if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
        return InvalidParameter;
 
    if (startpoint->X == endpoint->X && startpoint->Y == endpoint->Y)
        return OutOfMemory;
 
    rect.X = startpoint->X < endpoint->X ? startpoint->X : endpoint->X;
    rect.Y = startpoint->Y < endpoint->Y ? startpoint->Y : endpoint->Y;
    rect.Width = fabs(startpoint->X - endpoint->X);
    rect.Height = fabs(startpoint->Y - endpoint->Y);
 
    if (rect.Width == 0.0f)
    {
        rect.X -= rect.Height / 2.0f;
        rect.Width = rect.Height;
    }
    else if (rect.Height == 0.0f)
    {
        rect.Y -= rect.Width / 2.0f;
        rect.Height = rect.Width;
    }
 
    stat = create_line_brush(&rect, startcolor, endcolor, wrap, line);
    if (stat != Ok)
        return stat;
 
    linegradient_init_transform(startpoint, endpoint, *line);
 
    TRACE("<-- %p\n", *line);
 
    return Ok;
}

Referenced by GdipCreateLineBrushI(), metafile_deserialize_brush(), test_constructor_destructor2(), test_getgamma(), test_gradientgetrect(), test_lineblend(), test_linelinearblend(), test_penfilltype(), and test_transform().

◆ GdipCreateLineBrushFromRect()

GpStatus WINGDIPAPI GdipCreateLineBrushFromRect	(	GDIPCONST GpRectF *	rect,
		ARGB	startcolor,
		ARGB	endcolor,
		LinearGradientMode	mode,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 436 of file brush.c.

{
    float angle;
 
    TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
          wrap, line);
 
    if(!line || !rect)
        return InvalidParameter;
 
    switch (mode)
    {
    case LinearGradientModeHorizontal:
        angle = 0.0f;
        break;
    case LinearGradientModeVertical:
        angle = 90.0f;
        break;
    case LinearGradientModeForwardDiagonal:
        angle = 45.0f;
        break;
    case LinearGradientModeBackwardDiagonal:
        angle = 135.0f;
        break;
    default:
        return InvalidParameter;
    }
 
    return GdipCreateLineBrushFromRectWithAngle(rect, startcolor, endcolor, angle, TRUE, wrap, line);
}

Referenced by GdipCreateLineBrushFromRectI(), test_gradientgetrect(), and test_transform().

◆ GdipCreateLineBrushFromRectI()

GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI	(	GDIPCONST GpRect *	rect,
		ARGB	startcolor,
		ARGB	endcolor,
		LinearGradientMode	mode,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 469 of file brush.c.

{
    GpRectF rectF;
 
    TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
          wrap, line);
 
    rectF.X      = (REAL) rect->X;
    rectF.Y      = (REAL) rect->Y;
    rectF.Width  = (REAL) rect->Width;
    rectF.Height = (REAL) rect->Height;
 
    return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
}

Referenced by GdipCreateLineBrushFromRectWithAngleI().

◆ GdipCreateLineBrushFromRectWithAngle()

GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle	(	GDIPCONST GpRectF *	rect,
		ARGB	startcolor,
		ARGB	endcolor,
		REAL	angle,
		BOOL	isAngleScalable,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 489 of file brush.c.

{
    GpStatus stat;
    REAL exofs, eyofs, far_x, far_y;
    REAL sin_angle, cos_angle, sin_cos_angle;
    GpPointF start, end;
 
    TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
          wrap, line);
 
    if (!rect || !line || wrap == WrapModeClamp)
        return InvalidParameter;
 
    if (!rect->Width || !rect->Height)
        return OutOfMemory;
 
    angle = fmodf(angle, 360);
    if (angle < 0)
        angle += 360;
 
    if (isAngleScalable)
    {
        float add_angle = 0;
 
        while(angle >= 90) {
            angle -= 180;
            add_angle += M_PI;
        }
 
        if (angle != 90 && angle != -90)
            angle = atan((rect->Width / rect->Height) * tan(deg2rad(angle)));
        else
            angle = deg2rad(angle);
        angle += add_angle;
    }
    else
    {
        angle = deg2rad(angle);
    }
 
    sin_angle = sinf(angle);
    cos_angle = cosf(angle);
    sin_cos_angle = sin_angle * cos_angle;
 
    far_x = rect->X + rect->Width;
    far_y = rect->Y + rect->Height;
 
    if (angle == 0.0f)
    {
        start.X = min(rect->X, far_x);
        start.Y = rect->Y;
        end.X = max(rect->X, far_x);
        end.Y = rect->Y;
    }
    else if (sin_cos_angle >= 0)
    {
        start.X = min(rect->X, far_x);
        start.Y = min(rect->Y, far_y);
        end.X = max(rect->X, far_x);
        end.Y = max(rect->Y, far_y);
    }
    else
    {
        start.X = max(rect->X, far_x);
        start.Y = min(rect->Y, far_y);
        end.X = min(rect->X, far_x);
        end.Y = max(rect->Y, far_y);
    }
 
    stat = create_line_brush(rect, startcolor, endcolor, wrap, line);
    if (stat != Ok || angle == 0.0f)
        return stat;
 
    if (sin_cos_angle >= 0)
    {
        exofs = rect->Height * sin_cos_angle + rect->Width * cos_angle * cos_angle;
        eyofs = rect->Height * sin_angle * sin_angle + rect->Width * sin_cos_angle;
    }
    else
    {
        exofs = rect->Width * sin_angle * sin_angle + rect->Height * sin_cos_angle;
        eyofs = -rect->Width * sin_cos_angle + rect->Height * sin_angle * sin_angle;
    }
 
    if (sin_angle >= 0)
    {
        end.X = rect->X + exofs;
        end.Y = rect->Y + eyofs;
    }
    else
    {
        end.X = start.X;
        end.Y = start.Y;
        start.X = rect->X + exofs;
        start.Y = rect->Y + eyofs;
    }
 
    linegradient_init_transform(&start, &end, *line);
 
    return stat;
}

Referenced by GdipCreateLineBrushFromRect(), test_createLineBrushFromRectWithAngle(), and test_gradientgetrect().

◆ GdipCreateLineBrushFromRectWithAngleI()

GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI	(	GDIPCONST GpRect *	rect,
		ARGB	startcolor,
		ARGB	endcolor,
		REAL	angle,
		BOOL	isAngleScalable,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 593 of file brush.c.

{
    TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
          wrap, line);
 
    return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
                                        wrap, line);
}

◆ GdipCreateLineBrushI()

GpStatus WINGDIPAPI GdipCreateLineBrushI	(	GDIPCONST GpPoint *	startpoint,
		GDIPCONST GpPoint *	endpoint,
		ARGB	startcolor,
		ARGB	endcolor,
		GpWrapMode	wrap,
		GpLineGradient **	line
	)

Definition at line 415 of file brush.c.

{
    GpPointF stF;
    GpPointF endF;
 
    TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
          startcolor, endcolor, wrap, line);
 
    if(!startpoint || !endpoint)
        return InvalidParameter;
 
    stF.X  = (REAL)startpoint->X;
    stF.Y  = (REAL)startpoint->Y;
    endF.X = (REAL)endpoint->X;
    endF.Y = (REAL)endpoint->Y;
 
    return GdipCreateLineBrush(&stF, &endF, startcolor, endcolor, wrap, line);
}

◆ GdipCreateMatrix()

GpStatus WINGDIPAPI GdipCreateMatrix ( GpMatrix ** matrix )

Definition at line 140 of file matrix.c.

{
    TRACE("(%p)\n", matrix);
 
    if(!matrix)
        return InvalidParameter;
 
    *matrix = heap_alloc_zero(sizeof(GpMatrix));
    if(!*matrix)    return OutOfMemory;
 
    (*matrix)->matrix[0] = 1.0;
    (*matrix)->matrix[1] = 0.0;
    (*matrix)->matrix[2] = 0.0;
    (*matrix)->matrix[3] = 1.0;
    (*matrix)->matrix[4] = 0.0;
    (*matrix)->matrix[5] = 0.0;
 
    return Ok;
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), GdipIsOutlineVisiblePathPoint(), get_pen_transform(), SOFTWARE_GdipDrawPath(), SOFTWARE_GdipDrawThinPath(), test_BeginContainer2(), test_clipping(), test_clipping_2(), test_excludeinfinite(), test_flatten(), test_font_transform(), test_GdipDrawString(), test_Get_Release_DC(), test_getregiondata(), test_gradientgetrect(), test_scans(), test_string_functions(), test_transform(), test_widen(), and test_worldtransform().

◆ GdipCreateMatrix2()

GpStatus WINGDIPAPI GdipCreateMatrix2	(	REAL	m11,
		REAL	m12,
		REAL	m21,
		REAL	m22,
		REAL	dx,
		REAL	dy,
		GpMatrix **	matrix
	)

Definition at line 61 of file matrix.c.

{
    TRACE("(%.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %p)\n", m11, m12, m21, m22, dx, dy, matrix);
 
    if(!matrix)
        return InvalidParameter;
 
    *matrix = heap_alloc_zero(sizeof(GpMatrix));
    if(!*matrix)    return OutOfMemory;
 
    /* first row */
    (*matrix)->matrix[0] = m11;
    (*matrix)->matrix[1] = m12;
    /* second row */
    (*matrix)->matrix[2] = m21;
    (*matrix)->matrix[3] = m22;
    /* third row */
    (*matrix)->matrix[4] = dx;
    (*matrix)->matrix[5] = dy;
 
    return Ok;
}

Referenced by GdipCreateMatrix3(), test_BeginContainer2(), test_constructor_destructor(), test_DrawImage_scale(), test_invert(), test_isidentity(), test_isinfinite(), test_isinvertible(), test_shear(), test_transform(), and test_worldbounds().

◆ GdipCreateMatrix3()

GpStatus WINGDIPAPI GdipCreateMatrix3	(	GDIPCONST GpRectF *	rect,
		GDIPCONST GpPointF *	pt,
		GpMatrix **	matrix
	)

Definition at line 85 of file matrix.c.

{
    REAL m11, m12, m21, m22, dx, dy;
    TRACE("(%p, %p, %p)\n", rect, pt, matrix);
 
    if(!matrix || !pt)
        return InvalidParameter;
 
    m11 = (pt[1].X - pt[0].X) / rect->Width;
    m21 = (pt[2].X - pt[0].X) / rect->Height;
    dx = pt[0].X - m11 * rect->X - m21 * rect->Y;
    m12 = (pt[1].Y - pt[0].Y) / rect->Width;
    m22 = (pt[2].Y - pt[0].Y) / rect->Height;
    dy = pt[0].Y - m12 * rect->X - m22 * rect->Y;
 
    return GdipCreateMatrix2(m11, m12, m21, m22, dx, dy, matrix);
}

Referenced by GdipCreateMatrix3I(), METAFILE_PlaybackUpdateWorldTransform(), and test_constructor3().

◆ GdipCreateMatrix3I()

GpStatus WINGDIPAPI GdipCreateMatrix3I	(	GDIPCONST GpRect *	rect,
		GDIPCONST GpPoint *	pt,
		GpMatrix **	matrix
	)

Definition at line 104 of file matrix.c.

{
    GpRectF rectF;
    GpPointF ptF[3];
    int i;
 
    TRACE("(%p, %p, %p)\n", rect, pt, matrix);
 
    rectF.X = (REAL)rect->X;
    rectF.Y = (REAL)rect->Y;
    rectF.Width = (REAL)rect->Width;
    rectF.Height = (REAL)rect->Height;
 
    for (i = 0; i < 3; i++) {
        ptF[i].X = (REAL)pt[i].X;
        ptF[i].Y = (REAL)pt[i].Y;
    }
    return GdipCreateMatrix3(&rectF, ptF, matrix);
}

◆ GdipCreateMetafileFromEmf()

GpStatus WINGDIPAPI GdipCreateMetafileFromEmf	(	HENHMETAFILE	hemf,
		BOOL	delete,
		GpMetafile **	metafile
	)

Definition at line 3804 of file metafile.c.

{
    GpStatus stat;
    MetafileHeader header;
 
    TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
 
    if(!hemf || !metafile)
        return InvalidParameter;
 
    stat = GdipGetMetafileHeaderFromEmf(hemf, &header);
    if (stat != Ok)
        return stat;
 
    *metafile = heap_alloc_zero(sizeof(GpMetafile));
    if (!*metafile)
        return OutOfMemory;
 
    (*metafile)->image.type = ImageTypeMetafile;
    (*metafile)->image.format = ImageFormatEMF;
    (*metafile)->image.frame_count = 1;
    (*metafile)->image.xres = header.DpiX;
    (*metafile)->image.yres = header.DpiY;
    (*metafile)->bounds.X = (REAL)header.u.EmfHeader.rclFrame.left / 2540.0 * header.DpiX;
    (*metafile)->bounds.Y = (REAL)header.u.EmfHeader.rclFrame.top / 2540.0 * header.DpiY;
    (*metafile)->bounds.Width = (REAL)(header.u.EmfHeader.rclFrame.right - header.u.EmfHeader.rclFrame.left)
                                / 2540.0 * header.DpiX;
    (*metafile)->bounds.Height = (REAL)(header.u.EmfHeader.rclFrame.bottom - header.u.EmfHeader.rclFrame.top)
                                 / 2540.0 * header.DpiY;
    (*metafile)->unit = UnitPixel;
    (*metafile)->metafile_type = header.Type;
    (*metafile)->hemf = hemf;
    (*metafile)->preserve_hemf = !delete;
    list_init(&(*metafile)->containers);
 
    TRACE("<-- %p\n", *metafile);
 
    return Ok;
}

Referenced by GdipCreateMetafileFromWmf(), GdipCreateMetafileFromWmfFile(), load_emf(), sync_metafile(), test_drawimage(), test_emfonly(), and test_empty().

◆ GdipCreateMetafileFromFile()

GpStatus WINGDIPAPI GdipCreateMetafileFromFile	(	GDIPCONST WCHAR *	file,
		GpMetafile **	metafile
	)

Definition at line 3915 of file metafile.c.

{
    GpStatus status;
    IStream *stream;
 
    TRACE("(%p, %p)\n", file, metafile);
 
    if (!file || !metafile) return InvalidParameter;
 
    *metafile = NULL;
 
    status = GdipCreateStreamOnFile(file, GENERIC_READ, &stream);
    if (status == Ok)
    {
        status = GdipCreateMetafileFromStream(stream, metafile);
        IStream_Release(stream);
    }
    return status;
}

Referenced by GdipGetMetafileHeaderFromFile().

◆ GdipCreateMetafileFromStream()

GpStatus WINGDIPAPI GdipCreateMetafileFromStream	(	IStream *	stream,
		GpMetafile **	metafile
	)

Definition at line 3936 of file metafile.c.

{
    GpStatus stat;
 
    TRACE("%p %p\n", stream, metafile);
 
    stat = GdipLoadImageFromStream(stream, (GpImage **)metafile);
    if (stat != Ok) return stat;
 
    if ((*metafile)->image.type != ImageTypeMetafile)
    {
        GdipDisposeImage(&(*metafile)->image);
        *metafile = NULL;
        return GenericError;
    }
 
    return Ok;
}

Referenced by GdipCreateMetafileFromFile(), and GdipGetMetafileHeaderFromStream().

◆ GdipCreateMetafileFromWmf()

GpStatus WINGDIPAPI GdipCreateMetafileFromWmf	(	HMETAFILE	hwmf,
		BOOL	delete,
		GDIPCONST WmfPlaceableFileHeader *	placeable,
		GpMetafile **	metafile
	)

Definition at line 3845 of file metafile.c.

{
    UINT read;
    BYTE *copy;
    HENHMETAFILE hemf;
    GpStatus retval = Ok;
 
    TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
 
    if(!hwmf || !metafile)
        return InvalidParameter;
 
    *metafile = NULL;
    read = GetMetaFileBitsEx(hwmf, 0, NULL);
    if(!read)
        return GenericError;
    copy = heap_alloc_zero(read);
    GetMetaFileBitsEx(hwmf, read, copy);
 
    hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
    heap_free(copy);
 
    /* FIXME: We should store and use hwmf instead of converting to hemf */
    retval = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
 
    if (retval == Ok)
    {
        if (placeable)
        {
            (*metafile)->image.xres = (REAL)placeable->Inch;
            (*metafile)->image.yres = (REAL)placeable->Inch;
            (*metafile)->bounds.X = ((REAL)placeable->BoundingBox.Left) / ((REAL)placeable->Inch);
            (*metafile)->bounds.Y = ((REAL)placeable->BoundingBox.Top) / ((REAL)placeable->Inch);
            (*metafile)->bounds.Width = (REAL)(placeable->BoundingBox.Right -
                                               placeable->BoundingBox.Left);
            (*metafile)->bounds.Height = (REAL)(placeable->BoundingBox.Bottom -
                                                placeable->BoundingBox.Top);
            (*metafile)->metafile_type = MetafileTypeWmfPlaceable;
        }
        else
            (*metafile)->metafile_type = MetafileTypeWmf;
        (*metafile)->image.format = ImageFormatWMF;
 
        if (delete) DeleteMetaFile(hwmf);
    }
    else
        DeleteEnhMetaFile(hemf);
    return retval;
}

Referenced by GdipCreateMetafileFromWmfFile(), GdipGetMetafileHeaderFromWmf(), load_wmf(), test_createfromwmf(), and test_createfromwmf_noplaceable().

◆ GdipCreateMetafileFromWmfFile()

GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile	(	GDIPCONST WCHAR *	file,
		GDIPCONST WmfPlaceableFileHeader *	placeable,
		GpMetafile **	metafile
	)

Definition at line 3896 of file metafile.c.

{
    HMETAFILE hmf;
    HENHMETAFILE emf;
 
    TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
 
    hmf = GetMetaFileW(file);
    if(hmf)
        return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
 
    emf = GetEnhMetaFileW(file);
    if(emf)
        return GdipCreateMetafileFromEmf(emf, TRUE, metafile);
 
    return GenericError;
}

Referenced by test_fillpath().

◆ GdipCreatePath()

GpStatus WINGDIPAPI GdipCreatePath	(	GpFillMode	fill,
		GpPath **	path
	)

Definition at line 1197 of file graphicspath.c.

{
    TRACE("(%d, %p)\n", fill, path);
 
    if(!path)
        return InvalidParameter;
 
    *path = heap_alloc_zero(sizeof(GpPath));
    if(!*path)  return OutOfMemory;
 
    (*path)->fill = fill;
    (*path)->newfigure = TRUE;
 
    return Ok;
}

Referenced by GdipCreatePathGradient(), GdipCreatePathGradientI(), GdipCreateRegionHrgn(), GdipDrawArc(), GdipDrawBeziers(), GdipDrawClosedCurve2(), GdipDrawCurve2(), GdipDrawEllipse(), GdipDrawLines(), GdipDrawPie(), GdipDrawPolygon(), GdipDrawRectangle(), GdipDrawRectangles(), GdipEnumerateMetafileSrcRectDestPoints(), GdipFillClosedCurve2(), GdipFillEllipse(), GdipFillPie(), GdipFillPolygon(), GdipFillPolygonI(), GdipFillRectangles(), get_region_hrgn(), metafile_deserialize_path(), read_element(), test_addclosedcurve(), test_addcurve(), test_addpie(), test_arc(), test_captype(), test_combinereplace(), test_constructor_destructor(), test_drawpath(), test_ellipse(), test_empty_rect(), test_fillpath(), test_flatten(), test_GdipFillPath(), test_Get_Release_DC(), test_gethrgn(), test_getpathdata(), test_getregiondata(), test_getsubpathcount(), test_hascurve(), test_inset(), test_isvalid(), test_isvisible(), test_isvisiblepoint(), test_isvisiblerect(), test_lastpoint(), test_line2(), test_linei(), test_linejoin(), test_nextmarker(), test_nextmarkerpath(), test_nextpathtype(), test_nextsubpath(), test_nextsubpathpath(), test_pathgradientpath(), test_pathpath(), test_pen_thickness(), test_polygon(), test_rect(), test_reverse(), test_scale(), test_transform(), test_translate(), test_widen(), test_worldbounds(), and transform_region_element().

◆ GdipCreatePath2()

GpStatus WINGDIPAPI GdipCreatePath2	(	GDIPCONST GpPointF *	points,
		GDIPCONST BYTE *	types,
		INT	count,
		GpFillMode	fill,
		GpPath **	path
	)

Definition at line 1213 of file graphicspath.c.

{
    TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
 
    if(!path)
        return InvalidParameter;
 
    *path = heap_alloc_zero(sizeof(GpPath));
    if(!*path)  return OutOfMemory;
 
    (*path)->pathdata.Points = heap_alloc_zero(count * sizeof(PointF));
    (*path)->pathdata.Types = heap_alloc_zero(count);
 
    if(!(*path)->pathdata.Points || !(*path)->pathdata.Types){
        heap_free((*path)->pathdata.Points);
        heap_free((*path)->pathdata.Types);
        heap_free(*path);
        return OutOfMemory;
    }
 
    memcpy((*path)->pathdata.Points, points, count * sizeof(PointF));
    memcpy((*path)->pathdata.Types, types, count);
    (*path)->pathdata.Count = count;
    (*path)->datalen = count;
 
    (*path)->fill = fill;
    (*path)->newfigure = TRUE;
 
    return Ok;
}

Referenced by GdipCreatePath2I().

◆ GdipCreatePath2I()

GpStatus WINGDIPAPI GdipCreatePath2I	(	GDIPCONST GpPoint *	points,
		GDIPCONST BYTE *	types,
		INT	count,
		GpFillMode	fill,
		GpPath **	path
	)

Definition at line 1245 of file graphicspath.c.

{
    GpPointF *ptF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %d, %d, %p)\n", points, types, count, fill, path);
 
    ptF = heap_alloc_zero(sizeof(GpPointF)*count);
 
    for(i = 0;i < count; i++){
        ptF[i].X = (REAL)points[i].X;
        ptF[i].Y = (REAL)points[i].Y;
    }
 
    ret = GdipCreatePath2(ptF, types, count, fill, path);
 
    heap_free(ptF);
 
    return ret;
}

◆ GdipCreatePathGradient()

GpStatus WINGDIPAPI GdipCreatePathGradient	(	GDIPCONST GpPointF *	points,
		INT	count,
		GpWrapMode	wrap,
		GpPathGradient **	grad
	)

Definition at line 658 of file brush.c.

{
    GpStatus stat;
    GpPath *path;
 
    TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
 
    if(!grad)
        return InvalidParameter;
 
    if(!points || count <= 0)
        return OutOfMemory;
 
    stat = GdipCreatePath(FillModeAlternate, &path);
 
    if (stat == Ok)
    {
        stat = GdipAddPathLine2(path, points, count);
 
        if (stat == Ok)
            stat = create_path_gradient(path, 0xff000000, grad);
 
        if (stat != Ok)
            GdipDeletePath(path);
    }
 
    if (stat == Ok)
        (*grad)->wrap = wrap;
 
    return stat;
}

Referenced by test_getblend(), test_getbounds(), test_gradientblendcount(), test_gradientsurroundcolorcount(), test_pathgradientblend(), test_pathgradientcenterpoint(), test_pathgradientpath(), and test_pathgradientpresetblend().

◆ GdipCreatePathGradientFromPath()

GpStatus WINGDIPAPI GdipCreatePathGradientFromPath	(	GDIPCONST GpPath *	path,
		GpPathGradient **	grad
	)

Definition at line 727 of file brush.c.

{
    GpStatus stat;
    GpPath *new_path;
 
    TRACE("(%p, %p)\n", path, grad);
 
    if(!grad)
        return InvalidParameter;
 
    if (!path)
        return OutOfMemory;
 
    stat = GdipClonePath((GpPath*)path, &new_path);
 
    if (stat == Ok)
    {
        stat = create_path_gradient(new_path, 0xffffffff, grad);
 
        if (stat != Ok)
            GdipDeletePath(new_path);
    }
 
    return stat;
}

◆ GdipCreatePathGradientI()

GpStatus WINGDIPAPI GdipCreatePathGradientI	(	GDIPCONST GpPoint *	points,
		INT	count,
		GpWrapMode	wrap,
		GpPathGradient **	grad
	)

Definition at line 691 of file brush.c.

{
    GpStatus stat;
    GpPath *path;
 
    TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
 
    if(!grad)
        return InvalidParameter;
 
    if(!points || count <= 0)
        return OutOfMemory;
 
    stat = GdipCreatePath(FillModeAlternate, &path);
 
    if (stat == Ok)
    {
        stat = GdipAddPathLine2I(path, points, count);
 
        if (stat == Ok)
            stat = create_path_gradient(path, 0xff000000, grad);
 
        if (stat != Ok)
            GdipDeletePath(path);
    }
 
    if (stat == Ok)
        (*grad)->wrap = wrap;
 
    return stat;
}

◆ GdipCreatePathIter()

GpStatus WINGDIPAPI GdipCreatePathIter	(	GpPathIterator **	iterator,
		GpPath *	path
	)

Definition at line 34 of file pathiterator.c.

{
    INT size;
 
    TRACE("(%p, %p)\n", iterator, path);
 
    if(!iterator)
        return InvalidParameter;
 
    *iterator = heap_alloc_zero(sizeof(GpPathIterator));
    if(!*iterator)  return OutOfMemory;
 
    if(path){
        size = path->pathdata.Count;
 
        (*iterator)->pathdata.Types  = heap_alloc_zero(size);
        (*iterator)->pathdata.Points = heap_alloc_zero(size * sizeof(PointF));
 
        memcpy((*iterator)->pathdata.Types, path->pathdata.Types, size);
        memcpy((*iterator)->pathdata.Points, path->pathdata.Points,size * sizeof(PointF));
        (*iterator)->pathdata.Count = size;
    }
    else{
        (*iterator)->pathdata.Types  = NULL;
        (*iterator)->pathdata.Points = NULL;
        (*iterator)->pathdata.Count  = 0;
    }
 
    (*iterator)->subpath_pos  = 0;
    (*iterator)->marker_pos   = 0;
    (*iterator)->pathtype_pos = 0;
 
    return Ok;
}

Referenced by test_constructor_destructor(), test_getsubpathcount(), test_hascurve(), test_isvalid(), test_nextmarker(), test_nextmarkerpath(), test_nextpathtype(), test_nextsubpath(), and test_nextsubpathpath().

◆ GdipCreatePen1()

GpStatus WINGDIPAPI GdipCreatePen1	(	ARGB	color,
		REAL	width,
		GpUnit	unit,
		GpPen **	pen
	)

Definition at line 136 of file pen.c.

{
    GpBrush *brush;
    GpStatus status;
 
    TRACE("(%x, %.2f, %d, %p)\n", color, width, unit, pen);
 
    GdipCreateSolidFill(color, (GpSolidFill **)(&brush));
    status = GdipCreatePen2(brush, width, unit, pen);
    GdipDeleteBrush(brush);
    return status;
}

Referenced by test_brushfill(), test_compoundarray(), test_constructor_destructor(), test_customcap(), test_dasharray(), test_drawpath(), test_emfonly(), test_GdipDrawArc(), test_GdipDrawArcI(), test_GdipDrawBezierI(), test_GdipDrawCurve(), test_GdipDrawCurve2(), test_GdipDrawCurve2I(), test_GdipDrawCurve3(), test_GdipDrawCurve3I(), test_GdipDrawCurveI(), test_GdipDrawLineI(), test_GdipDrawLinesI(), test_Get_Release_DC(), test_pen_thickness(), test_penfilltype(), test_startup(), test_transform(), test_widen(), and test_worldbounds().

◆ GdipCreatePen2()

GpStatus WINGDIPAPI GdipCreatePen2	(	GpBrush *	brush,
		REAL	width,
		GpUnit	unit,
		GpPen **	pen
	)

Definition at line 150 of file pen.c.

{
    GpPen *gp_pen;
    GpBrush *clone_brush;
 
    TRACE("(%p, %.2f, %d, %p)\n", brush, width, unit, pen);
 
    if(!pen || !brush)
        return InvalidParameter;
 
    gp_pen = heap_alloc_zero(sizeof(GpPen));
    if(!gp_pen)    return OutOfMemory;
 
    gp_pen->style = GP_DEFAULT_PENSTYLE;
    gp_pen->width = width;
    gp_pen->unit = unit;
    gp_pen->endcap = LineCapFlat;
    gp_pen->join = LineJoinMiter;
    gp_pen->miterlimit = 10.0;
    gp_pen->dash = DashStyleSolid;
    gp_pen->offset = 0.0;
    gp_pen->customstart = NULL;
    gp_pen->customend = NULL;
    GdipSetMatrixElements(&gp_pen->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    if(!((gp_pen->unit == UnitWorld) || (gp_pen->unit == UnitPixel))) {
        FIXME("UnitWorld, UnitPixel only supported units\n");
        heap_free(gp_pen);
        return NotImplemented;
    }
 
    GdipCloneBrush(brush, &clone_brush);
    gp_pen->brush = clone_brush;
 
    *pen = gp_pen;
 
    TRACE("<-- %p\n", *pen);
 
    return Ok;
}

Referenced by GdipCreatePen1(), METAFILE_PlaybackObject(), test_constructor_destructor2(), and test_penfilltype().

◆ GdipCreateRegion()

GpStatus WINGDIPAPI GdipCreateRegion ( GpRegion ** region )

Definition at line 390 of file region.c.

{
    TRACE("%p\n", region);
 
    if(!region)
        return InvalidParameter;
 
    *region = heap_alloc_zero(sizeof(GpRegion));
    if(!*region)
        return OutOfMemory;
 
    TRACE("=> %p\n", *region);
 
    return init_region(*region, RegionDataInfiniteRect);
}

Referenced by GdipCreateFromHDC2(), GdipCreateRegionHrgn(), GdipCreateRegionRgnData(), GdipEnumerateMetafileSrcRectDestPoints(), GdipGetClipBounds(), GdipGetVisibleClipBounds(), GdipIsVisibleClipEmpty(), GdipIsVisiblePoint(), GdipIsVisibleRect(), get_visible_clip_region(), graphics_from_image(), metafile_deserialize_region(), test_clip_xform(), test_clipping(), test_clipping_2(), test_combinereplace(), test_excludeinfinite(), test_font_height_scaling(), test_GdipCreateRegionRgnData(), test_Get_Release_DC(), test_getbounds(), test_gethrgn(), test_getregiondata(), test_isempty(), test_isequal(), test_isinfinite(), test_isvisiblepoint(), test_isvisiblerect(), test_measure_string(), test_scans(), test_string_functions(), test_transform(), and test_translate().

◆ GdipCreateRegionHrgn()

GpStatus WINGDIPAPI GdipCreateRegionHrgn	(	HRGN	hrgn,
		GpRegion **	region
	)

Definition at line 506 of file region.c.

{
    DWORD size;
    LPRGNDATA buf;
    LPRECT rect;
    GpStatus stat;
    GpPath* path;
    GpRegion* local;
    DWORD i;
 
    TRACE("(%p, %p)\n", hrgn, region);
 
    if(!region || !(size = GetRegionData(hrgn, 0, NULL)))
        return InvalidParameter;
 
    buf = heap_alloc_zero(size);
    if(!buf)
        return OutOfMemory;
 
    if(!GetRegionData(hrgn, size, buf)){
        heap_free(buf);
        return GenericError;
    }
 
    if(buf->rdh.nCount == 0){
        if((stat = GdipCreateRegion(&local)) != Ok){
            heap_free(buf);
            return stat;
        }
        if((stat = GdipSetEmpty(local)) != Ok){
            heap_free(buf);
            GdipDeleteRegion(local);
            return stat;
        }
        *region = local;
        heap_free(buf);
        return Ok;
    }
 
    if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok){
        heap_free(buf);
        return stat;
    }
 
    rect = (LPRECT)buf->Buffer;
    for(i = 0; i < buf->rdh.nCount; i++){
        if((stat = GdipAddPathRectangle(path, (REAL)rect->left, (REAL)rect->top,
                        (REAL)(rect->right - rect->left), (REAL)(rect->bottom - rect->top))) != Ok){
            heap_free(buf);
            GdipDeletePath(path);
            return stat;
        }
        rect++;
    }
 
    stat = GdipCreateRegionPath(path, region);
 
    heap_free(buf);
    GdipDeletePath(path);
    return stat;
}

Referenced by GdipSetClipHrgn(), and test_fromhrgn().

◆ GdipCreateRegionPath()

GpStatus WINGDIPAPI GdipCreateRegionPath	(	GpPath *	path,
		GpRegion **	region
	)

Definition at line 425 of file region.c.

{
    region_element* element;
    GpStatus stat;
 
    TRACE("%p, %p\n", path, region);
 
    if (!(path && region))
        return InvalidParameter;
 
    *region = heap_alloc_zero(sizeof(GpRegion));
    if(!*region)
        return OutOfMemory;
    stat = init_region(*region, RegionDataPath);
    if (stat != Ok)
    {
        GdipDeleteRegion(*region);
        return stat;
    }
    element = &(*region)->node;
 
    stat = GdipClonePath(path, &element->elementdata.path);
    if (stat != Ok)
    {
        GdipDeleteRegion(*region);
        return stat;
    }
 
    return Ok;
}

Referenced by GdipCombineRegionPath(), GdipCreateRegionHrgn(), GdipIsVisiblePathPoint(), GdipPlayMetafileRecord(), SOFTWARE_GdipFillPath(), test_gethrgn(), test_getregiondata(), and transform_region_element().

◆ GdipCreateRegionRect()

GpStatus WINGDIPAPI GdipCreateRegionRect	(	GDIPCONST GpRectF *	rect,
		GpRegion **	region
	)

Definition at line 459 of file region.c.

{
    GpStatus stat;
 
    TRACE("%p, %p\n", rect, region);
 
    if (!(rect && region))
        return InvalidParameter;
 
    *region = heap_alloc_zero(sizeof(GpRegion));
    stat = init_region(*region, RegionDataRect);
    if(stat != Ok)
    {
        GdipDeleteRegion(*region);
        return stat;
    }
 
    (*region)->node.elementdata.rect.X = rect->X;
    (*region)->node.elementdata.rect.Y = rect->Y;
    (*region)->node.elementdata.rect.Width = rect->Width;
    (*region)->node.elementdata.rect.Height = rect->Height;
 
    return Ok;
}

Referenced by GdipCombineRegionRect(), GdipCreateRegionRectI(), GdipPlayMetafileRecord(), GdipSetClipRect(), test_clipping(), test_combinereplace(), test_get_set_clip(), and test_gethrgn().

◆ GdipCreateRegionRectI()

GpStatus WINGDIPAPI GdipCreateRegionRectI	(	GDIPCONST GpRect *	rect,
		GpRegion **	region
	)

Definition at line 488 of file region.c.

{
    GpRectF rectf;
 
    TRACE("%p, %p\n", rect, region);
 
    rectf.X = (REAL)rect->X;
    rectf.Y = (REAL)rect->Y;
    rectf.Width = (REAL)rect->Width;
    rectf.Height = (REAL)rect->Height;
 
    return GdipCreateRegionRect(&rectf, region);
}

Referenced by test_getregiondata().

◆ GdipCreateRegionRgnData()

GpStatus WINGDIPAPI GdipCreateRegionRgnData	(	GDIPCONST BYTE *	data,
		INT	size,
		GpRegion **	region
	)

Definition at line 946 of file region.c.

{
    const struct region_data_header *region_data_header;
    struct memory_buffer mbuf;
    GpStatus status;
    INT count;
 
    TRACE("(%p, %d, %p)\n", data, size, region);
 
    if (!data || !size)
        return InvalidParameter;
 
    init_memory_buffer(&mbuf, data, size);
 
    region_data_header = buffer_read(&mbuf, sizeof(*region_data_header));
    if (!region_data_header || !VALID_MAGIC(region_data_header->header.magic))
        return InvalidParameter;
 
    status = GdipCreateRegion(region);
    if (status != Ok)
        return status;
 
    count = 0;
    status = read_element(&mbuf, *region, &(*region)->node, &count);
    if (status == Ok && !count)
        status = InvalidParameter;
 
    if (status != Ok)
    {
        GdipDeleteRegion(*region);
        *region = NULL;
    }
 
    return status;
}

Referenced by test_GdipCreateRegionRgnData(), and test_region_data().

◆ GdipCreateSolidFill()

GpStatus WINGDIPAPI GdipCreateSolidFill	(	ARGB	color,
		GpSolidFill **	sf
	)

Definition at line 757 of file brush.c.

{
    TRACE("(%x, %p)\n", color, sf);
 
    if(!sf)  return InvalidParameter;
 
    *sf = heap_alloc_zero(sizeof(GpSolidFill));
    if (!*sf) return OutOfMemory;
 
    (*sf)->brush.bt = BrushTypeSolidColor;
    (*sf)->color = color;
 
    TRACE("<-- %p\n", *sf);
 
    return Ok;
}

Referenced by GdipCreatePen1(), GdipGraphicsClear(), GdipPlayMetafileRecord(), metafile_deserialize_brush(), test_brushfill(), test_clipping(), test_constructor_destructor(), test_containers(), test_fillpath(), test_fillrect(), test_GdipDrawString(), test_GdipFillClosedCurve(), test_GdipFillClosedCurve2(), test_GdipFillClosedCurve2I(), test_GdipFillClosedCurveI(), test_GdipFillPath(), test_GdipFillRectangles(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), test_Get_Release_DC(), test_hdc_caching(), test_nullframerect(), test_pagetransform(), test_penfilltype(), test_string_functions(), test_type(), and test_worldtransform().

◆ GdipCreateStreamOnFile()

GpStatus WINGDIPAPI GdipCreateStreamOnFile	(	GDIPCONST WCHAR *	filename,
		UINT	access,
		IStream **	stream
	)

Definition at line 2558 of file graphics.c.

{
    DWORD dwMode;
    HRESULT ret;
 
    TRACE("(%s, %u, %p)\n", debugstr_w(filename), access, stream);
 
    if(!stream || !filename)
        return InvalidParameter;
 
    if(access & GENERIC_WRITE)
        dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
    else if(access & GENERIC_READ)
        dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
    else
        return InvalidParameter;
 
    ret = SHCreateStreamOnFileW(filename, dwMode, stream);
 
    return hresult_to_status(ret);
}

Referenced by GdipCreateBitmapFromFile(), GdipCreateMetafileFromFile(), GdipLoadImageFromFile(), and GdipSaveImageToFile().

◆ GdipCreateStringFormat()

GpStatus WINGDIPAPI GdipCreateStringFormat	(	INT	attr,
		LANGID	lang,
		GpStringFormat **	format
	)

Definition at line 76 of file stringformat.c.

{
    TRACE("(%i, %x, %p)\n", attr, lang, format);
 
    if(!format)
        return InvalidParameter;
 
    *format = heap_alloc_zero(sizeof(GpStringFormat));
    if(!*format)   return OutOfMemory;
 
    (*format)->attr = attr;
    (*format)->lang = lang;
    (*format)->digitlang = LANG_NEUTRAL;
    (*format)->trimming = StringTrimmingCharacter;
    (*format)->digitsub = StringDigitSubstituteUser;
    (*format)->character_ranges = NULL;
    (*format)->range_count = 0;
    (*format)->generic_typographic = FALSE;
    /* tabstops */
    (*format)->tabcount = 0;
    (*format)->firsttab = 0.0;
    (*format)->tabs = NULL;
 
    TRACE("<-- %p\n", *format);
 
    return Ok;
}

Referenced by test_characterrange(), test_constructor(), test_digitsubstitution(), test_font_height_scaling(), test_font_transform(), test_GdipDrawString(), test_GdipMeasureString(), test_measure_string(), test_measured_extra_space(), test_string_functions(), test_stringformatflags(), and test_tabstops().

◆ GdipCreateTexture()

GpStatus WINGDIPAPI GdipCreateTexture	(	GpImage *	image,
		GpWrapMode	wrapmode,
		GpTexture **	texture
	)

Definition at line 786 of file brush.c.

{
    UINT width, height;
    GpImageAttributes *attributes;
    GpStatus stat;
 
    TRACE("%p, %d %p\n", image, wrapmode, texture);
 
    if (!(image && texture))
        return InvalidParameter;
 
    stat = GdipGetImageWidth(image, &width);
    if (stat != Ok) return stat;
    stat = GdipGetImageHeight(image, &height);
    if (stat != Ok) return stat;
 
    stat = GdipCreateImageAttributes(&attributes);
 
    if (stat == Ok)
    {
        attributes->wrap = wrapmode;
 
        stat = GdipCreateTextureIA(image, attributes, 0, 0, width, height,
            texture);
 
        GdipDisposeImageAttributes(attributes);
    }
 
    return stat;
}

Referenced by metafile_deserialize_brush(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_texturewrap(), and test_transform().

◆ GdipCreateTexture2()

GpStatus WINGDIPAPI GdipCreateTexture2	(	GpImage *	image,
		GpWrapMode	wrapmode,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		GpTexture **	texture
	)

Definition at line 821 of file brush.c.

{
    GpImageAttributes *attributes;
    GpStatus stat;
 
    TRACE("%p %d %f %f %f %f %p\n", image, wrapmode,
            x, y, width, height, texture);
 
    stat = GdipCreateImageAttributes(&attributes);
 
    if (stat == Ok)
    {
        attributes->wrap = wrapmode;
 
        stat = GdipCreateTextureIA(image, attributes, x, y, width, height,
                texture);
 
        GdipDisposeImageAttributes(attributes);
    }
 
    return stat;
}

◆ GdipCreateTexture2I()

GpStatus WINGDIPAPI GdipCreateTexture2I	(	GpImage *	image,
		GpWrapMode	wrapmode,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		GpTexture **	texture
	)

Definition at line 928 of file brush.c.

{
    GpImageAttributes *imageattr;
    GpStatus stat;
 
    TRACE("%p %d %d %d %d %d %p\n", image, wrapmode, x, y, width, height,
            texture);
 
    stat = GdipCreateImageAttributes(&imageattr);
 
    if (stat == Ok)
    {
        imageattr->wrap = wrapmode;
 
        stat = GdipCreateTextureIA(image, imageattr, x, y, width, height, texture);
        GdipDisposeImageAttributes(imageattr);
    }
 
    return stat;
}

◆ GdipCreateTextureIA()

GpStatus WINGDIPAPI GdipCreateTextureIA	(	GpImage *	image,
		GDIPCONST GpImageAttributes *	imageattr,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		GpTexture **	texture
	)

Definition at line 848 of file brush.c.

{
    GpStatus status;
    GpImage *new_image=NULL;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n", image, imageattr, x, y, width, height,
           texture);
 
    if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
        return InvalidParameter;
 
    *texture = NULL;
 
    if(image->type != ImageTypeBitmap){
        FIXME("not implemented for image type %d\n", image->type);
        return NotImplemented;
    }
 
    status = GdipCloneBitmapArea(x, y, width, height, PixelFormatDontCare, (GpBitmap*)image, (GpBitmap**)&new_image);
    if (status != Ok)
        return status;
 
    *texture = heap_alloc_zero(sizeof(GpTexture));
    if (!*texture){
        status = OutOfMemory;
        goto exit;
    }
 
    GdipSetMatrixElements(&(*texture)->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    if (imageattr)
    {
        status = GdipCloneImageAttributes(imageattr, &(*texture)->imageattributes);
    }
    else
    {
        status = GdipCreateImageAttributes(&(*texture)->imageattributes);
        if (status == Ok)
            (*texture)->imageattributes->wrap = WrapModeTile;
    }
    if (status == Ok)
    {
        (*texture)->brush.bt = BrushTypeTextureFill;
        (*texture)->image = new_image;
    }
 
exit:
    if (status == Ok)
    {
        TRACE("<-- %p\n", *texture);
    }
    else
    {
        if (*texture)
        {
            GdipDisposeImageAttributes((*texture)->imageattributes);
            heap_free(*texture);
            *texture = NULL;
        }
        GdipDisposeImage(new_image);
        TRACE("<-- error %u\n", status);
    }
 
    return status;
}

Referenced by GdipCloneBrush(), GdipCreateTexture(), GdipCreateTexture2(), GdipCreateTexture2I(), and GdipCreateTextureIAI().

◆ GdipCreateTextureIAI()

GpStatus WINGDIPAPI GdipCreateTextureIAI	(	GpImage *	image,
		GDIPCONST GpImageAttributes *	imageattr,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		GpTexture **	texture
	)

Definition at line 919 of file brush.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d, %p)\n", image, imageattr, x, y, width, height,
           texture);
 
    return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
}

◆ GdipDeleteBrush()

GpStatus WINGDIPAPI GdipDeleteBrush ( GpBrush * brush )

Definition at line 994 of file brush.c.

{
    TRACE("(%p)\n", brush);
 
    if(!brush)  return InvalidParameter;
 
    switch(brush->bt)
    {
        case BrushTypePathGradient:
            GdipDeletePath(((GpPathGradient*) brush)->path);
            heap_free(((GpPathGradient*) brush)->blendfac);
            heap_free(((GpPathGradient*) brush)->blendpos);
            heap_free(((GpPathGradient*) brush)->surroundcolors);
            heap_free(((GpPathGradient*) brush)->pblendcolor);
            heap_free(((GpPathGradient*) brush)->pblendpos);
            break;
        case BrushTypeLinearGradient:
            heap_free(((GpLineGradient*)brush)->blendfac);
            heap_free(((GpLineGradient*)brush)->blendpos);
            heap_free(((GpLineGradient*)brush)->pblendcolor);
            heap_free(((GpLineGradient*)brush)->pblendpos);
            break;
        case BrushTypeTextureFill:
            GdipDisposeImage(((GpTexture*)brush)->image);
            GdipDisposeImageAttributes(((GpTexture*)brush)->imageattributes);
            heap_free(((GpTexture*)brush)->bitmap_bits);
            break;
        default:
            break;
    }
 
    heap_free(brush);
 
    return Ok;
}

Referenced by GdipCreatePen1(), GdipDeletePen(), GdipGraphicsClear(), GdipPlayMetafileRecord(), GdipSetPenBrushFill(), metafile_deserialize_brush(), metafile_free_object_table_entry(), METAFILE_PlaybackObject(), test_brushfill(), test_clipping(), test_constructor_destructor(), test_constructor_destructor2(), test_containers(), test_createHatchBrush(), test_createLineBrushFromRectWithAngle(), test_fillpath(), test_fillrect(), test_GdipDrawString(), test_GdipFillClosedCurve(), test_GdipFillClosedCurve2(), test_GdipFillClosedCurve2I(), test_GdipFillClosedCurveI(), test_GdipFillPath(), test_GdipFillRectangles(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_Get_Release_DC(), test_getblend(), test_getbounds(), test_getgamma(), test_getHatchStyle(), test_gradientblendcount(), test_gradientgetrect(), test_gradientsurroundcolorcount(), test_hdc_caching(), test_lineblend(), test_linelinearblend(), test_nullframerect(), test_pagetransform(), test_pathgradientblend(), test_pathgradientcenterpoint(), test_pathgradientpath(), test_pathgradientpresetblend(), test_penfilltype(), test_string_functions(), test_texturewrap(), test_transform(), test_type(), and test_worldtransform().

◆ GdipDeleteCachedBitmap()

GpStatus WINGDIPAPI GdipDeleteCachedBitmap ( GpCachedBitmap * cachedbmp )

Definition at line 2055 of file image.c.

{
    TRACE("%p\n", cachedbmp);
 
    if(!cachedbmp)
        return InvalidParameter;
 
    GdipDisposeImage(cachedbmp->image);
    heap_free(cachedbmp);
 
    return Ok;
}

◆ GdipDeleteCustomLineCap()

GpStatus WINGDIPAPI GdipDeleteCustomLineCap ( GpCustomLineCap * customCap )

Definition at line 139 of file customlinecap.c.

{
    TRACE("(%p)\n", customCap);
 
    if(!customCap)
        return InvalidParameter;
 
    heap_free(customCap->pathdata.Points);
    heap_free(customCap->pathdata.Types);
    heap_free(customCap);
 
    return Ok;
}

Referenced by GdipDeletePen(), GdipSetPenCustomEndCap(), GdipSetPenCustomStartCap(), GdipSetPenEndCap(), GdipSetPenLineCap197819(), GdipSetPenStartCap(), test_captype(), test_constructor_destructor(), test_create_adjustable_cap(), test_inset(), test_linejoin(), and test_scale().

◆ GdipDeleteEffect()

GpStatus WINGDIPAPI GdipDeleteEffect ( CGpEffect * effect )

Definition at line 5287 of file image.c.

{
    FIXME("(%p): stub\n", effect);
    /* note: According to Jose Roca's GDI+ Docs, this is not implemented
     * in Windows's gdiplus */
    return NotImplemented;
}

◆ GdipDeleteFont()

GpStatus WINGDIPAPI GdipDeleteFont ( GpFont * font )

Definition at line 270 of file font.c.

{
    TRACE("(%p)\n", font);
 
    if(!font)
        return InvalidParameter;
 
    GdipDeleteFontFamily(font->family);
    heap_free(font);
 
    return Ok;
}

Referenced by check_family(), GdipAddPathString(), metafile_free_object_table_entry(), test_createfont(), test_font_height_scaling(), test_font_metrics(), test_font_substitution(), test_font_transform(), test_GdipDrawString(), test_GdipMeasureString(), test_heightgivendpi(), test_logfont(), test_long_name(), test_measure_string(), test_measured_extra_space(), and test_string_functions().

◆ GdipDeleteFontFamily()

GpStatus WINGDIPAPI GdipDeleteFontFamily ( GpFontFamily * FontFamily )

Definition at line 869 of file font.c.

{
    if (!FontFamily)
        return InvalidParameter;
    TRACE("Deleting %p (%s)\n", FontFamily, debugstr_w(FontFamily->FamilyName));
 
    heap_free (FontFamily);
 
    return Ok;
}

Referenced by add_font_proc(), check_family(), free_installed_fonts(), gdip_get_font_metrics(), GdipDeleteFont(), GdipGetFontCollectionFamilyList(), METAFILE_PlaybackObject(), test_createfont(), test_font_height_scaling(), test_font_metrics(), test_font_substitution(), test_fontfamily(), test_fontfamily_properties(), test_GdipGetFontCollectionFamilyList(), test_GdipMeasureString(), test_heightgivendpi(), test_logfont(), test_measure_string(), test_measured_extra_space(), and test_string_functions().

◆ GdipDeleteGraphics()

GpStatus WINGDIPAPI GdipDeleteGraphics ( GpGraphics * graphics )

Definition at line 2581 of file graphics.c.

{
    GraphicsContainerItem *cont, *next;
    GpStatus stat;
    TRACE("(%p)\n", graphics);
 
    if(!graphics) return InvalidParameter;
    if(graphics->busy) return ObjectBusy;
 
    if (graphics->image && graphics->image_type == ImageTypeMetafile)
    {
        stat = METAFILE_GraphicsDeleted((GpMetafile*)graphics->image);
        if (stat != Ok)
            return stat;
    }
 
    if(graphics->owndc)
        ReleaseDC(graphics->hwnd, graphics->hdc);
 
    LIST_FOR_EACH_ENTRY_SAFE(cont, next, &graphics->containers, GraphicsContainerItem, entry){
        list_remove(&cont->entry);
        delete_container(cont);
    }
 
    GdipDeleteRegion(graphics->clip);
 
    DeleteObject(graphics->gdi_clip);
 
    /* Native returns ObjectBusy on the second free, instead of crashing as we'd
     * do otherwise, but we can't have that in the test suite because it means
     * accessing freed memory. */
    graphics->busy = TRUE;
 
    heap_free(graphics);
 
    return Ok;
}

Referenced by check_metafile(), GdipAddPathString(), GdipGetImageThumbnail(), get_path_hrgn(), METAFILE_DrawImagePointsRect(), test_alpha_hdc(), test_BeginContainer2(), test_bitmapfromgraphics(), test_clear(), test_clip_xform(), test_cliphrgn_transform(), test_clipping(), test_clipping_2(), test_colorkey(), test_colormatrix(), test_constructor_destructor(), test_container_rects(), test_containers(), test_converttoemfplus(), test_DrawImage(), test_drawimage(), test_DrawImage_scale(), test_DrawImage_SourceCopy(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_font_height_scaling(), test_font_metrics(), test_font_substitution(), test_font_transform(), test_frameunit(), test_fromhrgn(), test_fromMemoryBitmap(), test_gamma(), test_GdipCreateRegionRgnData(), test_GdipDrawArc(), test_GdipDrawArcI(), test_GdipDrawBezierI(), test_GdipDrawCurve(), test_GdipDrawCurve2(), test_GdipDrawCurve2I(), test_GdipDrawCurve3(), test_GdipDrawCurve3I(), test_GdipDrawCurveI(), test_GdipDrawImagePointRect(), test_GdipDrawImagePointsRect(), test_GdipDrawImagePointsRectOnMemoryDC(), test_GdipDrawLineI(), test_GdipDrawLinesI(), test_GdipDrawString(), test_GdipFillClosedCurve(), test_GdipFillClosedCurve2(), test_GdipFillClosedCurve2I(), test_GdipFillClosedCurveI(), test_GdipFillPath(), test_GdipFillRectangles(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_GdipGetNearestColor(), test_GdipGetVisibleClipBounds(), test_GdipGetVisibleClipBounds_memoryDC(), test_GdipGetVisibleClipBounds_screen(), test_GdipGetVisibleClipBounds_window(), test_GdipGraphicsSetAbort(), test_GdipIsVisiblePoint(), test_GdipIsVisibleRect(), test_GdipMeasureString(), test_gditransform(), test_Get_Release_DC(), test_get_set_clip(), test_get_set_interpolation(), test_get_set_textrenderinghint(), test_getbounds(), test_getdc(), test_getdc_scaled(), test_gethrgn(), test_hdc_caching(), test_isempty(), test_isequal(), test_isinfinite(), test_isvisible(), test_isvisiblepoint(), test_isvisiblerect(), test_logfont(), test_measure_string(), test_measured_extra_space(), test_nullframerect(), test_pagetransform(), test_pen_thickness(), test_properties(), test_remaptable(), test_resolution(), test_save_restore(), test_string_functions(), test_textcontrast(), test_texturewrap(), test_transform(), test_transformpoints(), test_translate(), test_worldtransform(), and ZoomWnd_OnDraw().

◆ GdipDeleteMatrix()

GpStatus WINGDIPAPI GdipDeleteMatrix ( GpMatrix * matrix )

Definition at line 160 of file matrix.c.

{
    TRACE("(%p)\n", matrix);
 
    if(!matrix)
        return InvalidParameter;
 
    heap_free(matrix);
 
    return Ok;
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), GdipIsOutlineVisiblePathPoint(), get_pen_transform(), METAFILE_PlaybackUpdateWorldTransform(), SOFTWARE_GdipDrawPath(), SOFTWARE_GdipDrawThinPath(), test_BeginContainer2(), test_clipping(), test_clipping_2(), test_constructor3(), test_constructor_destructor(), test_DrawImage_scale(), test_excludeinfinite(), test_flatten(), test_font_transform(), test_GdipDrawString(), test_Get_Release_DC(), test_getregiondata(), test_gradientgetrect(), test_invert(), test_isidentity(), test_isinfinite(), test_isinvertible(), test_scans(), test_shear(), test_string_functions(), test_transform(), test_widen(), test_worldbounds(), and test_worldtransform().

◆ GdipDeletePath()

GpStatus WINGDIPAPI GdipDeletePath ( GpPath * path )

Definition at line 1268 of file graphicspath.c.

{
    TRACE("(%p)\n", path);
 
    if(!path)
        return InvalidParameter;
 
    heap_free(path->pathdata.Points);
    heap_free(path->pathdata.Types);
    heap_free(path);
 
    return Ok;
}

Referenced by brush_fill_pixels(), delete_element(), GdipAddPathRectangle(), GdipAddPathRectangles(), GdipAddPathString(), GdipCloneBrush(), GdipCreatePathGradient(), GdipCreatePathGradientFromPath(), GdipCreatePathGradientI(), GdipCreateRegionHrgn(), GdipDeleteBrush(), GdipDrawArc(), GdipDrawBeziers(), GdipDrawClosedCurve2(), GdipDrawCurve2(), GdipDrawEllipse(), GdipDrawLines(), GdipDrawPie(), GdipDrawPolygon(), GdipDrawRectangle(), GdipDrawRectangles(), GdipEnumerateMetafileSrcRectDestPoints(), GdipFillClosedCurve2(), GdipFillEllipse(), GdipFillPie(), GdipFillPolygon(), GdipFillPolygonI(), GdipFillRectangles(), GdipIsOutlineVisiblePathPoint(), GdipSetClipPath(), GdipWidenPath(), get_region_hrgn(), metafile_deserialize_path(), metafile_free_object_table_entry(), SOFTWARE_GdipDrawPath(), SOFTWARE_GdipDrawThinPath(), test_addclosedcurve(), test_addcurve(), test_addpie(), test_arc(), test_captype(), test_combinereplace(), test_constructor_destructor(), test_drawpath(), test_ellipse(), test_empty_rect(), test_fillpath(), test_flatten(), test_GdipFillPath(), test_Get_Release_DC(), test_gethrgn(), test_getpathdata(), test_getregiondata(), test_getsubpathcount(), test_hascurve(), test_inset(), test_isvalid(), test_isvisible(), test_isvisiblepoint(), test_isvisiblerect(), test_lastpoint(), test_line2(), test_linei(), test_linejoin(), test_nextmarker(), test_nextmarkerpath(), test_nextpathtype(), test_nextsubpath(), test_nextsubpathpath(), test_pathgradientpath(), test_pathpath(), test_pen_thickness(), test_polygon(), test_rect(), test_reverse(), test_scale(), test_transform(), test_translate(), test_widen(), test_worldbounds(), and transform_region_element().

◆ GdipDeletePathIter()

GpStatus WINGDIPAPI GdipDeletePathIter ( GpPathIterator * iter )

Definition at line 69 of file pathiterator.c.

{
    TRACE("(%p)\n", iter);
 
    if(!iter)
        return InvalidParameter;
 
    heap_free(iter->pathdata.Types);
    heap_free(iter->pathdata.Points);
    heap_free(iter);
 
    return Ok;
}

Referenced by test_constructor_destructor(), test_getsubpathcount(), test_hascurve(), test_isvalid(), test_nextmarker(), test_nextmarkerpath(), test_nextpathtype(), test_nextsubpath(), and test_nextsubpathpath().

◆ GdipDeletePen()

GpStatus WINGDIPAPI GdipDeletePen ( GpPen * pen )

Definition at line 192 of file pen.c.

{
    TRACE("(%p)\n", pen);
 
    if(!pen)    return InvalidParameter;
 
    GdipDeleteBrush(pen->brush);
    GdipDeleteCustomLineCap(pen->customstart);
    GdipDeleteCustomLineCap(pen->customend);
    heap_free(pen->dashes);
    heap_free(pen);
 
    return Ok;
}

Referenced by GdipClonePen(), metafile_free_object_table_entry(), METAFILE_PlaybackObject(), test_brushfill(), test_compoundarray(), test_constructor_destructor(), test_constructor_destructor2(), test_customcap(), test_dasharray(), test_drawpath(), test_emfonly(), test_GdipDrawArc(), test_GdipDrawArcI(), test_GdipDrawBezierI(), test_GdipDrawCurve(), test_GdipDrawCurve2(), test_GdipDrawCurve2I(), test_GdipDrawCurve3(), test_GdipDrawCurve3I(), test_GdipDrawCurveI(), test_GdipDrawLineI(), test_GdipDrawLinesI(), test_Get_Release_DC(), test_pen_thickness(), test_penfilltype(), test_startup(), test_transform(), test_widen(), and test_worldbounds().

◆ GdipDeletePrivateFontCollection()

GpStatus WINGDIPAPI GdipDeletePrivateFontCollection ( GpFontCollection ** fontCollection )

Definition at line 1118 of file font.c.

{
    INT i;
 
    TRACE("%p\n", fontCollection);
 
    if (!fontCollection)
        return InvalidParameter;
 
    for (i = 0; i < (*fontCollection)->count; i++) heap_free((*fontCollection)->FontFamilies[i]);
    heap_free((*fontCollection)->FontFamilies);
    heap_free(*fontCollection);
 
    return Ok;
}

Referenced by test_long_name().

◆ GdipDeleteRegion()

GpStatus WINGDIPAPI GdipDeleteRegion ( GpRegion * region )

Definition at line 571 of file region.c.

{
    TRACE("%p\n", region);
 
    if (!region)
        return InvalidParameter;
 
    delete_element(&region->node);
    heap_free(region);
 
    return Ok;
}

Referenced by delete_container(), GdipCombineRegionPath(), GdipCombineRegionRect(), GdipCreateRegionHrgn(), GdipCreateRegionPath(), GdipCreateRegionRect(), GdipCreateRegionRgnData(), GdipDeleteGraphics(), GdipEnumerateMetafileSrcRectDestPoints(), GdipGetClip(), GdipGetClipBounds(), GdipGetVisibleClipBounds(), GdipIsVisibleClipEmpty(), GdipIsVisiblePathPoint(), GdipIsVisiblePoint(), GdipIsVisibleRect(), GdipPlayMetafileRecord(), GdipSetClipHrgn(), GdipSetClipRect(), GdipSetClipRegion(), get_clip_hrgn(), get_region_scans_data(), get_visible_clip_region(), metafile_deserialize_region(), metafile_free_object_table_entry(), restore_container(), SOFTWARE_GdipFillPath(), SOFTWARE_GdipFillRegion(), test_clip_xform(), test_clipping(), test_clipping_2(), test_combinereplace(), test_excludeinfinite(), test_font_height_scaling(), test_fromhrgn(), test_GdipCreateRegionRgnData(), test_Get_Release_DC(), test_get_set_clip(), test_getbounds(), test_gethrgn(), test_getregiondata(), test_isempty(), test_isequal(), test_isinfinite(), test_isvisiblepoint(), test_isvisiblerect(), test_measure_string(), test_region_data(), test_scans(), test_string_functions(), test_transform(), and test_translate().

◆ GdipDeleteStringFormat()

GpStatus WINGDIPAPI GdipDeleteStringFormat ( GpStringFormat * format )

Definition at line 105 of file stringformat.c.

{
    if(!format)
        return InvalidParameter;
 
    if (format == &generic_default_format || format == &generic_typographic_format)
        return Ok;
 
    heap_free(format->character_ranges);
    heap_free(format->tabs);
    heap_free(format);
 
    return Ok;
}

Referenced by test_characterrange(), test_constructor(), test_digitsubstitution(), test_font_height_scaling(), test_font_transform(), test_GdipDrawString(), test_GdipMeasureString(), test_getgenericdefault(), test_getgenerictypographic(), test_measure_string(), test_measured_extra_space(), test_string_functions(), test_stringformatflags(), and test_tabstops().

◆ GdipDisposeImage()

GpStatus WINGDIPAPI GdipDisposeImage ( GpImage * image )

Definition at line 2155 of file image.c.

{
    GpStatus status;
 
    TRACE("%p\n", image);
 
    status = free_image_data(image);
    if (status != Ok) return status;
    image->type = ~0;
    heap_free(image);
 
    return Ok;
}

Referenced by decode_frame_wic(), DibLoadImage(), GdipCloneBitmapArea(), GdipCreateBitmapFromHBITMAP(), GdipCreateBitmapFromHICON(), GdipCreateBitmapFromScan0(), GdipCreateBitmapFromStream(), GdipCreateMetafileFromStream(), GdipCreateTextureIA(), GdipDeleteBrush(), GdipDeleteCachedBitmap(), GdipGetImageThumbnail(), GdipGetMetafileHeaderFromFile(), GdipGetMetafileHeaderFromStream(), GdipGetMetafileHeaderFromWmf(), GdipImageRotateFlip(), load_image(), metafile_deserialize_brush(), metafile_deserialize_image(), METAFILE_DrawImagePointsRect(), metafile_free_object_table_entry(), Preview_pFreeImage(), SetWallpaper(), sync_metafile(), test_ARGB_conversion(), test_bitmapbits(), test_bitmapfromgraphics(), test_bufferrawformat(), test_clear(), test_clipping(), test_CloneBitmapArea(), test_colorkey(), test_colormatrix(), test_containers(), test_converttoemfplus(), test_createfromwmf(), test_createfromwmf_noplaceable(), test_createhbitmap(), test_dispose(), test_DrawImage(), test_drawimage(), test_DrawImage_scale(), test_DrawImage_SourceCopy(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_frameunit(), test_FromGdiDib(), test_fromhicon(), test_fromMemoryBitmap(), test_gamma(), test_GdipCloneImage(), test_GdipCreateBitmapFromHBITMAP(), test_GdipDrawImagePointRect(), test_GdipDrawImagePointsRect(), test_GdipDrawImagePointsRectOnMemoryDC(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_GdipGetAllPropertyItems(), test_GdipGetImageFlags(), test_GdipGetNearestColor(), test_GdipImageGetFrameDimensionsCount(), test_GdipInitializePalette(), test_GdipMeasureString(), test_gditransform(), test_getdc(), test_getdc_scaled(), test_GetImageDimension(), test_getsetpixel(), test_getthumbnail(), test_gif_properties(), test_histogram(), test_image_format(), test_image_properties(), test_imageabort(), test_loadwmf(), test_LockBits(), test_LockBits_UserBuf(), test_multiframegif(), test_nullframerect(), test_pagetransform(), test_palette(), test_pen_thickness(), test_png_color_formats(), test_properties(), test_remaptable(), test_resolution(), test_rotateflip(), test_SavingImages(), test_Scan0(), test_supported_encoders(), test_texturewrap(), test_tiff_color_formats(), test_tiff_palette(), test_tiff_properties(), test_transform(), and test_worldtransform().

◆ GdipDisposeImageAttributes()

GpStatus WINGDIPAPI GdipDisposeImageAttributes ( GpImageAttributes * imageattr )

Definition at line 97 of file imageattributes.c.

{
    int i;
 
    TRACE("(%p)\n", imageattr);
 
    if(!imageattr)
        return InvalidParameter;
 
    for (i=0; i<ColorAdjustTypeCount; i++)
        heap_free(imageattr->colorremaptables[i].colormap);
 
    heap_free(imageattr);
 
    return Ok;
}

Referenced by GdipCreateTexture(), GdipCreateTexture2(), GdipCreateTexture2I(), GdipCreateTextureIA(), GdipDeleteBrush(), metafile_free_object_table_entry(), METAFILE_PlaybackObject(), test_colorkey(), test_colormatrix(), test_drawimage(), test_gamma(), test_getadjustedpalette(), test_remaptable(), and ZoomWnd_OnDraw().

◆ GdipDrawArc()

GpStatus WINGDIPAPI GdipDrawArc	(	GpGraphics *	graphics,
		GpPen *	pen,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 2619 of file graphics.c.

{
    GpStatus status;
    GpPath *path;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
          width, height, startAngle, sweepAngle);
 
    if(!graphics || !pen || width <= 0 || height <= 0)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathArc(path, x, y, width, height, startAngle, sweepAngle);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipDrawArcI(), GdipPlayMetafileRecord(), test_GdipDrawArc(), and test_Get_Release_DC().

◆ GdipDrawArcI()

GpStatus WINGDIPAPI GdipDrawArcI	(	GpGraphics *	graphics,
		GpPen *	pen,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 2645 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
          width, height, startAngle, sweepAngle);
 
    return GdipDrawArc(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
}

Referenced by GdipPlayMetafileRecord(), test_GdipDrawArcI(), and test_Get_Release_DC().

◆ GdipDrawBezier()

GpStatus WINGDIPAPI GdipDrawBezier	(	GpGraphics *	graphics,
		GpPen *	pen,
		REAL	x1,
		REAL	y1,
		REAL	x2,
		REAL	y2,
		REAL	x3,
		REAL	y3,
		REAL	x4,
		REAL	y4
	)

Definition at line 2654 of file graphics.c.

{
    GpPointF pt[4];
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1,
          x2, y2, x3, y3, x4, y4);
 
    if(!graphics || !pen)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    pt[0].X = x1;
    pt[0].Y = y1;
    pt[1].X = x2;
    pt[1].Y = y2;
    pt[2].X = x3;
    pt[2].Y = y3;
    pt[3].X = x4;
    pt[3].Y = y4;
    return GdipDrawBeziers(graphics, pen, pt, 4);
}

Referenced by GdipDrawBezierI(), and test_Get_Release_DC().

◆ GdipDrawBezierI()

GpStatus WINGDIPAPI GdipDrawBezierI	(	GpGraphics *	graphics,
		GpPen *	pen,
		INT	x1,
		INT	y1,
		INT	x2,
		INT	y2,
		INT	x3,
		INT	y3,
		INT	x4,
		INT	y4
	)

Definition at line 2679 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d)\n", graphics, pen, x1, y1,
          x2, y2, x3, y3, x4, y4);
 
    return GdipDrawBezier(graphics, pen, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2, (REAL)x3, (REAL)y3, (REAL)x4, (REAL)y4);
}

Referenced by test_GdipDrawBezierI(), and test_Get_Release_DC().

◆ GdipDrawBeziers()

GpStatus WINGDIPAPI GdipDrawBeziers	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 2688 of file graphics.c.

{
    GpStatus status;
    GpPath *path;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    if(!graphics || !pen || !points || (count <= 0))
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathBeziers(path, points, count);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipDrawBezier(), GdipDrawBeziersI(), and test_Get_Release_DC().

◆ GdipDrawBeziersI()

GpStatus WINGDIPAPI GdipDrawBeziersI	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 2713 of file graphics.c.

{
    GpPointF *pts;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    if(!graphics || !pen || !points || (count <= 0))
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    pts = heap_alloc_zero(sizeof(GpPointF) * count);
    if(!pts)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        pts[i].X = (REAL)points[i].X;
        pts[i].Y = (REAL)points[i].Y;
    }
 
    ret = GdipDrawBeziers(graphics,pen,pts,count);
 
    heap_free(pts);
 
    return ret;
}

Referenced by test_Get_Release_DC().

◆ GdipDrawCachedBitmap()

GpStatus WINGDIPAPI GdipDrawCachedBitmap	(	GpGraphics *	graphics,
		GpCachedBitmap *	cachedbmp,
		INT	x,
		INT	y
	)

Definition at line 2068 of file image.c.

{
    TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
 
    if(!graphics || !cachedbmp)
        return InvalidParameter;
 
    return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
}

◆ GdipDrawClosedCurve()

GpStatus WINGDIPAPI GdipDrawClosedCurve	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 2744 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    return GdipDrawClosedCurve2(graphics, pen, points, count, 1.0);
}

Referenced by test_Get_Release_DC().

◆ GdipDrawClosedCurve2()

GpStatus WINGDIPAPI GdipDrawClosedCurve2	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPointF *	points,
		INT	count,
		REAL	tension
	)

Definition at line 2760 of file graphics.c.

{
    GpPath *path;
    GpStatus status;
 
    TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
 
    if(!graphics || !pen || !points || count <= 0)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathClosedCurve2(path, points, count, tension);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
 
    return status;
}

Referenced by GdipDrawClosedCurve(), GdipDrawClosedCurve2I(), and test_Get_Release_DC().

◆ GdipDrawClosedCurve2I()

GpStatus WINGDIPAPI GdipDrawClosedCurve2I	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPoint *	points,
		INT	count,
		REAL	tension
	)

Definition at line 2786 of file graphics.c.

{
    GpPointF *ptf;
    GpStatus stat;
    INT i;
 
    TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
 
    if(!points || count <= 0)
        return InvalidParameter;
 
    ptf = heap_alloc_zero(sizeof(GpPointF)*count);
    if(!ptf)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        ptf[i].X = (REAL)points[i].X;
        ptf[i].Y = (REAL)points[i].Y;
    }
 
    stat = GdipDrawClosedCurve2(graphics, pen, ptf, count, tension);
 
    heap_free(ptf);
 
    return stat;
}

Referenced by GdipDrawClosedCurveI(), and test_Get_Release_DC().

◆ GdipDrawClosedCurveI()

GpStatus WINGDIPAPI GdipDrawClosedCurveI	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 2752 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    return GdipDrawClosedCurve2I(graphics, pen, points, count, 1.0);
}

Referenced by test_Get_Release_DC().

◆ GdipDrawCurve()

GpStatus WINGDIPAPI GdipDrawCurve	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 2814 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    return GdipDrawCurve2(graphics,pen,points,count,1.0);
}

Referenced by GdipDrawCurveI(), test_GdipDrawCurve(), and test_Get_Release_DC().

◆ GdipDrawCurve2()

GpStatus WINGDIPAPI GdipDrawCurve2	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPointF *	points,
		INT	count,
		REAL	tension
	)

Definition at line 2850 of file graphics.c.

{
    GpPath *path;
    GpStatus status;
 
    TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
 
    if(!graphics || !pen)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if(count < 2)
        return InvalidParameter;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathCurve2(path, points, count, tension);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipDrawCurve(), GdipDrawCurve2I(), GdipDrawCurve3(), test_GdipDrawCurve2(), and test_Get_Release_DC().

◆ GdipDrawCurve2I()

GpStatus WINGDIPAPI GdipDrawCurve2I	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPoint *	points,
		INT	count,
		REAL	tension
	)

Definition at line 2878 of file graphics.c.

{
    GpPointF *pointsF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
 
    if(!points)
        return InvalidParameter;
 
    pointsF = heap_alloc_zero(sizeof(GpPointF)*count);
    if(!pointsF)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        pointsF[i].X = (REAL)points[i].X;
        pointsF[i].Y = (REAL)points[i].Y;
    }
 
    ret = GdipDrawCurve2(graphics,pen,pointsF,count,tension);
    heap_free(pointsF);
 
    return ret;
}

Referenced by GdipDrawCurve3I(), test_GdipDrawCurve2I(), and test_Get_Release_DC().

◆ GdipDrawCurve3()

GpStatus WINGDIPAPI GdipDrawCurve3	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPointF *	points,
		INT	count,
		INT	offset,
		INT	numberOfSegments,
		REAL	tension
	)

Definition at line 2905 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
 
    if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
        return InvalidParameter;
    }
 
    return GdipDrawCurve2(graphics, pen, points + offset, numberOfSegments + 1, tension);
}

Referenced by test_GdipDrawCurve3().

◆ GdipDrawCurve3I()

GpStatus WINGDIPAPI GdipDrawCurve3I	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPoint *	points,
		INT	count,
		INT	offset,
		INT	numberOfSegments,
		REAL	tension
	)

Definition at line 2918 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
 
    if(count < 0){
        return OutOfMemory;
    }
 
    if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
        return InvalidParameter;
    }
 
    return GdipDrawCurve2I(graphics, pen, points + offset, numberOfSegments + 1, tension);
}

Referenced by test_GdipDrawCurve3I().

◆ GdipDrawCurveI()

GpStatus WINGDIPAPI GdipDrawCurveI	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 2822 of file graphics.c.

{
    GpPointF *pointsF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    if(!points)
        return InvalidParameter;
 
    pointsF = heap_alloc_zero(sizeof(GpPointF)*count);
    if(!pointsF)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        pointsF[i].X = (REAL)points[i].X;
        pointsF[i].Y = (REAL)points[i].Y;
    }
 
    ret = GdipDrawCurve(graphics,pen,pointsF,count);
    heap_free(pointsF);
 
    return ret;
}

Referenced by test_GdipDrawCurveI(), and test_Get_Release_DC().

◆ GdipDrawDriverString()

GpStatus WINGDIPAPI GdipDrawDriverString	(	GpGraphics *	graphics,
		GDIPCONST UINT16 *	text,
		INT	length,
		GDIPCONST GpFont *	font,
		GDIPCONST GpBrush *	brush,
		GDIPCONST PointF *	positions,
		INT	flags,
		GDIPCONST GpMatrix *	matrix
	)

Definition at line 7458 of file graphics.c.

{
    TRACE("(%p %s %p %p %p %d %p)\n", graphics, debugstr_wn(text, length), font, brush, positions, flags, matrix);
 
    if (!graphics || !text || !font || !brush || !positions)
        return InvalidParameter;
 
    return draw_driver_string(graphics, text, length, font, NULL,
                              brush, positions, flags, matrix);
}

Referenced by test_GdipDrawString().

◆ GdipDrawEllipse()

GpStatus WINGDIPAPI GdipDrawEllipse	(	GpGraphics *	graphics,
		GpPen *	pen,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height
	)

Definition at line 2935 of file graphics.c.

{
    GpPath *path;
    GpStatus status;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
 
    if(!graphics || !pen)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathEllipse(path, x, y, width, height);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipDrawEllipseI(), GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipDrawEllipseI()

GpStatus WINGDIPAPI GdipDrawEllipseI	(	GpGraphics *	graphics,
		GpPen *	pen,
		INT	x,
		INT	y,
		INT	width,
		INT	height
	)

Definition at line 2960 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
 
    return GdipDrawEllipse(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
}

Referenced by GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipDrawImage()

GpStatus WINGDIPAPI GdipDrawImage	(	GpGraphics *	graphics,
		GpImage *	image,
		REAL	x,
		REAL	y
	)

Definition at line 2969 of file graphics.c.

{
    UINT width, height;
 
    TRACE("(%p, %p, %.2f, %.2f)\n", graphics, image, x, y);
 
    if(!graphics || !image)
        return InvalidParameter;
 
    GdipGetImageWidth(image, &width);
    GdipGetImageHeight(image, &height);
 
    return GdipDrawImagePointRect(graphics, image, x, y,
                                  0.0, 0.0, (REAL)width, (REAL)height, UnitPixel);
}

Referenced by GdipDrawCachedBitmap(), and GdipDrawImageI().

◆ GdipDrawImageI()

GpStatus WINGDIPAPI GdipDrawImageI	(	GpGraphics *	graphics,
		GpImage *	image,
		INT	x,
		INT	y
	)

Definition at line 2985 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d)\n", graphics, image, x, y);
 
    return GdipDrawImage(graphics, image, (REAL)x, (REAL)y);
}

Referenced by test_DrawImage(), test_DrawImage_scale(), and test_DrawImage_SourceCopy().

◆ GdipDrawImagePointRect()

GpStatus WINGDIPAPI GdipDrawImagePointRect	(	GpGraphics *	graphics,
		GpImage *	image,
		REAL	x,
		REAL	y,
		REAL	srcx,
		REAL	srcy,
		REAL	srcwidth,
		REAL	srcheight,
		GpUnit	srcUnit
	)

Definition at line 2993 of file graphics.c.

{
    GpPointF points[3];
    REAL scale_x, scale_y, width, height;
 
    TRACE("(%p, %p, %f, %f, %f, %f, %f, %f, %d)\n", graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
 
    if (!graphics || !image) return InvalidParameter;
 
    scale_x = units_scale(srcUnit, graphics->unit, graphics->xres);
    scale_x *= graphics->xres / image->xres;
    scale_y = units_scale(srcUnit, graphics->unit, graphics->yres);
    scale_y *= graphics->yres / image->yres;
    width = srcwidth * scale_x;
    height = srcheight * scale_y;
 
    points[0].X = points[2].X = x;
    points[0].Y = points[1].Y = y;
    points[1].X = x + width;
    points[2].Y = y + height;
 
    return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
        srcwidth, srcheight, srcUnit, NULL, NULL, NULL);
}

Referenced by GdipDrawImage(), and GdipDrawImagePointRectI().

◆ GdipDrawImagePointRectI()

GpStatus WINGDIPAPI GdipDrawImagePointRectI	(	GpGraphics *	graphics,
		GpImage *	image,
		INT	x,
		INT	y,
		INT	srcx,
		INT	srcy,
		INT	srcwidth,
		INT	srcheight,
		GpUnit	srcUnit
	)

Definition at line 3020 of file graphics.c.

{
    return GdipDrawImagePointRect(graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
}

Referenced by test_GdipDrawImagePointRect().

◆ GdipDrawImagePoints()

GpStatus WINGDIPAPI GdipDrawImagePoints	(	GpGraphics *	graphics,
		GpImage *	image,
		GDIPCONST GpPointF *	dstpoints,
		INT	count
	)

Definition at line 3027 of file graphics.c.

{
    UINT width, height;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, image, dstpoints, count);
 
    if(!image)
        return InvalidParameter;
 
    GdipGetImageWidth(image, &width);
    GdipGetImageHeight(image, &height);
 
    return GdipDrawImagePointsRect(graphics, image, dstpoints, count, 0, 0,
        width, height, UnitPixel, NULL, NULL, NULL);
}

Referenced by GdipDrawImagePointsI().

◆ GdipDrawImagePointsI()

GpStatus WINGDIPAPI GdipDrawImagePointsI	(	GpGraphics *	graphics,
		GpImage *	image,
		GDIPCONST GpPoint *	dstpoints,
		INT	count
	)

Definition at line 3044 of file graphics.c.

{
    GpPointF ptf[3];
 
    TRACE("(%p, %p, %p, %d)\n", graphics, image, dstpoints, count);
 
    if (count != 3 || !dstpoints)
        return InvalidParameter;
 
    ptf[0].X = (REAL)dstpoints[0].X;
    ptf[0].Y = (REAL)dstpoints[0].Y;
    ptf[1].X = (REAL)dstpoints[1].X;
    ptf[1].Y = (REAL)dstpoints[1].Y;
    ptf[2].X = (REAL)dstpoints[2].X;
    ptf[2].Y = (REAL)dstpoints[2].Y;
 
    return GdipDrawImagePoints(graphics, image, ptf, count);
}

◆ GdipDrawImagePointsRect()

GpStatus WINGDIPAPI GdipDrawImagePointsRect	(	GpGraphics *	graphics,
		GpImage *	image,
		GDIPCONST GpPointF *	points,
		INT	count,
		REAL	srcx,
		REAL	srcy,
		REAL	srcwidth,
		REAL	srcheight,
		GpUnit	srcUnit,
		GDIPCONST GpImageAttributes *	imageAttributes,
		DrawImageAbort	callback,
		VOID *	callbackData
	)

Definition at line 3071 of file graphics.c.

{
    GpPointF ptf[4];
    POINT pti[4];
    GpStatus stat;
 
    TRACE("(%p, %p, %p, %d, %f, %f, %f, %f, %d, %p, %p, %p)\n", graphics, image, points,
          count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
          callbackData);
 
    if (count > 3)
        return NotImplemented;
 
    if(!graphics || !image || !points || count != 3)
         return InvalidParameter;
 
    TRACE("%s %s %s\n", debugstr_pointf(&points[0]), debugstr_pointf(&points[1]),
        debugstr_pointf(&points[2]));
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        return METAFILE_DrawImagePointsRect((GpMetafile*)graphics->image,
                image, points, count, srcx, srcy, srcwidth, srcheight,
                srcUnit, imageAttributes, callback, callbackData);
    }
 
    memcpy(ptf, points, 3 * sizeof(GpPointF));
 
    /* Ensure source width/height is positive */
    if (srcwidth < 0)
    {
        GpPointF tmp = ptf[1];
        srcx = srcx + srcwidth;
        srcwidth = -srcwidth;
        ptf[2].X = ptf[2].X + ptf[1].X - ptf[0].X;
        ptf[2].Y = ptf[2].Y + ptf[1].Y - ptf[0].Y;
        ptf[1] = ptf[0];
        ptf[0] = tmp;
    }
 
    if (srcheight < 0)
    {
        GpPointF tmp = ptf[2];
        srcy = srcy + srcheight;
        srcheight = -srcheight;
        ptf[1].X = ptf[1].X + ptf[2].X - ptf[0].X;
        ptf[1].Y = ptf[1].Y + ptf[2].Y - ptf[0].Y;
        ptf[2] = ptf[0];
        ptf[0] = tmp;
    }
 
    ptf[3].X = ptf[2].X + ptf[1].X - ptf[0].X;
    ptf[3].Y = ptf[2].Y + ptf[1].Y - ptf[0].Y;
    if (!srcwidth || !srcheight || (ptf[3].X == ptf[0].X && ptf[3].Y == ptf[0].Y))
        return Ok;
    gdip_transform_points(graphics, WineCoordinateSpaceGdiDevice, CoordinateSpaceWorld, ptf, 4);
    round_points(pti, ptf, 4);
 
    TRACE("%s %s %s %s\n", wine_dbgstr_point(&pti[0]), wine_dbgstr_point(&pti[1]),
        wine_dbgstr_point(&pti[2]), wine_dbgstr_point(&pti[3]));
 
    srcx = units_to_pixels(srcx, srcUnit, image->xres);
    srcy = units_to_pixels(srcy, srcUnit, image->yres);
    srcwidth = units_to_pixels(srcwidth, srcUnit, image->xres);
    srcheight = units_to_pixels(srcheight, srcUnit, image->yres);
    TRACE("src pixels: %f,%f %fx%f\n", srcx, srcy, srcwidth, srcheight);
 
    if (image->type == ImageTypeBitmap)
    {
        GpBitmap* bitmap = (GpBitmap*)image;
        BOOL do_resampling = FALSE;
        BOOL use_software = FALSE;
 
        TRACE("graphics: %.2fx%.2f dpi, fmt %#x, scale %f, image: %.2fx%.2f dpi, fmt %#x, color %08x\n",
            graphics->xres, graphics->yres,
            graphics->image && graphics->image->type == ImageTypeBitmap ? ((GpBitmap *)graphics->image)->format : 0,
            graphics->scale, image->xres, image->yres, bitmap->format,
            imageAttributes ? imageAttributes->outside_color : 0);
 
        if (ptf[1].Y != ptf[0].Y || ptf[2].X != ptf[0].X ||
            ptf[1].X - ptf[0].X != srcwidth || ptf[2].Y - ptf[0].Y != srcheight ||
            srcx < 0 || srcy < 0 ||
            srcx + srcwidth > bitmap->width || srcy + srcheight > bitmap->height)
            do_resampling = TRUE;
 
        if (imageAttributes || graphics->alpha_hdc || do_resampling ||
            (graphics->image && graphics->image->type == ImageTypeBitmap))
            use_software = TRUE;
 
        if (use_software)
        {
            RECT dst_area;
            GpRectF graphics_bounds;
            GpRect src_area;
            int i, x, y, src_stride, dst_stride;
            GpMatrix dst_to_src;
            REAL m11, m12, m21, m22, mdx, mdy;
            LPBYTE src_data, dst_data, dst_dyn_data=NULL;
            BitmapData lockeddata;
            InterpolationMode interpolation = graphics->interpolation;
            PixelOffsetMode offset_mode = graphics->pixeloffset;
            GpPointF dst_to_src_points[3] = {{0.0, 0.0}, {1.0, 0.0}, {0.0, 1.0}};
            REAL x_dx, x_dy, y_dx, y_dy;
            static const GpImageAttributes defaultImageAttributes = {WrapModeClamp, 0, FALSE};
 
            if (!imageAttributes)
                imageAttributes = &defaultImageAttributes;
 
            dst_area.left = dst_area.right = pti[0].x;
            dst_area.top = dst_area.bottom = pti[0].y;
            for (i=1; i<4; i++)
            {
                if (dst_area.left > pti[i].x) dst_area.left = pti[i].x;
                if (dst_area.right < pti[i].x) dst_area.right = pti[i].x;
                if (dst_area.top > pti[i].y) dst_area.top = pti[i].y;
                if (dst_area.bottom < pti[i].y) dst_area.bottom = pti[i].y;
            }
 
            stat = get_graphics_device_bounds(graphics, &graphics_bounds);
            if (stat != Ok) return stat;
 
            if (graphics_bounds.X > dst_area.left) dst_area.left = floorf(graphics_bounds.X);
            if (graphics_bounds.Y > dst_area.top) dst_area.top = floorf(graphics_bounds.Y);
            if (graphics_bounds.X + graphics_bounds.Width < dst_area.right) dst_area.right = ceilf(graphics_bounds.X + graphics_bounds.Width);
            if (graphics_bounds.Y + graphics_bounds.Height < dst_area.bottom) dst_area.bottom = ceilf(graphics_bounds.Y + graphics_bounds.Height);
 
            TRACE("dst_area: %s\n", wine_dbgstr_rect(&dst_area));
 
            if (IsRectEmpty(&dst_area)) return Ok;
 
            m11 = (ptf[1].X - ptf[0].X) / srcwidth;
            m21 = (ptf[2].X - ptf[0].X) / srcheight;
            mdx = ptf[0].X - m11 * srcx - m21 * srcy;
            m12 = (ptf[1].Y - ptf[0].Y) / srcwidth;
            m22 = (ptf[2].Y - ptf[0].Y) / srcheight;
            mdy = ptf[0].Y - m12 * srcx - m22 * srcy;
 
            GdipSetMatrixElements(&dst_to_src, m11, m12, m21, m22, mdx, mdy);
 
            stat = GdipInvertMatrix(&dst_to_src);
            if (stat != Ok) return stat;
 
            if (do_resampling)
            {
                get_bitmap_sample_size(interpolation, imageAttributes->wrap,
                    bitmap, srcx, srcy, srcwidth, srcheight, &src_area);
            }
            else
            {
                /* Make sure src_area is equal in size to dst_area. */
                src_area.X = srcx + dst_area.left - pti[0].x;
                src_area.Y = srcy + dst_area.top - pti[0].y;
                src_area.Width = dst_area.right - dst_area.left;
                src_area.Height = dst_area.bottom - dst_area.top;
            }
 
            TRACE("src_area: %d x %d\n", src_area.Width, src_area.Height);
 
            src_data = heap_alloc_zero(sizeof(ARGB) * src_area.Width * src_area.Height);
            if (!src_data)
                return OutOfMemory;
            src_stride = sizeof(ARGB) * src_area.Width;
 
            /* Read the bits we need from the source bitmap into a compatible buffer. */
            lockeddata.Width = src_area.Width;
            lockeddata.Height = src_area.Height;
            lockeddata.Stride = src_stride;
            lockeddata.Scan0 = src_data;
            if (!do_resampling && bitmap->format == PixelFormat32bppPARGB)
                lockeddata.PixelFormat = apply_image_attributes(imageAttributes, NULL, 0, 0, 0, ColorAdjustTypeBitmap, bitmap->format);
            else if (imageAttributes != &defaultImageAttributes)
                lockeddata.PixelFormat = PixelFormat32bppARGB;
            else
                lockeddata.PixelFormat = PixelFormat32bppPARGB;
 
            stat = GdipBitmapLockBits(bitmap, &src_area, ImageLockModeRead|ImageLockModeUserInputBuf,
                lockeddata.PixelFormat, &lockeddata);
 
            if (stat == Ok)
                stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
 
            if (stat != Ok)
            {
                heap_free(src_data);
                return stat;
            }
 
            apply_image_attributes(imageAttributes, src_data,
                src_area.Width, src_area.Height,
                src_stride, ColorAdjustTypeBitmap, lockeddata.PixelFormat);
 
            if (do_resampling)
            {
                REAL delta_xx, delta_xy, delta_yx, delta_yy;
 
                /* Transform the bits as needed to the destination. */
                dst_data = dst_dyn_data = heap_alloc_zero(sizeof(ARGB) * (dst_area.right - dst_area.left) * (dst_area.bottom - dst_area.top));
                if (!dst_data)
                {
                    heap_free(src_data);
                    return OutOfMemory;
                }
 
                dst_stride = sizeof(ARGB) * (dst_area.right - dst_area.left);
 
                GdipTransformMatrixPoints(&dst_to_src, dst_to_src_points, 3);
 
                x_dx = dst_to_src_points[1].X - dst_to_src_points[0].X;
                x_dy = dst_to_src_points[1].Y - dst_to_src_points[0].Y;
                y_dx = dst_to_src_points[2].X - dst_to_src_points[0].X;
                y_dy = dst_to_src_points[2].Y - dst_to_src_points[0].Y;
 
                delta_yy = dst_area.top * y_dy;
                delta_yx = dst_area.top * y_dx;
 
                for (y=dst_area.top; y<dst_area.bottom; y++)
                {
                    delta_xx = dst_area.left * x_dx;
                    delta_xy = dst_area.left * x_dy;
 
                    for (x=dst_area.left; x<dst_area.right; x++)
                    {
                        GpPointF src_pointf;
                        ARGB *dst_color;
 
                        src_pointf.X = dst_to_src_points[0].X + delta_xx + delta_yx;
                        src_pointf.Y = dst_to_src_points[0].Y + delta_xy + delta_yy;
 
                        dst_color = (ARGB*)(dst_data + dst_stride * (y - dst_area.top) + sizeof(ARGB) * (x - dst_area.left));
 
                        if (src_pointf.X >= srcx && src_pointf.X < srcx + srcwidth && src_pointf.Y >= srcy && src_pointf.Y < srcy+srcheight)
                        {
                            if (lockeddata.PixelFormat != PixelFormat32bppPARGB)
                                *dst_color = resample_bitmap_pixel(&src_area, src_data, bitmap->width, bitmap->height, &src_pointf,
                                                                   imageAttributes, interpolation, offset_mode);
                            else
                                *dst_color = resample_bitmap_pixel_premult(&src_area, src_data, bitmap->width, bitmap->height, &src_pointf,
                                                                           imageAttributes, interpolation, offset_mode);
                        }
                        else
                            *dst_color = 0;
 
                        delta_xx += x_dx;
                        delta_yx += y_dx;
                    }
 
                    delta_xy += x_dy;
                    delta_yy += y_dy;
                }
            }
            else
            {
                dst_data = src_data;
                dst_stride = src_stride;
            }
 
            gdi_transform_acquire(graphics);
 
            stat = alpha_blend_pixels(graphics, dst_area.left, dst_area.top,
                dst_data, dst_area.right - dst_area.left, dst_area.bottom - dst_area.top, dst_stride,
                lockeddata.PixelFormat);
 
            gdi_transform_release(graphics);
 
            heap_free(src_data);
 
            heap_free(dst_dyn_data);
 
            return stat;
        }
        else
        {
            HDC hdc;
            BOOL temp_hdc = FALSE, temp_bitmap = FALSE;
            HBITMAP hbitmap, old_hbm=NULL;
            HRGN hrgn;
            INT save_state;
 
            if (!(bitmap->format == PixelFormat16bppRGB555 ||
                  bitmap->format == PixelFormat24bppRGB ||
                  bitmap->format == PixelFormat32bppRGB ||
                  bitmap->format == PixelFormat32bppPARGB))
            {
                BITMAPINFOHEADER bih;
                BYTE *temp_bits;
                PixelFormat dst_format;
 
                /* we can't draw a bitmap of this format directly */
                hdc = CreateCompatibleDC(0);
                temp_hdc = TRUE;
                temp_bitmap = TRUE;
 
                bih.biSize = sizeof(BITMAPINFOHEADER);
                bih.biWidth = bitmap->width;
                bih.biHeight = -bitmap->height;
                bih.biPlanes = 1;
                bih.biBitCount = 32;
                bih.biCompression = BI_RGB;
                bih.biSizeImage = 0;
                bih.biXPelsPerMeter = 0;
                bih.biYPelsPerMeter = 0;
                bih.biClrUsed = 0;
                bih.biClrImportant = 0;
 
                hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
                    (void**)&temp_bits, NULL, 0);
 
                if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
                    dst_format = PixelFormat32bppPARGB;
                else
                    dst_format = PixelFormat32bppRGB;
 
                convert_pixels(bitmap->width, bitmap->height,
                    bitmap->width*4, temp_bits, dst_format,
                    bitmap->stride, bitmap->bits, bitmap->format,
                    bitmap->image.palette);
            }
            else
            {
                if (bitmap->hbitmap)
                    hbitmap = bitmap->hbitmap;
                else
                {
                    GdipCreateHBITMAPFromBitmap(bitmap, &hbitmap, 0);
                    temp_bitmap = TRUE;
                }
 
                hdc = bitmap->hdc;
                temp_hdc = (hdc == 0);
            }
 
            if (temp_hdc)
            {
                if (!hdc) hdc = CreateCompatibleDC(0);
                old_hbm = SelectObject(hdc, hbitmap);
            }
 
            save_state = SaveDC(graphics->hdc);
 
            stat = get_clip_hrgn(graphics, &hrgn);
 
            if (stat == Ok)
            {
                ExtSelectClipRgn(graphics->hdc, hrgn, RGN_COPY);
                DeleteObject(hrgn);
            }
 
            gdi_transform_acquire(graphics);
 
            if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
            {
                gdi_alpha_blend(graphics, pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
                                hdc, srcx, srcy, srcwidth, srcheight);
            }
            else
            {
                StretchBlt(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
                    hdc, srcx, srcy, srcwidth, srcheight, SRCCOPY);
            }
 
            gdi_transform_release(graphics);
 
            RestoreDC(graphics->hdc, save_state);
 
            if (temp_hdc)
            {
                SelectObject(hdc, old_hbm);
                DeleteDC(hdc);
            }
 
            if (temp_bitmap)
                DeleteObject(hbitmap);
        }
    }
    else if (image->type == ImageTypeMetafile && ((GpMetafile*)image)->hemf)
    {
        GpRectF rc;
 
        rc.X = srcx;
        rc.Y = srcy;
        rc.Width = srcwidth;
        rc.Height = srcheight;
 
        return GdipEnumerateMetafileSrcRectDestPoints(graphics, (GpMetafile*)image,
            points, count, &rc, srcUnit, play_metafile_proc, image, imageAttributes);
    }
    else
    {
        WARN("GpImage with nothing we can draw (metafile in wrong state?)\n");
        return InvalidParameter;
    }
 
    return Ok;
}

Referenced by GdipDrawImagePointRect(), GdipDrawImagePoints(), GdipDrawImagePointsRectI(), GdipDrawImageRectRect(), GdipDrawImageRectRectI(), GdipPlayMetafileRecord(), test_clear(), test_drawimage(), test_emfonly(), test_fillrect(), test_GdipDrawImagePointsRect(), and test_getdc().

◆ GdipDrawImagePointsRectI()

GpStatus WINGDIPAPI GdipDrawImagePointsRectI	(	GpGraphics *	graphics,
		GpImage *	image,
		GDIPCONST GpPoint *	points,
		INT	count,
		INT	srcx,
		INT	srcy,
		INT	srcwidth,
		INT	srcheight,
		GpUnit	srcUnit,
		GDIPCONST GpImageAttributes *	imageAttributes,
		DrawImageAbort	callback,
		VOID *	callbackData
	)

Definition at line 3469 of file graphics.c.

{
    GpPointF pointsF[3];
    INT i;
 
    TRACE("(%p, %p, %p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", graphics, image, points, count,
          srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
          callbackData);
 
    if(!points || count!=3)
        return InvalidParameter;
 
    for(i = 0; i < count; i++){
        pointsF[i].X = (REAL)points[i].X;
        pointsF[i].Y = (REAL)points[i].Y;
    }
 
    return GdipDrawImagePointsRect(graphics, image, pointsF, count, (REAL)srcx, (REAL)srcy,
                                   (REAL)srcwidth, (REAL)srcheight, srcUnit, imageAttributes,
                                   callback, callbackData);
}

◆ GdipDrawImageRect()

GpStatus WINGDIPAPI GdipDrawImageRect	(	GpGraphics *	graphics,
		GpImage *	image,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height
	)

Definition at line 3540 of file graphics.c.

{
    RectF bounds;
    GpUnit unit;
    GpStatus ret;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, image, x, y, width, height);
 
    if(!graphics || !image)
        return InvalidParameter;
 
    ret = GdipGetImageBounds(image, &bounds, &unit);
    if(ret != Ok)
        return ret;
 
    return GdipDrawImageRectRect(graphics, image, x, y, width, height,
                                 bounds.X, bounds.Y, bounds.Width, bounds.Height,
                                 unit, NULL, NULL, NULL);
}

Referenced by GdipDrawImageRectI().

◆ GdipDrawImageRectI()

GpStatus WINGDIPAPI GdipDrawImageRectI	(	GpGraphics *	graphics,
		GpImage *	image,
		INT	x,
		INT	y,
		INT	width,
		INT	height
	)

Definition at line 3561 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, image, x, y, width, height);
 
    return GdipDrawImageRect(graphics, image, (REAL)x, (REAL)y, (REAL)width, (REAL)height);
}

◆ GdipDrawImageRectRect()

GpStatus WINGDIPAPI GdipDrawImageRectRect	(	GpGraphics *	graphics,
		GpImage *	image,
		REAL	dstx,
		REAL	dsty,
		REAL	dstwidth,
		REAL	dstheight,
		REAL	srcx,
		REAL	srcy,
		REAL	srcwidth,
		REAL	srcheight,
		GpUnit	srcUnit,
		GDIPCONST GpImageAttributes *	imageattr,
		DrawImageAbort	callback,
		VOID *	callbackData
	)

Definition at line 3494 of file graphics.c.

{
    GpPointF points[3];
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p, %p, %p)\n",
          graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
          srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
 
    points[0].X = dstx;
    points[0].Y = dsty;
    points[1].X = dstx + dstwidth;
    points[1].Y = dsty;
    points[2].X = dstx;
    points[2].Y = dsty + dstheight;
 
    return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
               srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
}

Referenced by GdipDrawImageRect(), and ZoomWnd_OnDraw().

◆ GdipDrawImageRectRectI()

GpStatus WINGDIPAPI GdipDrawImageRectRectI	(	GpGraphics *	graphics,
		GpImage *	image,
		INT	dstx,
		INT	dsty,
		INT	dstwidth,
		INT	dstheight,
		INT	srcx,
		INT	srcy,
		INT	srcwidth,
		INT	srcheight,
		GpUnit	srcUnit,
		GDIPCONST GpImageAttributes *	imageAttributes,
		DrawImageAbort	callback,
		VOID *	callbackData
	)

Definition at line 3517 of file graphics.c.

{
    GpPointF points[3];
 
    TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
          graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
          srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
 
    points[0].X = dstx;
    points[0].Y = dsty;
    points[1].X = dstx + dstwidth;
    points[1].Y = dsty;
    points[2].X = dstx;
    points[2].Y = dsty + dstheight;
 
    return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
               srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
}

Referenced by GdipGetImageThumbnail(), METAFILE_DrawImagePointsRect(), test_colorkey(), test_colormatrix(), test_gamma(), test_GdipDrawImagePointsRectOnMemoryDC(), and test_remaptable().

◆ GdipDrawLine()

GpStatus WINGDIPAPI GdipDrawLine	(	GpGraphics *	graphics,
		GpPen *	pen,
		REAL	x1,
		REAL	y1,
		REAL	x2,
		REAL	y2
	)

Definition at line 3569 of file graphics.c.

{
    GpPointF pt[2];
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1, x2, y2);
 
    if (!pen)
        return InvalidParameter;
 
    if (pen->unit == UnitPixel && pen->width <= 0.0)
        return Ok;
 
    pt[0].X = x1;
    pt[0].Y = y1;
    pt[1].X = x2;
    pt[1].Y = y2;
    return GdipDrawLines(graphics, pen, pt, 2);
}

Referenced by GdipDrawLineI(), test_Get_Release_DC(), and test_pen_thickness().

◆ GdipDrawLineI()

GpStatus WINGDIPAPI GdipDrawLineI	(	GpGraphics *	graphics,
		GpPen *	pen,
		INT	x1,
		INT	y1,
		INT	x2,
		INT	y2
	)

Definition at line 3589 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x1, y1, x2, y2);
 
    return GdipDrawLine(graphics, pen, (REAL)x1, (REAL)y1, (REAL)x2, (REAL)y2);
}

Referenced by test_emfonly(), test_GdipDrawLineI(), and test_Get_Release_DC().

◆ GdipDrawLines()

GpStatus WINGDIPAPI GdipDrawLines	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 3597 of file graphics.c.

{
    GpStatus status;
    GpPath *path;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    if(!pen || !graphics || (count < 2))
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathLine2(path, points, count);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipDrawLine(), GdipDrawLinesI(), and test_Get_Release_DC().

◆ GdipDrawLinesI()

GpStatus WINGDIPAPI GdipDrawLinesI	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 3622 of file graphics.c.

{
    GpStatus retval;
    GpPointF *ptf;
    int i;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    ptf = heap_alloc_zero(count * sizeof(GpPointF));
    if(!ptf) return OutOfMemory;
 
    for(i = 0; i < count; i ++){
        ptf[i].X = (REAL) points[i].X;
        ptf[i].Y = (REAL) points[i].Y;
    }
 
    retval = GdipDrawLines(graphics, pen, ptf, count);
 
    heap_free(ptf);
    return retval;
}

Referenced by test_GdipDrawLinesI(), and test_Get_Release_DC().

◆ GdipDrawPath()

GpStatus WINGDIPAPI GdipDrawPath	(	GpGraphics *	graphics,
		GpPen *	pen,
		GpPath *	path
	)

Definition at line 4066 of file graphics.c.

{
    GpStatus retval;
 
    TRACE("(%p, %p, %p)\n", graphics, pen, path);
 
    if(!pen || !graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (path->pathdata.Count == 0)
        return Ok;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
        retval = METAFILE_DrawPath((GpMetafile*)graphics->image, pen, path);
    else if (!graphics->hdc || graphics->alpha_hdc || !brush_can_fill_path(pen->brush, FALSE))
        retval = SOFTWARE_GdipDrawPath(graphics, pen, path);
    else
        retval = GDI32_GdipDrawPath(graphics, pen, path);
 
    return retval;
}

Referenced by GdipDrawArc(), GdipDrawBeziers(), GdipDrawClosedCurve2(), GdipDrawCurve2(), GdipDrawEllipse(), GdipDrawLines(), GdipDrawPie(), GdipDrawPolygon(), GdipDrawRectangle(), GdipDrawRectangles(), GdipPlayMetafileRecord(), test_drawpath(), test_Get_Release_DC(), and test_pen_thickness().

◆ GdipDrawPie()

GpStatus WINGDIPAPI GdipDrawPie	(	GpGraphics *	graphics,
		GpPen *	pen,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 4091 of file graphics.c.

{
    GpStatus status;
    GpPath *path;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
            width, height, startAngle, sweepAngle);
 
    if(!graphics || !pen)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathPie(path, x, y, width, height, startAngle, sweepAngle);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipDrawPieI(), GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipDrawPieI()

GpStatus WINGDIPAPI GdipDrawPieI	(	GpGraphics *	graphics,
		GpPen *	pen,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 4117 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
            width, height, startAngle, sweepAngle);
 
    return GdipDrawPie(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
}

Referenced by GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipDrawPolygon()

GpStatus WINGDIPAPI GdipDrawPolygon	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 6572 of file graphics.c.

{
    GpStatus status;
    GpPath* path;
 
    TRACE("(%p, %p, %d)\n", graphics, points, count);
 
    if(!graphics || !pen || count<=0)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathPolygon(path, points, count);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
 
    return status;
}

Referenced by GdipDrawPolygonI(), and test_Get_Release_DC().

◆ GdipDrawPolygonI()

GpStatus WINGDIPAPI GdipDrawPolygonI	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 6598 of file graphics.c.

{
    GpStatus ret;
    GpPointF *ptf;
    INT i;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
 
    if(count<=0)    return InvalidParameter;
    ptf = heap_alloc_zero(sizeof(GpPointF) * count);
 
    for(i = 0;i < count; i++){
        ptf[i].X = (REAL)points[i].X;
        ptf[i].Y = (REAL)points[i].Y;
    }
 
    ret = GdipDrawPolygon(graphics,pen,ptf,count);
    heap_free(ptf);
 
    return ret;
}

Referenced by test_Get_Release_DC().

◆ GdipDrawRectangle()

GpStatus WINGDIPAPI GdipDrawRectangle	(	GpGraphics *	graphics,
		GpPen *	pen,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height
	)

Definition at line 4126 of file graphics.c.

{
    GpStatus status;
    GpPath *path;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
 
    if(!pen || !graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathRectangle(path, x, y, width, height);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipDrawRectangleI(), and test_Get_Release_DC().

◆ GdipDrawRectangleI()

GpStatus WINGDIPAPI GdipDrawRectangleI	(	GpGraphics *	graphics,
		GpPen *	pen,
		INT	x,
		INT	y,
		INT	width,
		INT	height
	)

Definition at line 4151 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
 
    return GdipDrawRectangle(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
}

Referenced by test_Get_Release_DC().

◆ GdipDrawRectangles()

GpStatus WINGDIPAPI GdipDrawRectangles	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpRectF *	rects,
		INT	count
	)

Definition at line 4159 of file graphics.c.

{
    GpStatus status;
    GpPath *path;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
 
    if(!graphics || !pen || !rects || count < 1)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathRectangles(path, rects, count);
    if (status == Ok)
        status = GdipDrawPath(graphics, pen, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipDrawRectanglesI(), GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipDrawRectanglesI()

GpStatus WINGDIPAPI GdipDrawRectanglesI	(	GpGraphics *	graphics,
		GpPen *	pen,
		GDIPCONST GpRect *	rects,
		INT	count
	)

Definition at line 4184 of file graphics.c.

{
    GpRectF *rectsF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
 
    if(!rects || count<=0)
        return InvalidParameter;
 
    rectsF = heap_alloc_zero(sizeof(GpRectF) * count);
    if(!rectsF)
        return OutOfMemory;
 
    for(i = 0;i < count;i++){
        rectsF[i].X      = (REAL)rects[i].X;
        rectsF[i].Y      = (REAL)rects[i].Y;
        rectsF[i].Width  = (REAL)rects[i].Width;
        rectsF[i].Height = (REAL)rects[i].Height;
    }
 
    ret = GdipDrawRectangles(graphics, pen, rectsF, count);
    heap_free(rectsF);
 
    return ret;
}

Referenced by test_Get_Release_DC().

◆ GdipDrawString()

GpStatus WINGDIPAPI GdipDrawString	(	GpGraphics *	graphics,
		GDIPCONST WCHAR *	string,
		INT	length,
		GDIPCONST GpFont *	font,
		GDIPCONST RectF *	rect,
		GDIPCONST GpStringFormat *	format,
		GDIPCONST GpBrush *	brush
	)

Definition at line 5696 of file graphics.c.

{
    HRGN rgn = NULL;
    HFONT gdifont;
    GpPointF pt[3], rectcpy[4];
    POINT corners[4];
    REAL rel_width, rel_height, margin_x;
    INT save_state, format_flags = 0;
    REAL offsety = 0.0;
    struct draw_string_args args;
    RectF scaled_rect;
    HDC hdc, temp_hdc=NULL;
    TEXTMETRICW textmetric;
 
    TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
        length, font, debugstr_rectf(rect), format, brush);
 
    if(!graphics || !string || !font || !brush || !rect)
        return InvalidParameter;
 
    if(graphics->hdc)
    {
        hdc = graphics->hdc;
    }
    else
    {
        hdc = temp_hdc = CreateCompatibleDC(0);
    }
 
    if(format){
        TRACE("may be ignoring some format flags: attr %x\n", format->attr);
 
        format_flags = format->attr;
 
        /* Should be no need to explicitly test for StringAlignmentNear as
         * that is default behavior if no alignment is passed. */
        if(format->line_align != StringAlignmentNear){
            RectF bounds, in_rect = *rect;
            in_rect.Height = 0.0; /* avoid height clipping */
            GdipMeasureString(graphics, string, length, font, &in_rect, format, &bounds, 0, 0);
 
            TRACE("bounds %s\n", debugstr_rectf(&bounds));
 
            if(format->line_align == StringAlignmentCenter)
                offsety = (rect->Height - bounds.Height) / 2;
            else if(format->line_align == StringAlignmentFar)
                offsety = (rect->Height - bounds.Height);
        }
        TRACE("line align %d, offsety %f\n", format->line_align, offsety);
    }
 
    save_state = SaveDC(hdc);
 
    pt[0].X = 0.0;
    pt[0].Y = 0.0;
    pt[1].X = 1.0;
    pt[1].Y = 0.0;
    pt[2].X = 0.0;
    pt[2].Y = 1.0;
    gdip_transform_points(graphics, WineCoordinateSpaceGdiDevice, CoordinateSpaceWorld, pt, 3);
    rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
                     (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
    rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
                      (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
 
    rectcpy[3].X = rectcpy[0].X = rect->X;
    rectcpy[1].Y = rectcpy[0].Y = rect->Y;
    rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
    rectcpy[3].Y = rectcpy[2].Y = rect->Y + rect->Height;
    gdip_transform_points(graphics, WineCoordinateSpaceGdiDevice, CoordinateSpaceWorld, rectcpy, 4);
    round_points(corners, rectcpy, 4);
 
    margin_x = (format && format->generic_typographic) ? 0.0 : font->emSize / 6.0;
    margin_x *= units_scale(font->unit, graphics->unit, graphics->xres);
 
    scaled_rect.X = margin_x * rel_width;
    scaled_rect.Y = 0.0;
    scaled_rect.Width = rel_width * rect->Width;
    scaled_rect.Height = rel_height * rect->Height;
    if (scaled_rect.Width >= 0.5)
    {
        scaled_rect.Width -= margin_x * 2.0 * rel_width;
        if (scaled_rect.Width < 0.5) return Ok; /* doesn't fit */
    }
 
    if (scaled_rect.Width >= 1 << 23) scaled_rect.Width = 1 << 23;
    if (scaled_rect.Height >= 1 << 23) scaled_rect.Height = 1 << 23;
 
    if (!(format_flags & StringFormatFlagsNoClip) &&
        scaled_rect.Width != 1 << 23 && scaled_rect.Height != 1 << 23 &&
        rect->Width > 0.0 && rect->Height > 0.0)
    {
        /* FIXME: If only the width or only the height is 0, we should probably still clip */
        rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
        SelectClipRgn(hdc, rgn);
    }
 
    get_font_hfont(graphics, font, format, &gdifont, NULL);
    SelectObject(hdc, gdifont);
 
    args.graphics = graphics;
    args.brush = brush;
 
    args.x = rect->X;
    args.y = rect->Y + offsety;
 
    args.rel_width = rel_width;
    args.rel_height = rel_height;
 
    gdi_transform_acquire(graphics);
 
    GetTextMetricsW(hdc, &textmetric);
    args.ascent = textmetric.tmAscent / rel_height;
 
    gdip_format_string(hdc, string, length, font, &scaled_rect, format, TRUE,
        draw_string_callback, &args);
 
    gdi_transform_release(graphics);
 
    DeleteObject(rgn);
    DeleteObject(gdifont);
 
    RestoreDC(hdc, save_state);
 
    DeleteDC(temp_hdc);
 
    return Ok;
}

Referenced by test_GdipDrawString(), and test_string_functions().

◆ GdipEmfToWmfBits()

GpStatus WINGDIPAPI GdipEmfToWmfBits	(	HENHMETAFILE	hemf,
		UINT	cbData16,
		LPBYTE	pData16,
		INT	iMapMode,
		INT	eFlags
	)

Definition at line 3986 of file metafile.c.

{
    FIXME("(%p, %d, %p, %d, %d): stub\n", hemf, cbData16, pData16, iMapMode, eFlags);
    return NotImplemented;
}

◆ GdipEndContainer()

GpStatus WINGDIPAPI GdipEndContainer	(	GpGraphics *	graphics,
		GraphicsContainer	state
	)

Definition at line 6039 of file graphics.c.

{
    TRACE("(%p, %x)\n", graphics, state);
    return end_container(graphics, BEGIN_CONTAINER, state);
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), GdipPlayMetafileRecord(), test_BeginContainer2(), test_container_rects(), test_containers(), and test_save_restore().

◆ GdipEnumerateMetafileDestPoint()

GpStatus WINGDIPAPI GdipEnumerateMetafileDestPoint	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpPointF *	dest,
		EnumerateMetafileProc	callback,
		VOID *	cb_data,
		GDIPCONST GpImageAttributes *	attrs
	)

Definition at line 3602 of file metafile.c.

{
    GpRectF destf;
 
    if (!graphics || !metafile || !dest) return InvalidParameter;
 
    destf.X = dest->X;
    destf.Y = dest->Y;
    destf.Width = units_to_pixels(metafile->bounds.Width, metafile->unit, metafile->image.xres);
    destf.Height = units_to_pixels(metafile->bounds.Height, metafile->unit, metafile->image.yres);
 
    return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
}

Referenced by GdipEnumerateMetafileDestPointI().

◆ GdipEnumerateMetafileDestPointI()

GpStatus WINGDIPAPI GdipEnumerateMetafileDestPointI	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpPoint *	dest,
		EnumerateMetafileProc	callback,
		VOID *	cb_data,
		GDIPCONST GpImageAttributes *	attrs
	)

Definition at line 3618 of file metafile.c.

{
    GpPointF ptf;
 
    if (!graphics || !metafile || !dest) return InvalidParameter;
 
    ptf.X = dest->X;
    ptf.Y = dest->Y;
 
    return GdipEnumerateMetafileDestPoint(graphics, metafile, &ptf, callback, cb_data, attrs);
}

◆ GdipEnumerateMetafileDestRect()

GpStatus WINGDIPAPI GdipEnumerateMetafileDestRect	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpRectF *	dest,
		EnumerateMetafileProc	callback,
		VOID *	cb_data,
		GDIPCONST GpImageAttributes *	attrs
	)

Definition at line 3569 of file metafile.c.

{
    GpPointF points[3];
 
    if (!graphics || !metafile || !dest) return InvalidParameter;
 
    points[0].X = points[2].X = dest->X;
    points[0].Y = points[1].Y = dest->Y;
    points[1].X = dest->X + dest->Width;
    points[2].Y = dest->Y + dest->Height;
 
    return GdipEnumerateMetafileSrcRectDestPoints(graphics, metafile, points, 3,
        &metafile->bounds, metafile->unit, callback, cb_data, attrs);
}

Referenced by GdipEnumerateMetafileDestPoint(), and GdipEnumerateMetafileDestRectI().

◆ GdipEnumerateMetafileDestRectI()

GpStatus WINGDIPAPI GdipEnumerateMetafileDestRectI	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpRect *	dest,
		EnumerateMetafileProc	callback,
		VOID *	cb_data,
		GDIPCONST GpImageAttributes *	attrs
	)

Definition at line 3586 of file metafile.c.

{
    GpRectF destf;
 
    if (!graphics || !metafile || !dest) return InvalidParameter;
 
    destf.X = dest->X;
    destf.Y = dest->Y;
    destf.Width = dest->Width;
    destf.Height = dest->Height;
 
    return GdipEnumerateMetafileDestRect(graphics, metafile, &destf, callback, cb_data, attrs);
}

◆ GdipEnumerateMetafileSrcRectDestPoints()

GpStatus WINGDIPAPI GdipEnumerateMetafileSrcRectDestPoints	(	GpGraphics *	graphics,
		GDIPCONST GpMetafile *	metafile,
		GDIPCONST GpPointF *	destPoints,
		INT	count,
		GDIPCONST GpRectF *	srcRect,
		Unit	srcUnit,
		EnumerateMetafileProc	callback,
		VOID *	callbackData,
		GDIPCONST GpImageAttributes *	imageAttributes
	)

Definition at line 3435 of file metafile.c.

{
    struct enum_metafile_data data;
    GpStatus stat;
    GpMetafile *real_metafile = (GpMetafile*)metafile; /* whoever made this const was joking */
    GraphicsContainer state;
    GpPath *dst_path;
 
    TRACE("(%p,%p,%p,%i,%p,%i,%p,%p,%p)\n", graphics, metafile,
        destPoints, count, srcRect, srcUnit, callback, callbackData,
        imageAttributes);
 
    if (!graphics || !metafile || !destPoints || count != 3 || !srcRect)
        return InvalidParameter;
 
    if (!metafile->hemf)
        return InvalidParameter;
 
    if (metafile->playback_graphics)
        return ObjectBusy;
 
    TRACE("%s %i -> %s %s %s\n", debugstr_rectf(srcRect), srcUnit,
        debugstr_pointf(&destPoints[0]), debugstr_pointf(&destPoints[1]),
        debugstr_pointf(&destPoints[2]));
 
    data.callback = callback;
    data.callback_data = callbackData;
    data.metafile = real_metafile;
 
    real_metafile->playback_graphics = graphics;
    real_metafile->playback_dc = NULL;
    real_metafile->src_rect = *srcRect;
 
    memcpy(real_metafile->playback_points, destPoints, sizeof(PointF) * 3);
    stat = GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, real_metafile->playback_points, 3);
 
    if (stat == Ok)
        stat = GdipBeginContainer2(graphics, &state);
 
    if (stat == Ok)
    {
        stat = GdipSetPageScale(graphics, 1.0);
 
        if (stat == Ok)
            stat = GdipSetPageUnit(graphics, UnitPixel);
 
        if (stat == Ok)
            stat = GdipResetWorldTransform(graphics);
 
        if (stat == Ok)
            stat = GdipCreateRegion(&real_metafile->base_clip);
 
        if (stat == Ok)
            stat = GdipGetClip(graphics, real_metafile->base_clip);
 
        if (stat == Ok)
            stat = GdipCreateRegion(&real_metafile->clip);
 
        if (stat == Ok)
            stat = GdipCreatePath(FillModeAlternate, &dst_path);
 
        if (stat == Ok)
        {
            GpPointF clip_points[4];
 
            clip_points[0] = real_metafile->playback_points[0];
            clip_points[1] = real_metafile->playback_points[1];
            clip_points[2].X = real_metafile->playback_points[1].X + real_metafile->playback_points[2].X
                - real_metafile->playback_points[0].X;
            clip_points[2].Y = real_metafile->playback_points[1].Y + real_metafile->playback_points[2].Y
                - real_metafile->playback_points[0].Y;
            clip_points[3] = real_metafile->playback_points[2];
 
            stat = GdipAddPathPolygon(dst_path, clip_points, 4);
 
            if (stat == Ok)
                stat = GdipCombineRegionPath(real_metafile->base_clip, dst_path, CombineModeIntersect);
 
            GdipDeletePath(dst_path);
        }
 
        if (stat == Ok)
            stat = GdipCreateMatrix(&real_metafile->world_transform);
 
        if (stat == Ok)
        {
            real_metafile->page_unit = UnitDisplay;
            real_metafile->page_scale = 1.0;
            stat = METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
 
        if (stat == Ok)
        {
            stat = METAFILE_PlaybackUpdateClip(real_metafile);
        }
 
        if (stat == Ok && (metafile->metafile_type == MetafileTypeEmf ||
            metafile->metafile_type == MetafileTypeWmfPlaceable ||
            metafile->metafile_type == MetafileTypeWmf))
            stat = METAFILE_PlaybackGetDC(real_metafile);
 
        if (stat == Ok)
            EnumEnhMetaFile(0, metafile->hemf, enum_metafile_proc, &data, NULL);
 
        METAFILE_PlaybackReleaseDC(real_metafile);
 
        GdipDeleteMatrix(real_metafile->world_transform);
        real_metafile->world_transform = NULL;
 
        GdipDeleteRegion(real_metafile->base_clip);
        real_metafile->base_clip = NULL;
 
        GdipDeleteRegion(real_metafile->clip);
        real_metafile->clip = NULL;
 
        while (list_head(&real_metafile->containers))
        {
            container* cont = LIST_ENTRY(list_head(&real_metafile->containers), container, entry);
            list_remove(&cont->entry);
            GdipDeleteRegion(cont->clip);
            heap_free(cont);
        }
 
        GdipEndContainer(graphics, state);
    }
 
    real_metafile->playback_graphics = NULL;
 
    return stat;
}

Referenced by check_metafile(), GdipDrawImagePointsRect(), GdipEnumerateMetafileDestRect(), and play_metafile().

◆ GdipFillClosedCurve()

GpStatus WINGDIPAPI GdipFillClosedCurve	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 4274 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
    return GdipFillClosedCurve2(graphics, brush, points, count,
               0.5f, FillModeAlternate);
}

Referenced by test_GdipFillClosedCurve(), and test_Get_Release_DC().

◆ GdipFillClosedCurve2()

GpStatus WINGDIPAPI GdipFillClosedCurve2	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpPointF *	points,
		INT	count,
		REAL	tension,
		GpFillMode	fill
	)

Definition at line 4213 of file graphics.c.

{
    GpPath *path;
    GpStatus status;
 
    TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
            count, tension, fill);
 
    if(!graphics || !brush || !points)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if(count == 1)    /* Do nothing */
        return Ok;
 
    status = GdipCreatePath(fill, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathClosedCurve2(path, points, count, tension);
    if (status == Ok)
        status = GdipFillPath(graphics, brush, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipFillClosedCurve(), GdipFillClosedCurve2I(), GdipPlayMetafileRecord(), test_GdipFillClosedCurve2(), and test_Get_Release_DC().

◆ GdipFillClosedCurve2I()

GpStatus WINGDIPAPI GdipFillClosedCurve2I	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpPoint *	points,
		INT	count,
		REAL	tension,
		GpFillMode	fill
	)

Definition at line 4242 of file graphics.c.

{
    GpPointF *ptf;
    GpStatus stat;
    INT i;
 
    TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
            count, tension, fill);
 
    if(!points || count == 0)
        return InvalidParameter;
 
    if(count == 1)    /* Do nothing */
        return Ok;
 
    ptf = heap_alloc_zero(sizeof(GpPointF)*count);
    if(!ptf)
        return OutOfMemory;
 
    for(i = 0;i < count;i++){
        ptf[i].X = (REAL)points[i].X;
        ptf[i].Y = (REAL)points[i].Y;
    }
 
    stat = GdipFillClosedCurve2(graphics, brush, ptf, count, tension, fill);
 
    heap_free(ptf);
 
    return stat;
}

Referenced by GdipFillClosedCurveI(), test_GdipFillClosedCurve2I(), and test_Get_Release_DC().

◆ GdipFillClosedCurveI()

GpStatus WINGDIPAPI GdipFillClosedCurveI	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 4282 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
    return GdipFillClosedCurve2I(graphics, brush, points, count,
               0.5f, FillModeAlternate);
}

Referenced by test_GdipFillClosedCurveI(), and test_Get_Release_DC().

◆ GdipFillEllipse()

GpStatus WINGDIPAPI GdipFillEllipse	(	GpGraphics *	graphics,
		GpBrush *	brush,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height
	)

Definition at line 4290 of file graphics.c.

{
    GpStatus stat;
    GpPath *path;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
 
    if(!graphics || !brush)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    stat = GdipCreatePath(FillModeAlternate, &path);
 
    if (stat == Ok)
    {
        stat = GdipAddPathEllipse(path, x, y, width, height);
 
        if (stat == Ok)
            stat = GdipFillPath(graphics, brush, path);
 
        GdipDeletePath(path);
    }
 
    return stat;
}

Referenced by GdipFillEllipseI(), GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipFillEllipseI()

GpStatus WINGDIPAPI GdipFillEllipseI	(	GpGraphics *	graphics,
		GpBrush *	brush,
		INT	x,
		INT	y,
		INT	width,
		INT	height
	)

Definition at line 4319 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
 
    return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
}

Referenced by GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipFillPath()

GpStatus WINGDIPAPI GdipFillPath	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GpPath *	path
	)

Definition at line 4391 of file graphics.c.

{
    GpStatus stat = NotImplemented;
 
    TRACE("(%p, %p, %p)\n", graphics, brush, path);
 
    if(!brush || !graphics || !path)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (!path->pathdata.Count)
        return Ok;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
        return METAFILE_FillPath((GpMetafile*)graphics->image, brush, path);
 
    if (!graphics->image && !graphics->alpha_hdc)
        stat = GDI32_GdipFillPath(graphics, brush, path);
 
    if (stat == NotImplemented)
        stat = SOFTWARE_GdipFillPath(graphics, brush, path);
 
    if (stat == NotImplemented)
    {
        FIXME("Not implemented for brushtype %i\n", brush->bt);
        stat = Ok;
    }
 
    return stat;
}

Referenced by GdipFillClosedCurve2(), GdipFillEllipse(), GdipFillPie(), GdipFillPolygon(), GdipFillPolygonI(), GdipFillRectangles(), GdipPlayMetafileRecord(), SOFTWARE_GdipDrawPath(), test_fillpath(), test_GdipFillPath(), and test_Get_Release_DC().

◆ GdipFillPie()

GpStatus WINGDIPAPI GdipFillPie	(	GpGraphics *	graphics,
		GpBrush *	brush,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 4424 of file graphics.c.

{
    GpStatus stat;
    GpPath *path;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
            graphics, brush, x, y, width, height, startAngle, sweepAngle);
 
    if(!graphics || !brush)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    stat = GdipCreatePath(FillModeAlternate, &path);
 
    if (stat == Ok)
    {
        stat = GdipAddPathPie(path, x, y, width, height, startAngle, sweepAngle);
 
        if (stat == Ok)
            stat = GdipFillPath(graphics, brush, path);
 
        GdipDeletePath(path);
    }
 
    return stat;
}

Referenced by GdipFillPieI(), GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipFillPieI()

GpStatus WINGDIPAPI GdipFillPieI	(	GpGraphics *	graphics,
		GpBrush *	brush,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		REAL	startAngle,
		REAL	sweepAngle
	)

Definition at line 4454 of file graphics.c.

{
    TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
            graphics, brush, x, y, width, height, startAngle, sweepAngle);
 
    return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
}

Referenced by GdipPlayMetafileRecord(), and test_Get_Release_DC().

◆ GdipFillPolygon()

GpStatus WINGDIPAPI GdipFillPolygon	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpPointF *	points,
		INT	count,
		GpFillMode	fillMode
	)

Definition at line 4463 of file graphics.c.

{
    GpStatus stat;
    GpPath *path;
 
    TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
 
    if(!graphics || !brush || !points || !count)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    stat = GdipCreatePath(fillMode, &path);
 
    if (stat == Ok)
    {
        stat = GdipAddPathPolygon(path, points, count);
 
        if (stat == Ok)
            stat = GdipFillPath(graphics, brush, path);
 
        GdipDeletePath(path);
    }
 
    return stat;
}

Referenced by GdipFillPolygon2(), and test_Get_Release_DC().

◆ GdipFillPolygon2()

GpStatus WINGDIPAPI GdipFillPolygon2	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpPointF *	points,
		INT	count
	)

Definition at line 4521 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
 
    return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
}

Referenced by test_Get_Release_DC().

◆ GdipFillPolygon2I()

GpStatus WINGDIPAPI GdipFillPolygon2I	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpPoint *	points,
		INT	count
	)

Definition at line 4529 of file graphics.c.

{
    TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
 
    return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
}

Referenced by test_Get_Release_DC().

◆ GdipFillPolygonI()

GpStatus WINGDIPAPI GdipFillPolygonI	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpPoint *	points,
		INT	count,
		GpFillMode	fillMode
	)

Definition at line 4492 of file graphics.c.

{
    GpStatus stat;
    GpPath *path;
 
    TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
 
    if(!graphics || !brush || !points || !count)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    stat = GdipCreatePath(fillMode, &path);
 
    if (stat == Ok)
    {
        stat = GdipAddPathPolygonI(path, points, count);
 
        if (stat == Ok)
            stat = GdipFillPath(graphics, brush, path);
 
        GdipDeletePath(path);
    }
 
    return stat;
}

Referenced by GdipFillPolygon2I(), and test_Get_Release_DC().

◆ GdipFillRectangle()

GpStatus WINGDIPAPI GdipFillRectangle	(	GpGraphics *	graphics,
		GpBrush *	brush,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height
	)

Definition at line 4537 of file graphics.c.

{
    GpRectF rect;
 
    TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
 
    rect.X = x;
    rect.Y = y;
    rect.Width = width;
    rect.Height = height;
 
    return GdipFillRectangles(graphics, brush, &rect, 1);
}

Referenced by draw_string_callback(), GdipGraphicsClear(), test_clipping(), test_containers(), test_Get_Release_DC(), test_pagetransform(), test_transform(), and test_worldtransform().

◆ GdipFillRectangleI()

GpStatus WINGDIPAPI GdipFillRectangleI	(	GpGraphics *	graphics,
		GpBrush *	brush,
		INT	x,
		INT	y,
		INT	width,
		INT	height
	)

Definition at line 4552 of file graphics.c.

{
    GpRectF rect;
 
    TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
 
    rect.X = (REAL)x;
    rect.Y = (REAL)y;
    rect.Width = (REAL)width;
    rect.Height = (REAL)height;
 
    return GdipFillRectangles(graphics, brush, &rect, 1);
}

Referenced by test_fillrect(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_Get_Release_DC(), test_hdc_caching(), test_nullframerect(), test_pagetransform(), and test_worldtransform().

◆ GdipFillRectangles()

GpStatus WINGDIPAPI GdipFillRectangles	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpRectF *	rects,
		INT	count
	)

Definition at line 4567 of file graphics.c.

{
    GpStatus status;
    GpPath *path;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
 
    if(!graphics || !brush || !rects || count <= 0)
        return InvalidParameter;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        status = METAFILE_FillRectangles((GpMetafile*)graphics->image, brush, rects, count);
        /* FIXME: Add gdi32 drawing. */
        return status;
    }
 
    status = GdipCreatePath(FillModeAlternate, &path);
    if (status != Ok) return status;
 
    status = GdipAddPathRectangles(path, rects, count);
    if (status == Ok)
        status = GdipFillPath(graphics, brush, path);
 
    GdipDeletePath(path);
    return status;
}

Referenced by GdipFillRectangle(), GdipFillRectangleI(), GdipFillRectanglesI(), GdipPlayMetafileRecord(), test_GdipFillRectangles(), and test_Get_Release_DC().

◆ GdipFillRectanglesI()

GpStatus WINGDIPAPI GdipFillRectanglesI	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GDIPCONST GpRect *	rects,
		INT	count
	)

Definition at line 4596 of file graphics.c.

{
    GpRectF *rectsF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
 
    if(!rects || count <= 0)
        return InvalidParameter;
 
    rectsF = heap_alloc_zero(sizeof(GpRectF)*count);
    if(!rectsF)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        rectsF[i].X      = (REAL)rects[i].X;
        rectsF[i].Y      = (REAL)rects[i].Y;
        rectsF[i].Width  = (REAL)rects[i].Width;
        rectsF[i].Height = (REAL)rects[i].Height;
    }
 
    ret = GdipFillRectangles(graphics,brush,rectsF,count);
    heap_free(rectsF);
 
    return ret;
}

Referenced by test_Get_Release_DC().

◆ GdipFillRegion()

GpStatus WINGDIPAPI GdipFillRegion	(	GpGraphics *	graphics,
		GpBrush *	brush,
		GpRegion *	region
	)

Definition at line 4758 of file graphics.c.

{
    GpStatus stat = NotImplemented;
 
    TRACE("(%p, %p, %p)\n", graphics, brush, region);
 
    if (!(graphics && brush && region))
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (!graphics->image && !graphics->alpha_hdc)
        stat = GDI32_GdipFillRegion(graphics, brush, region);
 
    if (stat == NotImplemented)
        stat = SOFTWARE_GdipFillRegion(graphics, brush, region);
 
    if (stat == NotImplemented)
    {
        FIXME("not implemented for brushtype %i\n", brush->bt);
        stat = Ok;
    }
 
    return stat;
}

Referenced by SOFTWARE_GdipFillPath(), and test_Get_Release_DC().

◆ GdipFindFirstImageItem()

GpStatus WINGDIPAPI GdipFindFirstImageItem	(	GpImage *	image,
		ImageItemData *	item
	)

Definition at line 2169 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%p)\n", image, item);
 
    if(!image || !item)
        return InvalidParameter;
 
    if (!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipFindNextImageItem()

GpStatus WINGDIPAPI GdipFindNextImageItem	(	GpImage *	,
		ImageItemData *
	)

◆ GdipFlattenPath()

GpStatus WINGDIPAPI GdipFlattenPath	(	GpPath *	path,
		GpMatrix *	matrix,
		REAL	flatness
	)

Definition at line 1282 of file graphicspath.c.

{
    path_list_node_t *list, *node;
    GpPointF pt;
    INT i = 1;
    INT startidx = 0;
    GpStatus stat;
 
    TRACE("(%p, %p, %.2f)\n", path, matrix, flatness);
 
    if(!path)
        return InvalidParameter;
 
    if(path->pathdata.Count == 0)
        return Ok;
 
    stat = GdipTransformPath(path, matrix);
    if(stat != Ok)
        return stat;
 
    pt = path->pathdata.Points[0];
    if(!init_path_list(&list, pt.X, pt.Y))
        return OutOfMemory;
 
    node = list;
 
    while(i < path->pathdata.Count){
 
        BYTE type = path->pathdata.Types[i] & PathPointTypePathTypeMask;
        path_list_node_t *start;
 
        pt = path->pathdata.Points[i];
 
        /* save last start point index */
        if(type == PathPointTypeStart)
            startidx = i;
 
        /* always add line points and start points */
        if((type == PathPointTypeStart) || (type == PathPointTypeLine)){
            if(!add_path_list_node(node, pt.X, pt.Y, path->pathdata.Types[i]))
                goto memout;
 
            node = node->next;
            ++i;
            continue;
        }
 
        /* Bezier curve */
 
        /* test for closed figure */
        if(path->pathdata.Types[i+1] & PathPointTypeCloseSubpath){
            pt = path->pathdata.Points[startidx];
            ++i;
        }
        else
        {
            i += 2;
            pt = path->pathdata.Points[i];
        };
 
        start = node;
        /* add Bezier end point */
        type = (path->pathdata.Types[i] & ~PathPointTypePathTypeMask) | PathPointTypeLine;
        if(!add_path_list_node(node, pt.X, pt.Y, type))
            goto memout;
        node = node->next;
 
        /* flatten curve */
        if(!flatten_bezier(start, path->pathdata.Points[i-2].X, path->pathdata.Points[i-2].Y,
                                  path->pathdata.Points[i-1].X, path->pathdata.Points[i-1].Y,
                           node, flatness))
            goto memout;
 
        ++i;
    }/* while */
 
    /* store path data back */
    i = path_list_count(list);
    if(!lengthen_path(path, i))
        goto memout;
    path->pathdata.Count = i;
 
    node = list;
    for(i = 0; i < path->pathdata.Count; i++){
        path->pathdata.Points[i] = node->pt;
        path->pathdata.Types[i]  = node->type;
        node = node->next;
    }
 
    free_path_list(list);
    return Ok;
 
memout:
    free_path_list(list);
    return OutOfMemory;
}

Referenced by brush_fill_pixels(), GdipWidenPath(), SOFTWARE_GdipDrawThinPath(), and test_flatten().

◆ GdipFlush()

GpStatus WINGDIPAPI GdipFlush	(	GpGraphics *	graphics,
		GpFlushIntention	intention
	)

Definition at line 4786 of file graphics.c.

{
    TRACE("(%p,%u)\n", graphics, intention);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    /* We have no internal operation queue, so there's no need to clear it. */
 
    if (graphics->hdc)
        GdiFlush();
 
    return Ok;
}

Referenced by test_Get_Release_DC().

◆ GdipGetAdjustableArrowCapFillState()

GpStatus WINGDIPAPI GdipGetAdjustableArrowCapFillState	(	GpAdjustableArrowCap *	cap,
		BOOL *	fill
	)

Definition at line 364 of file customlinecap.c.

{
    TRACE("(%p,%p)\n", cap, fill);
 
    if (!cap || !fill)
        return InvalidParameter;
 
    *fill = cap->cap.fill;
    return Ok;
}

Referenced by test_create_adjustable_cap().

◆ GdipGetAdjustableArrowCapHeight()

GpStatus WINGDIPAPI GdipGetAdjustableArrowCapHeight	(	GpAdjustableArrowCap *	cap,
		REAL *	height
	)

Definition at line 375 of file customlinecap.c.

{
    TRACE("(%p,%p)\n", cap, height);
 
    if (!cap || !height)
        return InvalidParameter;
 
    *height = cap->height;
    return Ok;
}

Referenced by test_create_adjustable_cap().

◆ GdipGetAdjustableArrowCapMiddleInset()

GpStatus WINGDIPAPI GdipGetAdjustableArrowCapMiddleInset	(	GpAdjustableArrowCap *	cap,
		REAL *	middle
	)

Definition at line 386 of file customlinecap.c.

{
    TRACE("(%p,%p)\n", cap, middle);
 
    if (!cap || !middle)
        return InvalidParameter;
 
    *middle = cap->middle_inset;
    return Ok;
}

Referenced by test_create_adjustable_cap().

◆ GdipGetAdjustableArrowCapWidth()

GpStatus WINGDIPAPI GdipGetAdjustableArrowCapWidth	(	GpAdjustableArrowCap *	cap,
		REAL *	width
	)

Definition at line 397 of file customlinecap.c.

{
    TRACE("(%p,%p)\n", cap, width);
 
    if (!cap || !width)
        return InvalidParameter;
 
    *width = cap->width;
    return Ok;
}

Referenced by test_create_adjustable_cap().

◆ GdipGetAllPropertyItems()

GpStatus WINGDIPAPI GdipGetAllPropertyItems	(	GpImage *	image,
		UINT	size,
		UINT	count,
		PropertyItem *	buf
	)

Definition at line 2805 of file image.c.

{
    GpStatus status;
    HRESULT hr;
    IWICMetadataReader *reader;
    IWICEnumMetadataItem *enumerator;
    UINT prop_count, prop_size, i;
    PROPVARIANT id, value;
    char *item_value;
 
    TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
 
    if (!image || !buf) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    status = GdipGetPropertySize(image, &prop_size, &prop_count);
    if (status != Ok) return status;
 
    if (prop_count != count || prop_size != size) return InvalidParameter;
 
    if (((GpBitmap *)image)->prop_item)
    {
        memcpy(buf, ((GpBitmap *)image)->prop_item, prop_size);
 
        item_value = (char *)(buf + prop_count);
 
        for (i = 0; i < prop_count; i++)
        {
            buf[i].value = item_value;
            item_value += buf[i].length;
        }
 
        return Ok;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader) return PropertyNotFound;
 
    hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    IWICEnumMetadataItem_Reset(enumerator);
 
    item_value = (char *)(buf + prop_count);
 
    PropVariantInit(&id);
    PropVariantInit(&value);
 
    for (i = 0; i < prop_count; i++)
    {
        PropertyItem *item;
        UINT items_returned, item_size;
 
        hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
        if (hr != S_OK) break;
 
        if (id.vt != VT_UI2)
        {
            FIXME("not supported propvariant type for id: %u\n", id.vt);
            continue;
        }
 
        item_size = propvariant_size(&value);
        if (item_size)
        {
            item = heap_alloc(item_size + sizeof(*item));
 
            propvariant_to_item(&value, item, item_size + sizeof(*item), id.u.uiVal);
            buf[i].id = item->id;
            buf[i].type = item->type;
            buf[i].length = item_size;
            buf[i].value = item_value;
            memcpy(item_value, item->value, item_size);
            item_value += item_size;
 
            heap_free(item);
        }
 
        PropVariantClear(&id);
        PropVariantClear(&value);
    }
 
    IWICEnumMetadataItem_Release(enumerator);
 
    if (hr != S_OK) return PropertyNotFound;
 
    return Ok;
}

Referenced by test_GdipGetAllPropertyItems(), and test_gif_properties().

◆ GdipGetBrushType()

GpStatus WINGDIPAPI GdipGetBrushType	(	GpBrush *	brush,
		GpBrushType *	type
	)

Definition at line 950 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, type);
 
    if(!brush || !type)  return InvalidParameter;
 
    *type = brush->bt;
 
    return Ok;
}

Referenced by test_brushfill(), and test_type().

◆ GdipGetCellAscent()

GpStatus WINGDIPAPI GdipGetCellAscent	(	GDIPCONST GpFontFamily *	family,
		INT	style,
		UINT16 *	CellAscent
	)

Definition at line 880 of file font.c.

{
    if (!(family && CellAscent)) return InvalidParameter;
 
    *CellAscent = family->ascent;
    TRACE("%s => %u\n", debugstr_w(family->FamilyName), *CellAscent);
 
    return Ok;
}

Referenced by gdip_get_font_metrics(), and test_fontfamily_properties().

◆ GdipGetCellDescent()

GpStatus WINGDIPAPI GdipGetCellDescent	(	GDIPCONST GpFontFamily *	family,
		INT	style,
		UINT16 *	CellDescent
	)

Definition at line 891 of file font.c.

{
    TRACE("(%p, %d, %p)\n", family, style, CellDescent);
 
    if (!(family && CellDescent)) return InvalidParameter;
 
    *CellDescent = family->descent;
    TRACE("%s => %u\n", debugstr_w(family->FamilyName), *CellDescent);
 
    return Ok;
}

Referenced by gdip_get_font_metrics(), and test_fontfamily_properties().

◆ GdipGetClip()

GpStatus WINGDIPAPI GdipGetClip	(	GpGraphics *	graphics,
		GpRegion *	region
	)

Definition at line 6809 of file graphics.c.

{
    GpRegion *clip;
    GpStatus status;
    GpMatrix device_to_world;
 
    TRACE("(%p, %p)\n", graphics, region);
 
    if(!graphics || !region)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
        return status;
 
    get_graphics_transform(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, &device_to_world);
    status = GdipTransformRegion(clip, &device_to_world);
    if (status != Ok)
    {
        GdipDeleteRegion(clip);
        return status;
    }
 
    /* free everything except root node and header */
    delete_element(&region->node);
    memcpy(region, clip, sizeof(GpRegion));
    heap_free(clip);
 
    return Ok;
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), GdipGetClipBounds(), test_clip_xform(), test_clipping(), test_clipping_2(), test_Get_Release_DC(), and test_get_set_clip().

◆ GdipGetClipBounds()

GpStatus WINGDIPAPI GdipGetClipBounds	(	GpGraphics *	graphics,
		GpRectF *	rect
	)

Definition at line 4807 of file graphics.c.

{
    GpStatus status;
    GpRegion *clip;
 
    TRACE("(%p, %p)\n", graphics, rect);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipCreateRegion(&clip);
    if (status != Ok) return status;
 
    status = GdipGetClip(graphics, clip);
    if (status == Ok)
        status = GdipGetRegionBounds(clip, graphics, rect);
 
    GdipDeleteRegion(clip);
    return status;
}

Referenced by test_BeginContainer2(), test_clipping(), and test_Get_Release_DC().

◆ GdipGetClipBoundsI()

GpStatus WINGDIPAPI GdipGetClipBoundsI	(	GpGraphics *	graphics,
		GpRect *	rect
	)

Definition at line 4834 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, rect);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
}

Referenced by test_Get_Release_DC().

◆ GdipGetCompositingMode()

GpStatus WINGDIPAPI GdipGetCompositingMode	(	GpGraphics *	graphics,
		CompositingMode *	mode
	)

Definition at line 4848 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, mode);
 
    if(!graphics || !mode)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *mode = graphics->compmode;
 
    return Ok;
}

Referenced by test_BeginContainer2(), and test_Get_Release_DC().

◆ GdipGetCompositingQuality()

GpStatus WINGDIPAPI GdipGetCompositingQuality	(	GpGraphics *	graphics,
		CompositingQuality *	quality
	)

Definition at line 4865 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, quality);
 
    if(!graphics || !quality)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *quality = graphics->compqual;
 
    return Ok;
}

Referenced by test_BeginContainer2(), and test_Get_Release_DC().

◆ GdipGetCustomLineCapBaseCap()

GpStatus WINGDIPAPI GdipGetCustomLineCapBaseCap	(	GpCustomLineCap *	customCap,
		GpLineCap *	baseCap
	)

Definition at line 260 of file customlinecap.c.

{
    TRACE("(%p, %p)\n", customCap, baseCap);
 
    if(!customCap || !baseCap)
        return InvalidParameter;
 
    *baseCap = customCap->cap;
 
    return Ok;
}

Referenced by test_create_adjustable_cap().

◆ GdipGetCustomLineCapBaseInset()

GpStatus WINGDIPAPI GdipGetCustomLineCapBaseInset	(	GpCustomLineCap *	custom,
		REAL *	inset
	)

Definition at line 208 of file customlinecap.c.

{
    TRACE("(%p, %p)\n", custom, inset);
 
    if(!custom || !inset)
        return InvalidParameter;
 
    *inset = custom->inset;
 
    return Ok;
}

Referenced by test_create_adjustable_cap(), and test_inset().

◆ GdipGetCustomLineCapStrokeJoin()

GpStatus WINGDIPAPI GdipGetCustomLineCapStrokeJoin	(	GpCustomLineCap *	customCap,
		GpLineJoin *	lineJoin
	)

Definition at line 153 of file customlinecap.c.

{
    TRACE("(%p, %p)\n", customCap, lineJoin);
 
    if(!customCap || !lineJoin)
        return InvalidParameter;
 
    *lineJoin = customCap->join;
 
    return Ok;
}

Referenced by test_create_adjustable_cap(), and test_linejoin().

◆ GdipGetCustomLineCapType()

GpStatus WINGDIPAPI GdipGetCustomLineCapType	(	GpCustomLineCap *	customCap,
		CustomLineCapType *	type
	)

Definition at line 272 of file customlinecap.c.

{
    TRACE("(%p, %p)\n", customCap, type);
 
    if(!customCap || !type)
        return InvalidParameter;
 
    *type = customCap->type;
    return Ok;
}

Referenced by test_captype().

◆ GdipGetCustomLineCapWidthScale()

GpStatus WINGDIPAPI GdipGetCustomLineCapWidthScale	(	GpCustomLineCap *	custom,
		REAL *	widthScale
	)

Definition at line 166 of file customlinecap.c.

{
    TRACE("(%p, %p)\n", custom, widthScale);
 
    if(!custom || !widthScale)
        return InvalidParameter;
 
    *widthScale = custom->scale;
 
    return Ok;
}

Referenced by test_create_adjustable_cap(), and test_scale().

◆ GdipGetDC()

GpStatus WINGDIPAPI GdipGetDC	(	GpGraphics *	graphics,
		HDC *	hdc
	)

Definition at line 6682 of file graphics.c.

{
    GpStatus stat=Ok;
 
    TRACE("(%p, %p)\n", graphics, hdc);
 
    if(!graphics || !hdc)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        stat = METAFILE_GetDC((GpMetafile*)graphics->image, hdc);
    }
    else if (!graphics->hdc ||
        (graphics->image && graphics->image->type == ImageTypeBitmap && ((GpBitmap*)graphics->image)->format & PixelFormatAlpha))
    {
        /* Create a fake HDC and fill it with a constant color. */
        HDC temp_hdc;
        HBITMAP hbitmap;
        GpRectF bounds;
        BITMAPINFOHEADER bmih;
        int i;
 
        stat = get_graphics_bounds(graphics, &bounds);
        if (stat != Ok)
            return stat;
 
        graphics->temp_hbitmap_width = bounds.Width;
        graphics->temp_hbitmap_height = bounds.Height;
 
        bmih.biSize = sizeof(bmih);
        bmih.biWidth = graphics->temp_hbitmap_width;
        bmih.biHeight = -graphics->temp_hbitmap_height;
        bmih.biPlanes = 1;
        bmih.biBitCount = 32;
        bmih.biCompression = BI_RGB;
        bmih.biSizeImage = 0;
        bmih.biXPelsPerMeter = 0;
        bmih.biYPelsPerMeter = 0;
        bmih.biClrUsed = 0;
        bmih.biClrImportant = 0;
 
        hbitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
            (void**)&graphics->temp_bits, NULL, 0);
        if (!hbitmap)
            return GenericError;
 
        temp_hdc = CreateCompatibleDC(0);
        if (!temp_hdc)
        {
            DeleteObject(hbitmap);
            return GenericError;
        }
 
        for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
            ((DWORD*)graphics->temp_bits)[i] = DC_BACKGROUND_KEY;
 
        SelectObject(temp_hdc, hbitmap);
 
        graphics->temp_hbitmap = hbitmap;
        *hdc = graphics->temp_hdc = temp_hdc;
    }
    else
    {
        *hdc = graphics->hdc;
    }
 
    if (stat == Ok)
        graphics->busy = TRUE;
 
    return stat;
}

Referenced by METAFILE_PlaybackGetDC(), test_alpha_hdc(), test_emfonly(), test_fromMemoryBitmap(), test_gditransform(), test_Get_Release_DC(), test_getdc(), test_getdc_scaled(), and test_nullframerect().

◆ GdipGetDpiX()

GpStatus WINGDIPAPI GdipGetDpiX	(	GpGraphics *	graphics,
		REAL *	dpi
	)

Definition at line 6621 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, dpi);
 
    if(!graphics || !dpi)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *dpi = graphics->xres;
    return Ok;
}

Referenced by create_graphics(), GdipCreateBitmapFromGraphics(), test_bitmapfromgraphics(), test_container_rects(), test_containers(), test_Get_Release_DC(), test_measured_extra_space(), test_pagetransform(), and test_resolution().

◆ GdipGetDpiY()

GpStatus WINGDIPAPI GdipGetDpiY	(	GpGraphics *	graphics,
		REAL *	dpi
	)

Definition at line 6635 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, dpi);
 
    if(!graphics || !dpi)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *dpi = graphics->yres;
    return Ok;
}

Referenced by create_graphics(), GdipCreateBitmapFromGraphics(), GdipGetFontHeight(), test_bitmapfromgraphics(), test_container_rects(), test_containers(), test_font_height_scaling(), test_Get_Release_DC(), test_pagetransform(), and test_resolution().

◆ GdipGetEmHeight()

GpStatus WINGDIPAPI GdipGetEmHeight	(	GDIPCONST GpFontFamily *	family,
		INT	style,
		UINT16 *	EmHeight
	)

Definition at line 918 of file font.c.

{
    if (!(family && EmHeight)) return InvalidParameter;
 
    TRACE("%p (%s), %d, %p\n", family, debugstr_w(family->FamilyName), style, EmHeight);
 
    *EmHeight = family->em_height;
    TRACE("%s => %u\n", debugstr_w(family->FamilyName), *EmHeight);
 
    return Ok;
}

Referenced by gdip_get_font_metrics(), GdipAddPathString(), GdipGetFontHeightGivenDPI(), test_fontfamily_properties(), and test_logfont().

◆ GdipGetEncoderParameterListSize()

GpStatus WINGDIPAPI GdipGetEncoderParameterListSize	(	GpImage *	image,
		GDIPCONST CLSID *	clsidEncoder,
		UINT *	size
	)

Definition at line 5093 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    *size = 0;
 
    return NotImplemented;
}

◆ GdipGetFamily()

GpStatus WINGDIPAPI GdipGetFamily	(	GpFont *	font,
		GpFontFamily **	family
	)

Definition at line 319 of file font.c.

{
    TRACE("%p %p\n", font, family);
 
    if (!(font && family))
        return InvalidParameter;
 
    return GdipCloneFontFamily(font->family, family);
}

Referenced by gdip_get_font_metrics(), test_createfont(), and test_logfont().

◆ GdipGetFamilyName()

GpStatus WINGDIPAPI GdipGetFamilyName	(	GDIPCONST GpFontFamily *	family,
		WCHAR *	name,
		LANGID	language
	)

Definition at line 837 of file font.c.

{
    static int lang_fixme;
 
    if (family == NULL)
         return InvalidParameter;
 
    TRACE("%p, %p, %d\n", family, name, language);
 
    if (language != LANG_NEUTRAL && !lang_fixme++)
        FIXME("No support for handling of multiple languages!\n");
 
    lstrcpynW (name, family->FamilyName, LF_FACESIZE);
 
    return Ok;
}

Referenced by check_family(), GdipCreateFont(), test_createfont(), test_fontfamily(), and test_long_name().

◆ GdipGetFontCollectionFamilyCount()

GpStatus WINGDIPAPI GdipGetFontCollectionFamilyCount	(	GpFontCollection *	fontCollection,
		INT *	numFound
	)

Definition at line 1559 of file font.c.

{
    TRACE("%p, %p\n", fontCollection, numFound);
 
    if (!(fontCollection && numFound))
        return InvalidParameter;
 
    *numFound = fontCollection->count;
    return Ok;
}

Referenced by test_GdipGetFontCollectionFamilyCount(), test_GdipGetFontCollectionFamilyList(), and test_long_name().

◆ GdipGetFontCollectionFamilyList()

GpStatus WINGDIPAPI GdipGetFontCollectionFamilyList	(	GpFontCollection *	fontCollection,
		INT	numSought,
		GpFontFamily *	gpfamilies[],
		INT *	numFound
	)

Definition at line 1574 of file font.c.

{
    INT i;
    GpStatus stat=Ok;
 
    TRACE("%p, %d, %p, %p\n", fontCollection, numSought, gpfamilies, numFound);
 
    if (!(fontCollection && gpfamilies && numFound))
        return InvalidParameter;
 
    memset(gpfamilies, 0, sizeof(*gpfamilies) * numSought);
 
    for (i = 0; i < numSought && i < fontCollection->count && stat == Ok; i++)
    {
        stat = GdipCloneFontFamily(fontCollection->FontFamilies[i], &gpfamilies[i]);
    }
 
    if (stat == Ok)
        *numFound = i;
    else
    {
        int numToFree=i;
        for (i=0; i<numToFree; i++)
        {
            GdipDeleteFontFamily(gpfamilies[i]);
            gpfamilies[i] = NULL;
        }
    }
 
    return stat;
}

Referenced by test_GdipGetFontCollectionFamilyList(), and test_long_name().

◆ GdipGetFontHeight()

GpStatus WINGDIPAPI GdipGetFontHeight	(	GDIPCONST GpFont *	font,
		GDIPCONST GpGraphics *	graphics,
		REAL *	height
	)

Definition at line 552 of file font.c.

{
    REAL dpi;
    GpStatus stat;
    REAL font_height;
 
    TRACE("%p %p %p\n", font, graphics, height);
 
    if (!font || !height) return InvalidParameter;
 
    stat = GdipGetFontHeightGivenDPI(font, font->family->dpi, &font_height);
    if (stat != Ok) return stat;
 
    if (!graphics)
    {
        *height = font_height;
        TRACE("%s,%d => %f\n",
              debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *height);
        return Ok;
    }
 
    stat = GdipGetDpiY((GpGraphics *)graphics, &dpi);
    if (stat != Ok) return stat;
 
    *height = pixels_to_units(font_height, graphics->unit, dpi);
 
    TRACE("%s,%d(unit %d) => %f\n",
          debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, graphics->unit, *height);
    return Ok;
}

Referenced by gdip_get_font_metrics(), test_font_height_scaling(), test_font_transform(), and test_logfont().

◆ GdipGetFontHeightGivenDPI()

GpStatus WINGDIPAPI GdipGetFontHeightGivenDPI	(	GDIPCONST GpFont *	font,
		REAL	dpi,
		REAL *	height
	)

Definition at line 599 of file font.c.

{
    GpStatus stat;
    INT style;
    UINT16 line_spacing, em_height;
    REAL font_size;
 
    if (!font || !height) return InvalidParameter;
 
    TRACE("%p (%s), %f, %p\n", font,
            debugstr_w(font->family->FamilyName), dpi, height);
 
    font_size = units_to_pixels(get_font_size(font), font->unit, dpi);
    style = get_font_style(font);
    stat = GdipGetLineSpacing(font->family, style, &line_spacing);
    if (stat != Ok) return stat;
    stat = GdipGetEmHeight(font->family, style, &em_height);
    if (stat != Ok) return stat;
 
    *height = (REAL)line_spacing * font_size / (REAL)em_height;
 
    TRACE("%s,%d => %f\n",
          debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *height);
 
    return Ok;
}

Referenced by GdipGetFontHeight(), and test_heightgivendpi().

◆ GdipGetFontSize()

GpStatus WINGDIPAPI GdipGetFontSize	(	GpFont *	font,
		REAL *	size
	)

Definition at line 350 of file font.c.

{
    TRACE("(%p, %p)\n", font, size);
 
    if (!(font && size)) return InvalidParameter;
 
    *size = get_font_size(font);
    TRACE("%s,%d => %f\n", debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *size);
 
    return Ok;
}

Referenced by gdip_get_font_metrics(), test_createfont(), test_GdipMeasureString(), test_logfont(), and test_measured_extra_space().

◆ GdipGetFontStyle()

GpStatus WINGDIPAPI GdipGetFontStyle	(	GpFont *	font,
		INT *	style
	)

Definition at line 393 of file font.c.

{
    TRACE("%p %p\n", font, style);
 
    if (!(font && style))
        return InvalidParameter;
 
    *style = get_font_style(font);
    TRACE("%s,%d => %d\n", debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *style);
 
    return Ok;
}

Referenced by gdip_get_font_metrics(), and test_logfont().

◆ GdipGetFontUnit()

GpStatus WINGDIPAPI GdipGetFontUnit	(	GpFont *	font,
		Unit *	unit
	)

Definition at line 417 of file font.c.

{
    TRACE("(%p, %p)\n", font, unit);
 
    if (!(font && unit)) return InvalidParameter;
 
    *unit = font->unit;
    TRACE("%s,%d => %d\n", debugstr_w(font->family->FamilyName), font->otm.otmTextMetrics.tmHeight, *unit);
 
    return Ok;
}

Referenced by test_createfont(), test_font_metrics(), test_GdipMeasureString(), test_heightgivendpi(), and test_logfont().

◆ GdipGetGenericFontFamilyMonospace()

GpStatus WINGDIPAPI GdipGetGenericFontFamilyMonospace ( GpFontFamily ** nativeFamily )

Definition at line 1010 of file font.c.

{
    static const WCHAR CourierNew[] = {'C','o','u','r','i','e','r',' ','N','e','w','\0'};
    static const WCHAR LiberationMono[] = {'L','i','b','e','r','a','t','i','o','n',' ','M','o','n','o','\0'};
    GpStatus stat;
 
    if (nativeFamily == NULL) return InvalidParameter;
 
    stat = GdipCreateFontFamilyFromName(CourierNew, NULL, nativeFamily);
 
    if (stat == FontFamilyNotFound)
        stat = GdipCreateFontFamilyFromName(LiberationMono, NULL, nativeFamily);
 
    if (stat == FontFamilyNotFound)
        ERR("Missing 'Courier New' font\n");
 
    return stat;
}

Referenced by test_getgenerics().

◆ GdipGetGenericFontFamilySansSerif()

GpStatus WINGDIPAPI GdipGetGenericFontFamilySansSerif ( GpFontFamily ** nativeFamily )

Definition at line 1074 of file font.c.

{
    GpStatus stat;
    static const WCHAR MicrosoftSansSerif[] = {'M','i','c','r','o','s','o','f','t',' ','S','a','n','s',' ','S','e','r','i','f','\0'};
    static const WCHAR Tahoma[] = {'T','a','h','o','m','a','\0'};
 
    TRACE("(%p)\n", nativeFamily);
 
    if (nativeFamily == NULL) return InvalidParameter;
 
    stat = GdipCreateFontFamilyFromName(MicrosoftSansSerif, NULL, nativeFamily);
 
    if (stat == FontFamilyNotFound)
        /* FIXME: Microsoft Sans Serif is not installed on Wine. */
        stat = GdipCreateFontFamilyFromName(Tahoma, NULL, nativeFamily);
 
    return stat;
}

Referenced by test_getgenerics().

◆ GdipGetGenericFontFamilySerif()

GpStatus WINGDIPAPI GdipGetGenericFontFamilySerif ( GpFontFamily ** nativeFamily )

Definition at line 1041 of file font.c.

{
    static const WCHAR TimesNewRoman[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n','\0'};
    static const WCHAR LiberationSerif[] = {'L','i','b','e','r','a','t','i','o','n',' ','S','e','r','i','f','\0'};
    GpStatus stat;
 
    TRACE("(%p)\n", nativeFamily);
 
    if (nativeFamily == NULL) return InvalidParameter;
 
    stat = GdipCreateFontFamilyFromName(TimesNewRoman, NULL, nativeFamily);
 
    if (stat == FontFamilyNotFound)
        stat = GdipCreateFontFamilyFromName(LiberationSerif, NULL, nativeFamily);
 
    if (stat == FontFamilyNotFound)
        ERR("Missing 'Times New Roman' font\n");
 
    return stat;
}

Referenced by test_getgenerics().

◆ GdipGetHatchBackgroundColor()

GpStatus WINGDIPAPI GdipGetHatchBackgroundColor	(	GpHatch *	brush,
		ARGB *	backcol
	)

Definition at line 961 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, backcol);
 
    if(!brush || !backcol)  return InvalidParameter;
 
    *backcol = brush->backcol;
 
    return Ok;
}

◆ GdipGetHatchForegroundColor()

GpStatus WINGDIPAPI GdipGetHatchForegroundColor	(	GpHatch *	brush,
		ARGB *	forecol
	)

Definition at line 972 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, forecol);
 
    if(!brush || !forecol)  return InvalidParameter;
 
    *forecol = brush->forecol;
 
    return Ok;
}

◆ GdipGetHatchStyle()

GpStatus WINGDIPAPI GdipGetHatchStyle	(	GpHatch *	brush,
		GpHatchStyle *	hatchstyle
	)

Definition at line 983 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, hatchstyle);
 
    if(!brush || !hatchstyle)  return InvalidParameter;
 
    *hatchstyle = brush->hatchstyle;
 
    return Ok;
}

Referenced by test_getHatchStyle().

◆ GdipGetHemfFromMetafile()

GpStatus WINGDIPAPI GdipGetHemfFromMetafile	(	GpMetafile *	metafile,
		HENHMETAFILE *	hEmf
	)

Definition at line 1613 of file metafile.c.

{
    TRACE("(%p,%p)\n", metafile, hEmf);
 
    if (!metafile || !hEmf || !metafile->hemf)
        return InvalidParameter;
 
    *hEmf = metafile->hemf;
    metafile->hemf = NULL;
 
    return Ok;
}

Referenced by sync_metafile(), test_clear(), test_drawimage(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_gditransform(), test_getdc(), and test_properties().

◆ GdipGetImageAttributesAdjustedPalette()

GpStatus WINGDIPAPI GdipGetImageAttributesAdjustedPalette	(	GpImageAttributes *	imageattr,
		ColorPalette *	palette,
		ColorAdjustType	type
	)

Definition at line 114 of file imageattributes.c.

{
    TRACE("(%p,%p,%u)\n", imageattr, palette, type);
 
    if (!imageattr || !palette || !palette->Count ||
        type >= ColorAdjustTypeCount || type == ColorAdjustTypeDefault)
        return InvalidParameter;
 
    apply_image_attributes(imageattr, (LPBYTE)palette->Entries, palette->Count, 1, 0,
        type, PixelFormat32bppARGB);
 
    return Ok;
}

Referenced by test_getadjustedpalette().

◆ GdipGetImageBounds()

GpStatus WINGDIPAPI GdipGetImageBounds	(	GpImage *	image,
		GpRectF *	srcRect,
		GpUnit *	srcUnit
	)

Definition at line 2196 of file image.c.

{
    TRACE("%p %p %p\n", image, srcRect, srcUnit);
 
    if(!image || !srcRect || !srcUnit)
        return InvalidParameter;
    if(image->type == ImageTypeMetafile){
        *srcRect = ((GpMetafile*)image)->bounds;
        *srcUnit = ((GpMetafile*)image)->unit;
    }
    else if(image->type == ImageTypeBitmap){
        srcRect->X = srcRect->Y = 0.0;
        srcRect->Width = (REAL) ((GpBitmap*)image)->width;
        srcRect->Height = (REAL) ((GpBitmap*)image)->height;
        *srcUnit = UnitPixel;
    }
    else{
        WARN("GpImage with no image data\n");
        return InvalidParameter;
    }
 
    TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
          srcRect->Width, srcRect->Height, *srcUnit);
 
    return Ok;
}

Referenced by GdipDrawImageRect(), get_graphics_device_bounds(), test_createfromwmf(), test_emfonly(), test_empty(), test_frameunit(), test_GdipCloneImage(), test_loadwmf(), and test_nullframerect().

◆ GdipGetImageDecoders()

GpStatus WINGDIPAPI GdipGetImageDecoders	(	UINT	numDecoders,
		UINT	size,
		ImageCodecInfo *	decoders
	)

Definition at line 5018 of file image.c.

{
    int i, decoder_count=0;
    TRACE("%u %u %p\n", numDecoders, size, decoders);
 
    if (!decoders ||
        size != numDecoders * sizeof(ImageCodecInfo))
        return GenericError;
 
    for (i=0; i<NUM_CODECS; i++)
    {
        if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
        {
            if (decoder_count == numDecoders) return GenericError;
            memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
            decoder_count++;
        }
    }
 
    if (decoder_count < numDecoders) return GenericError;
 
    return Ok;
}

Referenced by GdipGetSupportedFileExtensions(), and pBuildFileList().

◆ GdipGetImageDecodersSize()

GpStatus WINGDIPAPI GdipGetImageDecodersSize	(	UINT *	numDecoders,
		UINT *	size
	)

Definition at line 4994 of file image.c.

{
    int decoder_count=0;
    int i;
    TRACE("%p %p\n", numDecoders, size);
 
    if (!numDecoders || !size)
        return InvalidParameter;
 
    for (i=0; i<NUM_CODECS; i++)
    {
        if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
            decoder_count++;
    }
 
    *numDecoders = decoder_count;
    *size = decoder_count * sizeof(ImageCodecInfo);
 
    return Ok;
}

Referenced by GdipGetSupportedFileExtensions(), and pBuildFileList().

◆ GdipGetImageDimension()

GpStatus WINGDIPAPI GdipGetImageDimension	(	GpImage *	image,
		REAL *	width,
		REAL *	height
	)

Definition at line 2224 of file image.c.

{
    TRACE("%p %p %p\n", image, width, height);
 
    if(!image || !height || !width)
        return InvalidParameter;
 
    if(image->type == ImageTypeMetafile){
        *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
        *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
    }
    else if(image->type == ImageTypeBitmap){
        *height = ((GpBitmap*)image)->height;
        *width = ((GpBitmap*)image)->width;
    }
    else{
        WARN("GpImage with no image data\n");
        return InvalidParameter;
    }
 
    TRACE("returning (%f, %f)\n", *height, *width);
    return Ok;
}

Referenced by test_GdipCreateBitmapFromHBITMAP(), test_GetImageDimension(), and test_SavingImages().

◆ GdipGetImageEncoders()

GpStatus WINGDIPAPI GdipGetImageEncoders	(	UINT	numEncoders,
		UINT	size,
		ImageCodecInfo *	encoders
	)

Definition at line 5069 of file image.c.

{
    int i, encoder_count=0;
    TRACE("%u %u %p\n", numEncoders, size, encoders);
 
    if (!encoders ||
        size != numEncoders * sizeof(ImageCodecInfo))
        return GenericError;
 
    for (i=0; i<NUM_CODECS; i++)
    {
        if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
        {
            if (encoder_count == numEncoders) return GenericError;
            memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
            encoder_count++;
        }
    }
 
    if (encoder_count < numEncoders) return GenericError;
 
    return Ok;
}

Referenced by GdipGetEncoderClsid(), get_encoder_clsid(), Preview_pSaveImage(), Preview_pSaveImageAs(), test_encoders(), and test_SavingImages().

◆ GdipGetImageEncodersSize()

GpStatus WINGDIPAPI GdipGetImageEncodersSize	(	UINT *	numEncoders,
		UINT *	size
	)

Definition at line 5045 of file image.c.

{
    int encoder_count=0;
    int i;
    TRACE("%p %p\n", numEncoders, size);
 
    if (!numEncoders || !size)
        return InvalidParameter;
 
    for (i=0; i<NUM_CODECS; i++)
    {
        if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
            encoder_count++;
    }
 
    *numEncoders = encoder_count;
    *size = encoder_count * sizeof(ImageCodecInfo);
 
    return Ok;
}

Referenced by GdipGetEncoderClsid(), get_encoder_clsid(), Preview_pSaveImage(), Preview_pSaveImageAs(), test_encoders(), and test_SavingImages().

◆ GdipGetImageFlags()

GpStatus WINGDIPAPI GdipGetImageFlags	(	GpImage *	image,
		UINT *	flags
	)

Definition at line 5314 of file image.c.

{
    TRACE("%p %p\n", image, flags);
 
    if(!image || !flags)
        return InvalidParameter;
 
    *flags = image->flags;
 
    return Ok;
}

Referenced by test_GdipGetImageFlags(), test_png_color_formats(), and ZoomWnd_OnDraw().

◆ GdipGetImageGraphicsContext()

GpStatus WINGDIPAPI GdipGetImageGraphicsContext	(	GpImage *	image,
		GpGraphics **	graphics
	)

Definition at line 2249 of file image.c.

{
    HDC hdc;
    GpStatus stat;
 
    TRACE("%p %p\n", image, graphics);
 
    if(!image || !graphics)
        return InvalidParameter;
 
    if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
    {
        hdc = ((GpBitmap*)image)->hdc;
 
        if(!hdc){
            hdc = CreateCompatibleDC(0);
            SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
            ((GpBitmap*)image)->hdc = hdc;
        }
 
        stat = GdipCreateFromHDC(hdc, graphics);
 
        if (stat == Ok)
        {
            (*graphics)->image = image;
            (*graphics)->xres = image->xres;
            (*graphics)->yres = image->yres;
        }
    }
    else if (image->type == ImageTypeMetafile)
        stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
    else
        stat = graphics_from_image(image, graphics);
 
    return stat;
}

Referenced by create_graphics(), GdipGetImageThumbnail(), METAFILE_DrawImagePointsRect(), test_clear(), test_clipping(), test_colorkey(), test_colormatrix(), test_containers(), test_converttoemfplus(), test_DrawImage(), test_drawimage(), test_DrawImage_scale(), test_DrawImage_SourceCopy(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_frameunit(), test_fromMemoryBitmap(), test_gamma(), test_GdipDrawImagePointRect(), test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipGetNearestColor(), test_gditransform(), test_getdc(), test_getdc_scaled(), test_nullframerect(), test_pagetransform(), test_pen_thickness(), test_properties(), test_remaptable(), test_resolution(), and test_worldtransform().

◆ GdipGetImageHeight()

GpStatus WINGDIPAPI GdipGetImageHeight	(	GpImage *	image,
		UINT *	height
	)

Definition at line 2287 of file image.c.

{
    TRACE("%p %p\n", image, height);
 
    if(!image || !height)
        return InvalidParameter;
 
    if(image->type == ImageTypeMetafile)
        *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
    else if(image->type == ImageTypeBitmap)
        *height = ((GpBitmap*)image)->height;
    else
    {
        WARN("GpImage with no image data\n");
        return InvalidParameter;
    }
 
    TRACE("returning %d\n", *height);
 
    return Ok;
}

Referenced by DibLoadImage(), encode_image_wic(), GdipBitmapGetHistogram(), GdipCloneBrush(), GdipCreateHBITMAPFromBitmap(), GdipCreateTexture(), GdipDrawImage(), GdipDrawImagePoints(), GdipGetImageThumbnail(), Preview_ResetZoom(), test_bitmapfromgraphics(), test_fromhicon(), test_getthumbnail(), test_pagetransform(), test_rotateflip(), ZoomWnd_OnDraw(), ZoomWnd_OnHVScroll(), and ZoomWnd_UpdateScroll().

◆ GdipGetImageHorizontalResolution()

GpStatus WINGDIPAPI GdipGetImageHorizontalResolution	(	GpImage *	image,
		REAL *	res
	)

Definition at line 2309 of file image.c.

{
    if(!image || !res)
        return InvalidParameter;
 
    *res = image->xres;
 
    TRACE("(%p) <-- %0.2f\n", image, *res);
 
    return Ok;
}

Referenced by create_graphics(), test_bitmapfromgraphics(), test_createfromwmf(), test_emfonly(), test_empty(), test_frameunit(), test_loadwmf(), test_pagetransform(), and test_resolution().

◆ GdipGetImageItemData()

GpStatus WINGDIPAPI GdipGetImageItemData	(	GpImage *	image,
		ImageItemData *	item
	)

Definition at line 2184 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%p)\n", image, item);
 
    if (!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipGetImagePalette()

GpStatus WINGDIPAPI GdipGetImagePalette	(	GpImage *	image,
		ColorPalette *	palette,
		INT	size
	)

Definition at line 4710 of file image.c.

{
    INT count;
 
    TRACE("(%p,%p,%i)\n", image, palette, size);
 
    if (!image || !palette)
        return InvalidParameter;
 
    count = image->palette ? image->palette->Count : 0;
 
    if (size < (sizeof(UINT)*2+sizeof(ARGB)*count))
    {
        TRACE("<-- InsufficientBuffer\n");
        return InsufficientBuffer;
    }
 
    if (image->palette)
    {
        palette->Flags = image->palette->Flags;
        palette->Count = image->palette->Count;
        memcpy(palette->Entries, image->palette->Entries, sizeof(ARGB)*image->palette->Count);
    }
    else
    {
        palette->Flags = 0;
        palette->Count = 0;
    }
    return Ok;
}

Referenced by test_multiframegif(), test_palette(), and test_tiff_palette().

◆ GdipGetImagePaletteSize()

GpStatus WINGDIPAPI GdipGetImagePaletteSize	(	GpImage *	image,
		INT *	size
	)

Definition at line 2321 of file image.c.

{
    TRACE("%p %p\n", image, size);
 
    if(!image || !size)
        return InvalidParameter;
 
    if (!image->palette || image->palette->Count == 0)
        *size = sizeof(ColorPalette);
    else
        *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette->Count;
 
    TRACE("<-- %u\n", *size);
 
    return Ok;
}

Referenced by test_multiframegif(), test_palette(), and test_tiff_palette().

◆ GdipGetImagePixelFormat()

GpStatus WINGDIPAPI GdipGetImagePixelFormat	(	GpImage *	image,
		PixelFormat *	format
	)

Definition at line 2339 of file image.c.

{
    TRACE("%p %p\n", image, format);
 
    if(!image || !format)
        return InvalidParameter;
 
    if(image->type != ImageTypeBitmap)
        *format = PixelFormat24bppRGB;
    else
        *format = ((GpBitmap*) image)->format;
 
    return Ok;
}

Referenced by test_bitmapfromgraphics(), test_FromGdiDib(), test_fromhicon(), test_GdipCreateBitmapFromHBITMAP(), test_image_format(), test_multiframegif(), test_png_color_formats(), test_tiff_color_formats(), and test_tiff_palette().

◆ GdipGetImageRawFormat()

GpStatus WINGDIPAPI GdipGetImageRawFormat	(	GpImage *	image,
		GUID *	format
	)

Definition at line 2354 of file image.c.

{
    TRACE("(%p, %p)\n", image, format);
 
    if(!image || !format)
        return InvalidParameter;
 
    memcpy(format, &image->format, sizeof(GUID));
 
    return Ok;
}

Referenced by expect_rawformat(), Preview_pSaveImage(), Preview_pSaveImageAs(), and SetWallpaper().

◆ GdipGetImageThumbnail()

GpStatus WINGDIPAPI GdipGetImageThumbnail	(	GpImage *	image,
		UINT	width,
		UINT	height,
		GpImage **	ret_image,
		GetThumbnailImageAbort	cb,
		VOID *	cb_data
	)

Definition at line 5357 of file image.c.

{
    GpStatus stat;
    GpGraphics *graphics;
    UINT srcwidth, srcheight;
 
    TRACE("(%p %u %u %p %p %p)\n",
        image, width, height, ret_image, cb, cb_data);
 
    if (!image || !ret_image)
        return InvalidParameter;
 
    if (!width) width = 120;
    if (!height) height = 120;
 
    GdipGetImageWidth(image, &srcwidth);
    GdipGetImageHeight(image, &srcheight);
 
    stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
        NULL, (GpBitmap**)ret_image);
 
    if (stat == Ok)
    {
        stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
 
        if (stat == Ok)
        {
            stat = GdipDrawImageRectRectI(graphics, image,
                0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
                NULL, NULL, NULL);
 
            GdipDeleteGraphics(graphics);
        }
 
        if (stat != Ok)
        {
            GdipDisposeImage(*ret_image);
            *ret_image = NULL;
        }
    }
 
    return stat;
}

Referenced by test_getthumbnail(), and test_image_format().

◆ GdipGetImageType()

GpStatus WINGDIPAPI GdipGetImageType	(	GpImage *	image,
		ImageType *	type
	)

Definition at line 2366 of file image.c.

{
    TRACE("%p %p\n", image, type);
 
    if(!image || !type)
        return InvalidParameter;
 
    *type = image->type;
 
    return Ok;
}

Referenced by load_image(), test_fromhicon(), test_image_properties(), test_png_color_formats(), and test_tiff_color_formats().

◆ GdipGetImageVerticalResolution()

GpStatus WINGDIPAPI GdipGetImageVerticalResolution	(	GpImage *	image,
		REAL *	res
	)

Definition at line 2378 of file image.c.

{
    if(!image || !res)
        return InvalidParameter;
 
    *res = image->yres;
 
    TRACE("(%p) <-- %0.2f\n", image, *res);
 
    return Ok;
}

Referenced by create_graphics(), test_bitmapfromgraphics(), test_createfromwmf(), test_emfonly(), test_empty(), test_frameunit(), test_loadwmf(), test_pagetransform(), and test_resolution().

◆ GdipGetImageWidth()

GpStatus WINGDIPAPI GdipGetImageWidth	(	GpImage *	image,
		UINT *	width
	)

Definition at line 2390 of file image.c.

{
    TRACE("%p %p\n", image, width);
 
    if(!image || !width)
        return InvalidParameter;
 
    if(image->type == ImageTypeMetafile)
        *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
    else if(image->type == ImageTypeBitmap)
        *width = ((GpBitmap*)image)->width;
    else
    {
        WARN("GpImage with no image data\n");
        return InvalidParameter;
    }
 
    TRACE("returning %d\n", *width);
 
    return Ok;
}

Referenced by DibLoadImage(), encode_image_wic(), GdipBitmapGetHistogram(), GdipCloneBrush(), GdipCreateHBITMAPFromBitmap(), GdipCreateTexture(), GdipDrawImage(), GdipDrawImagePoints(), GdipGetImageThumbnail(), Preview_ResetZoom(), test_bitmapfromgraphics(), test_fromhicon(), test_getthumbnail(), test_pagetransform(), test_rotateflip(), ZoomWnd_OnDraw(), ZoomWnd_OnHVScroll(), and ZoomWnd_UpdateScroll().

◆ GdipGetInterpolationMode()

GpStatus WINGDIPAPI GdipGetInterpolationMode	(	GpGraphics *	graphics,
		InterpolationMode *	mode
	)

Definition at line 4882 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, mode);
 
    if(!graphics || !mode)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *mode = graphics->interpolation;
 
    return Ok;
}

Referenced by test_BeginContainer2(), test_Get_Release_DC(), test_get_set_interpolation(), and test_save_restore().

◆ GdipGetLineBlend()

GpStatus WINGDIPAPI GdipGetLineBlend	(	GpLineGradient *	brush,
		REAL *	factors,
		REAL *	positions,
		INT	count
	)

Definition at line 1403 of file brush.c.

{
    TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
 
    if (!brush || !factors || !positions || count <= 0 || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    if (count < brush->blendcount)
        return InsufficientBuffer;
 
    memcpy(factors, brush->blendfac, brush->blendcount * sizeof(REAL));
    memcpy(positions, brush->blendpos, brush->blendcount * sizeof(REAL));
 
    return Ok;
}

Referenced by test_lineblend(), and test_linelinearblend().

◆ GdipGetLineBlendCount()

GpStatus WINGDIPAPI GdipGetLineBlendCount	(	GpLineGradient *	brush,
		INT *	count
	)

Definition at line 1420 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, count);
 
    if (!brush || !count || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    *count = brush->blendcount;
 
    return Ok;
}

Referenced by test_lineblend(), and test_linelinearblend().

◆ GdipGetLineColors()

GpStatus WINGDIPAPI GdipGetLineColors	(	GpLineGradient *	brush,
		ARGB *	colors
	)

Definition at line 1983 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, colors);
 
    if(!brush || !colors || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    colors[0] = brush->startcolor;
    colors[1] = brush->endcolor;
 
    return Ok;
}

Referenced by test_gradientgetrect().

◆ GdipGetLineGammaCorrection()

GpStatus WINGDIPAPI GdipGetLineGammaCorrection	(	GpLineGradient *	line,
		BOOL *	usinggamma
	)

Definition at line 1030 of file brush.c.

{
    TRACE("(%p, %p)\n", line, usinggamma);
 
    if(!line || !usinggamma)
        return InvalidParameter;
 
    *usinggamma = line->gamma;
 
    return Ok;
}

Referenced by test_getgamma().

◆ GdipGetLinePresetBlend()

GpStatus WINGDIPAPI GdipGetLinePresetBlend	(	GpLineGradient *	brush,
		ARGB *	blend,
		REAL *	positions,
		INT	count
	)

Definition at line 2077 of file brush.c.

{
    if (!brush || !blend || !positions || count < 2 || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    if (brush->pblendcount == 0)
        return GenericError;
 
    if (count < brush->pblendcount)
        return InsufficientBuffer;
 
    memcpy(blend, brush->pblendcolor, sizeof(ARGB) * brush->pblendcount);
    memcpy(positions, brush->pblendpos, sizeof(REAL) * brush->pblendcount);
 
    return Ok;
}

Referenced by test_lineblend().

◆ GdipGetLinePresetBlendCount()

GpStatus WINGDIPAPI GdipGetLinePresetBlendCount	(	GpLineGradient *	brush,
		INT *	count
	)

Definition at line 2095 of file brush.c.

{
    if (!brush || !count || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    *count = brush->pblendcount;
 
    return Ok;
}

Referenced by test_lineblend().

◆ GdipGetLineRect()

GpStatus WINGDIPAPI GdipGetLineRect	(	GpLineGradient *	brush,
		GpRectF *	rect
	)

Definition at line 2191 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, rect);
 
    if(!brush || !rect || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    *rect = brush->rect;
 
    return Ok;
}

Referenced by GdipGetLineRectI(), test_gradientgetrect(), and test_transform().

◆ GdipGetLineRectI()

GpStatus WINGDIPAPI GdipGetLineRectI	(	GpLineGradient *	brush,
		GpRect *	rect
	)

Definition at line 2203 of file brush.c.

{
    GpRectF  rectF;
    GpStatus ret;
 
    TRACE("(%p, %p)\n", brush, rect);
 
    if(!rect)
        return InvalidParameter;
 
    ret = GdipGetLineRect(brush, &rectF);
 
    if(ret == Ok){
        rect->X      = gdip_round(rectF.X);
        rect->Y      = gdip_round(rectF.Y);
        rect->Width  = gdip_round(rectF.Width);
        rect->Height = gdip_round(rectF.Height);
    }
 
    return ret;
}

◆ GdipGetLineSpacing()

GpStatus WINGDIPAPI GdipGetLineSpacing	(	GDIPCONST GpFontFamily *	family,
		INT	style,
		UINT16 *	LineSpacing
	)

Definition at line 945 of file font.c.

{
    TRACE("%p, %d, %p\n", family, style, LineSpacing);
 
    if (!(family && LineSpacing))
        return InvalidParameter;
 
    if (style) FIXME("ignoring style\n");
 
    *LineSpacing = family->line_spacing;
    TRACE("%s => %u\n", debugstr_w(family->FamilyName), *LineSpacing);
 
    return Ok;
}

Referenced by gdip_get_font_metrics(), GdipGetFontHeightGivenDPI(), test_fontfamily_properties(), and test_logfont().

◆ GdipGetLineTransform()

GpStatus WINGDIPAPI GdipGetLineTransform	(	GpLineGradient *	brush,
		GpMatrix *	matrix
	)

Definition at line 2129 of file brush.c.

{
    TRACE("(%p,%p)\n", brush, matrix);
 
    if(!brush || !matrix)
        return InvalidParameter;
 
    *matrix = brush->transform;
 
    return Ok;
}

Referenced by test_gradientgetrect(), and test_transform().

◆ GdipGetLineWrapMode()

GpStatus WINGDIPAPI GdipGetLineWrapMode	(	GpLineGradient *	brush,
		GpWrapMode *	wrapmode
	)

Definition at line 1043 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, wrapmode);
 
    if(!brush || !wrapmode || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    *wrapmode = brush->wrap;
 
    return Ok;
}

◆ GdipGetLogFontA()

GpStatus WINGDIPAPI GdipGetLogFontA	(	GpFont *	font,
		GpGraphics *	graphics,
		LOGFONTA *	lfa
	)

Definition at line 432 of file font.c.

{
    GpStatus status;
    LOGFONTW lfw;
 
    TRACE("(%p, %p, %p)\n", font, graphics, lfa);
 
    status = GdipGetLogFontW(font, graphics, &lfw);
    if(status != Ok)
        return status;
 
    memcpy(lfa, &lfw, FIELD_OFFSET(LOGFONTA,lfFaceName) );
 
    if(!WideCharToMultiByte(CP_ACP, 0, lfw.lfFaceName, -1, lfa->lfFaceName, LF_FACESIZE, NULL, NULL))
        return GenericError;
 
    return Ok;
}

Referenced by test_font_substitution(), test_font_transform(), and test_logfont().

◆ GdipGetLogFontW()

GpStatus WINGDIPAPI GdipGetLogFontW	(	GpFont *	font,
		GpGraphics *	graphics,
		LOGFONTW *	lf
	)

Definition at line 455 of file font.c.

{
    REAL angle, rel_height, height;
    GpMatrix matrix;
    GpPointF pt[3];
 
    TRACE("(%p, %p, %p)\n", font, graphics, lf);
 
    if (!font || !graphics || !lf)
        return InvalidParameter;
 
    matrix = graphics->worldtrans;
 
    if (font->unit == UnitPixel || font->unit == UnitWorld)
    {
        height = units_to_pixels(font->emSize, graphics->unit, graphics->yres);
        if (graphics->unit != UnitDisplay)
            GdipScaleMatrix(&matrix, graphics->scale, graphics->scale, MatrixOrderAppend);
    }
    else
    {
        if (graphics->unit == UnitDisplay || graphics->unit == UnitPixel)
            height = units_to_pixels(font->emSize, font->unit, graphics->xres);
        else
            height = units_to_pixels(font->emSize, font->unit, graphics->yres);
    }
 
    pt[0].X = 0.0;
    pt[0].Y = 0.0;
    pt[1].X = 1.0;
    pt[1].Y = 0.0;
    pt[2].X = 0.0;
    pt[2].Y = 1.0;
    GdipTransformMatrixPoints(&matrix, pt, 3);
    angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
    rel_height = sqrt((pt[2].Y - pt[0].Y) * (pt[2].Y - pt[0].Y)+
                      (pt[2].X - pt[0].X) * (pt[2].X - pt[0].X));
 
    lf->lfHeight = -gdip_round(height * rel_height);
    lf->lfWidth = 0;
    lf->lfEscapement = lf->lfOrientation = gdip_round((angle / M_PI) * 1800.0);
    if (lf->lfEscapement < 0)
    {
        lf->lfEscapement += 3600;
        lf->lfOrientation += 3600;
    }
    lf->lfWeight = font->otm.otmTextMetrics.tmWeight;
    lf->lfItalic = font->otm.otmTextMetrics.tmItalic ? 1 : 0;
    lf->lfUnderline = font->otm.otmTextMetrics.tmUnderlined ? 1 : 0;
    lf->lfStrikeOut = font->otm.otmTextMetrics.tmStruckOut ? 1 : 0;
    lf->lfCharSet = font->otm.otmTextMetrics.tmCharSet;
    lf->lfOutPrecision = OUT_DEFAULT_PRECIS;
    lf->lfClipPrecision = CLIP_DEFAULT_PRECIS;
    lf->lfQuality = DEFAULT_QUALITY;
    lf->lfPitchAndFamily = 0;
    strcpyW(lf->lfFaceName, font->family->FamilyName);
 
    TRACE("=> %s,%d\n", debugstr_w(lf->lfFaceName), lf->lfHeight);
 
    return Ok;
}

Referenced by GdipGetLogFontA(), test_font_metrics(), and test_GdipMeasureString().

◆ GdipGetMatrixElements()

GpStatus WINGDIPAPI GdipGetMatrixElements	(	GDIPCONST GpMatrix *	matrix,
		REAL *	out
	)

Definition at line 172 of file matrix.c.

{
    TRACE("(%p, %p)\n", matrix, out);
 
    if(!matrix || !out)
        return InvalidParameter;
 
    memcpy(out, matrix->matrix, sizeof(matrix->matrix));
 
    return Ok;
}

Referenced by get_pen_transform(), test_BeginContainer2(), test_constructor3(), test_gradientgetrect(), test_invert(), test_transform(), and test_worldtransform().

◆ GdipGetMetafileHeaderFromEmf()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromEmf	(	HENHMETAFILE	hemf,
		MetafileHeader *	header
	)

Definition at line 3688 of file metafile.c.

{
    ENHMETAHEADER3 emfheader;
    EmfPlusHeader emfplusheader;
    MetafileType metafile_type;
 
    TRACE("(%p,%p)\n", hemf, header);
 
    if(!hemf || !header)
        return InvalidParameter;
 
    if (GetEnhMetaFileHeader(hemf, sizeof(emfheader), (ENHMETAHEADER*)&emfheader) == 0)
        return GenericError;
 
    emfplusheader.Header.Type = 0;
 
    EnumEnhMetaFile(NULL, hemf, get_emfplus_header_proc, &emfplusheader, NULL);
 
    if (emfplusheader.Header.Type == EmfPlusRecordTypeHeader)
    {
        if ((emfplusheader.Header.Flags & 1) == 1)
            metafile_type = MetafileTypeEmfPlusDual;
        else
            metafile_type = MetafileTypeEmfPlusOnly;
    }
    else
        metafile_type = MetafileTypeEmf;
 
    header->Type = metafile_type;
    header->Size = emfheader.nBytes;
    header->DpiX = (REAL)emfheader.szlDevice.cx * 25.4 / emfheader.szlMillimeters.cx;
    header->DpiY = (REAL)emfheader.szlDevice.cy * 25.4 / emfheader.szlMillimeters.cy;
    header->X = gdip_round((REAL)emfheader.rclFrame.left / 2540.0 * header->DpiX);
    header->Y = gdip_round((REAL)emfheader.rclFrame.top / 2540.0 * header->DpiY);
    header->Width = gdip_round((REAL)(emfheader.rclFrame.right - emfheader.rclFrame.left) / 2540.0 * header->DpiX);
    header->Height = gdip_round((REAL)(emfheader.rclFrame.bottom - emfheader.rclFrame.top) / 2540.0 * header->DpiY);
    header->u.EmfHeader = emfheader;
 
    if (metafile_type == MetafileTypeEmfPlusDual || metafile_type == MetafileTypeEmfPlusOnly)
    {
        header->Version = emfplusheader.Version;
        header->EmfPlusFlags = emfplusheader.EmfPlusFlags;
        header->EmfPlusHeaderSize = emfplusheader.Header.Size;
        header->LogicalDpiX = emfplusheader.LogicalDpiX;
        header->LogicalDpiY = emfplusheader.LogicalDpiY;
    }
    else
    {
        header->Version = emfheader.nVersion;
        header->EmfPlusFlags = 0;
        header->EmfPlusHeaderSize = 0;
        header->LogicalDpiX = 0;
        header->LogicalDpiY = 0;
    }
 
    return Ok;
}

Referenced by GdipCreateMetafileFromEmf(), GdipGetMetafileHeaderFromMetafile(), METAFILE_GraphicsDeleted(), test_emfonly(), and test_empty().

◆ GdipGetMetafileHeaderFromFile()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromFile	(	GDIPCONST WCHAR *	filename,
		MetafileHeader *	header
	)

Definition at line 3764 of file metafile.c.

{
    GpStatus status;
    GpMetafile *metafile;
 
    TRACE("(%s,%p)\n", debugstr_w(filename), header);
 
    if (!filename || !header)
        return InvalidParameter;
 
    status = GdipCreateMetafileFromFile(filename, &metafile);
    if (status == Ok)
    {
        status = GdipGetMetafileHeaderFromMetafile(metafile, header);
        GdipDisposeImage(&metafile->image);
    }
    return status;
}

◆ GdipGetMetafileHeaderFromMetafile()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile	(	GpMetafile *	metafile,
		MetafileHeader *	header
	)

Definition at line 3632 of file metafile.c.

{
    GpStatus status;
 
    TRACE("(%p, %p)\n", metafile, header);
 
    if(!metafile || !header)
        return InvalidParameter;
 
    if (metafile->hemf)
    {
        status = GdipGetMetafileHeaderFromEmf(metafile->hemf, header);
        if (status != Ok) return status;
    }
    else
    {
        memset(header, 0, sizeof(*header));
        header->Version = VERSION_MAGIC2;
    }
 
    header->Type = metafile->metafile_type;
    header->DpiX = metafile->image.xres;
    header->DpiY = metafile->image.yres;
    header->Width = gdip_round(metafile->bounds.Width);
    header->Height = gdip_round(metafile->bounds.Height);
 
    return Ok;
}

Referenced by GdipGetMetafileHeaderFromFile(), GdipGetMetafileHeaderFromStream(), GdipGetMetafileHeaderFromWmf(), test_createfromwmf(), test_emfonly(), test_empty(), test_gditransform(), and test_loadwmf().

◆ GdipGetMetafileHeaderFromStream()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromStream	(	IStream *	stream,
		MetafileHeader *	header
	)

Definition at line 3784 of file metafile.c.

{
    GpStatus status;
    GpMetafile *metafile;
 
    TRACE("(%p,%p)\n", stream, header);
 
    if (!stream || !header)
        return InvalidParameter;
 
    status = GdipCreateMetafileFromStream(stream, &metafile);
    if (status == Ok)
    {
        status = GdipGetMetafileHeaderFromMetafile(metafile, header);
        GdipDisposeImage(&metafile->image);
    }
    return status;
}

◆ GdipGetMetafileHeaderFromWmf()

GpStatus WINGDIPAPI GdipGetMetafileHeaderFromWmf	(	HMETAFILE	hwmf,
		GDIPCONST WmfPlaceableFileHeader *	placeable,
		MetafileHeader *	header
	)

Definition at line 3747 of file metafile.c.

{
    GpStatus status;
    GpMetafile *metafile;
 
    TRACE("(%p,%p,%p)\n", hwmf, placeable, header);
 
    status = GdipCreateMetafileFromWmf(hwmf, FALSE, placeable, &metafile);
    if (status == Ok)
    {
        status = GdipGetMetafileHeaderFromMetafile(metafile, header);
        GdipDisposeImage(&metafile->image);
    }
    return status;
}

◆ GdipGetNearestColor()

GpStatus WINGDIPAPI GdipGetNearestColor	(	GpGraphics *	graphics,
		ARGB *	argb
	)

Definition at line 4899 of file graphics.c.

{
    FIXME("(%p, %p): Passing color unmodified\n", graphics, argb);
 
    if(!graphics || !argb)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    return Ok;
}

Referenced by test_GdipGetNearestColor(), and test_Get_Release_DC().

◆ GdipGetPageScale()

GpStatus WINGDIPAPI GdipGetPageScale	(	GpGraphics *	graphics,
		REAL *	scale
	)

Definition at line 4912 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, scale);
 
    if(!graphics || !scale)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *scale = graphics->scale;
 
    return Ok;
}

Referenced by test_BeginContainer2(), test_Get_Release_DC(), and test_pagetransform().

◆ GdipGetPageUnit()

GpStatus WINGDIPAPI GdipGetPageUnit	(	GpGraphics *	graphics,
		GpUnit *	unit
	)

Definition at line 4927 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, unit);
 
    if(!graphics || !unit)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *unit = graphics->unit;
 
    return Ok;
}

Referenced by test_BeginContainer2(), test_clipping(), test_clipping_2(), test_Get_Release_DC(), and test_pagetransform().

◆ GdipGetPathData()

GpStatus WINGDIPAPI GdipGetPathData	(	GpPath *	path,
		GpPathData *	pathData
	)

Definition at line 1379 of file graphicspath.c.

{
    TRACE("(%p, %p)\n", path, pathData);
 
    if(!path || !pathData)
        return InvalidParameter;
 
    /* Only copy data. pathData allocation/freeing controlled by wrapper class.
       Assumed that pathData is enough wide to get all data - controlled by wrapper too. */
    memcpy(pathData->Points, path->pathdata.Points, sizeof(PointF) * pathData->Count);
    memcpy(pathData->Types , path->pathdata.Types , pathData->Count);
 
    return Ok;
}

Referenced by test_getpathdata().

◆ GdipGetPathFillMode()

GpStatus WINGDIPAPI GdipGetPathFillMode	(	GpPath *	path,
		GpFillMode *	fillmode
	)

Definition at line 1394 of file graphicspath.c.

{
    TRACE("(%p, %p)\n", path, fillmode);
 
    if(!path || !fillmode)
        return InvalidParameter;
 
    *fillmode = path->fill;
 
    return Ok;
}

◆ GdipGetPathGradientBlend()

GpStatus WINGDIPAPI GdipGetPathGradientBlend	(	GpPathGradient *	brush,
		REAL *	blend,
		REAL *	positions,
		INT	count
	)

Definition at line 1055 of file brush.c.

{
    TRACE("(%p, %p, %p, %d)\n", brush, blend, positions, count);
 
    if(!brush || !blend || !positions || count <= 0 || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    if(count < brush->blendcount)
        return InsufficientBuffer;
 
    memcpy(blend, brush->blendfac, count*sizeof(REAL));
    if(brush->blendcount > 1){
        memcpy(positions, brush->blendpos, count*sizeof(REAL));
    }
 
    return Ok;
}

Referenced by test_getblend(), and test_pathgradientblend().

◆ GdipGetPathGradientBlendCount()

GpStatus WINGDIPAPI GdipGetPathGradientBlendCount	(	GpPathGradient *	brush,
		INT *	count
	)

Definition at line 1074 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, count);
 
    if(!brush || !count || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *count = brush->blendcount;
 
    return Ok;
}

Referenced by test_gradientblendcount(), and test_pathgradientblend().

◆ GdipGetPathGradientCenterColor()

GpStatus WINGDIPAPI GdipGetPathGradientCenterColor	(	GpPathGradient *	grad,
		ARGB *	colors
	)

Definition at line 1121 of file brush.c.

{
    TRACE("(%p,%p)\n", grad, colors);
 
    if (!grad || !colors || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *colors = grad->centercolor;
 
    return Ok;
}

◆ GdipGetPathGradientCenterPoint()

GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint	(	GpPathGradient *	grad,
		GpPointF *	point
	)

Definition at line 1086 of file brush.c.

{
    TRACE("(%p, %p)\n", grad, point);
 
    if(!grad || !point || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    point->X = grad->center.X;
    point->Y = grad->center.Y;
 
    return Ok;
}

Referenced by GdipGetPathGradientCenterPointI(), and test_pathgradientcenterpoint().

◆ GdipGetPathGradientCenterPointI()

GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI	(	GpPathGradient *	grad,
		GpPoint *	point
	)

Definition at line 1100 of file brush.c.

{
    GpStatus ret;
    GpPointF ptf;
 
    TRACE("(%p, %p)\n", grad, point);
 
    if(!point)
        return InvalidParameter;
 
    ret = GdipGetPathGradientCenterPoint(grad,&ptf);
 
    if(ret == Ok){
        point->X = gdip_round(ptf.X);
        point->Y = gdip_round(ptf.Y);
    }
 
    return ret;
}

◆ GdipGetPathGradientFocusScales()

GpStatus WINGDIPAPI GdipGetPathGradientFocusScales	(	GpPathGradient *	grad,
		REAL *	x,
		REAL *	y
	)

Definition at line 1134 of file brush.c.

{
    TRACE("(%p, %p, %p)\n", grad, x, y);
 
    if(!grad || !x || !y || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *x = grad->focus.X;
    *y = grad->focus.Y;
 
    return Ok;
}

◆ GdipGetPathGradientGammaCorrection()

GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection	(	GpPathGradient *	grad,
		BOOL *	gamma
	)

Definition at line 1148 of file brush.c.

{
    TRACE("(%p, %p)\n", grad, gamma);
 
    if(!grad || !gamma || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *gamma = grad->gamma;
 
    return Ok;
}

◆ GdipGetPathGradientPath()

GpStatus WINGDIPAPI GdipGetPathGradientPath	(	GpPathGradient *	grad,
		GpPath *	path
	)

Definition at line 1161 of file brush.c.

{
    static int calls;
 
    TRACE("(%p, %p)\n", grad, path);
 
    if (!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

Referenced by test_pathgradientpath().

◆ GdipGetPathGradientPointCount()

GpStatus WINGDIPAPI GdipGetPathGradientPointCount	(	GpPathGradient *	grad,
		INT *	count
	)

Definition at line 1173 of file brush.c.

{
    TRACE("(%p, %p)\n", grad, count);
 
    if(!grad || !count || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *count = grad->path->pathdata.Count;
 
    return Ok;
}

◆ GdipGetPathGradientPresetBlend()

GpStatus WINGDIPAPI GdipGetPathGradientPresetBlend	(	GpPathGradient *	brush,
		ARGB *	blend,
		REAL *	pos,
		INT	count
	)

Definition at line 1616 of file brush.c.

{
    TRACE("(%p,%p,%p,%i)\n", brush, blend, pos, count);
 
    if (count < 0)
        return OutOfMemory;
 
    if (!brush || !blend || !pos || count < 2 || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    if (brush->pblendcount == 0)
        return GenericError;
 
    if (count != brush->pblendcount)
    {
        /* Native lines up the ends of each array, and copies the destination size. */
        FIXME("Braindead behavior on wrong-sized buffer not implemented.\n");
        return InvalidParameter;
    }
 
    memcpy(blend, brush->pblendcolor, sizeof(ARGB) * brush->pblendcount);
    memcpy(pos, brush->pblendpos, sizeof(REAL) * brush->pblendcount);
 
    return Ok;
}

Referenced by test_pathgradientpresetblend().

◆ GdipGetPathGradientPresetBlendCount()

GpStatus WINGDIPAPI GdipGetPathGradientPresetBlendCount	(	GpPathGradient *	brush,
		INT *	count
	)

Definition at line 1643 of file brush.c.

{
    TRACE("(%p,%p)\n", brush, count);
 
    if (!brush || !count || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *count = brush->pblendcount;
 
    return Ok;
}

Referenced by test_pathgradientpresetblend().

◆ GdipGetPathGradientRect()

GpStatus WINGDIPAPI GdipGetPathGradientRect	(	GpPathGradient *	brush,
		GpRectF *	rect
	)

Definition at line 1186 of file brush.c.

{
    GpStatus stat;
 
    TRACE("(%p, %p)\n", brush, rect);
 
    if(!brush || !rect || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    stat = GdipGetPathWorldBounds(brush->path, rect, NULL, NULL);
 
    return stat;
}

Referenced by GdipGetPathGradientRectI(), and test_getbounds().

◆ GdipGetPathGradientRectI()

GpStatus WINGDIPAPI GdipGetPathGradientRectI	(	GpPathGradient *	brush,
		GpRect *	rect
	)

Definition at line 1200 of file brush.c.

{
    GpRectF rectf;
    GpStatus stat;
 
    TRACE("(%p, %p)\n", brush, rect);
 
    if(!brush || !rect)
        return InvalidParameter;
 
    stat = GdipGetPathGradientRect(brush, &rectf);
    if(stat != Ok)  return stat;
 
    rect->X = gdip_round(rectf.X);
    rect->Y = gdip_round(rectf.Y);
    rect->Width  = gdip_round(rectf.Width);
    rect->Height = gdip_round(rectf.Height);
 
    return Ok;
}

◆ GdipGetPathGradientSurroundColorCount()

GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorCount	(	GpPathGradient *	brush,
		INT *	count
	)

Definition at line 1244 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, count);
 
    if (!brush || !count || brush->brush.bt != BrushTypePathGradient)
       return InvalidParameter;
 
    /* Yes, this actually returns the number of points in the path (which is the
     * required size of a buffer to get the surround colors), rather than the
     * number of surround colors. The real count is returned when getting the
     * colors. */
    *count = brush->path->pathdata.Count;
 
    return Ok;
}

Referenced by test_gradientsurroundcolorcount().

◆ GdipGetPathGradientSurroundColorsWithCount()

GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount	(	GpPathGradient *	grad,
		ARGB *	argb,
		INT *	count
	)

Definition at line 1221 of file brush.c.

{
    INT i;
 
    TRACE("(%p,%p,%p)\n", grad, argb, count);
 
    if(!grad || !argb || !count || (*count < grad->path->pathdata.Count) || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    for (i=0; i<grad->path->pathdata.Count; i++)
    {
        if (i < grad->surroundcolorcount)
            argb[i] = grad->surroundcolors[i];
        else
            argb[i] = grad->surroundcolors[grad->surroundcolorcount-1];
    }
 
    *count = grad->surroundcolorcount;
 
    return Ok;
}

Referenced by test_gradientsurroundcolorcount().

◆ GdipGetPathGradientTransform()

GpStatus WINGDIPAPI GdipGetPathGradientTransform	(	GpPathGradient *	grad,
		GpMatrix *	matrix
	)

Definition at line 1858 of file brush.c.

{
    TRACE("(%p,%p)\n", grad, matrix);
 
    if (!grad || !matrix || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *matrix = grad->transform;
 
    return Ok;
}

◆ GdipGetPathGradientWrapMode()

GpStatus WINGDIPAPI GdipGetPathGradientWrapMode	(	GpPathGradient *	brush,
		GpWrapMode *	wrapmode
	)

Definition at line 1260 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, wrapmode);
 
    if(!brush || !wrapmode || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    *wrapmode = brush->wrap;
 
    return Ok;
}

◆ GdipGetPathLastPoint()

GpStatus WINGDIPAPI GdipGetPathLastPoint	(	GpPath *	path,
		GpPointF *	lastPoint
	)

Definition at line 1406 of file graphicspath.c.

{
    INT count;
 
    TRACE("(%p, %p)\n", path, lastPoint);
 
    if(!path || !lastPoint)
        return InvalidParameter;
 
    count = path->pathdata.Count;
    if(count > 0)
        *lastPoint = path->pathdata.Points[count-1];
 
    return Ok;
}

Referenced by test_lastpoint().

◆ GdipGetPathPoints()

GpStatus WINGDIPAPI GdipGetPathPoints	(	GpPath *	path,
		GpPointF *	points,
		INT	count
	)

Definition at line 1422 of file graphicspath.c.

{
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(!path)
        return InvalidParameter;
 
    if(count < path->pathdata.Count)
        return InsufficientBuffer;
 
    memcpy(points, path->pathdata.Points, path->pathdata.Count * sizeof(GpPointF));
 
    return Ok;
}

Referenced by GdipGetPathPointsI(), and ok_path().

◆ GdipGetPathPointsI()

GpStatus WINGDIPAPI GdipGetPathPointsI	(	GpPath *	path,
		GpPoint *	points,
		INT	count
	)

Definition at line 1437 of file graphicspath.c.

{
    GpStatus ret;
    GpPointF *ptf;
    INT i;
 
    TRACE("(%p, %p, %d)\n", path, points, count);
 
    if(count <= 0)
        return InvalidParameter;
 
    ptf = heap_alloc_zero(sizeof(GpPointF)*count);
    if(!ptf)    return OutOfMemory;
 
    ret = GdipGetPathPoints(path,ptf,count);
    if(ret == Ok)
        for(i = 0;i < count;i++){
            points[i].X = gdip_round(ptf[i].X);
            points[i].Y = gdip_round(ptf[i].Y);
        };
    heap_free(ptf);
 
    return ret;
}

◆ GdipGetPathTypes()

GpStatus WINGDIPAPI GdipGetPathTypes	(	GpPath *	path,
		BYTE *	types,
		INT	count
	)

Definition at line 1462 of file graphicspath.c.

{
    TRACE("(%p, %p, %d)\n", path, types, count);
 
    if(!path)
        return InvalidParameter;
 
    if(count < path->pathdata.Count)
        return InsufficientBuffer;
 
    memcpy(types, path->pathdata.Types, path->pathdata.Count);
 
    return Ok;
}

Referenced by ok_path().

◆ GdipGetPathWorldBounds()

GpStatus WINGDIPAPI GdipGetPathWorldBounds	(	GpPath *	path,
		GpRectF *	bounds,
		GDIPCONST GpMatrix *	matrix,
		GDIPCONST GpPen *	pen
	)

Definition at line 1481 of file graphicspath.c.

{
    GpPointF * points, temp_pts[4];
    INT count, i;
    REAL path_width = 1.0, width, height, temp, low_x, low_y, high_x, high_y;
 
    TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
 
    /* Matrix and pen can be null. */
    if(!path || !bounds)
        return InvalidParameter;
 
    /* If path is empty just return. */
    count = path->pathdata.Count;
    if(count == 0){
        bounds->X = bounds->Y = bounds->Width = bounds->Height = 0.0;
        return Ok;
    }
 
    points = path->pathdata.Points;
 
    low_x = high_x = points[0].X;
    low_y = high_y = points[0].Y;
 
    for(i = 1; i < count; i++){
        low_x = min(low_x, points[i].X);
        low_y = min(low_y, points[i].Y);
        high_x = max(high_x, points[i].X);
        high_y = max(high_y, points[i].Y);
    }
 
    width = high_x - low_x;
    height = high_y - low_y;
 
    /* This looks unusual but it's the only way I can imitate windows. */
    if(matrix){
        temp_pts[0].X = low_x;
        temp_pts[0].Y = low_y;
        temp_pts[1].X = low_x;
        temp_pts[1].Y = high_y;
        temp_pts[2].X = high_x;
        temp_pts[2].Y = high_y;
        temp_pts[3].X = high_x;
        temp_pts[3].Y = low_y;
 
        GdipTransformMatrixPoints((GpMatrix*)matrix, temp_pts, 4);
        low_x = temp_pts[0].X;
        low_y = temp_pts[0].Y;
 
        for(i = 1; i < 4; i++){
            low_x = min(low_x, temp_pts[i].X);
            low_y = min(low_y, temp_pts[i].Y);
        }
 
        temp = width;
        width = height * fabs(matrix->matrix[2]) + width * fabs(matrix->matrix[0]);
        height = height * fabs(matrix->matrix[3]) + temp * fabs(matrix->matrix[1]);
    }
 
    if(pen){
        path_width = pen->width / 2.0;
 
        if(count > 2)
            path_width = max(path_width,  pen->width * pen->miterlimit / 2.0);
        /* FIXME: this should probably also check for the startcap */
        if(pen->endcap & LineCapNoAnchor)
            path_width = max(path_width,  pen->width * 2.2);
 
        low_x -= path_width;
        low_y -= path_width;
        width += 2.0 * path_width;
        height += 2.0 * path_width;
    }
 
    bounds->X = low_x;
    bounds->Y = low_y;
    bounds->Width = width;
    bounds->Height = height;
 
    return Ok;
}

Referenced by create_path_gradient(), GdipGetPathGradientRect(), GdipGetPathWorldBoundsI(), and test_worldbounds().

◆ GdipGetPathWorldBoundsI()

GpStatus WINGDIPAPI GdipGetPathWorldBoundsI	(	GpPath *	path,
		GpRect *	bounds,
		GDIPCONST GpMatrix *	matrix,
		GDIPCONST GpPen *	pen
	)

Definition at line 1564 of file graphicspath.c.

{
    GpStatus ret;
    GpRectF boundsF;
 
    TRACE("(%p, %p, %p, %p)\n", path, bounds, matrix, pen);
 
    ret = GdipGetPathWorldBounds(path,&boundsF,matrix,pen);
 
    if(ret == Ok){
        bounds->X      = gdip_round(boundsF.X);
        bounds->Y      = gdip_round(boundsF.Y);
        bounds->Width  = gdip_round(boundsF.Width);
        bounds->Height = gdip_round(boundsF.Height);
    }
 
    return ret;
}

◆ GdipGetPenBrushFill()

GpStatus WINGDIPAPI GdipGetPenBrushFill	(	GpPen *	pen,
		GpBrush **	brush
	)

Definition at line 207 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, brush);
 
    if(!pen || !brush)
        return InvalidParameter;
 
    return GdipCloneBrush(pen->brush, brush);
}

Referenced by test_brushfill().

◆ GdipGetPenColor()

GpStatus WINGDIPAPI GdipGetPenColor	(	GpPen *	pen,
		ARGB *	argb
	)

Definition at line 217 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, argb);
 
    if(!pen || !argb)
        return InvalidParameter;
 
    if(pen->brush->bt != BrushTypeSolidColor)
        return NotImplemented;
 
    return GdipGetSolidFillColor(((GpSolidFill*)pen->brush), argb);
}

Referenced by test_brushfill().

◆ GdipGetPenCompoundCount()

GpStatus WINGDIPAPI GdipGetPenCompoundCount	(	GpPen *	pen,
		INT *	count
	)

Definition at line 526 of file pen.c.

{
    FIXME("(%p, %p): stub\n", pen, count);
 
    if (!pen || !count)
        return InvalidParameter;
 
    return NotImplemented;
}

Referenced by test_compoundarray().

◆ GdipGetPenCustomEndCap()

GpStatus WINGDIPAPI GdipGetPenCustomEndCap	(	GpPen *	pen,
		GpCustomLineCap **	customCap
	)

Definition at line 230 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, customCap);
 
    if(!pen || !customCap)
        return InvalidParameter;
 
    if(!pen->customend){
        *customCap = NULL;
        return Ok;
    }
 
    return GdipCloneCustomLineCap(pen->customend, customCap);
}

Referenced by test_customcap().

◆ GdipGetPenCustomStartCap()

GpStatus WINGDIPAPI GdipGetPenCustomStartCap	(	GpPen *	pen,
		GpCustomLineCap **	customCap
	)

Definition at line 245 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, customCap);
 
    if(!pen || !customCap)
        return InvalidParameter;
 
    if(!pen->customstart){
        *customCap = NULL;
        return Ok;
    }
 
    return GdipCloneCustomLineCap(pen->customstart, customCap);
}

Referenced by test_customcap().

◆ GdipGetPenDashArray()

GpStatus WINGDIPAPI GdipGetPenDashArray	(	GpPen *	pen,
		REAL *	dash,
		INT	count
	)

Definition at line 260 of file pen.c.

{
    TRACE("(%p, %p, %d)\n", pen, dash, count);
 
    if(!pen || !dash || count > pen->numdashes)
        return InvalidParameter;
 
    /* note: if you pass a negative value for count, it crashes native gdiplus. */
    if(count < 0)
        return GenericError;
 
    memcpy(dash, pen->dashes, count * sizeof(REAL));
 
    return Ok;
}

Referenced by test_dasharray().

◆ GdipGetPenDashCap197819()

GpStatus WINGDIPAPI GdipGetPenDashCap197819	(	GpPen *	pen,
		GpDashCap *	dashCap
	)

Definition at line 276 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, dashCap);
 
    if(!pen || !dashCap)
        return InvalidParameter;
 
    *dashCap = pen->dashcap;
 
    return Ok;
}

◆ GdipGetPenDashCount()

GpStatus WINGDIPAPI GdipGetPenDashCount	(	GpPen *	pen,
		INT *	count
	)

Definition at line 288 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, count);
 
    if(!pen || !count)
        return InvalidParameter;
 
    *count = pen->numdashes;
 
    return Ok;
}

◆ GdipGetPenDashOffset()

GpStatus WINGDIPAPI GdipGetPenDashOffset	(	GpPen *	pen,
		REAL *	offset
	)

Definition at line 300 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, offset);
 
    if(!pen || !offset)
        return InvalidParameter;
 
    *offset = pen->offset;
 
    return Ok;
}

◆ GdipGetPenDashStyle()

GpStatus WINGDIPAPI GdipGetPenDashStyle	(	GpPen *	pen,
		GpDashStyle *	dash
	)

Definition at line 312 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, dash);
 
    if(!pen || !dash)
        return InvalidParameter;
 
    *dash = pen->dash;
 
    return Ok;
}

Referenced by test_dasharray().

◆ GdipGetPenEndCap()

GpStatus WINGDIPAPI GdipGetPenEndCap	(	GpPen *	pen,
		GpLineCap *	endCap
	)

Definition at line 324 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, endCap);
 
    if(!pen || !endCap)
        return InvalidParameter;
 
    *endCap = pen->endcap;
 
    return Ok;
}

◆ GdipGetPenFillType()

GpStatus WINGDIPAPI GdipGetPenFillType	(	GpPen *	pen,
		GpPenType *	type
	)

Definition at line 336 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, type);
 
    if(!pen || !type)
        return InvalidParameter;
 
    *type = bt_to_pt(pen->brush->bt);
 
    return Ok;
}

Referenced by test_penfilltype().

◆ GdipGetPenLineJoin()

GpStatus WINGDIPAPI GdipGetPenLineJoin	(	GpPen *	pen,
		GpLineJoin *	lineJoin
	)

Definition at line 348 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, lineJoin);
 
    if(!pen || !lineJoin)
        return InvalidParameter;
 
    *lineJoin = pen->join;
 
    return Ok;
}

◆ GdipGetPenMiterLimit()

GpStatus WINGDIPAPI GdipGetPenMiterLimit	(	GpPen *	pen,
		REAL *	miterLimit
	)

Definition at line 372 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, miterLimit);
 
    if(!pen || !miterLimit)
        return InvalidParameter;
 
    *miterLimit = pen->miterlimit;
 
    return Ok;
}

◆ GdipGetPenMode()

GpStatus WINGDIPAPI GdipGetPenMode	(	GpPen *	pen,
		GpPenAlignment *	mode
	)

Definition at line 360 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, mode);
 
    if(!pen || !mode)
        return InvalidParameter;
 
    *mode = pen->align;
 
    return Ok;
}

◆ GdipGetPenStartCap()

GpStatus WINGDIPAPI GdipGetPenStartCap	(	GpPen *	pen,
		GpLineCap *	startCap
	)

Definition at line 384 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, startCap);
 
    if(!pen || !startCap)
        return InvalidParameter;
 
    *startCap = pen->startcap;
 
    return Ok;
}

◆ GdipGetPenTransform()

GpStatus WINGDIPAPI GdipGetPenTransform	(	GpPen *	pen,
		GpMatrix *	matrix
	)

Definition at line 449 of file pen.c.

{
    TRACE("(%p,%p)\n", pen, matrix);
 
    if(!pen || !matrix)
        return InvalidParameter;
 
    *matrix = pen->transform;
 
    return Ok;
}

Referenced by get_pen_transform(), and test_transform().

◆ GdipGetPenUnit()

GpStatus WINGDIPAPI GdipGetPenUnit	(	GpPen *	pen,
		GpUnit *	unit
	)

Definition at line 396 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, unit);
 
    if(!pen || !unit)
        return InvalidParameter;
 
    *unit = pen->unit;
 
    return Ok;
}

◆ GdipGetPenWidth()

GpStatus WINGDIPAPI GdipGetPenWidth	(	GpPen *	pen,
		REAL *	width
	)

Definition at line 408 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, width);
 
    if(!pen || !width)
        return InvalidParameter;
 
    *width = pen->width;
 
    return Ok;
}

◆ GdipGetPixelOffsetMode()

GpStatus WINGDIPAPI GdipGetPixelOffsetMode	(	GpGraphics *	graphics,
		PixelOffsetMode *	mode
	)

Definition at line 4943 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, mode);
 
    if(!graphics || !mode)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *mode = graphics->pixeloffset;
 
    return Ok;
}

Referenced by test_BeginContainer2(), and test_Get_Release_DC().

◆ GdipGetPointCount()

GpStatus WINGDIPAPI GdipGetPointCount	(	GpPath *	path,
		INT *	count
	)

Definition at line 1584 of file graphicspath.c.

{
    TRACE("(%p, %p)\n", path, count);
 
    if(!path)
        return InvalidParameter;
 
    *count = path->pathdata.Count;
 
    return Ok;
}

Referenced by ok_path(), test_empty_rect(), test_getpathdata(), test_nextmarkerpath(), test_nextsubpathpath(), and test_widen().

◆ GdipGetPropertyCount()

GpStatus WINGDIPAPI GdipGetPropertyCount	(	GpImage *	image,
		UINT *	num
	)

Definition at line 2412 of file image.c.

{
    TRACE("(%p, %p)\n", image, num);
 
    if (!image || !num) return InvalidParameter;
 
    *num = 0;
 
    if (image->type == ImageTypeBitmap)
    {
        if (((GpBitmap *)image)->prop_item)
        {
            *num = ((GpBitmap *)image)->prop_count;
            return Ok;
        }
 
        if (((GpBitmap *)image)->metadata_reader)
            IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
    }
 
    return Ok;
}

Referenced by test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), and test_tiff_properties().

◆ GdipGetPropertyIdList()

GpStatus WINGDIPAPI GdipGetPropertyIdList	(	GpImage *	image,
		UINT	num,
		PROPID *	list
	)

Definition at line 2435 of file image.c.

{
    HRESULT hr;
    IWICMetadataReader *reader;
    IWICEnumMetadataItem *enumerator;
    UINT prop_count, i, items_returned;
 
    TRACE("(%p, %u, %p)\n", image, num, list);
 
    if (!image || !list) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    if (((GpBitmap *)image)->prop_item)
    {
        if (num != ((GpBitmap *)image)->prop_count) return InvalidParameter;
 
        for (i = 0; i < num; i++)
        {
            list[i] = ((GpBitmap *)image)->prop_item[i].id;
        }
 
        return Ok;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader)
    {
        if (num != 0) return InvalidParameter;
        return Ok;
    }
 
    hr = IWICMetadataReader_GetCount(reader, &prop_count);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    if (num != prop_count) return InvalidParameter;
 
    hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    IWICEnumMetadataItem_Reset(enumerator);
 
    for (i = 0; i < num; i++)
    {
        PROPVARIANT id;
 
        hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
        if (hr != S_OK) break;
 
        if (id.vt != VT_UI2)
        {
            FIXME("not supported propvariant type for id: %u\n", id.vt);
            list[i] = 0;
            continue;
        }
        list[i] = id.u.uiVal;
    }
 
    IWICEnumMetadataItem_Release(enumerator);
 
    return hr == S_OK ? Ok : hresult_to_status(hr);
}

Referenced by test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), and test_tiff_properties().

◆ GdipGetPropertyItem()

GpStatus WINGDIPAPI GdipGetPropertyItem	(	GpImage *	image,
		PROPID	propid,
		UINT	size,
		PropertyItem *	buffer
	)

Definition at line 2682 of file image.c.

{
    GpStatus stat;
    HRESULT hr;
    IWICMetadataReader *reader;
    PROPVARIANT id, value;
 
    TRACE("(%p,%#x,%u,%p)\n", image, propid, size, buffer);
 
    if (!image || !buffer) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    if (((GpBitmap *)image)->prop_item)
    {
        UINT i;
 
        for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
        {
            if (propid == ((GpBitmap *)image)->prop_item[i].id)
            {
                if (size != sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length)
                    return InvalidParameter;
 
                *buffer = ((GpBitmap *)image)->prop_item[i];
                buffer->value = buffer + 1;
                memcpy(buffer->value, ((GpBitmap *)image)->prop_item[i].value, buffer->length);
                return Ok;
            }
        }
 
        return PropertyNotFound;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader) return PropertyNotFound;
 
    id.vt = VT_UI2;
    id.u.uiVal = propid;
    hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
    if (FAILED(hr)) return PropertyNotFound;
 
    stat = propvariant_to_item(&value, buffer, size, propid);
    PropVariantClear(&value);
 
    return stat;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), and test_tiff_properties().

◆ GdipGetPropertyItemSize()

GpStatus WINGDIPAPI GdipGetPropertyItemSize	(	GpImage *	image,
		PROPID	propid,
		UINT *	size
	)

Definition at line 2536 of file image.c.

{
    HRESULT hr;
    IWICMetadataReader *reader;
    PROPVARIANT id, value;
 
    TRACE("(%p,%#x,%p)\n", image, propid, size);
 
    if (!size || !image) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    if (((GpBitmap *)image)->prop_item)
    {
        UINT i;
 
        for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
        {
            if (propid == ((GpBitmap *)image)->prop_item[i].id)
            {
                *size = sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
                return Ok;
            }
        }
 
        return PropertyNotFound;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader) return PropertyNotFound;
 
    id.vt = VT_UI2;
    id.u.uiVal = propid;
    hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
    if (FAILED(hr)) return PropertyNotFound;
 
    *size = propvariant_size(&value);
    if (*size) *size += sizeof(PropertyItem);
    PropVariantClear(&value);
 
    return Ok;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_gif_properties(), test_image_properties(), and test_tiff_properties().

◆ GdipGetPropertySize()

GpStatus WINGDIPAPI GdipGetPropertySize	(	GpImage *	image,
		UINT *	size,
		UINT *	count
	)

Definition at line 2735 of file image.c.

{
    HRESULT hr;
    IWICMetadataReader *reader;
    IWICEnumMetadataItem *enumerator;
    UINT prop_count, prop_size, i;
    PROPVARIANT id, value;
 
    TRACE("(%p,%p,%p)\n", image, size, count);
 
    if (!image || !size || !count) return InvalidParameter;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %d\n", image->type);
        return NotImplemented;
    }
 
    if (((GpBitmap *)image)->prop_item)
    {
        *count = ((GpBitmap *)image)->prop_count;
        *size = 0;
 
        for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
        {
            *size += sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
        }
 
        return Ok;
    }
 
    reader = ((GpBitmap *)image)->metadata_reader;
    if (!reader) return PropertyNotFound;
 
    hr = IWICMetadataReader_GetCount(reader, &prop_count);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    IWICEnumMetadataItem_Reset(enumerator);
 
    prop_size = 0;
 
    PropVariantInit(&id);
    PropVariantInit(&value);
 
    for (i = 0; i < prop_count; i++)
    {
        UINT items_returned, item_size;
 
        hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
        if (hr != S_OK) break;
 
        item_size = propvariant_size(&value);
        if (item_size) prop_size += sizeof(PropertyItem) + item_size;
 
        PropVariantClear(&id);
        PropVariantClear(&value);
    }
 
    IWICEnumMetadataItem_Release(enumerator);
 
    if (hr != S_OK) return PropertyNotFound;
 
    *count = prop_count;
    *size = prop_size;
    return Ok;
}

Referenced by add_property(), GdipGetAllPropertyItems(), test_GdipGetAllPropertyItems(), and test_gif_properties().

◆ GdipGetRegionBounds()

GpStatus WINGDIPAPI GdipGetRegionBounds	(	GpRegion *	region,
		GpGraphics *	graphics,
		GpRectF *	rect
	)

Definition at line 587 of file region.c.

{
    HRGN hrgn;
    RECT r;
    GpStatus status;
 
    TRACE("(%p, %p, %p)\n", region, graphics, rect);
 
    if(!region || !graphics || !rect)
        return InvalidParameter;
 
    /* Contrary to MSDN, native ignores the graphics transform. */
    status = GdipGetRegionHRgn(region, NULL, &hrgn);
    if(status != Ok)
        return status;
 
    /* infinite */
    if(!hrgn){
        rect->X = rect->Y = -(REAL)(1 << 22);
        rect->Width = rect->Height = (REAL)(1 << 23);
        TRACE("%p => infinite\n", region);
        return Ok;
    }
 
    if(GetRgnBox(hrgn, &r)){
        rect->X = r.left;
        rect->Y = r.top;
        rect->Width  = r.right  - r.left;
        rect->Height = r.bottom - r.top;
        TRACE("%p => %s\n", region, debugstr_rectf(rect));
    }
    else
        status = GenericError;
 
    DeleteObject(hrgn);
 
    return status;
}

Referenced by GdipGetClipBounds(), GdipGetRegionBoundsI(), GdipGetVisibleClipBounds(), GdipIsEmptyRegion(), test_clipping(), test_font_height_scaling(), test_getbounds(), and test_measure_string().

◆ GdipGetRegionBoundsI()

GpStatus WINGDIPAPI GdipGetRegionBoundsI	(	GpRegion *	region,
		GpGraphics *	graphics,
		GpRect *	rect
	)

Definition at line 629 of file region.c.

{
    GpRectF rectf;
    GpStatus status;
 
    TRACE("(%p, %p, %p)\n", region, graphics, rect);
 
    if(!rect)
        return InvalidParameter;
 
    status = GdipGetRegionBounds(region, graphics, &rectf);
    if(status == Ok){
        rect->X = gdip_round(rectf.X);
        rect->Y = gdip_round(rectf.Y);
        rect->Width  = gdip_round(rectf.Width);
        rect->Height = gdip_round(rectf.Height);
    }
 
    return status;
}

Referenced by GdipGetClipBoundsI().

◆ GdipGetRegionData()

GpStatus WINGDIPAPI GdipGetRegionData	(	GpRegion *	region,
		BYTE *	buffer,
		UINT	size,
		UINT *	needed
	)

Definition at line 747 of file region.c.

{
    struct region_data_header *region_data_header;
    UINT required;
 
    TRACE("%p, %p, %d, %p\n", region, buffer, size, needed);
 
    if (!region || !buffer || !size)
        return InvalidParameter;
 
    required = FIELD_OFFSET(struct region_data_header, header) + write_region_data(region, NULL);
    if (size < required)
    {
        if (needed) *needed = size;
        return InsufficientBuffer;
    }
 
    region_data_header = (struct region_data_header *)buffer;
    region_data_header->size = write_region_data(region, &region_data_header->header);
    region_data_header->checksum = 0;
 
    if (needed)
        *needed = required;
 
    return Ok;
}

Referenced by get_region_type(), test_clip_xform(), test_combinereplace(), test_fromhrgn(), test_GdipCreateRegionRgnData(), test_getregiondata(), and test_region_data().

◆ GdipGetRegionDataSize()

GpStatus WINGDIPAPI GdipGetRegionDataSize	(	GpRegion *	region,
		UINT *	needed
	)

Definition at line 985 of file region.c.

{
    TRACE("%p, %p\n", region, needed);
 
    if (!(region && needed))
        return InvalidParameter;
 
    /* header.size doesn't count header.size and header.checksum */
    *needed = FIELD_OFFSET(struct region_data_header, header) + write_region_data(region, NULL);
 
    return Ok;
}

Referenced by get_region_type(), test_combinereplace(), test_fromhrgn(), test_getregiondata(), and test_region_data().

◆ GdipGetRegionHRgn()

GpStatus WINGDIPAPI GdipGetRegionHRgn	(	GpRegion *	region,
		GpGraphics *	graphics,
		HRGN *	hrgn
	)

Definition at line 1194 of file region.c.

{
    TRACE("(%p, %p, %p)\n", region, graphics, hrgn);
 
    if (!region || !hrgn)
        return InvalidParameter;
 
    return get_region_hrgn(&region->node, graphics, hrgn);
}

Referenced by GDI32_GdipFillRegion(), GdipGetRegionBounds(), GdipIsEqualRegion(), GdipIsVisiblePathPoint(), GdipIsVisibleRegionPoint(), GdipIsVisibleRegionRect(), get_clip_hrgn(), get_region_scans_data(), SOFTWARE_GdipFillRegion(), test_clipping(), test_clipping_2(), and test_gethrgn().

◆ GdipGetRegionScans()

GpStatus WINGDIPAPI GdipGetRegionScans	(	GpRegion *	region,
		GpRectF *	scans,
		INT *	count,
		GpMatrix *	matrix
	)

Definition at line 1656 of file region.c.

{
    GpStatus stat;
    DWORD i;
    LPRGNDATA data;
    RECT *rects;
 
    if (!region || !count || !matrix)
        return InvalidParameter;
 
    stat = get_region_scans_data(region, matrix, &data);
 
    if (stat == Ok)
    {
        *count = data->rdh.nCount;
        rects = (RECT*)data->Buffer;
 
        if (scans)
        {
            for (i=0; i<data->rdh.nCount; i++)
            {
                scans[i].X = rects[i].left;
                scans[i].Y = rects[i].top;
                scans[i].Width = rects[i].right - rects[i].left;
                scans[i].Height = rects[i].bottom - rects[i].top;
            }
        }
 
        heap_free(data);
    }
 
    return Ok;
}

Referenced by test_excludeinfinite(), and test_scans().

◆ GdipGetRegionScansCount()

GpStatus WINGDIPAPI GdipGetRegionScansCount	(	GpRegion *	region,
		UINT *	count,
		GpMatrix *	matrix
	)

Definition at line 1601 of file region.c.

{
    GpStatus stat;
    LPRGNDATA data;
 
    TRACE("(%p, %p, %p)\n", region, count, matrix);
 
    if (!region || !count || !matrix)
        return InvalidParameter;
 
    stat = get_region_scans_data(region, matrix, &data);
 
    if (stat == Ok)
    {
        *count = data->rdh.nCount;
        heap_free(data);
    }
 
    return stat;
}

Referenced by test_excludeinfinite(), and test_scans().

◆ GdipGetRegionScansI()

GpStatus WINGDIPAPI GdipGetRegionScansI	(	GpRegion *	region,
		GpRect *	scans,
		INT *	count,
		GpMatrix *	matrix
	)

Definition at line 1622 of file region.c.

{
    GpStatus stat;
    DWORD i;
    LPRGNDATA data;
    RECT *rects;
 
    if (!region || !count || !matrix)
        return InvalidParameter;
 
    stat = get_region_scans_data(region, matrix, &data);
 
    if (stat == Ok)
    {
        *count = data->rdh.nCount;
        rects = (RECT*)data->Buffer;
 
        if (scans)
        {
            for (i=0; i<data->rdh.nCount; i++)
            {
                scans[i].X = rects[i].left;
                scans[i].Y = rects[i].top;
                scans[i].Width = rects[i].right - rects[i].left;
                scans[i].Height = rects[i].bottom - rects[i].top;
            }
        }
 
        heap_free(data);
    }
 
    return Ok;
}

Referenced by test_scans().

◆ GdipGetRenderingOrigin()

GpStatus WINGDIPAPI GdipGetRenderingOrigin	(	GpGraphics *	graphics,
		INT *	x,
		INT *	y
	)

Definition at line 6276 of file graphics.c.

{
    TRACE("(%p,%p,%p)\n", graphics, x, y);
 
    if (!graphics || !x || !y)
        return InvalidParameter;
 
    *x = graphics->origin_x;
    *y = graphics->origin_y;
 
    return Ok;
}

◆ GdipGetSmoothingMode()

GpStatus WINGDIPAPI GdipGetSmoothingMode	(	GpGraphics *	graphics,
		SmoothingMode *	mode
	)

Definition at line 4960 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, mode);
 
    if(!graphics || !mode)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *mode = graphics->smoothing;
 
    return Ok;
}

Referenced by test_BeginContainer2(), and test_Get_Release_DC().

◆ GdipGetSolidFillColor()

GpStatus WINGDIPAPI GdipGetSolidFillColor	(	GpSolidFill *	sf,
		ARGB *	argb
	)

Definition at line 1273 of file brush.c.

{
    TRACE("(%p, %p)\n", sf, argb);
 
    if(!sf || !argb)
        return InvalidParameter;
 
    *argb = sf->color;
 
    return Ok;
}

Referenced by GdipGetPenColor(), and test_brushfill().

◆ GdipGetStringFormatAlign()

GpStatus WINGDIPAPI GdipGetStringFormatAlign	(	GpStringFormat *	format,
		StringAlignment *	align
	)

Definition at line 130 of file stringformat.c.

{
    if(!format || !align)
        return InvalidParameter;
 
    *align = format->align;
 
    return Ok;
}

Referenced by test_constructor(), test_getgenericdefault(), and test_getgenerictypographic().

◆ GdipGetStringFormatDigitSubstitution()

GpStatus WINGDIPAPI GdipGetStringFormatDigitSubstitution	(	GDIPCONST GpStringFormat *	format,
		LANGID *	language,
		StringDigitSubstitute *	substitute
	)

Definition at line 141 of file stringformat.c.

{
    if(!format)
        return InvalidParameter;
 
    if(language)    *language   = format->digitlang;
    if(substitute)  *substitute = format->digitsub;
 
    return Ok;
}

Referenced by test_constructor(), test_digitsubstitution(), test_getgenericdefault(), and test_getgenerictypographic().

◆ GdipGetStringFormatFlags()

GpStatus WINGDIPAPI GdipGetStringFormatFlags	(	GDIPCONST GpStringFormat *	format,
		INT *	flags
	)

Definition at line 153 of file stringformat.c.

{
    if (!(format && flags))
        return InvalidParameter;
 
    *flags = format->attr;
 
    return Ok;
}

Referenced by test_getgenericdefault(), test_getgenerictypographic(), and test_stringformatflags().

◆ GdipGetStringFormatHotkeyPrefix()

GpStatus WINGDIPAPI GdipGetStringFormatHotkeyPrefix	(	GDIPCONST GpStringFormat *	format,
		INT *	hkpx
	)

Definition at line 164 of file stringformat.c.

{
    if(!format || !hkpx)
        return InvalidParameter;
 
    *hkpx = (INT)format->hkprefix;
 
    return Ok;
}

Referenced by test_constructor(), test_getgenericdefault(), and test_getgenerictypographic().

◆ GdipGetStringFormatLineAlign()

GpStatus WINGDIPAPI GdipGetStringFormatLineAlign	(	GpStringFormat *	format,
		StringAlignment *	align
	)

Definition at line 175 of file stringformat.c.

{
    if(!format || !align)
        return InvalidParameter;
 
    *align = format->line_align;
 
    return Ok;
}

Referenced by test_constructor(), test_getgenericdefault(), and test_getgenerictypographic().

◆ GdipGetStringFormatMeasurableCharacterRangeCount()

GpStatus WINGDIPAPI GdipGetStringFormatMeasurableCharacterRangeCount	(	GDIPCONST GpStringFormat *	format,
		INT *	count
	)

Definition at line 186 of file stringformat.c.

{
    if (!(format && count))
        return InvalidParameter;
 
    TRACE("%p %p\n", format, count);
 
    *count = format->range_count;
 
    return Ok;
}

Referenced by test_characterrange(), and test_constructor().

◆ GdipGetStringFormatTabStopCount()

GpStatus WINGDIPAPI GdipGetStringFormatTabStopCount	(	GDIPCONST GpStringFormat *	format,
		INT *	count
	)

Definition at line 199 of file stringformat.c.

{
    if(!format || !count)
        return InvalidParameter;
 
    *count = format->tabcount;
 
    return Ok;
}

Referenced by test_getgenericdefault(), test_getgenerictypographic(), and test_tabstops().

◆ GdipGetStringFormatTabStops()

GpStatus WINGDIPAPI GdipGetStringFormatTabStops	(	GDIPCONST GpStringFormat *	format,
		INT	count,
		REAL *	firsttab,
		REAL *	tabs
	)

Definition at line 210 of file stringformat.c.

{
    if(!format || !firsttab || !tabs)
        return InvalidParameter;
 
    /* native simply crashes on count < 0 */
    if(count != 0)
        memcpy(tabs, format->tabs, sizeof(REAL)*count);
 
    *firsttab = format->firsttab;
 
    return Ok;
}

Referenced by test_tabstops().

◆ GdipGetStringFormatTrimming()

GpStatus WINGDIPAPI GdipGetStringFormatTrimming	(	GpStringFormat *	format,
		StringTrimming *	trimming
	)

Definition at line 225 of file stringformat.c.

{
    if(!format || !trimming)
        return InvalidParameter;
 
    *trimming = format->trimming;
 
    return Ok;
}

Referenced by test_constructor(), test_getgenericdefault(), and test_getgenerictypographic().

◆ GdipGetTextContrast()

GpStatus WINGDIPAPI GdipGetTextContrast	(	GpGraphics *	graphics,
		UINT *	contrast
	)

Definition at line 4975 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, contrast);
 
    if(!graphics || !contrast)
        return InvalidParameter;
 
    *contrast = graphics->textcontrast;
 
    return Ok;
}

Referenced by test_BeginContainer2(), and test_textcontrast().

◆ GdipGetTextRenderingHint()

GpStatus WINGDIPAPI GdipGetTextRenderingHint	(	GpGraphics *	graphics,
		TextRenderingHint *	hint
	)

Definition at line 4988 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, hint);
 
    if(!graphics || !hint)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *hint = graphics->texthint;
 
    return Ok;
}

Referenced by test_BeginContainer2(), test_Get_Release_DC(), and test_get_set_textrenderinghint().

◆ GdipGetTextureImage()

GpStatus WINGDIPAPI GdipGetTextureImage	(	GpTexture *	brush,
		GpImage **	image
	)

Definition at line 1288 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, image);
 
    if(!brush || !image)
        return InvalidParameter;
 
    return GdipCloneImage(brush->image, image);
}

◆ GdipGetTextureTransform()

GpStatus WINGDIPAPI GdipGetTextureTransform	(	GpTexture *	brush,
		GpMatrix *	matrix
	)

Definition at line 1301 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, matrix);
 
    if(!brush || !matrix)
        return InvalidParameter;
 
    *matrix = brush->transform;
 
    return Ok;
}

Referenced by test_transform().

◆ GdipGetTextureWrapMode()

GpStatus WINGDIPAPI GdipGetTextureWrapMode	(	GpTexture *	brush,
		GpWrapMode *	wrapmode
	)

Definition at line 1316 of file brush.c.

{
    TRACE("(%p, %p)\n", brush, wrapmode);
 
    if(!brush || !wrapmode)
        return InvalidParameter;
 
    *wrapmode = brush->imageattributes->wrap;
 
    return Ok;
}

Referenced by test_texturewrap().

◆ GdipGetVisibleClipBounds()

GpStatus WINGDIPAPI GdipGetVisibleClipBounds	(	GpGraphics *	graphics,
		GpRectF *	rect
	)

Definition at line 5004 of file graphics.c.

{
    GpRegion *clip_rgn;
    GpStatus stat;
    GpMatrix device_to_world;
 
    TRACE("(%p, %p)\n", graphics, rect);
 
    if(!graphics || !rect)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    /* intersect window and graphics clipping regions */
    if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
        return stat;
 
    if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
        goto cleanup;
 
    /* transform to world coordinates */
    if((stat = get_graphics_transform(graphics, CoordinateSpaceWorld, CoordinateSpaceDevice, &device_to_world)) != Ok)
        goto cleanup;
 
    if((stat = GdipTransformRegion(clip_rgn, &device_to_world)) != Ok)
        goto cleanup;
 
    /* get bounds of the region */
    stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
 
cleanup:
    GdipDeleteRegion(clip_rgn);
 
    return stat;
}

Referenced by GdipGetVisibleClipBoundsI(), GdipGraphicsClear(), test_alpha_hdc(), test_cliphrgn_transform(), test_clipping(), test_GdipGetVisibleClipBounds(), test_GdipGetVisibleClipBounds_screen(), and test_GdipGetVisibleClipBounds_window().

◆ GdipGetVisibleClipBoundsI()

GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI	(	GpGraphics *	graphics,
		GpRect *	rect
	)

Definition at line 5041 of file graphics.c.

{
    GpRectF rectf;
    GpStatus stat;
 
    TRACE("(%p, %p)\n", graphics, rect);
 
    if(!graphics || !rect)
        return InvalidParameter;
 
    if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
    {
        rect->X = gdip_round(rectf.X);
        rect->Y = gdip_round(rectf.Y);
        rect->Width  = gdip_round(rectf.Width);
        rect->Height = gdip_round(rectf.Height);
    }
 
    return stat;
}

Referenced by test_GdipGetVisibleClipBounds(), test_GdipGetVisibleClipBounds_memoryDC(), test_GdipGetVisibleClipBounds_screen(), and test_GdipGetVisibleClipBounds_window().

◆ GdipGetWorldTransform()

GpStatus WINGDIPAPI GdipGetWorldTransform	(	GpGraphics *	graphics,
		GpMatrix *	matrix
	)

Definition at line 5062 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, matrix);
 
    if(!graphics || !matrix)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    *matrix = graphics->worldtrans;
    return Ok;
}

Referenced by test_BeginContainer2(), test_Get_Release_DC(), and test_worldtransform().

◆ GdipGraphicsClear()

GpStatus WINGDIPAPI GdipGraphicsClear	(	GpGraphics *	graphics,
		ARGB	color
	)

Definition at line 5076 of file graphics.c.

{
    GpSolidFill *brush;
    GpStatus stat;
    GpRectF wnd_rect;
 
    TRACE("(%p, %x)\n", graphics, color);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
        return METAFILE_GraphicsClear((GpMetafile*)graphics->image, color);
 
    if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
        return stat;
 
    if((stat = GdipGetVisibleClipBounds(graphics, &wnd_rect)) != Ok){
        GdipDeleteBrush((GpBrush*)brush);
        return stat;
    }
 
    GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
                                                 wnd_rect.Width, wnd_rect.Height);
 
    GdipDeleteBrush((GpBrush*)brush);
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), test_alpha_hdc(), test_clear(), test_clip_xform(), test_fromMemoryBitmap(), test_Get_Release_DC(), and test_pen_thickness().

◆ GdipGraphicsSetAbort()

GpStatus WINGDIPAPI GdipGraphicsSetAbort	(	GpGraphics *	graphics,
		GdiplusAbort *	pabort
	)

Definition at line 7507 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, pabort);
 
    if (!graphics)
        return InvalidParameter;
 
    if (pabort)
        FIXME("Abort callback is not supported.\n");
 
    return Ok;
}

◆ GdipImageForceValidation()

GpStatus WINGDIPAPI GdipImageForceValidation ( GpImage * image )

Definition at line 5347 of file image.c.

{
    TRACE("%p\n", image);
 
    return Ok;
}

◆ GdipImageGetFrameCount()

GpStatus WINGDIPAPI GdipImageGetFrameCount	(	GpImage *	image,
		GDIPCONST GUID *	dimensionID,
		UINT *	count
	)

Definition at line 2913 of file image.c.

{
    TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
 
    if(!image || !count)
        return InvalidParameter;
 
    if (!dimensionID ||
        IsEqualGUID(dimensionID, &image->format) ||
        IsEqualGUID(dimensionID, &FrameDimensionPage) ||
        IsEqualGUID(dimensionID, &FrameDimensionTime))
    {
        *count = image->frame_count;
        return Ok;
    }
 
    return InvalidParameter;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_GdipImageGetFrameDimensionsCount(), test_gif_properties(), test_multiframegif(), and test_tiff_properties().

◆ GdipImageGetFrameDimensionsCount()

GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount	(	GpImage *	image,
		UINT *	count
	)

Definition at line 2933 of file image.c.

{
    TRACE("(%p, %p)\n", image, count);
 
    /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
 
    if(!image || !count)
        return InvalidParameter;
 
    *count = 1;
 
    return Ok;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_GdipImageGetFrameDimensionsCount(), test_gif_properties(), test_multiframegif(), and test_tiff_properties().

◆ GdipImageGetFrameDimensionsList()

GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList	(	GpImage *	image,
		GUID *	dimensionIDs,
		UINT	count
	)

Definition at line 2948 of file image.c.

{
    int i;
    const GUID *result=NULL;
 
    TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
 
    if(!image || !dimensionIDs || count != 1)
        return InvalidParameter;
 
    for (i=0; image_format_dimensions[i].format; i++)
    {
        if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
        {
            result = image_format_dimensions[i].dimension;
            break;
        }
    }
 
    if (!result)
        result = &FrameDimensionPage;
 
    memcpy(dimensionIDs, result, sizeof(GUID));
 
    return Ok;
}

Referenced by Anime_LoadInfo(), test_GdipGetAllPropertyItems(), test_GdipImageGetFrameDimensionsCount(), test_gif_properties(), test_multiframegif(), and test_tiff_properties().

◆ GdipImageRotateFlip()

GpStatus WINGDIPAPI GdipImageRotateFlip	(	GpImage *	image,
		RotateFlipType	type
	)

Definition at line 5406 of file image.c.

{
    GpBitmap *new_bitmap;
    GpBitmap *bitmap;
    int bpp, bytesperpixel;
    BOOL rotate_90, flip_x, flip_y;
    int src_x_offset, src_y_offset;
    LPBYTE src_origin;
    UINT x, y, width, height;
    BitmapData src_lock, dst_lock;
    GpStatus stat;
    BOOL unlock;
 
    TRACE("(%p, %u)\n", image, type);
 
    if (!image)
        return InvalidParameter;
    if (!image_lock(image, &unlock))
        return ObjectBusy;
 
    rotate_90 = type&1;
    flip_x = (type&6) == 2 || (type&6) == 4;
    flip_y = (type&3) == 1 || (type&3) == 2;
 
    if (image->type != ImageTypeBitmap)
    {
        FIXME("Not implemented for type %i\n", image->type);
        image_unlock(image, unlock);
        return NotImplemented;
    }
 
    bitmap = (GpBitmap*)image;
    bpp = PIXELFORMATBPP(bitmap->format);
 
    if (bpp < 8)
    {
        FIXME("Not implemented for %i bit images\n", bpp);
        image_unlock(image, unlock);
        return NotImplemented;
    }
 
    if (rotate_90)
    {
        width = bitmap->height;
        height = bitmap->width;
    }
    else
    {
        width = bitmap->width;
        height = bitmap->height;
    }
 
    bytesperpixel = bpp/8;
 
    stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
 
    if (stat != Ok)
    {
        image_unlock(image, unlock);
        return stat;
    }
 
    stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
 
    if (stat == Ok)
    {
        stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
 
        if (stat == Ok)
        {
            LPBYTE src_row, src_pixel;
            LPBYTE dst_row, dst_pixel;
 
            src_origin = src_lock.Scan0;
            if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
            if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
 
            if (rotate_90)
            {
                if (flip_y) src_x_offset = -src_lock.Stride;
                else src_x_offset = src_lock.Stride;
                if (flip_x) src_y_offset = -bytesperpixel;
                else src_y_offset = bytesperpixel;
            }
            else
            {
                if (flip_x) src_x_offset = -bytesperpixel;
                else src_x_offset = bytesperpixel;
                if (flip_y) src_y_offset = -src_lock.Stride;
                else src_y_offset = src_lock.Stride;
            }
 
            src_row = src_origin;
            dst_row = dst_lock.Scan0;
            for (y=0; y<height; y++)
            {
                src_pixel = src_row;
                dst_pixel = dst_row;
                for (x=0; x<width; x++)
                {
                    /* FIXME: This could probably be faster without memcpy. */
                    memcpy(dst_pixel, src_pixel, bytesperpixel);
                    dst_pixel += bytesperpixel;
                    src_pixel += src_x_offset;
                }
                src_row += src_y_offset;
                dst_row += dst_lock.Stride;
            }
 
            GdipBitmapUnlockBits(new_bitmap, &dst_lock);
        }
 
        GdipBitmapUnlockBits(bitmap, &src_lock);
    }
 
    if (stat == Ok)
        move_bitmap(bitmap, new_bitmap, FALSE);
    else
        GdipDisposeImage(&new_bitmap->image);
 
    image_unlock(image, unlock);
    return stat;
}

Referenced by Preview_OnCommand(), test_multiframegif(), and test_rotateflip().

◆ GdipImageSelectActiveFrame()

GpStatus WINGDIPAPI GdipImageSelectActiveFrame	(	GpImage *	image,
		GDIPCONST GUID *	dimensionID,
		UINT	frame
	)

Definition at line 4350 of file image.c.

{
    GpStatus stat;
    const struct image_codec *codec = NULL;
    BOOL unlock;
 
    TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
 
    if (!image || !dimensionID)
        return InvalidParameter;
    if(!image_lock(image, &unlock))
        return ObjectBusy;
 
    if (frame >= image->frame_count)
    {
        WARN("requested frame %u, but image has only %u\n", frame, image->frame_count);
        image_unlock(image, unlock);
        return InvalidParameter;
    }
 
    if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
    {
        WARN("invalid image type %d\n", image->type);
        image_unlock(image, unlock);
        return InvalidParameter;
    }
 
    if (image->current_frame == frame)
    {
        image_unlock(image, unlock);
        return Ok;
    }
 
    if (!image->decoder)
    {
        TRACE("image doesn't have an associated decoder\n");
        image_unlock(image, unlock);
        return Ok;
    }
 
    /* choose an appropriate image decoder */
    stat = get_decoder_info_from_image(image, &codec);
    if (stat != Ok)
    {
        WARN("can't find decoder info\n");
        image_unlock(image, unlock);
        return stat;
    }
 
    stat = codec->select_func(image, frame);
    image_unlock(image, unlock);
    return stat;
}

Referenced by Anime_SetFrameIndex(), test_GdipImageGetFrameDimensionsCount(), test_gif_properties(), and test_multiframegif().

◆ GdipImageSetAbort()

GpStatus WINGDIPAPI GdipImageSetAbort	(	GpImage *	image,
		GdiplusAbort *	pabort
	)

Definition at line 5533 of file image.c.

{
    TRACE("(%p, %p)\n", image, pabort);
 
    if (!image)
        return InvalidParameter;
 
    if (pabort)
        FIXME("Abort callback is not supported.\n");
 
    return Ok;
}

◆ GdipInitializePalette()

GpStatus WINGDIPAPI GdipInitializePalette	(	ColorPalette *	palette,
		PaletteType	type,
		INT	desired,
		BOOL	transparent,
		GpBitmap *	bitmap
	)

Definition at line 5748 of file image.c.

{
    TRACE("(%p,%d,%d,%d,%p)\n", palette, type, desired, transparent, bitmap);
 
    if (!palette) return InvalidParameter;
 
    switch (type)
    {
    case PaletteTypeCustom:
        return Ok;
 
    case PaletteTypeOptimal:
        return create_optimal_palette(palette, desired, transparent, bitmap);
 
    /* WIC palette type enumeration matches these gdiplus enums */
    case PaletteTypeFixedBW:
    case PaletteTypeFixedHalftone8:
    case PaletteTypeFixedHalftone27:
    case PaletteTypeFixedHalftone64:
    case PaletteTypeFixedHalftone125:
    case PaletteTypeFixedHalftone216:
    case PaletteTypeFixedHalftone252:
    case PaletteTypeFixedHalftone256:
    {
        ColorPalette *wic_palette;
        GpStatus status = Ok;
 
        wic_palette = get_palette(NULL, type);
        if (!wic_palette) return OutOfMemory;
 
        if (palette->Count >= wic_palette->Count)
        {
            palette->Flags = wic_palette->Flags;
            palette->Count = wic_palette->Count;
            memcpy(palette->Entries, wic_palette->Entries, wic_palette->Count * sizeof(wic_palette->Entries[0]));
        }
        else
            status = GenericError;
 
        heap_free(wic_palette);
 
        return status;
    }
 
    default:
        FIXME("unknown palette type %d\n", type);
        break;
    }
 
    return InvalidParameter;
}

◆ GdipInvertMatrix()

GpStatus WINGDIPAPI GdipInvertMatrix ( GpMatrix * matrix )

Definition at line 185 of file matrix.c.

{
    GpMatrix copy;
    REAL det;
    BOOL invertible;
 
    TRACE("(%p)\n", matrix);
 
    if(!matrix)
        return InvalidParameter;
 
    GdipIsMatrixInvertible(matrix, &invertible);
    if(!invertible)
        return InvalidParameter;
 
    /* optimize inverting simple scaling and translation matrices */
    if(matrix->matrix[1] == 0 && matrix->matrix[2] == 0)
    {
        matrix->matrix[4] = -matrix->matrix[4] / matrix->matrix[0];
        matrix->matrix[5] = -matrix->matrix[5] / matrix->matrix[3];
        matrix->matrix[0] = 1 / matrix->matrix[0];
        matrix->matrix[3] = 1 / matrix->matrix[3];
 
        return Ok;
    }
 
    det = matrix_det(matrix);
 
    copy = *matrix;
    /* store result */
    matrix->matrix[0] =   copy.matrix[3] / det;
    matrix->matrix[1] =  -copy.matrix[1] / det;
    matrix->matrix[2] =  -copy.matrix[2] / det;
    matrix->matrix[3] =   copy.matrix[0] / det;
    matrix->matrix[4] =  (copy.matrix[2]*copy.matrix[5]-copy.matrix[3]*copy.matrix[4]) / det;
    matrix->matrix[5] = -(copy.matrix[0]*copy.matrix[5]-copy.matrix[1]*copy.matrix[4]) / det;
 
    return Ok;
}

Referenced by brush_fill_pixels(), GdipDrawImagePointsRect(), GdipIsOutlineVisiblePathPoint(), get_graphics_transform(), SOFTWARE_GdipDrawPath(), and test_invert().

◆ GdipIsClipEmpty()

GpStatus WINGDIPAPI GdipIsClipEmpty	(	GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 5109 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, res);
 
    if(!graphics || !res)
        return InvalidParameter;
 
    return GdipIsEmptyRegion(graphics->clip, graphics, res);
}

Referenced by test_isempty().

◆ GdipIsEmptyRegion()

GpStatus WINGDIPAPI GdipIsEmptyRegion	(	GpRegion *	region,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1204 of file region.c.

{
    GpStatus status;
    GpRectF rect;
 
    TRACE("(%p, %p, %p)\n", region, graphics, res);
 
    if(!region || !graphics || !res)
        return InvalidParameter;
 
    status = GdipGetRegionBounds(region, graphics, &rect);
    if (status != Ok) return status;
 
    *res = rect.Width == 0.0 && rect.Height == 0.0;
    TRACE("=> %d\n", *res);
 
    return Ok;
}

Referenced by GdipIsClipEmpty(), GdipIsVisibleClipEmpty(), test_fromhrgn(), test_GdipCreateRegionRgnData(), test_get_set_clip(), test_isempty(), and test_string_functions().

◆ GdipIsEqualRegion()

GpStatus WINGDIPAPI GdipIsEqualRegion	(	GpRegion *	region,
		GpRegion *	region2,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1226 of file region.c.

{
    HRGN hrgn1, hrgn2;
    GpStatus stat;
 
    TRACE("(%p, %p, %p, %p)\n", region, region2, graphics, res);
 
    if(!region || !region2 || !graphics || !res)
        return InvalidParameter;
 
    stat = GdipGetRegionHRgn(region, graphics, &hrgn1);
    if(stat != Ok)
        return stat;
    stat = GdipGetRegionHRgn(region2, graphics, &hrgn2);
    if(stat != Ok){
        DeleteObject(hrgn1);
        return stat;
    }
 
    *res = EqualRgn(hrgn1, hrgn2);
 
    /* one of GpRegions is infinite */
    if(*res == ERROR)
        *res = (!hrgn1 && !hrgn2);
 
    DeleteObject(hrgn1);
    DeleteObject(hrgn2);
 
    return Ok;
}

Referenced by test_isequal(), test_transform(), and test_translate().

◆ GdipIsInfiniteRegion()

GpStatus WINGDIPAPI GdipIsInfiniteRegion	(	GpRegion *	region,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1261 of file region.c.

{
    /* I think graphics is ignored here */
    TRACE("(%p, %p, %p)\n", region, graphics, res);
 
    if(!region || !graphics || !res)
        return InvalidParameter;
 
    *res = (region->node.type == RegionDataInfiniteRect);
 
    return Ok;
}

Referenced by test_GdipCreateRegionRgnData(), test_get_set_clip(), test_isinfinite(), test_isvisiblepoint(), and test_isvisiblerect().

◆ GdipIsMatrixEqual()

GpStatus WINGDIPAPI GdipIsMatrixEqual	(	GDIPCONST GpMatrix *	matrix,
		GDIPCONST GpMatrix *	matrix2,
		BOOL *	result
	)

Definition at line 499 of file matrix.c.

{
    TRACE("(%p, %p, %p)\n", matrix, matrix2, result);
 
    if(!matrix || !matrix2 || !result)
        return InvalidParameter;
    /* based on single array member of GpMatrix */
    *result = (memcmp(matrix->matrix, matrix2->matrix, sizeof(GpMatrix)) == 0);
 
    return Ok;
}

Referenced by GdipIsMatrixIdentity(), test_invert(), test_shear(), and test_transform().

◆ GdipIsMatrixIdentity()

GpStatus WINGDIPAPI GdipIsMatrixIdentity	(	GDIPCONST GpMatrix *	matrix,
		BOOL *	result
	)

Definition at line 512 of file matrix.c.

{
    static const GpMatrix identity =
    {
      { 1.0, 0.0,
        0.0, 1.0,
        0.0, 0.0 }
    };
 
    TRACE("(%p, %p)\n", matrix, result);
 
    if(!matrix || !result)
        return InvalidParameter;
 
    return GdipIsMatrixEqual(matrix, &identity, result);
}

Referenced by brush_fill_pixels(), GdipSetClipRect(), GdipSetClipRegion(), get_clip_hrgn(), METAFILE_AddPenObject(), test_gradientgetrect(), test_isidentity(), test_transform(), and test_worldtransform().

◆ GdipIsMatrixInvertible()

GpStatus WINGDIPAPI GdipIsMatrixInvertible	(	GDIPCONST GpMatrix *	matrix,
		BOOL *	result
	)

Definition at line 225 of file matrix.c.

{
    TRACE("(%p, %p)\n", matrix, result);
 
    if(!matrix || !result)
        return InvalidParameter;
 
    if(matrix->matrix[1] == 0 && matrix->matrix[2] == 0)
        *result = matrix->matrix[0] != 0 && matrix->matrix[3] != 0;
    else
        *result = (fabs(matrix_det(matrix)) >= 1e-5);
 
    return Ok;
}

Referenced by GdipInvertMatrix(), and test_isinvertible().

◆ GdipIsOutlineVisiblePathPoint()

GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPoint	(	GpPath *	path,
		REAL	x,
		REAL	y,
		GpPen *	pen,
		GpGraphics *	graphics,
		BOOL *	result
	)

Definition at line 1660 of file graphicspath.c.

{
    GpStatus stat;
    GpPath *wide_path;
    GpMatrix *transform = NULL;
 
    TRACE("(%p,%0.2f,%0.2f,%p,%p,%p)\n", path, x, y, pen, graphics, result);
 
    if(!path || !pen)
        return InvalidParameter;
 
    stat = GdipClonePath(path, &wide_path);
 
    if (stat != Ok)
        return stat;
 
    if (pen->unit == UnitPixel && graphics != NULL)
    {
        stat = GdipCreateMatrix(&transform);
 
        if (stat == Ok)
            stat = get_graphics_transform(graphics, CoordinateSpaceDevice,
                CoordinateSpaceWorld, transform);
    }
 
    if (stat == Ok)
        stat = GdipWidenPath(wide_path, pen, transform, 1.0);
 
    if (pen->unit == UnitPixel && graphics != NULL)
    {
        if (stat == Ok)
            stat = GdipInvertMatrix(transform);
 
        if (stat == Ok)
            stat = GdipTransformPath(wide_path, transform);
    }
 
    if (stat == Ok)
        stat = GdipIsVisiblePathPoint(wide_path, x, y, graphics, result);
 
    GdipDeleteMatrix(transform);
 
    GdipDeletePath(wide_path);
 
    return stat;
}

Referenced by GdipIsOutlineVisiblePathPointI().

◆ GdipIsOutlineVisiblePathPointI()

GpStatus WINGDIPAPI GdipIsOutlineVisiblePathPointI	(	GpPath *	path,
		INT	x,
		INT	y,
		GpPen *	pen,
		GpGraphics *	graphics,
		BOOL *	result
	)

Definition at line 1652 of file graphicspath.c.

{
    TRACE("(%p, %d, %d, %p, %p, %p)\n", path, x, y, pen, graphics, result);
 
    return GdipIsOutlineVisiblePathPoint(path, x, y, pen, graphics, result);
}

◆ GdipIsStyleAvailable()

GpStatus WINGDIPAPI GdipIsStyleAvailable	(	GDIPCONST GpFontFamily *	family,
		INT	style,
		BOOL *	IsStyleAvailable
	)

Definition at line 976 of file font.c.

{
    HDC hdc;
 
    TRACE("%p %d %p\n", family, style, IsStyleAvailable);
 
    if (!(family && IsStyleAvailable))
        return InvalidParameter;
 
    *IsStyleAvailable = FALSE;
 
    hdc = CreateCompatibleDC(0);
 
    if(!EnumFontFamiliesW(hdc, family->FamilyName, font_has_style_proc, (LPARAM)style))
        *IsStyleAvailable = TRUE;
 
    DeleteDC(hdc);
 
    return Ok;
}

◆ GdipIsVisibleClipEmpty()

GpStatus WINGDIPAPI GdipIsVisibleClipEmpty	(	GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 7475 of file graphics.c.

{
    GpStatus stat;
    GpRegion* rgn;
 
    TRACE("(%p, %p)\n", graphics, res);
 
    if((stat = GdipCreateRegion(&rgn)) != Ok)
        return stat;
 
    if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
        goto cleanup;
 
    stat = GdipIsEmptyRegion(rgn, graphics, res);
 
cleanup:
    GdipDeleteRegion(rgn);
    return stat;
}

◆ GdipIsVisiblePathPoint()

GpStatus WINGDIPAPI GdipIsVisiblePathPoint	(	GpPath *	path,
		REAL	x,
		REAL	y,
		GpGraphics *	graphics,
		BOOL *	result
	)

Definition at line 1718 of file graphicspath.c.

{
    GpRegion *region;
    HRGN hrgn;
    GpStatus status;
 
    if(!path || !result) return InvalidParameter;
 
    status = GdipCreateRegionPath(path, &region);
    if(status != Ok)
        return status;
 
    status = GdipGetRegionHRgn(region, graphics, &hrgn);
    if(status != Ok){
        GdipDeleteRegion(region);
        return status;
    }
 
    *result = PtInRegion(hrgn, gdip_round(x), gdip_round(y));
 
    DeleteObject(hrgn);
    GdipDeleteRegion(region);
 
    return Ok;
}

Referenced by GdipIsOutlineVisiblePathPoint(), GdipIsVisiblePathPointI(), test_empty_rect(), and test_isvisible().

◆ GdipIsVisiblePathPointI()

GpStatus WINGDIPAPI GdipIsVisiblePathPointI	(	GpPath *	path,
		INT	x,
		INT	y,
		GpGraphics *	graphics,
		BOOL *	result
	)

Definition at line 1708 of file graphicspath.c.

{
    TRACE("(%p, %d, %d, %p, %p)\n", path, x, y, graphics, result);
 
    return GdipIsVisiblePathPoint(path, x, y, graphics, result);
}

◆ GdipIsVisiblePoint()

GpStatus WINGDIPAPI GdipIsVisiblePoint	(	GpGraphics *	graphics,
		REAL	x,
		REAL	y,
		BOOL *	result
	)

Definition at line 5119 of file graphics.c.

{
    GpStatus stat;
    GpRegion* rgn;
    GpPointF pt;
 
    TRACE("(%p, %.2f, %.2f, %p)\n", graphics, x, y, result);
 
    if(!graphics || !result)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    pt.X = x;
    pt.Y = y;
    if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
                   CoordinateSpaceWorld, &pt, 1)) != Ok)
        return stat;
 
    if((stat = GdipCreateRegion(&rgn)) != Ok)
        return stat;
 
    if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
        goto cleanup;
 
    stat = GdipIsVisibleRegionPoint(rgn, pt.X, pt.Y, graphics, result);
 
cleanup:
    GdipDeleteRegion(rgn);
    return stat;
}

Referenced by GdipIsVisiblePointI(), test_cliphrgn_transform(), test_GdipIsVisiblePoint(), and test_Get_Release_DC().

◆ GdipIsVisiblePointI()

GpStatus WINGDIPAPI GdipIsVisiblePointI	(	GpGraphics *	graphics,
		INT	x,
		INT	y,
		BOOL *	result
	)

Definition at line 5152 of file graphics.c.

{
    return GdipIsVisiblePoint(graphics, (REAL)x, (REAL)y, result);
}

Referenced by test_GdipIsVisiblePoint(), and test_Get_Release_DC().

◆ GdipIsVisibleRect()

GpStatus WINGDIPAPI GdipIsVisibleRect	(	GpGraphics *	graphics,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		BOOL *	result
	)

Definition at line 5157 of file graphics.c.

{
    GpStatus stat;
    GpRegion* rgn;
    GpPointF pts[2];
 
    TRACE("(%p %.2f %.2f %.2f %.2f %p)\n", graphics, x, y, width, height, result);
 
    if(!graphics || !result)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    pts[0].X = x;
    pts[0].Y = y;
    pts[1].X = x + width;
    pts[1].Y = y + height;
 
    if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
                    CoordinateSpaceWorld, pts, 2)) != Ok)
        return stat;
 
    pts[1].X -= pts[0].X;
    pts[1].Y -= pts[0].Y;
 
    if((stat = GdipCreateRegion(&rgn)) != Ok)
        return stat;
 
    if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
        goto cleanup;
 
    stat = GdipIsVisibleRegionRect(rgn, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y, graphics, result);
 
cleanup:
    GdipDeleteRegion(rgn);
    return stat;
}

Referenced by GdipIsVisibleRectI(), and test_GdipIsVisibleRect().

◆ GdipIsVisibleRectI()

GpStatus WINGDIPAPI GdipIsVisibleRectI	(	GpGraphics *	graphics,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		BOOL *	result
	)

Definition at line 5196 of file graphics.c.

{
    return GdipIsVisibleRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, result);
}

Referenced by test_GdipIsVisibleRect().

◆ GdipIsVisibleRegionPoint()

GpStatus WINGDIPAPI GdipIsVisibleRegionPoint	(	GpRegion *	region,
		REAL	x,
		REAL	y,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1320 of file region.c.

{
    HRGN hrgn;
    GpStatus stat;
 
    TRACE("(%p, %.2f, %.2f, %p, %p)\n", region, x, y, graphics, res);
 
    if(!region || !res)
        return InvalidParameter;
 
    if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
        return stat;
 
    /* infinite */
    if(!hrgn){
        *res = TRUE;
        return Ok;
    }
 
    *res = PtInRegion(hrgn, gdip_round(x), gdip_round(y));
 
    DeleteObject(hrgn);
 
    return Ok;
}

Referenced by GdipIsVisiblePoint(), GdipIsVisibleRegionPointI(), and test_isvisiblepoint().

◆ GdipIsVisibleRegionPointI()

GpStatus WINGDIPAPI GdipIsVisibleRegionPointI	(	GpRegion *	region,
		INT	x,
		INT	y,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1349 of file region.c.

{
    TRACE("(%p, %d, %d, %p, %p)\n", region, x, y, graphics, res);
 
    return GdipIsVisibleRegionPoint(region, (REAL)x, (REAL)y, graphics, res);
}

Referenced by test_isvisiblepoint().

◆ GdipIsVisibleRegionRect()

GpStatus WINGDIPAPI GdipIsVisibleRegionRect	(	GpRegion *	region,
		REAL	x,
		REAL	y,
		REAL	w,
		REAL	h,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1277 of file region.c.

{
    HRGN hrgn;
    GpStatus stat;
    RECT rect;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %p, %p)\n", region, x, y, w, h, graphics, res);
 
    if(!region || !res)
        return InvalidParameter;
 
    if((stat = GdipGetRegionHRgn(region, NULL, &hrgn)) != Ok)
        return stat;
 
    /* infinite */
    if(!hrgn){
        *res = TRUE;
        return Ok;
    }
 
    SetRect(&rect, ceilr(x), ceilr(y), ceilr(x + w), ceilr(y + h));
    *res = RectInRegion(hrgn, &rect);
 
    DeleteObject(hrgn);
 
    return Ok;
}

Referenced by GdipIsVisibleRect(), GdipIsVisibleRegionRectI(), and test_isvisiblerect().

◆ GdipIsVisibleRegionRectI()

GpStatus WINGDIPAPI GdipIsVisibleRegionRectI	(	GpRegion *	region,
		INT	x,
		INT	y,
		INT	w,
		INT	h,
		GpGraphics *	graphics,
		BOOL *	res
	)

Definition at line 1308 of file region.c.

{
    TRACE("(%p, %d, %d, %d, %d, %p, %p)\n", region, x, y, w, h, graphics, res);
    if(!region || !res)
        return InvalidParameter;
 
    return GdipIsVisibleRegionRect(region, (REAL)x, (REAL)y, (REAL)w, (REAL)h, graphics, res);
}

Referenced by test_isvisiblerect().

◆ GdipLoadImageFromFile()

GpStatus WINGDIPAPI GdipLoadImageFromFile	(	GDIPCONST WCHAR *	filename,
		GpImage **	image
	)

Definition at line 2976 of file image.c.

{
    GpStatus stat;
    IStream *stream;
 
    TRACE("(%s) %p\n", debugstr_w(filename), image);
 
    if (!filename || !image)
        return InvalidParameter;
 
    *image = NULL;
 
    stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
 
    if (stat != Ok)
        return stat;
 
    stat = GdipLoadImageFromStream(stream, image);
 
    IStream_Release(stream);
 
    return stat;
}

Referenced by GdipLoadImageFromFileICM(), SetWallpaper(), test_LoadingImages(), and test_SavingImages().

◆ GdipLoadImageFromFileICM()

GpStatus WINGDIPAPI GdipLoadImageFromFileICM	(	GDIPCONST WCHAR *	filename,
		GpImage **	image
	)

Definition at line 3002 of file image.c.

{
    TRACE("(%s) %p\n", debugstr_w(filename), image);
 
    return GdipLoadImageFromFile(filename, image);
}

Referenced by test_LoadingImages().

◆ GdipLoadImageFromStream()

GpStatus WINGDIPAPI GdipLoadImageFromStream	(	IStream *	stream,
		GpImage **	image
	)

Definition at line 4405 of file image.c.

{
    GpStatus stat;
    LARGE_INTEGER seek;
    HRESULT hr;
    const struct image_codec *codec=NULL;
 
    TRACE("%p %p\n", stream, image);
 
    if (!stream || !image)
        return InvalidParameter;
 
    /* choose an appropriate image decoder */
    stat = get_decoder_info(stream, &codec);
    if (stat != Ok) return stat;
 
    /* seek to the start of the stream */
    seek.QuadPart = 0;
    hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
    if (FAILED(hr)) return hresult_to_status(hr);
 
    /* call on the image decoder to do the real work */
    stat = codec->decode_func(stream, image);
 
    /* take note of the original data format */
    if (stat == Ok)
    {
        memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
        return Ok;
    }
 
    return stat;
}

Referenced by GdipCreateBitmapFromStream(), GdipCreateMetafileFromStream(), GdipLoadImageFromFile(), GdipLoadImageFromStreamICM(), load_image(), Preview_pLoadImage(), test_bufferrawformat(), test_GdipLoadImageFromStream(), and test_loadwmf().

◆ GdipLoadImageFromStreamICM()

GpStatus WINGDIPAPI GdipLoadImageFromStreamICM	(	IStream *	stream,
		GpImage **	image
	)

Definition at line 4440 of file image.c.

{
    TRACE("%p %p\n", stream, image);
 
    return GdipLoadImageFromStream(stream, image);
}

◆ GdiplusNotificationHook()

GpStatus WINAPI GdiplusNotificationHook ( ULONG_PTR * token )

Definition at line 110 of file gdiplus.c.

{
    FIXME("%p\n", token);
    return NotificationHook(token);
}

◆ GdiplusNotificationUnhook()

void WINAPI GdiplusNotificationUnhook ( ULONG_PTR token )

Definition at line 116 of file gdiplus.c.

{
    FIXME("%ld\n", token);
    NotificationUnhook(token);
}

◆ GdipMeasureCharacterRanges()

GpStatus WINGDIPAPI GdipMeasureCharacterRanges	(	GpGraphics *	graphics,
		GDIPCONST WCHAR *	string,
		INT	length,
		GDIPCONST GpFont *	font,
		GDIPCONST RectF *	layoutRect,
		GDIPCONST GpStringFormat *	stringFormat,
		INT	regionCount,
		GpRegion **	regions
	)

Definition at line 5423 of file graphics.c.

{
    GpStatus stat;
    int i;
    HFONT gdifont, oldfont;
    struct measure_ranges_args args;
    HDC hdc, temp_hdc=NULL;
    GpPointF pt[3];
    RectF scaled_rect;
    REAL margin_x;
 
    TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_wn(string, length),
            length, font, debugstr_rectf(layoutRect), stringFormat, regionCount, regions);
 
    if (!(graphics && string && font && layoutRect && stringFormat && regions))
        return InvalidParameter;
 
    if (regionCount < stringFormat->range_count)
        return InvalidParameter;
 
    if(!graphics->hdc)
    {
        hdc = temp_hdc = CreateCompatibleDC(0);
        if (!temp_hdc) return OutOfMemory;
    }
    else
        hdc = graphics->hdc;
 
    if (stringFormat->attr)
        TRACE("may be ignoring some format flags: attr %x\n", stringFormat->attr);
 
    pt[0].X = 0.0;
    pt[0].Y = 0.0;
    pt[1].X = 1.0;
    pt[1].Y = 0.0;
    pt[2].X = 0.0;
    pt[2].Y = 1.0;
    gdip_transform_points(graphics, WineCoordinateSpaceGdiDevice, CoordinateSpaceWorld, pt, 3);
    args.rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
                     (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
    args.rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
                      (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
 
    margin_x = stringFormat->generic_typographic ? 0.0 : font->emSize / 6.0;
    margin_x *= units_scale(font->unit, graphics->unit, graphics->xres);
 
    scaled_rect.X = (layoutRect->X + margin_x) * args.rel_width;
    scaled_rect.Y = layoutRect->Y * args.rel_height;
    scaled_rect.Width = layoutRect->Width * args.rel_width;
    scaled_rect.Height = layoutRect->Height * args.rel_height;
 
    if (scaled_rect.Width >= 1 << 23) scaled_rect.Width = 1 << 23;
    if (scaled_rect.Height >= 1 << 23) scaled_rect.Height = 1 << 23;
 
    get_font_hfont(graphics, font, stringFormat, &gdifont, NULL);
    oldfont = SelectObject(hdc, gdifont);
 
    for (i=0; i<stringFormat->range_count; i++)
    {
        stat = GdipSetEmpty(regions[i]);
        if (stat != Ok)
            return stat;
    }
 
    args.regions = regions;
 
    gdi_transform_acquire(graphics);
 
    stat = gdip_format_string(hdc, string, length, font, &scaled_rect, stringFormat,
        (stringFormat->attr & StringFormatFlagsNoClip) != 0, measure_ranges_callback, &args);
 
    gdi_transform_release(graphics);
 
    SelectObject(hdc, oldfont);
    DeleteObject(gdifont);
 
    if (temp_hdc)
        DeleteDC(temp_hdc);
 
    return stat;
}

Referenced by test_font_height_scaling(), test_measure_string(), and test_string_functions().

◆ GdipMeasureDriverString()

GpStatus WINGDIPAPI GdipMeasureDriverString	(	GpGraphics *	graphics,
		GDIPCONST UINT16 *	text,
		INT	length,
		GDIPCONST GpFont *	font,
		GDIPCONST PointF *	positions,
		INT	flags,
		GDIPCONST GpMatrix *	matrix,
		RectF *	boundingBox
	)

Definition at line 7059 of file graphics.c.

{
    static const INT unsupported_flags = ~(DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance);
    HFONT hfont;
    HDC hdc;
    REAL min_x, min_y, max_x, max_y, x, y;
    int i;
    TEXTMETRICW textmetric;
    const WORD *glyph_indices;
    WORD *dynamic_glyph_indices=NULL;
    REAL rel_width, rel_height, ascent, descent;
    GpPointF pt[3];
 
    TRACE("(%p %p %d %p %p %d %p %p)\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
 
    if (!graphics || !text || !font || !positions || !boundingBox)
        return InvalidParameter;
 
    if (length == -1)
        length = strlenW(text);
 
    if (length == 0)
    {
        boundingBox->X = 0.0;
        boundingBox->Y = 0.0;
        boundingBox->Width = 0.0;
        boundingBox->Height = 0.0;
    }
 
    if (flags & unsupported_flags)
        FIXME("Ignoring flags %x\n", flags & unsupported_flags);
 
    get_font_hfont(graphics, font, NULL, &hfont, matrix);
 
    hdc = CreateCompatibleDC(0);
    SelectObject(hdc, hfont);
 
    GetTextMetricsW(hdc, &textmetric);
 
    pt[0].X = 0.0;
    pt[0].Y = 0.0;
    pt[1].X = 1.0;
    pt[1].Y = 0.0;
    pt[2].X = 0.0;
    pt[2].Y = 1.0;
    if (matrix)
    {
        GpMatrix xform = *matrix;
        GdipTransformMatrixPoints(&xform, pt, 3);
    }
    gdip_transform_points(graphics, WineCoordinateSpaceGdiDevice, CoordinateSpaceWorld, pt, 3);
    rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
                     (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
    rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
                      (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
 
    if (flags & DriverStringOptionsCmapLookup)
    {
        glyph_indices = dynamic_glyph_indices = heap_alloc_zero(sizeof(WORD) * length);
        if (!glyph_indices)
        {
            DeleteDC(hdc);
            DeleteObject(hfont);
            return OutOfMemory;
        }
 
        GetGlyphIndicesW(hdc, text, length, dynamic_glyph_indices, 0);
    }
    else
        glyph_indices = text;
 
    min_x = max_x = x = positions[0].X;
    min_y = max_y = y = positions[0].Y;
 
    ascent = textmetric.tmAscent / rel_height;
    descent = textmetric.tmDescent / rel_height;
 
    for (i=0; i<length; i++)
    {
        int char_width;
        ABC abc;
 
        if (!(flags & DriverStringOptionsRealizedAdvance))
        {
            x = positions[i].X;
            y = positions[i].Y;
        }
 
        GetCharABCWidthsW(hdc, glyph_indices[i], glyph_indices[i], &abc);
        char_width = abc.abcA + abc.abcB + abc.abcC;
 
        if (min_y > y - ascent) min_y = y - ascent;
        if (max_y < y + descent) max_y = y + descent;
        if (min_x > x) min_x = x;
 
        x += char_width / rel_width;
 
        if (max_x < x) max_x = x;
    }
 
    heap_free(dynamic_glyph_indices);
    DeleteDC(hdc);
    DeleteObject(hfont);
 
    boundingBox->X = min_x;
    boundingBox->Y = min_y;
    boundingBox->Width = max_x - min_x;
    boundingBox->Height = max_y - min_y;
 
    return Ok;
}

Referenced by test_font_transform(), and test_string_functions().

◆ GdipMeasureString()

GpStatus WINGDIPAPI GdipMeasureString	(	GpGraphics *	graphics,
		GDIPCONST WCHAR *	string,
		INT	length,
		GDIPCONST GpFont *	font,
		GDIPCONST RectF *	rect,
		GDIPCONST GpStringFormat *	format,
		RectF *	bounds,
		INT *	codepointsfitted,
		INT *	linesfilled
	)

Definition at line 5546 of file graphics.c.

{
    HFONT oldfont, gdifont;
    struct measure_string_args args;
    HDC temp_hdc=NULL, hdc;
    GpPointF pt[3];
    RectF scaled_rect;
    REAL margin_x;
    INT lines, glyphs;
 
    TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
        debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
        bounds, codepointsfitted, linesfilled);
 
    if(!graphics || !string || !font || !rect || !bounds)
        return InvalidParameter;
 
    if(!graphics->hdc)
    {
        hdc = temp_hdc = CreateCompatibleDC(0);
        if (!temp_hdc) return OutOfMemory;
    }
    else
        hdc = graphics->hdc;
 
    if(linesfilled) *linesfilled = 0;
    if(codepointsfitted) *codepointsfitted = 0;
 
    if(format)
        TRACE("may be ignoring some format flags: attr %x\n", format->attr);
 
    pt[0].X = 0.0;
    pt[0].Y = 0.0;
    pt[1].X = 1.0;
    pt[1].Y = 0.0;
    pt[2].X = 0.0;
    pt[2].Y = 1.0;
    gdip_transform_points(graphics, WineCoordinateSpaceGdiDevice, CoordinateSpaceWorld, pt, 3);
    args.rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
                     (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
    args.rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
                      (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
 
    margin_x = (format && format->generic_typographic) ? 0.0 : font->emSize / 6.0;
    margin_x *= units_scale(font->unit, graphics->unit, graphics->xres);
 
    scaled_rect.X = (rect->X + margin_x) * args.rel_width;
    scaled_rect.Y = rect->Y * args.rel_height;
    scaled_rect.Width = rect->Width * args.rel_width;
    scaled_rect.Height = rect->Height * args.rel_height;
    if (scaled_rect.Width >= 0.5)
    {
        scaled_rect.Width -= margin_x * 2.0 * args.rel_width;
        if (scaled_rect.Width < 0.5) return Ok; /* doesn't fit */
    }
 
    if (scaled_rect.Width >= 1 << 23) scaled_rect.Width = 1 << 23;
    if (scaled_rect.Height >= 1 << 23) scaled_rect.Height = 1 << 23;
 
    get_font_hfont(graphics, font, format, &gdifont, NULL);
    oldfont = SelectObject(hdc, gdifont);
 
    bounds->X = rect->X;
    bounds->Y = rect->Y;
    bounds->Width = 0.0;
    bounds->Height = 0.0;
 
    args.bounds = bounds;
    args.codepointsfitted = &glyphs;
    args.linesfilled = &lines;
    lines = glyphs = 0;
 
    gdi_transform_acquire(graphics);
 
    gdip_format_string(hdc, string, length, font, &scaled_rect, format, TRUE,
        measure_string_callback, &args);
 
    gdi_transform_release(graphics);
 
    if (linesfilled) *linesfilled = lines;
    if (codepointsfitted) *codepointsfitted = glyphs;
 
    if (lines)
        bounds->Width += margin_x * 2.0;
 
    SelectObject(hdc, oldfont);
    DeleteObject(gdifont);
 
    if (temp_hdc)
        DeleteDC(temp_hdc);
 
    return Ok;
}

Referenced by GdipDrawString(), test_font_height_scaling(), test_font_transform(), test_GdipMeasureString(), test_measure_string(), test_measured_extra_space(), and test_string_functions().

◆ GdipMultiplyLineTransform()

GpStatus WINGDIPAPI GdipMultiplyLineTransform	(	GpLineGradient *	brush,
		GDIPCONST GpMatrix *	matrix,
		GpMatrixOrder	order
	)

Definition at line 2152 of file brush.c.

{
    TRACE("(%p,%p,%u)\n", brush, matrix, order);
 
    if(!brush)
        return InvalidParameter;
 
    if(!matrix)
        return Ok;
 
    return GdipMultiplyMatrix(&brush->transform, matrix, order);
}

Referenced by test_transform().

◆ GdipMultiplyMatrix()

GpStatus WINGDIPAPI GdipMultiplyMatrix	(	GpMatrix *	matrix,
		GDIPCONST GpMatrix *	matrix2,
		GpMatrixOrder	order
	)

Definition at line 240 of file matrix.c.

{
    TRACE("(%p, %p, %d)\n", matrix, matrix2, order);
 
    if(!matrix || !matrix2)
        return InvalidParameter;
 
    if(order == MatrixOrderAppend)
        matrix_multiply(matrix->matrix, matrix2->matrix, matrix->matrix);
    else if (order == MatrixOrderPrepend)
        matrix_multiply(matrix2->matrix, matrix->matrix, matrix->matrix);
    else
        return InvalidParameter;
 
    return Ok;
}

Referenced by GdipBeginContainer(), GdipMultiplyLineTransform(), GdipMultiplyPathGradientTransform(), GdipMultiplyPenTransform(), GdipMultiplyTextureTransform(), GdipMultiplyWorldTransform(), GdipPlayMetafileRecord(), get_graphics_transform(), linegradient_init_transform(), and METAFILE_PlaybackUpdateWorldTransform().

◆ GdipMultiplyPathGradientTransform()

GpStatus WINGDIPAPI GdipMultiplyPathGradientTransform	(	GpPathGradient *	grad,
		GDIPCONST GpMatrix *	matrix,
		GpMatrixOrder	order
	)

Definition at line 1871 of file brush.c.

{
    TRACE("(%p,%p,%i)\n", grad, matrix, order);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipMultiplyMatrix(&grad->transform, matrix, order);
}

◆ GdipMultiplyPenTransform()

GpStatus WINGDIPAPI GdipMultiplyPenTransform	(	GpPen *	pen,
		GDIPCONST GpMatrix *	matrix,
		GpMatrixOrder	order
	)

Definition at line 491 of file pen.c.

{
    TRACE("(%p,%p,%u)\n", pen, matrix, order);
 
    if(!pen)
        return InvalidParameter;
 
    return GdipMultiplyMatrix(&pen->transform, matrix, order);
}

Referenced by test_transform().

◆ GdipMultiplyTextureTransform()

GpStatus WINGDIPAPI GdipMultiplyTextureTransform	(	GpTexture *	brush,
		GDIPCONST GpMatrix *	matrix,
		GpMatrixOrder	order
	)

Definition at line 1331 of file brush.c.

{
    TRACE("(%p, %p, %d)\n", brush, matrix, order);
 
    if(!brush || !matrix)
        return InvalidParameter;
 
    return GdipMultiplyMatrix(&brush->transform, matrix, order);
}

◆ GdipMultiplyWorldTransform()

GpStatus WINGDIPAPI GdipMultiplyWorldTransform	(	GpGraphics *	graphics,
		GDIPCONST GpMatrix *	matrix,
		GpMatrixOrder	order
	)

Definition at line 6649 of file graphics.c.

{
    GpMatrix m;
    GpStatus ret;
 
    TRACE("(%p, %p, %d)\n", graphics, matrix, order);
 
    if(!graphics || !matrix)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile) {
        ret = METAFILE_MultiplyWorldTransform((GpMetafile*)graphics->image, matrix, order);
 
        if (ret != Ok)
            return ret;
    }
 
    m = graphics->worldtrans;
 
    ret = GdipMultiplyMatrix(&m, matrix, order);
    if(ret == Ok)
        graphics->worldtrans = m;
 
    return ret;
}

Referenced by test_Get_Release_DC(), and test_worldtransform().

◆ GdipNewInstalledFontCollection()

GpStatus WINGDIPAPI GdipNewInstalledFontCollection ( GpFontCollection ** fontCollection )

Definition at line 1679 of file font.c.

{
    TRACE("(%p)\n",fontCollection);
 
    if (!fontCollection)
        return InvalidParameter;
 
    if (installedFontCollection.count == 0)
    {
        struct add_font_param param;
        HDC hdc;
        LOGFONTW lfw;
 
        hdc = CreateCompatibleDC(0);
 
        lfw.lfCharSet = DEFAULT_CHARSET;
        lfw.lfFaceName[0] = 0;
        lfw.lfPitchAndFamily = 0;
 
        param.collection = &installedFontCollection;
        param.is_system = TRUE;
        if (!EnumFontFamiliesExW(hdc, &lfw, add_font_proc, (LPARAM)&param, 0))
        {
            free_installed_fonts();
            DeleteDC(hdc);
            return param.stat;
        }
 
        DeleteDC(hdc);
    }
 
    *fontCollection = &installedFontCollection;
 
    return Ok;
}

Referenced by test_GdipGetFontCollectionFamilyCount(), test_GdipGetFontCollectionFamilyList(), and test_installedfonts().

◆ GdipNewPrivateFontCollection()

GpStatus WINGDIPAPI GdipNewPrivateFontCollection ( GpFontCollection ** fontCollection )

Definition at line 1096 of file font.c.

{
    TRACE("%p\n", fontCollection);
 
    if (!fontCollection)
        return InvalidParameter;
 
    *fontCollection = heap_alloc_zero(sizeof(GpFontCollection));
    if (!*fontCollection) return OutOfMemory;
 
    (*fontCollection)->FontFamilies = NULL;
    (*fontCollection)->count = 0;
    (*fontCollection)->allocated = 0;
 
    TRACE("<-- %p\n", *fontCollection);
 
    return Ok;
}

Referenced by test_long_name().

◆ GdipPathIterCopyData()

GpStatus WINGDIPAPI GdipPathIterCopyData	(	GpPathIterator *	iterator,
		INT *	resultCount,
		GpPointF *	points,
		BYTE *	types,
		INT	startIndex,
		INT	endIndex
	)

Definition at line 83 of file pathiterator.c.

{
    TRACE("(%p, %p, %p, %p, %d, %d)\n", iterator, resultCount, points, types,
           startIndex, endIndex);
 
    if(!iterator || !types || !points)
        return InvalidParameter;
 
    if(endIndex > iterator->pathdata.Count - 1 || startIndex < 0 ||
        endIndex < startIndex){
        *resultCount = 0;
        return Ok;
    }
 
    *resultCount = endIndex - startIndex + 1;
 
    memcpy(types, &(iterator->pathdata.Types[startIndex]), *resultCount);
    memcpy(points, &(iterator->pathdata.Points[startIndex]),
        *resultCount * sizeof(PointF));
 
    return Ok;
}

Referenced by GdipPathIterEnumerate().

◆ GdipPathIterEnumerate()

GpStatus WINGDIPAPI GdipPathIterEnumerate	(	GpPathIterator *	iterator,
		INT *	resultCount,
		GpPointF *	points,
		BYTE *	types,
		INT	count
	)

Definition at line 267 of file pathiterator.c.

{
    TRACE("(%p, %p, %p, %p, %d)\n", iterator, resultCount, points, types, count);
 
    if((count < 0) || !resultCount)
        return InvalidParameter;
 
    if(count == 0){
        *resultCount = 0;
        return Ok;
    }
 
    return GdipPathIterCopyData(iterator, resultCount, points, types, 0, count-1);
}

◆ GdipPathIterGetCount()

GpStatus WINGDIPAPI GdipPathIterGetCount	(	GpPathIterator *	iterator,
		INT *	count
	)

Definition at line 255 of file pathiterator.c.

{
    TRACE("(%p, %p)\n", iterator, count);
 
    if(!iterator || !count)
        return InvalidParameter;
 
    *count = iterator->pathdata.Count;
 
    return Ok;
}

◆ GdipPathIterGetSubpathCount()

GpStatus WINGDIPAPI GdipPathIterGetSubpathCount	(	GpPathIterator *	iterator,
		INT *	count
	)

Definition at line 127 of file pathiterator.c.

{
    INT i;
 
    TRACE("(%p, %p)\n", iterator, count);
 
    if(!iterator || !count)
        return InvalidParameter;
 
    *count = 0;
    for(i = 0; i < iterator->pathdata.Count; i++){
        if(iterator->pathdata.Types[i] == PathPointTypeStart)
            (*count)++;
    }
 
    return Ok;
}

Referenced by test_getsubpathcount().

◆ GdipPathIterHasCurve()

GpStatus WINGDIPAPI GdipPathIterHasCurve	(	GpPathIterator *	iterator,
		BOOL *	hasCurve
	)

Definition at line 107 of file pathiterator.c.

{
    INT i;
 
    TRACE("(%p, %p)\n", iterator, hasCurve);
 
    if(!iterator)
        return InvalidParameter;
 
    *hasCurve = FALSE;
 
    for(i = 0; i < iterator->pathdata.Count; i++)
        if((iterator->pathdata.Types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
            *hasCurve = TRUE;
            break;
        }
 
    return Ok;
}

Referenced by test_hascurve().

◆ GdipPathIterIsValid()

GpStatus WINGDIPAPI GdipPathIterIsValid	(	GpPathIterator *	iterator,
		BOOL *	valid
	)

Definition at line 283 of file pathiterator.c.

{
    TRACE("(%p, %p)\n", iterator, valid);
 
    if(!iterator || !valid)
        return InvalidParameter;
 
    *valid = TRUE;
 
    return Ok;
}

Referenced by test_isvalid().

◆ GdipPathIterNextMarker()

GpStatus WINGDIPAPI GdipPathIterNextMarker	(	GpPathIterator *	iterator,
		INT *	resultCount,
		INT *	startIndex,
		INT *	endIndex
	)

Definition at line 145 of file pathiterator.c.

{
    INT i;
 
    TRACE("(%p, %p, %p, %p)\n", iterator, resultCount, startIndex, endIndex);
 
    if(!iterator || !startIndex || !endIndex)
        return InvalidParameter;
 
    *resultCount = 0;
 
    /* first call could start with second point as all subsequent, cause
       path couldn't contain only one */
    for(i = iterator->marker_pos + 1; i < iterator->pathdata.Count; i++){
        if((iterator->pathdata.Types[i] & PathPointTypePathMarker) ||
           (i == iterator->pathdata.Count - 1)){
            *startIndex = iterator->marker_pos;
            if(iterator->marker_pos > 0) (*startIndex)++;
            *endIndex   = iterator->marker_pos = i;
            *resultCount= *endIndex - *startIndex + 1;
            break;
        }
    }
 
    return Ok;
}

Referenced by GdipPathIterNextMarkerPath(), test_isvalid(), and test_nextmarker().

◆ GdipPathIterNextMarkerPath()

GpStatus WINGDIPAPI GdipPathIterNextMarkerPath	(	GpPathIterator *	iterator,
		INT *	result,
		GpPath *	path
	)

Definition at line 173 of file pathiterator.c.

{
    INT start, end;
 
    TRACE("(%p, %p, %p)\n", iterator, result, path);
 
    if(!iterator || !result)
        return InvalidParameter;
 
    GdipPathIterNextMarker(iterator, result, &start, &end);
    /* return path */
    if(((*result) > 0) && path){
        GdipResetPath(path);
 
        if(!lengthen_path(path, *result))
            return OutOfMemory;
 
        memcpy(path->pathdata.Points, &(iterator->pathdata.Points[start]), sizeof(GpPointF)*(*result));
        memcpy(path->pathdata.Types,  &(iterator->pathdata.Types[start]),  sizeof(BYTE)*(*result));
        path->pathdata.Count = *result;
    }
 
    return Ok;
}

Referenced by test_nextmarkerpath().

◆ GdipPathIterNextPathType()

GpStatus WINGDIPAPI GdipPathIterNextPathType	(	GpPathIterator *	iter,
		INT *	result,
		BYTE *	type,
		INT *	start,
		INT *	end
	)

Definition at line 295 of file pathiterator.c.

{
    FIXME("(%p, %p, %p, %p, %p) stub\n", iter, result, type, start, end);
 
    if(!iter || !result || !type || !start || !end)
        return InvalidParameter;
 
    return NotImplemented;
}

Referenced by test_nextpathtype().

◆ GdipPathIterNextSubpath()

GpStatus WINGDIPAPI GdipPathIterNextSubpath	(	GpPathIterator *	iterator,
		INT *	resultCount,
		INT *	startIndex,
		INT *	endIndex,
		BOOL *	isClosed
	)

Definition at line 199 of file pathiterator.c.

{
    INT i, count;
 
    TRACE("(%p, %p, %p, %p, %p)\n", iterator, resultCount, startIndex,
           endIndex, isClosed);
 
    if(!iterator || !startIndex || !endIndex || !isClosed || !resultCount)
        return InvalidParameter;
 
    count = iterator->pathdata.Count;
 
    /* iterator created with NULL path */
    if(count == 0){
        *resultCount = 0;
        return Ok;
    }
 
    if(iterator->subpath_pos == count){
        *startIndex = *endIndex = *resultCount = 0;
        *isClosed = TRUE;
        return Ok;
    }
 
    *startIndex = iterator->subpath_pos;
 
    for(i = iterator->subpath_pos + 1; i < count &&
        !(iterator->pathdata.Types[i] == PathPointTypeStart); i++);
 
    *endIndex = i - 1;
    iterator->subpath_pos = i;
 
    *resultCount = *endIndex - *startIndex + 1;
 
    if(iterator->pathdata.Types[*endIndex] & PathPointTypeCloseSubpath)
        *isClosed = TRUE;
    else
        *isClosed = FALSE;
 
    return Ok;
}

Referenced by GdipPathIterNextSubpathPath(), and test_nextsubpath().

◆ GdipPathIterNextSubpathPath()

GpStatus WINGDIPAPI GdipPathIterNextSubpathPath	(	GpPathIterator *	iter,
		INT *	result,
		GpPath *	path,
		BOOL *	closed
	)

Definition at line 306 of file pathiterator.c.

{
    INT start, end;
 
    TRACE("(%p, %p, %p, %p)\n", iter, result, path, closed);
 
    if(!iter || !result || !closed)
        return InvalidParameter;
 
    GdipPathIterNextSubpath(iter, result, &start, &end, closed);
    /* return path */
    if(((*result) > 0) && path){
        GdipResetPath(path);
 
        if(!lengthen_path(path, *result))
            return OutOfMemory;
 
        memcpy(path->pathdata.Points, &(iter->pathdata.Points[start]), sizeof(GpPointF)*(*result));
        memcpy(path->pathdata.Types,  &(iter->pathdata.Types[start]),  sizeof(BYTE)*(*result));
        path->pathdata.Count = *result;
    }
 
    return Ok;
}

Referenced by test_nextsubpathpath().

◆ GdipPathIterRewind()

GpStatus WINGDIPAPI GdipPathIterRewind ( GpPathIterator * iterator )

Definition at line 241 of file pathiterator.c.

{
    TRACE("(%p)\n", iterator);
 
    if(!iterator)
        return InvalidParameter;
 
    iterator->subpath_pos = 0;
    iterator->marker_pos = 0;
    iterator->pathtype_pos = 0;
 
    return Ok;
}

◆ GdipPlayMetafileRecord()

GpStatus WINGDIPAPI GdipPlayMetafileRecord	(	GDIPCONST GpMetafile *	metafile,
		EmfPlusRecordType	recordType,
		UINT	flags,
		UINT	dataSize,
		GDIPCONST BYTE *	data
	)

Definition at line 2461 of file metafile.c.

{
    GpStatus stat;
    GpMetafile *real_metafile = (GpMetafile*)metafile;
 
    TRACE("(%p,%x,%x,%d,%p)\n", metafile, recordType, flags, dataSize, data);
 
    if (!metafile || (dataSize && !data) || !metafile->playback_graphics)
        return InvalidParameter;
 
    if (recordType >= 1 && recordType <= 0x7a)
    {
        /* regular EMF record */
        if (metafile->playback_dc)
        {
            switch (recordType)
            {
            case EMR_SETMAPMODE:
            case EMR_SAVEDC:
            case EMR_RESTOREDC:
            case EMR_SETWINDOWORGEX:
            case EMR_SETWINDOWEXTEX:
            case EMR_SETVIEWPORTORGEX:
            case EMR_SETVIEWPORTEXTEX:
            case EMR_SCALEVIEWPORTEXTEX:
            case EMR_SCALEWINDOWEXTEX:
            case EMR_MODIFYWORLDTRANSFORM:
                FIXME("not implemented for record type %x\n", recordType);
                break;
            case EMR_SETWORLDTRANSFORM:
            {
                const XFORM* xform = (void*)data;
                real_metafile->gdiworldtransform = *xform;
                METAFILE_PlaybackUpdateGdiTransform(real_metafile);
                break;
            }
            case EMR_EXTSELECTCLIPRGN:
            {
                DWORD rgndatasize = *(DWORD*)data;
                DWORD mode = *(DWORD*)(data + 4);
                const RGNDATA *rgndata = (const RGNDATA*)(data + 8);
                HRGN hrgn = NULL;
 
                if (dataSize > 8)
                {
                    XFORM final;
 
                    METAFILE_GetFinalGdiTransform(metafile, &final);
 
                    hrgn = ExtCreateRegion(&final, rgndatasize, rgndata);
                }
 
                ExtSelectClipRgn(metafile->playback_dc, hrgn, mode);
 
                DeleteObject(hrgn);
 
                return Ok;
            }
            default:
            {
                ENHMETARECORD *record = heap_alloc_zero(dataSize + 8);
 
                if (record)
                {
                    record->iType = recordType;
                    record->nSize = dataSize + 8;
                    memcpy(record->dParm, data, dataSize);
 
                    if(PlayEnhMetaFileRecord(metafile->playback_dc, metafile->handle_table,
                            record, metafile->handle_count) == 0)
                        ERR("PlayEnhMetaFileRecord failed\n");
 
                    heap_free(record);
                }
                else
                    return OutOfMemory;
 
                break;
            }
            }
        }
    }
    else
    {
        EmfPlusRecordHeader *header = (EmfPlusRecordHeader*)(data)-1;
 
        METAFILE_PlaybackReleaseDC((GpMetafile*)metafile);
 
        switch(recordType)
        {
        case EmfPlusRecordTypeHeader:
        case EmfPlusRecordTypeEndOfFile:
            break;
        case EmfPlusRecordTypeGetDC:
            METAFILE_PlaybackGetDC((GpMetafile*)metafile);
            break;
        case EmfPlusRecordTypeClear:
        {
            EmfPlusClear *record = (EmfPlusClear*)header;
 
            if (dataSize != sizeof(record->Color))
                return InvalidParameter;
 
            return GdipGraphicsClear(metafile->playback_graphics, record->Color);
        }
        case EmfPlusRecordTypeFillRects:
        {
            EmfPlusFillRects *record = (EmfPlusFillRects*)header;
            GpBrush *brush, *temp_brush=NULL;
            GpRectF *rects, *temp_rects=NULL;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects))
                return InvalidParameter;
 
            if (flags & 0x4000)
            {
                if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(EmfPlusRect) * record->Count)
                    return InvalidParameter;
            }
            else
            {
                if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusFillRects) + sizeof(GpRectF) * record->Count)
                    return InvalidParameter;
            }
 
            if (flags & 0x8000)
            {
                stat = GdipCreateSolidFill(record->BrushID, (GpSolidFill **)&temp_brush);
                brush = temp_brush;
            }
            else
            {
                if (record->BrushID >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[record->BrushID].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[record->BrushID].u.brush;
                stat = Ok;
            }
 
            if (stat == Ok)
            {
                if (flags & 0x4000)
                {
                    EmfPlusRect *int_rects = (EmfPlusRect*)(record+1);
                    int i;
 
                    rects = temp_rects = heap_alloc_zero(sizeof(GpRectF) * record->Count);
                    if (rects)
                    {
                        for (i=0; i<record->Count; i++)
                        {
                            rects[i].X = int_rects[i].X;
                            rects[i].Y = int_rects[i].Y;
                            rects[i].Width = int_rects[i].Width;
                            rects[i].Height = int_rects[i].Height;
                        }
                    }
                    else
                        stat = OutOfMemory;
                }
                else
                    rects = (GpRectF*)(record+1);
            }
 
            if (stat == Ok)
            {
                stat = GdipFillRectangles(metafile->playback_graphics, brush, rects, record->Count);
            }
 
            GdipDeleteBrush(temp_brush);
            heap_free(temp_rects);
 
            return stat;
        }
        case EmfPlusRecordTypeSetClipRect:
        {
            EmfPlusSetClipRect *record = (EmfPlusSetClipRect*)header;
            CombineMode mode = (CombineMode)((flags >> 8) & 0xf);
            GpRegion *region;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(*record))
                return InvalidParameter;
 
            stat = GdipCreateRegionRect(&record->ClipRect, &region);
 
            if (stat == Ok)
            {
                stat = metafile_set_clip_region(real_metafile, region, mode);
                GdipDeleteRegion(region);
            }
 
            return stat;
        }
        case EmfPlusRecordTypeSetClipRegion:
        {
            CombineMode mode = (flags >> 8) & 0xf;
            BYTE regionid = flags & 0xff;
            GpRegion *region;
 
            if (dataSize != 0)
                return InvalidParameter;
 
            if (regionid >= EmfPlusObjectTableSize || real_metafile->objtable[regionid].type != ObjectTypeRegion)
                return InvalidParameter;
 
            stat = GdipCloneRegion(real_metafile->objtable[regionid].u.region, &region);
            if (stat == Ok)
            {
                stat = metafile_set_clip_region(real_metafile, region, mode);
                GdipDeleteRegion(region);
            }
 
            return stat;
        }
        case EmfPlusRecordTypeSetClipPath:
        {
            CombineMode mode = (flags >> 8) & 0xf;
            BYTE pathid = flags & 0xff;
            GpRegion *region;
 
            if (dataSize != 0)
                return InvalidParameter;
 
            if (pathid >= EmfPlusObjectTableSize || real_metafile->objtable[pathid].type != ObjectTypePath)
                return InvalidParameter;
 
            stat = GdipCreateRegionPath(real_metafile->objtable[pathid].u.path, &region);
            if (stat == Ok)
            {
                stat = metafile_set_clip_region(real_metafile, region, mode);
                GdipDeleteRegion(region);
            }
 
            return stat;
        }
        case EmfPlusRecordTypeSetPageTransform:
        {
            EmfPlusSetPageTransform *record = (EmfPlusSetPageTransform*)header;
            GpUnit unit = (GpUnit)flags;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetPageTransform))
                return InvalidParameter;
 
            real_metafile->page_unit = unit;
            real_metafile->page_scale = record->PageScale;
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeSetWorldTransform:
        {
            EmfPlusSetWorldTransform *record = (EmfPlusSetWorldTransform*)header;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusSetWorldTransform))
                return InvalidParameter;
 
            memcpy(real_metafile->world_transform->matrix, record->MatrixData, sizeof(record->MatrixData));
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeScaleWorldTransform:
        {
            EmfPlusScaleWorldTransform *record = (EmfPlusScaleWorldTransform*)header;
            MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusScaleWorldTransform))
                return InvalidParameter;
 
            GdipScaleMatrix(real_metafile->world_transform, record->Sx, record->Sy, order);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeMultiplyWorldTransform:
        {
            EmfPlusMultiplyWorldTransform *record = (EmfPlusMultiplyWorldTransform*)header;
            MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
            GpMatrix matrix;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusMultiplyWorldTransform))
                return InvalidParameter;
 
            memcpy(matrix.matrix, record->MatrixData, sizeof(matrix.matrix));
 
            GdipMultiplyMatrix(real_metafile->world_transform, &matrix, order);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeRotateWorldTransform:
        {
            EmfPlusRotateWorldTransform *record = (EmfPlusRotateWorldTransform*)header;
            MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusRotateWorldTransform))
                return InvalidParameter;
 
            GdipRotateMatrix(real_metafile->world_transform, record->Angle, order);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeTranslateWorldTransform:
        {
            EmfPlusTranslateWorldTransform *record = (EmfPlusTranslateWorldTransform*)header;
            MatrixOrder order = (flags & 0x2000) ? MatrixOrderAppend : MatrixOrderPrepend;
 
            if (dataSize + sizeof(EmfPlusRecordHeader) < sizeof(EmfPlusTranslateWorldTransform))
                return InvalidParameter;
 
            GdipTranslateMatrix(real_metafile->world_transform, record->dx, record->dy, order);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeResetWorldTransform:
        {
            GdipSetMatrixElements(real_metafile->world_transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeBeginContainer:
        {
            EmfPlusBeginContainer *record = (EmfPlusBeginContainer*)header;
            container* cont;
            GpUnit unit;
            REAL scale_x, scale_y;
            GpRectF scaled_srcrect;
            GpMatrix transform;
 
            cont = heap_alloc_zero(sizeof(*cont));
            if (!cont)
                return OutOfMemory;
 
            stat = GdipCloneRegion(metafile->clip, &cont->clip);
            if (stat != Ok)
            {
                heap_free(cont);
                return stat;
            }
 
            stat = GdipBeginContainer2(metafile->playback_graphics, &cont->state);
 
            if (stat != Ok)
            {
                GdipDeleteRegion(cont->clip);
                heap_free(cont);
                return stat;
            }
 
            cont->id = record->StackIndex;
            cont->type = BEGIN_CONTAINER;
            cont->world_transform = *metafile->world_transform;
            cont->page_unit = metafile->page_unit;
            cont->page_scale = metafile->page_scale;
            list_add_head(&real_metafile->containers, &cont->entry);
 
            unit = record->Header.Flags & 0xff;
 
            scale_x = units_to_pixels(1.0, unit, metafile->image.xres);
            scale_y = units_to_pixels(1.0, unit, metafile->image.yres);
 
            scaled_srcrect.X = scale_x * record->SrcRect.X;
            scaled_srcrect.Y = scale_y * record->SrcRect.Y;
            scaled_srcrect.Width = scale_x * record->SrcRect.Width;
            scaled_srcrect.Height = scale_y * record->SrcRect.Height;
 
            transform.matrix[0] = record->DestRect.Width / scaled_srcrect.Width;
            transform.matrix[1] = 0.0;
            transform.matrix[2] = 0.0;
            transform.matrix[3] = record->DestRect.Height / scaled_srcrect.Height;
            transform.matrix[4] = record->DestRect.X - scaled_srcrect.X;
            transform.matrix[5] = record->DestRect.Y - scaled_srcrect.Y;
 
            GdipMultiplyMatrix(real_metafile->world_transform, &transform, MatrixOrderPrepend);
 
            return METAFILE_PlaybackUpdateWorldTransform(real_metafile);
        }
        case EmfPlusRecordTypeBeginContainerNoParams:
        case EmfPlusRecordTypeSave:
        {
            EmfPlusContainerRecord *record = (EmfPlusContainerRecord*)header;
            container* cont;
 
            cont = heap_alloc_zero(sizeof(*cont));
            if (!cont)
                return OutOfMemory;
 
            stat = GdipCloneRegion(metafile->clip, &cont->clip);
            if (stat != Ok)
            {
                heap_free(cont);
                return stat;
            }
 
            if (recordType == EmfPlusRecordTypeBeginContainerNoParams)
                stat = GdipBeginContainer2(metafile->playback_graphics, &cont->state);
            else
                stat = GdipSaveGraphics(metafile->playback_graphics, &cont->state);
 
            if (stat != Ok)
            {
                GdipDeleteRegion(cont->clip);
                heap_free(cont);
                return stat;
            }
 
            cont->id = record->StackIndex;
            if (recordType == EmfPlusRecordTypeBeginContainerNoParams)
                cont->type = BEGIN_CONTAINER;
            else
                cont->type = SAVE_GRAPHICS;
            cont->world_transform = *metafile->world_transform;
            cont->page_unit = metafile->page_unit;
            cont->page_scale = metafile->page_scale;
            list_add_head(&real_metafile->containers, &cont->entry);
 
            break;
        }
        case EmfPlusRecordTypeEndContainer:
        case EmfPlusRecordTypeRestore:
        {
            EmfPlusContainerRecord *record = (EmfPlusContainerRecord*)header;
            container* cont;
            enum container_type type;
            BOOL found=FALSE;
 
            if (recordType == EmfPlusRecordTypeEndContainer)
                type = BEGIN_CONTAINER;
            else
                type = SAVE_GRAPHICS;
 
            LIST_FOR_EACH_ENTRY(cont, &real_metafile->containers, container, entry)
            {
                if (cont->id == record->StackIndex && cont->type == type)
                {
                    found = TRUE;
                    break;
                }
            }
 
            if (found)
            {
                container* cont2;
 
                /* pop any newer items on the stack */
                while ((cont2 = LIST_ENTRY(list_head(&real_metafile->containers), container, entry)) != cont)
                {
                    list_remove(&cont2->entry);
                    GdipDeleteRegion(cont2->clip);
                    heap_free(cont2);
                }
 
                if (type == BEGIN_CONTAINER)
                    GdipEndContainer(real_metafile->playback_graphics, cont->state);
                else
                    GdipRestoreGraphics(real_metafile->playback_graphics, cont->state);
 
                *real_metafile->world_transform = cont->world_transform;
                real_metafile->page_unit = cont->page_unit;
                real_metafile->page_scale = cont->page_scale;
                GdipCombineRegionRegion(real_metafile->clip, cont->clip, CombineModeReplace);
 
                list_remove(&cont->entry);
                GdipDeleteRegion(cont->clip);
                heap_free(cont);
            }
 
            break;
        }
        case EmfPlusRecordTypeSetPixelOffsetMode:
        {
            return GdipSetPixelOffsetMode(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeSetCompositingQuality:
        {
            return GdipSetCompositingQuality(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeSetInterpolationMode:
        {
            return GdipSetInterpolationMode(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeSetTextRenderingHint:
        {
            return GdipSetTextRenderingHint(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeSetAntiAliasMode:
        {
            return GdipSetSmoothingMode(real_metafile->playback_graphics, (flags >> 1) & 0xff);
        }
        case EmfPlusRecordTypeSetCompositingMode:
        {
            return GdipSetCompositingMode(real_metafile->playback_graphics, flags & 0xff);
        }
        case EmfPlusRecordTypeObject:
        {
            return METAFILE_PlaybackObject(real_metafile, flags, dataSize, data);
        }
        case EmfPlusRecordTypeDrawImage:
        {
            EmfPlusDrawImage *draw = (EmfPlusDrawImage *)header;
            BYTE image = flags & 0xff;
            GpPointF points[3];
 
            if (image >= EmfPlusObjectTableSize || real_metafile->objtable[image].type != ObjectTypeImage)
                return InvalidParameter;
 
            if (dataSize != FIELD_OFFSET(EmfPlusDrawImage, RectData) - sizeof(EmfPlusRecordHeader) +
                    (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (draw->ImageAttributesID >= EmfPlusObjectTableSize ||
                    real_metafile->objtable[draw->ImageAttributesID].type != ObjectTypeImageAttributes)
                return InvalidParameter;
 
            if (flags & 0x4000) /* C */
            {
                points[0].X = draw->RectData.rect.X;
                points[0].Y = draw->RectData.rect.Y;
                points[1].X = points[0].X + draw->RectData.rect.Width;
                points[1].Y = points[0].Y;
                points[2].X = points[1].X;
                points[2].Y = points[1].Y + draw->RectData.rect.Height;
            }
            else
            {
                points[0].X = draw->RectData.rectF.X;
                points[0].Y = draw->RectData.rectF.Y;
                points[1].X = points[0].X + draw->RectData.rectF.Width;
                points[1].Y = points[0].Y;
                points[2].X = points[1].X;
                points[2].Y = points[1].Y + draw->RectData.rectF.Height;
            }
 
            return GdipDrawImagePointsRect(real_metafile->playback_graphics, real_metafile->objtable[image].u.image,
                points, 3, draw->SrcRect.X, draw->SrcRect.Y, draw->SrcRect.Width, draw->SrcRect.Height, draw->SrcUnit,
                real_metafile->objtable[draw->ImageAttributesID].u.image_attributes, NULL, NULL);
        }
        case EmfPlusRecordTypeDrawImagePoints:
        {
            EmfPlusDrawImagePoints *draw = (EmfPlusDrawImagePoints *)header;
            static const UINT fixed_part_size = FIELD_OFFSET(EmfPlusDrawImagePoints, PointData) -
                FIELD_OFFSET(EmfPlusDrawImagePoints, ImageAttributesID);
            BYTE image = flags & 0xff;
            GpPointF points[3];
            unsigned int i;
            UINT size;
 
            if (image >= EmfPlusObjectTableSize || real_metafile->objtable[image].type != ObjectTypeImage)
                return InvalidParameter;
 
            if (dataSize <= fixed_part_size)
                return InvalidParameter;
            dataSize -= fixed_part_size;
 
            if (draw->ImageAttributesID >= EmfPlusObjectTableSize ||
                    real_metafile->objtable[draw->ImageAttributesID].type != ObjectTypeImageAttributes)
                return InvalidParameter;
 
            if (draw->count != 3)
                return InvalidParameter;
 
            if ((flags >> 13) & 1) /* E */
                FIXME("image effects are not supported.\n");
 
            if ((flags >> 11) & 1) /* P */
                size = sizeof(EmfPlusPointR7) * draw->count;
            else if ((flags >> 14) & 1) /* C */
                size = sizeof(EmfPlusPoint) * draw->count;
            else
                size = sizeof(EmfPlusPointF) * draw->count;
 
            if (dataSize != size)
                return InvalidParameter;
 
            if ((flags >> 11) & 1) /* P */
            {
                points[0].X = draw->PointData.pointsR[0].X;
                points[0].Y = draw->PointData.pointsR[0].Y;
                for (i = 1; i < 3; i++)
                {
                    points[i].X = points[i-1].X + draw->PointData.pointsR[i].X;
                    points[i].Y = points[i-1].Y + draw->PointData.pointsR[i].Y;
                }
            }
            else if ((flags >> 14) & 1) /* C */
            {
                for (i = 0; i < 3; i++)
                {
                    points[i].X = draw->PointData.points[i].X;
                    points[i].Y = draw->PointData.points[i].Y;
                }
            }
            else
                memcpy(points, draw->PointData.pointsF, sizeof(points));
 
            return GdipDrawImagePointsRect(real_metafile->playback_graphics, real_metafile->objtable[image].u.image,
                points, 3, draw->SrcRect.X, draw->SrcRect.Y, draw->SrcRect.Width, draw->SrcRect.Height, draw->SrcUnit,
                real_metafile->objtable[draw->ImageAttributesID].u.image_attributes, NULL, NULL);
        }
        case EmfPlusRecordTypeFillPath:
        {
            EmfPlusFillPath *fill = (EmfPlusFillPath *)header;
            GpSolidFill *solidfill = NULL;
            BYTE path = flags & 0xff;
            GpBrush *brush;
 
            if (path >= EmfPlusObjectTableSize || real_metafile->objtable[path].type != ObjectTypePath)
                return InvalidParameter;
 
            if (dataSize != sizeof(fill->data.BrushId))
                return InvalidParameter;
 
            if (flags & 0x8000)
            {
                stat = GdipCreateSolidFill(fill->data.Color, (GpSolidFill **)&solidfill);
                if (stat != Ok)
                    return stat;
                brush = (GpBrush *)solidfill;
            }
            else
            {
                if (fill->data.BrushId >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[fill->data.BrushId].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[fill->data.BrushId].u.brush;
            }
 
            stat = GdipFillPath(real_metafile->playback_graphics, brush, real_metafile->objtable[path].u.path);
            GdipDeleteBrush((GpBrush *)solidfill);
            return stat;
        }
        case EmfPlusRecordTypeFillClosedCurve:
        {
            static const UINT fixed_part_size = FIELD_OFFSET(EmfPlusFillClosedCurve, PointData) -
                sizeof(EmfPlusRecordHeader);
            EmfPlusFillClosedCurve *fill = (EmfPlusFillClosedCurve *)header;
            GpSolidFill *solidfill = NULL;
            GpFillMode mode;
            GpBrush *brush;
            UINT size, i;
 
            if (dataSize <= fixed_part_size)
                return InvalidParameter;
 
            if (fill->Count == 0)
                return InvalidParameter;
 
            if (flags & 0x800) /* P */
                size = (fixed_part_size + sizeof(EmfPlusPointR7) * fill->Count + 3) & ~3;
            else if (flags & 0x4000) /* C */
                size = fixed_part_size + sizeof(EmfPlusPoint) * fill->Count;
            else
                size = fixed_part_size + sizeof(EmfPlusPointF) * fill->Count;
 
            if (dataSize != size)
                return InvalidParameter;
 
            mode = flags & 0x200 ? FillModeWinding : FillModeAlternate; /* W */
 
            if (flags & 0x8000) /* S */
            {
                stat = GdipCreateSolidFill(fill->BrushId, (GpSolidFill **)&solidfill);
                if (stat != Ok)
                    return stat;
                brush = (GpBrush *)solidfill;
            }
            else
            {
                if (fill->BrushId >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[fill->BrushId].u.brush;
            }
 
            if (flags & (0x800 | 0x4000))
            {
                GpPointF *points = GdipAlloc(fill->Count * sizeof(*points));
                if (points)
                {
                    if (flags & 0x800) /* P */
                    {
                        for (i = 1; i < fill->Count; i++)
                        {
                            points[i].X = points[i - 1].X + fill->PointData.pointsR[i].X;
                            points[i].Y = points[i - 1].Y + fill->PointData.pointsR[i].Y;
                        }
                    }
                    else
                    {
                        for (i = 0; i < fill->Count; i++)
                        {
                            points[i].X = fill->PointData.points[i].X;
                            points[i].Y = fill->PointData.points[i].Y;
                        }
                    }
 
                    stat = GdipFillClosedCurve2(real_metafile->playback_graphics, brush,
                        points, fill->Count, fill->Tension, mode);
                    GdipFree(points);
                }
                else
                    stat = OutOfMemory;
            }
            else
                stat = GdipFillClosedCurve2(real_metafile->playback_graphics, brush,
                    (const GpPointF *)fill->PointData.pointsF, fill->Count, fill->Tension, mode);
 
            GdipDeleteBrush((GpBrush *)solidfill);
            return stat;
        }
        case EmfPlusRecordTypeFillEllipse:
        {
            EmfPlusFillEllipse *fill = (EmfPlusFillEllipse *)header;
            GpSolidFill *solidfill = NULL;
            GpBrush *brush;
 
            if (dataSize <= FIELD_OFFSET(EmfPlusFillEllipse, RectData) - sizeof(EmfPlusRecordHeader))
                return InvalidParameter;
            dataSize -= FIELD_OFFSET(EmfPlusFillEllipse, RectData) - sizeof(EmfPlusRecordHeader);
 
            if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x8000)
            {
                stat = GdipCreateSolidFill(fill->BrushId, (GpSolidFill **)&solidfill);
                if (stat != Ok)
                    return stat;
                brush = (GpBrush *)solidfill;
            }
            else
            {
                if (fill->BrushId >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[fill->BrushId].u.brush;
            }
 
            if (flags & 0x4000)
                stat = GdipFillEllipseI(real_metafile->playback_graphics, brush, fill->RectData.rect.X,
                    fill->RectData.rect.Y, fill->RectData.rect.Width, fill->RectData.rect.Height);
            else
                stat = GdipFillEllipse(real_metafile->playback_graphics, brush, fill->RectData.rectF.X,
                    fill->RectData.rectF.Y, fill->RectData.rectF.Width, fill->RectData.rectF.Height);
 
            GdipDeleteBrush((GpBrush *)solidfill);
            return stat;
        }
        case EmfPlusRecordTypeFillPie:
        {
            EmfPlusFillPie *fill = (EmfPlusFillPie *)header;
            GpSolidFill *solidfill = NULL;
            GpBrush *brush;
 
            if (dataSize <= FIELD_OFFSET(EmfPlusFillPie, RectData) - sizeof(EmfPlusRecordHeader))
                return InvalidParameter;
            dataSize -= FIELD_OFFSET(EmfPlusFillPie, RectData) - sizeof(EmfPlusRecordHeader);
 
            if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x8000) /* S */
            {
                stat = GdipCreateSolidFill(fill->BrushId, (GpSolidFill **)&solidfill);
                if (stat != Ok)
                    return stat;
                brush = (GpBrush *)solidfill;
            }
            else
            {
                if (fill->BrushId >= EmfPlusObjectTableSize ||
                        real_metafile->objtable[fill->BrushId].type != ObjectTypeBrush)
                    return InvalidParameter;
 
                brush = real_metafile->objtable[fill->BrushId].u.brush;
            }
 
            if (flags & 0x4000) /* C */
                stat = GdipFillPieI(real_metafile->playback_graphics, brush, fill->RectData.rect.X,
                    fill->RectData.rect.Y, fill->RectData.rect.Width, fill->RectData.rect.Height,
                    fill->StartAngle, fill->SweepAngle);
            else
                stat = GdipFillPie(real_metafile->playback_graphics, brush, fill->RectData.rectF.X,
                    fill->RectData.rectF.Y, fill->RectData.rectF.Width, fill->RectData.rectF.Height,
                    fill->StartAngle, fill->SweepAngle);
 
            GdipDeleteBrush((GpBrush *)solidfill);
            return stat;
        }
        case EmfPlusRecordTypeDrawPath:
        {
            EmfPlusDrawPath *draw = (EmfPlusDrawPath *)header;
            BYTE path = flags & 0xff;
 
            if (dataSize != sizeof(draw->PenId))
                return InvalidParameter;
 
            if (path >= EmfPlusObjectTableSize || draw->PenId >= EmfPlusObjectTableSize)
                return InvalidParameter;
 
            if (real_metafile->objtable[path].type != ObjectTypePath ||
                    real_metafile->objtable[draw->PenId].type != ObjectTypePen)
                return InvalidParameter;
 
            return GdipDrawPath(real_metafile->playback_graphics, real_metafile->objtable[draw->PenId].u.pen,
                real_metafile->objtable[path].u.path);
        }
        case EmfPlusRecordTypeDrawArc:
        {
            EmfPlusDrawArc *draw = (EmfPlusDrawArc *)header;
            BYTE pen = flags & 0xff;
 
            if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
                return InvalidParameter;
 
            if (dataSize != FIELD_OFFSET(EmfPlusDrawArc, RectData) - sizeof(EmfPlusRecordHeader) +
                    (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x4000) /* C */
                return GdipDrawArcI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
                    draw->RectData.rect.Height, draw->StartAngle, draw->SweepAngle);
            else
                return GdipDrawArc(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
                    draw->RectData.rectF.Height, draw->StartAngle, draw->SweepAngle);
        }
        case EmfPlusRecordTypeDrawEllipse:
        {
            EmfPlusDrawEllipse *draw = (EmfPlusDrawEllipse *)header;
            BYTE pen = flags & 0xff;
 
            if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
                return InvalidParameter;
 
            if (dataSize != (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x4000) /* C */
                return GdipDrawEllipseI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
                    draw->RectData.rect.Height);
            else
                return GdipDrawEllipse(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
                    draw->RectData.rectF.Height);
        }
        case EmfPlusRecordTypeDrawPie:
        {
            EmfPlusDrawPie *draw = (EmfPlusDrawPie *)header;
            BYTE pen = flags & 0xff;
 
            if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
                return InvalidParameter;
 
            if (dataSize != FIELD_OFFSET(EmfPlusDrawPie, RectData) - sizeof(EmfPlusRecordHeader) +
                    (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x4000) /* C */
                return GdipDrawPieI(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rect.X, draw->RectData.rect.Y, draw->RectData.rect.Width,
                    draw->RectData.rect.Height, draw->StartAngle, draw->SweepAngle);
            else
                return GdipDrawPie(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    draw->RectData.rectF.X, draw->RectData.rectF.Y, draw->RectData.rectF.Width,
                    draw->RectData.rectF.Height, draw->StartAngle, draw->SweepAngle);
        }
        case EmfPlusRecordTypeDrawRects:
        {
            EmfPlusDrawRects *draw = (EmfPlusDrawRects *)header;
            BYTE pen = flags & 0xff;
            GpRectF *rects = NULL;
 
            if (pen >= EmfPlusObjectTableSize || real_metafile->objtable[pen].type != ObjectTypePen)
                return InvalidParameter;
 
            if (dataSize <= FIELD_OFFSET(EmfPlusDrawRects, RectData) - sizeof(EmfPlusRecordHeader))
                return InvalidParameter;
            dataSize -= FIELD_OFFSET(EmfPlusDrawRects, RectData) - sizeof(EmfPlusRecordHeader);
 
            if (dataSize != draw->Count * (flags & 0x4000 ? sizeof(EmfPlusRect) : sizeof(EmfPlusRectF)))
                return InvalidParameter;
 
            if (flags & 0x4000)
            {
                DWORD i;
 
                rects = GdipAlloc(draw->Count * sizeof(*rects));
                if (!rects)
                    return OutOfMemory;
 
                for (i = 0; i < draw->Count; i++)
                {
                    rects[i].X = draw->RectData.rect[i].X;
                    rects[i].Y = draw->RectData.rect[i].Y;
                    rects[i].Width = draw->RectData.rect[i].Width;
                    rects[i].Height = draw->RectData.rect[i].Height;
                }
            }
 
            stat = GdipDrawRectangles(real_metafile->playback_graphics, real_metafile->objtable[pen].u.pen,
                    rects ? rects : (GpRectF *)draw->RectData.rectF, draw->Count);
            GdipFree(rects);
            return stat;
        }
        default:
            FIXME("Not implemented for record type %x\n", recordType);
            return NotImplemented;
        }
    }
 
    return Ok;
}

Referenced by play_metafile_proc(), and test_gditransform_cb().

◆ GdipPrivateAddFontFile()

GpStatus WINGDIPAPI GdipPrivateAddFontFile	(	GpFontCollection *	collection,
		GDIPCONST WCHAR *	name
	)

Definition at line 1137 of file font.c.

{
    HANDLE file, mapping;
    LARGE_INTEGER size;
    void *mem;
    GpStatus status;
 
    TRACE("%p, %s\n", collection, debugstr_w(name));
 
    if (!collection || !name) return InvalidParameter;
 
    file = CreateFileW(name, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
    if (file == INVALID_HANDLE_VALUE) return InvalidParameter;
 
    if (!GetFileSizeEx(file, &size) || size.u.HighPart)
    {
        CloseHandle(file);
        return InvalidParameter;
    }
 
    mapping = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL);
    CloseHandle(file);
    if (!mapping) return InvalidParameter;
 
    mem = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
    CloseHandle(mapping);
    if (!mem) return InvalidParameter;
 
    /* GdipPrivateAddMemoryFont creates a copy of the memory block */
    status = GdipPrivateAddMemoryFont(collection, mem, size.u.LowPart);
    UnmapViewOfFile(mem);
 
    return status;
}

Referenced by test_long_name().

◆ GdipPrivateAddMemoryFont()

GpStatus WINGDIPAPI GdipPrivateAddMemoryFont	(	GpFontCollection *	fontCollection,
		GDIPCONST void *	memory,
		INT	length
	)

Definition at line 1509 of file font.c.

{
    WCHAR *name;
    DWORD count = 0;
    HANDLE font;
    GpStatus ret = Ok;
    TRACE("%p, %p, %d\n", fontCollection, memory, length);
 
    if (!fontCollection || !memory || !length)
        return InvalidParameter;
 
    name = load_ttf_name_id(memory, length, NAME_ID_FULL_FONT_NAME);
    if (!name)
        return OutOfMemory;
 
    font = AddFontMemResourceEx((void*)memory, length, NULL, &count);
    TRACE("%s: %p/%u\n", debugstr_w(name), font, count);
    if (!font || !count)
        ret = InvalidParameter;
    else
    {
        struct add_font_param param;
        HDC hdc;
        LOGFONTW lfw;
 
        hdc = CreateCompatibleDC(0);
 
        /* Truncate name if necessary, GDI32 can't deal with long names */
        if(lstrlenW(name) > LF_FACESIZE - 1)
            name[LF_FACESIZE - 1] = 0;
 
        lfw.lfCharSet = DEFAULT_CHARSET;
        lstrcpyW(lfw.lfFaceName, name);
        lfw.lfPitchAndFamily = 0;
 
        param.collection = fontCollection;
        param.is_system = FALSE;
        if (!EnumFontFamiliesExW(hdc, &lfw, add_font_proc, (LPARAM)&param, 0))
            ret = param.stat;
 
        DeleteDC(hdc);
    }
    heap_free(name);
    return ret;
}

Referenced by GdipPrivateAddFontFile().

◆ GdipRecordMetafile()

GpStatus WINGDIPAPI GdipRecordMetafile	(	HDC	hdc,
		EmfType	type,
		GDIPCONST GpRectF *	frameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 735 of file metafile.c.

{
    HDC record_dc;
    REAL dpix, dpiy;
    REAL framerect_factor_x, framerect_factor_y;
    RECT rc, *lprc;
    GpStatus stat;
 
    TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 
    if (!hdc || type < EmfTypeEmfOnly || type > EmfTypeEmfPlusDual || !metafile)
        return InvalidParameter;
 
    dpix = (REAL)GetDeviceCaps(hdc, HORZRES) / GetDeviceCaps(hdc, HORZSIZE) * 25.4;
    dpiy = (REAL)GetDeviceCaps(hdc, VERTRES) / GetDeviceCaps(hdc, VERTSIZE) * 25.4;
 
    if (frameRect)
    {
        switch (frameUnit)
        {
        case MetafileFrameUnitPixel:
            framerect_factor_x = 2540.0 / dpix;
            framerect_factor_y = 2540.0 / dpiy;
            break;
        case MetafileFrameUnitPoint:
            framerect_factor_x = framerect_factor_y = 2540.0 / 72.0;
            break;
        case MetafileFrameUnitInch:
            framerect_factor_x = framerect_factor_y = 2540.0;
            break;
        case MetafileFrameUnitDocument:
            framerect_factor_x = framerect_factor_y = 2540.0 / 300.0;
            break;
        case MetafileFrameUnitMillimeter:
            framerect_factor_x = framerect_factor_y = 100.0;
            break;
        case MetafileFrameUnitGdi:
            framerect_factor_x = framerect_factor_y = 1.0;
            break;
        default:
            return InvalidParameter;
        }
 
        rc.left = framerect_factor_x * frameRect->X;
        rc.top = framerect_factor_y * frameRect->Y;
        rc.right = rc.left + framerect_factor_x * frameRect->Width;
        rc.bottom = rc.top + framerect_factor_y * frameRect->Height;
 
        lprc = &rc;
    }
    else
        lprc = NULL;
 
    record_dc = CreateEnhMetaFileW(hdc, NULL, lprc, desc);
 
    if (!record_dc)
        return GenericError;
 
    *metafile = heap_alloc_zero(sizeof(GpMetafile));
    if(!*metafile)
    {
        DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
        return OutOfMemory;
    }
 
    (*metafile)->image.type = ImageTypeMetafile;
    (*metafile)->image.flags   = ImageFlagsNone;
    (*metafile)->image.palette = NULL;
    (*metafile)->image.xres = dpix;
    (*metafile)->image.yres = dpiy;
    (*metafile)->bounds.X = (*metafile)->bounds.Y = 0.0;
    (*metafile)->bounds.Width = (*metafile)->bounds.Height = 1.0;
    (*metafile)->unit = UnitPixel;
    (*metafile)->metafile_type = type;
    (*metafile)->record_dc = record_dc;
    (*metafile)->comment_data = NULL;
    (*metafile)->comment_data_size = 0;
    (*metafile)->comment_data_length = 0;
    (*metafile)->hemf = NULL;
    list_init(&(*metafile)->containers);
 
    if (!frameRect)
    {
        (*metafile)->auto_frame = TRUE;
        (*metafile)->auto_frame_min.X = 0;
        (*metafile)->auto_frame_min.Y = 0;
        (*metafile)->auto_frame_max.X = -1;
        (*metafile)->auto_frame_max.Y = -1;
    }
 
    stat = METAFILE_WriteHeader(*metafile, hdc);
 
    if (stat != Ok)
    {
        DeleteEnhMetaFile(CloseEnhMetaFile(record_dc));
        heap_free(*metafile);
        *metafile = NULL;
        return OutOfMemory;
    }
 
    return stat;
}

Referenced by GdipRecordMetafileI(), GdipRecordMetafileStream(), test_clear(), test_clipping(), test_containers(), test_converttoemfplus(), test_drawimage(), test_drawpath(), test_emfonly(), test_empty(), test_fillpath(), test_fillrect(), test_frameunit(), test_gditransform(), test_getdc(), test_nullframerect(), test_pagetransform(), test_properties(), and test_worldtransform().

◆ GdipRecordMetafileFileName()

GpStatus WINGDIPAPI GdipRecordMetafileFileName	(	GDIPCONST WCHAR *	fileName,
		HDC	hdc,
		EmfType	type,
		GDIPCONST GpRectF *	pFrameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 3993 of file metafile.c.

{
    FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
                                 frameUnit, debugstr_w(desc), metafile);
 
    return NotImplemented;
}

◆ GdipRecordMetafileFileNameI()

GpStatus WINGDIPAPI GdipRecordMetafileFileNameI	(	GDIPCONST WCHAR *	fileName,
		HDC	hdc,
		EmfType	type,
		GDIPCONST GpRect *	pFrameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 4004 of file metafile.c.

{
    FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
                                 frameUnit, debugstr_w(desc), metafile);
 
    return NotImplemented;
}

◆ GdipRecordMetafileI()

GpStatus WINGDIPAPI GdipRecordMetafileI	(	HDC	hdc,
		EmfType	type,
		GDIPCONST GpRect *	frameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 842 of file metafile.c.

{
    GpRectF frameRectF, *pFrameRectF;
 
    TRACE("(%p %d %p %d %p %p)\n", hdc, type, frameRect, frameUnit, desc, metafile);
 
    if (frameRect)
    {
        frameRectF.X = frameRect->X;
        frameRectF.Y = frameRect->Y;
        frameRectF.Width = frameRect->Width;
        frameRectF.Height = frameRect->Height;
        pFrameRectF = &frameRectF;
    }
    else
        pFrameRectF = NULL;
 
    return GdipRecordMetafile(hdc, type, pFrameRectF, frameUnit, desc, metafile);
}

◆ GdipRecordMetafileStream()

GpStatus WINGDIPAPI GdipRecordMetafileStream	(	IStream *	stream,
		HDC	hdc,
		EmfType	type,
		GDIPCONST GpRectF *	frameRect,
		MetafileFrameUnit	frameUnit,
		GDIPCONST WCHAR *	desc,
		GpMetafile **	metafile
	)

Definition at line 863 of file metafile.c.

{
    GpStatus stat;
 
    TRACE("(%p %p %d %p %d %p %p)\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
 
    if (!stream)
        return InvalidParameter;
 
    stat = GdipRecordMetafile(hdc, type, frameRect, frameUnit, desc, metafile);
 
    if (stat == Ok)
    {
        (*metafile)->record_stream = stream;
        IStream_AddRef(stream);
    }
 
    return stat;
}

◆ GdipReleaseDC()

GpStatus WINGDIPAPI GdipReleaseDC	(	GpGraphics *	graphics,
		HDC	hdc
	)

Definition at line 6758 of file graphics.c.

{
    GpStatus stat=Ok;
 
    TRACE("(%p, %p)\n", graphics, hdc);
 
    if(!graphics || !hdc || !graphics->busy)
        return InvalidParameter;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        stat = METAFILE_ReleaseDC((GpMetafile*)graphics->image, hdc);
    }
    else if (graphics->temp_hdc == hdc)
    {
        DWORD* pos;
        int i;
 
        /* Find the pixels that have changed, and mark them as opaque. */
        pos = (DWORD*)graphics->temp_bits;
        for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
        {
            if (*pos != DC_BACKGROUND_KEY)
            {
                *pos |= 0xff000000;
            }
            pos++;
        }
 
        /* Write the changed pixels to the real target. */
        alpha_blend_pixels(graphics, 0, 0, graphics->temp_bits,
            graphics->temp_hbitmap_width, graphics->temp_hbitmap_height,
            graphics->temp_hbitmap_width * 4, PixelFormat32bppARGB);
 
        /* Clean up. */
        DeleteDC(graphics->temp_hdc);
        DeleteObject(graphics->temp_hbitmap);
        graphics->temp_hdc = NULL;
        graphics->temp_hbitmap = NULL;
    }
    else if (hdc != graphics->hdc)
    {
        stat = InvalidParameter;
    }
 
    if (stat == Ok)
        graphics->busy = FALSE;
 
    return stat;
}

Referenced by METAFILE_PlaybackReleaseDC(), test_alpha_hdc(), test_emfonly(), test_fromMemoryBitmap(), test_gditransform(), test_Get_Release_DC(), test_getdc(), test_getdc_scaled(), and test_nullframerect().

◆ GdipRemovePropertyItem()

GpStatus WINGDIPAPI GdipRemovePropertyItem	(	GpImage *	image,
		PROPID	propId
	)

Definition at line 4447 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%u)\n", image, propId);
 
    if(!image)
        return InvalidParameter;
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipResetClip()

GpStatus WINGDIPAPI GdipResetClip ( GpGraphics * graphics )

Definition at line 5827 of file graphics.c.

{
    TRACE("(%p)\n", graphics);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    return GdipSetInfinite(graphics->clip);
}

Referenced by test_clip_xform(), test_GdipGetVisibleClipBounds_window(), test_Get_Release_DC(), and test_get_set_clip().

◆ GdipResetImageAttributes()

GpStatus WINGDIPAPI GdipResetImageAttributes	(	GpImageAttributes *	imageAttr,
		ColorAdjustType	type
	)

Definition at line 323 of file imageattributes.c.

{
    TRACE("(%p,%u)\n", imageAttr, type);
 
    if(!imageAttr || type >= ColorAdjustTypeCount)
        return InvalidParameter;
 
    memset(&imageAttr->colormatrices[type], 0, sizeof(imageAttr->colormatrices[type]));
    GdipSetImageAttributesColorKeys(imageAttr, type, FALSE, 0, 0);
    GdipSetImageAttributesRemapTable(imageAttr, type, FALSE, 0, NULL);
    GdipSetImageAttributesGamma(imageAttr, type, FALSE, 0.0);
    imageAttr->noop[type] = IMAGEATTR_NOOP_UNDEFINED;
 
    return Ok;
}

Referenced by test_colorkey(), test_colormatrix(), test_gamma(), and test_remaptable().

◆ GdipResetLineTransform()

GpStatus WINGDIPAPI GdipResetLineTransform ( GpLineGradient * brush )

Definition at line 2106 of file brush.c.

{
    TRACE("(%p)\n", brush);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipSetMatrixElements(&brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
}

Referenced by test_transform().

◆ GdipResetPath()

GpStatus WINGDIPAPI GdipResetPath ( GpPath * path )

Definition at line 1756 of file graphicspath.c.

{
    TRACE("(%p)\n", path);
 
    if(!path)
        return InvalidParameter;
 
    path->pathdata.Count = 0;
    path->newfigure = TRUE;
    path->fill = FillModeAlternate;
 
    return Ok;
}

Referenced by GdipPathIterNextMarkerPath(), GdipPathIterNextSubpathPath(), test_addcurve(), test_addpie(), test_flatten(), test_GdipFillPath(), test_transform(), test_translate(), and test_widen().

◆ GdipResetPathGradientTransform()

GpStatus WINGDIPAPI GdipResetPathGradientTransform ( GpPathGradient * grad )

Definition at line 1882 of file brush.c.

{
    TRACE("(%p)\n", grad);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipSetMatrixElements(&grad->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
}

◆ GdipResetPenTransform()

GpStatus WINGDIPAPI GdipResetPenTransform ( GpPen * pen )

Definition at line 420 of file pen.c.

{
    TRACE("(%p)\n", pen);
 
    if(!pen)
        return InvalidParameter;
 
    GdipSetMatrixElements(&pen->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 
    return Ok;
}

Referenced by test_transform().

◆ GdipResetTextureTransform()

GpStatus WINGDIPAPI GdipResetTextureTransform ( GpTexture * brush )

Definition at line 1345 of file brush.c.

{
    TRACE("(%p)\n", brush);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipSetMatrixElements(&brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
}

Referenced by test_transform().

◆ GdipResetWorldTransform()

GpStatus WINGDIPAPI GdipResetWorldTransform ( GpGraphics * graphics )

Definition at line 5840 of file graphics.c.

{
    GpStatus stat;
 
    TRACE("(%p)\n", graphics);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile) {
        stat = METAFILE_ResetWorldTransform((GpMetafile*)graphics->image);
 
        if (stat != Ok)
            return stat;
    }
 
    return GdipSetMatrixElements(&graphics->worldtrans, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), test_clip_xform(), test_container_rects(), test_Get_Release_DC(), and test_worldtransform().

◆ GdipRestoreGraphics()

GpStatus WINGDIPAPI GdipRestoreGraphics	(	GpGraphics *	graphics,
		GraphicsState	state
	)

Definition at line 6045 of file graphics.c.

{
    TRACE("(%p, %x)\n", graphics, state);
    return end_container(graphics, SAVE_GRAPHICS, state);
}

Referenced by GdipPlayMetafileRecord(), test_clipping(), test_containers(), and test_save_restore().

◆ GdipReversePath()

GpStatus WINGDIPAPI GdipReversePath ( GpPath * path )

Definition at line 1596 of file graphicspath.c.

{
    INT i, count;
    INT start = 0; /* position in reversed path */
    GpPathData revpath;
 
    TRACE("(%p)\n", path);
 
    if(!path)
        return InvalidParameter;
 
    count = path->pathdata.Count;
 
    if(count == 0) return Ok;
 
    revpath.Points = heap_alloc_zero(sizeof(GpPointF)*count);
    revpath.Types  = heap_alloc_zero(sizeof(BYTE)*count);
    revpath.Count  = count;
    if(!revpath.Points || !revpath.Types){
        heap_free(revpath.Points);
        heap_free(revpath.Types);
        return OutOfMemory;
    }
 
    for(i = 0; i < count; i++){
 
        /* find next start point */
        if(path->pathdata.Types[count-i-1] == PathPointTypeStart){
            INT j;
            for(j = start; j <= i; j++){
                revpath.Points[j] = path->pathdata.Points[count-j-1];
                revpath.Types[j] = path->pathdata.Types[count-j-1];
            }
            /* mark start point */
            revpath.Types[start] = PathPointTypeStart;
            /* set 'figure' endpoint type */
            if(i-start > 1){
                revpath.Types[i] = path->pathdata.Types[count-start-1] & ~PathPointTypePathTypeMask;
                revpath.Types[i] |= revpath.Types[i-1];
            }
            else
                revpath.Types[i] = path->pathdata.Types[start];
 
            start = i+1;
        }
    }
 
    memcpy(path->pathdata.Points, revpath.Points, sizeof(GpPointF)*count);
    memcpy(path->pathdata.Types,  revpath.Types,  sizeof(BYTE)*count);
 
    heap_free(revpath.Points);
    heap_free(revpath.Types);
 
    return Ok;
}

Referenced by test_reverse().

◆ GdipRotateLineTransform()

GpStatus WINGDIPAPI GdipRotateLineTransform	(	GpLineGradient *	brush,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 2225 of file brush.c.

{
    static int calls;
 
    TRACE("(%p,%0.2f,%u)\n", brush, angle, order);
 
    if(!brush || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    if(!(calls++))
        FIXME("(%p, %.2f, %d) stub\n", brush, angle, order);
 
    return NotImplemented;
}

◆ GdipRotateMatrix()

GpStatus WINGDIPAPI GdipRotateMatrix	(	GpMatrix *	matrix,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 258 of file matrix.c.

{
    REAL cos_theta, sin_theta, rotate[6];
 
    TRACE("(%p, %.2f, %d)\n", matrix, angle, order);
 
    if(!matrix)
        return InvalidParameter;
 
    angle = deg2rad(angle);
    cos_theta = cos(angle);
    sin_theta = sin(angle);
 
    rotate[0] = cos_theta;
    rotate[1] = sin_theta;
    rotate[2] = -sin_theta;
    rotate[3] = cos_theta;
    rotate[4] = 0.0;
    rotate[5] = 0.0;
 
    if(order == MatrixOrderAppend)
        matrix_multiply(matrix->matrix, rotate, matrix->matrix);
    else if (order == MatrixOrderPrepend)
        matrix_multiply(rotate, matrix->matrix, matrix->matrix);
    else
        return InvalidParameter;
 
    return Ok;
}

Referenced by draw_cap(), GdipPlayMetafileRecord(), GdipRotatePathGradientTransform(), GdipRotatePenTransform(), GdipRotateTextureTransform(), GdipRotateWorldTransform(), test_clipping(), test_clipping_2(), test_font_transform(), and test_transform().

◆ GdipRotatePathGradientTransform()

GpStatus WINGDIPAPI GdipRotatePathGradientTransform	(	GpPathGradient *	grad,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 1892 of file brush.c.

{
    TRACE("(%p,%0.2f,%i)\n", grad, angle, order);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipRotateMatrix(&grad->transform, angle, order);
}

◆ GdipRotatePenTransform()

GpStatus WINGDIPAPI GdipRotatePenTransform	(	GpPen *	pen,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 481 of file pen.c.

{
    TRACE("(%p,%0.2f,%u)\n", pen, angle, order);
 
    if(!pen)
        return InvalidParameter;
 
    return GdipRotateMatrix(&pen->transform, angle, order);
}

Referenced by test_transform().

◆ GdipRotateTextureTransform()

GpStatus WINGDIPAPI GdipRotateTextureTransform	(	GpTexture *	brush,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 1999 of file brush.c.

{
    TRACE("(%p, %.2f, %d)\n", brush, angle, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipRotateMatrix(&brush->transform, angle, order);
}

◆ GdipRotateWorldTransform()

GpStatus WINGDIPAPI GdipRotateWorldTransform	(	GpGraphics *	graphics,
		REAL	angle,
		GpMatrixOrder	order
	)

Definition at line 5862 of file graphics.c.

{
    GpStatus stat;
 
    TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile) {
        stat = METAFILE_RotateWorldTransform((GpMetafile*)graphics->image, angle, order);
 
        if (stat != Ok)
            return stat;
    }
 
    return GdipRotateMatrix(&graphics->worldtrans, angle, order);
}

Referenced by test_Get_Release_DC(), and test_worldtransform().

◆ GdipSaveAdd()

GpStatus WINGDIPAPI GdipSaveAdd	(	GpImage *	image,
		GDIPCONST EncoderParameters *	params
	)

Definition at line 4701 of file image.c.

{
    FIXME("(%p,%p): stub\n", image, params);
    return Ok;
}

◆ GdipSaveGraphics()

GpStatus WINGDIPAPI GdipSaveGraphics	(	GpGraphics *	graphics,
		GraphicsState *	state
	)

Definition at line 5911 of file graphics.c.

{
    TRACE("(%p, %p)\n", graphics, state);
    return begin_container(graphics, SAVE_GRAPHICS, state);
}

Referenced by GdipPlayMetafileRecord(), test_clipping(), test_containers(), and test_save_restore().

◆ GdipSaveImageToFile()

GpStatus WINGDIPAPI GdipSaveImageToFile	(	GpImage *	image,
		GDIPCONST WCHAR *	filename,
		GDIPCONST CLSID *	clsidEncoder,
		GDIPCONST EncoderParameters *	encoderParams
	)

Definition at line 4476 of file image.c.

{
    GpStatus stat;
    IStream *stream;
 
    TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
 
    if (!image || !filename|| !clsidEncoder)
        return InvalidParameter;
 
    stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
    if (stat != Ok)
        return GenericError;
 
    stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
 
    IStream_Release(stream);
    return stat;
}

Referenced by Preview_pSaveImage(), Preview_pSaveImageAs(), SetWallpaper(), and test_SavingImages().

◆ GdipSaveImageToStream()

GpStatus WINGDIPAPI GdipSaveImageToStream	(	GpImage *	image,
		IStream *	stream,
		GDIPCONST CLSID *	clsid,
		GDIPCONST EncoderParameters *	params
	)

Definition at line 4671 of file image.c.

{
    GpStatus stat;
    encode_image_func encode_image;
    int i;
 
    TRACE("%p, %p, %s, %p\n", image, stream, wine_dbgstr_guid(clsid), params);
 
    if(!image || !stream)
        return InvalidParameter;
 
    /* select correct encoder */
    encode_image = NULL;
    for (i = 0; i < NUM_CODECS; i++) {
        if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
            IsEqualCLSID(clsid, &codecs[i].info.Clsid))
            encode_image = codecs[i].encode_func;
    }
    if (encode_image == NULL)
        return UnknownImageFormat;
 
    stat = encode_image(image, stream, params);
 
    return stat;
}

Referenced by GdipSaveImageToFile(), and test_supported_encoders().

◆ GdipScaleLineTransform()

GpStatus WINGDIPAPI GdipScaleLineTransform	(	GpLineGradient *	brush,
		REAL	sx,
		REAL	sy,
		GpMatrixOrder	order
	)

Definition at line 2141 of file brush.c.

{
    TRACE("(%p,%0.2f,%0.2f,%u)\n", brush, sx, sy, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipScaleMatrix(&brush->transform, sx, sy, order);
}

Referenced by test_transform().

◆ GdipScaleMatrix()

GpStatus WINGDIPAPI GdipScaleMatrix	(	GpMatrix *	matrix,
		REAL	scaleX,
		REAL	scaleY,
		GpMatrixOrder	order
	)

Definition at line 289 of file matrix.c.

{
    REAL scale[6];
 
    TRACE("(%p, %.2f, %.2f, %d)\n", matrix, scaleX, scaleY, order);
 
    if(!matrix)
        return InvalidParameter;
 
    scale[0] = scaleX;
    scale[1] = 0.0;
    scale[2] = 0.0;
    scale[3] = scaleY;
    scale[4] = 0.0;
    scale[5] = 0.0;
 
    if(order == MatrixOrderAppend)
        matrix_multiply(matrix->matrix, scale, matrix->matrix);
    else if (order == MatrixOrderPrepend)
        matrix_multiply(scale, matrix->matrix, matrix->matrix);
    else
        return InvalidParameter;
 
    return Ok;
}

Referenced by draw_cap(), GdipGetLogFontW(), GdipPlayMetafileRecord(), GdipScaleLineTransform(), GdipScalePathGradientTransform(), GdipScalePenTransform(), GdipScaleTextureTransform(), GdipScaleWorldTransform(), get_graphics_transform(), linegradient_init_transform(), METAFILE_PlaybackUpdateWorldTransform(), test_clipping(), test_clipping_2(), test_font_transform(), test_transform(), and test_widen().

◆ GdipScalePathGradientTransform()

GpStatus WINGDIPAPI GdipScalePathGradientTransform	(	GpPathGradient *	grad,
		REAL	sx,
		REAL	sy,
		GpMatrixOrder	order
	)

Definition at line 1903 of file brush.c.

{
    TRACE("(%p,%0.2f,%0.2f,%i)\n", grad, sx, sy, order);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipScaleMatrix(&grad->transform, sx, sy, order);
}

◆ GdipScalePenTransform()

GpStatus WINGDIPAPI GdipScalePenTransform	(	GpPen *	pen,
		REAL	sx,
		REAL	sy,
		GpMatrixOrder	order
	)

Definition at line 471 of file pen.c.

{
    TRACE("(%p,%0.2f,%0.2f,%u)\n", pen, sx, sy, order);
 
    if(!pen)
        return InvalidParameter;
 
    return GdipScaleMatrix(&pen->transform, sx, sy, order);
}

Referenced by test_transform().

◆ GdipScaleTextureTransform()

GpStatus WINGDIPAPI GdipScaleTextureTransform	(	GpTexture *	brush,
		REAL	sx,
		REAL	sy,
		GpMatrixOrder	order
	)

Definition at line 1358 of file brush.c.

{
    TRACE("(%p, %.2f, %.2f, %d)\n", brush, sx, sy, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipScaleMatrix(&brush->transform, sx, sy, order);
}

◆ GdipScaleWorldTransform()

GpStatus WINGDIPAPI GdipScaleWorldTransform	(	GpGraphics *	graphics,
		REAL	sx,
		REAL	sy,
		GpMatrixOrder	order
	)

Definition at line 6051 of file graphics.c.

{
    GpStatus stat;
 
    TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile) {
        stat = METAFILE_ScaleWorldTransform((GpMetafile*)graphics->image, sx, sy, order);
 
        if (stat != Ok)
            return stat;
    }
 
    return GdipScaleMatrix(&graphics->worldtrans, sx, sy, order);
}

Referenced by test_clip_xform(), test_container_rects(), test_containers(), test_font_height_scaling(), test_GdipGetVisibleClipBounds_window(), test_Get_Release_DC(), test_getbounds(), test_getdc_scaled(), test_gethrgn(), and test_worldtransform().

◆ GdipSetAdjustableArrowCapFillState()

GpStatus WINGDIPAPI GdipSetAdjustableArrowCapFillState	(	GpAdjustableArrowCap *	cap,
		BOOL	fill
	)

Definition at line 408 of file customlinecap.c.

{
    TRACE("(%p,%i)\n", cap, fill);
 
    if (!cap)
        return InvalidParameter;
 
    cap->cap.fill = fill;
    arrowcap_update_path(cap);
    return Ok;
}

◆ GdipSetAdjustableArrowCapHeight()

GpStatus WINGDIPAPI GdipSetAdjustableArrowCapHeight	(	GpAdjustableArrowCap *	cap,
		REAL	height
	)

Definition at line 420 of file customlinecap.c.

{
    TRACE("(%p,%0.2f)\n", cap, height);
 
    if (!cap)
        return InvalidParameter;
 
    cap->height = height;
    arrowcap_update_path(cap);
    return Ok;
}

Referenced by test_create_adjustable_cap().

◆ GdipSetAdjustableArrowCapMiddleInset()

GpStatus WINGDIPAPI GdipSetAdjustableArrowCapMiddleInset	(	GpAdjustableArrowCap *	cap,
		REAL	middle
	)

Definition at line 432 of file customlinecap.c.

{
    TRACE("(%p,%0.2f)\n", cap, middle);
 
    if (!cap)
        return InvalidParameter;
 
    cap->middle_inset = middle;
    arrowcap_update_path(cap);
    return Ok;
}

Referenced by test_create_adjustable_cap().

◆ GdipSetAdjustableArrowCapWidth()

GpStatus WINGDIPAPI GdipSetAdjustableArrowCapWidth	(	GpAdjustableArrowCap *	cap,
		REAL	width
	)

Definition at line 444 of file customlinecap.c.

{
    TRACE("(%p,%0.2f)\n", cap, width);
 
    if (!cap)
        return InvalidParameter;
 
    cap->width = width;
    arrowcap_update_path(cap);
    return Ok;
}

◆ GdipSetClipGraphics()

GpStatus WINGDIPAPI GdipSetClipGraphics	(	GpGraphics *	graphics,
		GpGraphics *	srcgraphics,
		CombineMode	mode
	)

Definition at line 6074 of file graphics.c.

{
    TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
 
    if(!graphics || !srcgraphics)
        return InvalidParameter;
 
    return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
}

◆ GdipSetClipHrgn()

GpStatus WINGDIPAPI GdipSetClipHrgn	(	GpGraphics *	graphics,
		HRGN	hrgn,
		CombineMode	mode
	)

Definition at line 6412 of file graphics.c.

{
    GpRegion *region;
    GpStatus status;
    GpMatrix transform;
 
    TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    /* hrgn is in gdi32 device units */
    status = GdipCreateRegionHrgn(hrgn, &region);
 
    if (status == Ok)
    {
        status = get_graphics_transform(graphics, CoordinateSpaceDevice, WineCoordinateSpaceGdiDevice, &transform);
 
        if (status == Ok)
            status = GdipTransformRegion(region, &transform);
 
        if (status == Ok)
            status = GdipCombineRegionRegion(graphics->clip, region, mode);
 
        GdipDeleteRegion(region);
    }
    return status;
}

Referenced by test_cliphrgn_transform(), and test_Get_Release_DC().

◆ GdipSetClipPath()

GpStatus WINGDIPAPI GdipSetClipPath	(	GpGraphics *	graphics,
		GpPath *	path,
		CombineMode	mode
	)

Definition at line 6444 of file graphics.c.

{
    GpStatus status;
    GpPath *clip_path;
 
    TRACE("(%p, %p, %d)\n", graphics, path, mode);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    status = GdipClonePath(path, &clip_path);
    if (status == Ok)
    {
        GpMatrix world_to_device;
 
        get_graphics_transform(graphics, CoordinateSpaceDevice,
                               CoordinateSpaceWorld, &world_to_device);
        status = GdipTransformPath(clip_path, &world_to_device);
        if (status == Ok)
            GdipCombineRegionPath(graphics->clip, clip_path, mode);
 
        GdipDeletePath(clip_path);
    }
    return status;
}

Referenced by test_Get_Release_DC(), and test_get_set_clip().

◆ GdipSetClipRect()

GpStatus WINGDIPAPI GdipSetClipRect	(	GpGraphics *	graphics,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		CombineMode	mode
	)

Definition at line 6473 of file graphics.c.

{
    GpStatus status;
    GpRectF rect;
    GpRegion *region;
 
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        status = METAFILE_SetClipRect((GpMetafile*)graphics->image, x, y, width, height, mode);
        if (status != Ok)
            return status;
    }
 
    rect.X = x;
    rect.Y = y;
    rect.Width  = width;
    rect.Height = height;
    status = GdipCreateRegionRect(&rect, &region);
    if (status == Ok)
    {
        GpMatrix world_to_device;
        BOOL identity;
 
        get_graphics_transform(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &world_to_device);
        status = GdipIsMatrixIdentity(&world_to_device, &identity);
        if (status == Ok && !identity)
            status = GdipTransformRegion(region, &world_to_device);
        if (status == Ok)
            status = GdipCombineRegionRegion(graphics->clip, region, mode);
 
        GdipDeleteRegion(region);
    }
    return status;
}

Referenced by GdipSetClipRectI(), test_BeginContainer2(), test_clip_xform(), test_clipping(), test_GdipGetVisibleClipBounds_screen(), test_GdipGetVisibleClipBounds_window(), test_GdipIsVisiblePoint(), test_GdipIsVisibleRect(), test_Get_Release_DC(), and test_isvisible().

◆ GdipSetClipRectI()

GpStatus WINGDIPAPI GdipSetClipRectI	(	GpGraphics *	graphics,
		INT	x,
		INT	y,
		INT	width,
		INT	height,
		CombineMode	mode
	)

Definition at line 6518 of file graphics.c.

{
    TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
}

Referenced by test_GdipFillRectanglesOnBitmapTextureBrush(), test_GdipFillRectanglesOnMemoryDCSolidBrush(), test_GdipFillRectanglesOnMemoryDCTextureBrush(), test_GdipGetVisibleClipBounds_memoryDC(), and test_Get_Release_DC().

◆ GdipSetClipRegion()

GpStatus WINGDIPAPI GdipSetClipRegion	(	GpGraphics *	graphics,
		GpRegion *	region,
		CombineMode	mode
	)

Definition at line 6533 of file graphics.c.

{
    GpStatus status;
    GpRegion *clip;
 
    TRACE("(%p, %p, %d)\n", graphics, region, mode);
 
    if(!graphics || !region)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        status = METAFILE_SetClipRegion((GpMetafile*)graphics->image, region, mode);
        if (status != Ok)
            return status;
    }
 
    status = GdipCloneRegion(region, &clip);
    if (status == Ok)
    {
        GpMatrix world_to_device;
        BOOL identity;
 
        get_graphics_transform(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &world_to_device);
        status = GdipIsMatrixIdentity(&world_to_device, &identity);
        if (status == Ok && !identity)
            status = GdipTransformRegion(clip, &world_to_device);
        if (status == Ok)
            status = GdipCombineRegionRegion(graphics->clip, clip, mode);
 
        GdipDeleteRegion(clip);
    }
    return status;
}

Referenced by test_clipping(), test_clipping_2(), test_Get_Release_DC(), and test_get_set_clip().

◆ GdipSetCompositingMode()

GpStatus WINGDIPAPI GdipSetCompositingMode	(	GpGraphics *	graphics,
		CompositingMode	mode
	)

Definition at line 6085 of file graphics.c.

{
    TRACE("(%p, %d)\n", graphics, mode);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if(graphics->compmode == mode)
        return Ok;
 
    if(graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        GpStatus stat;
 
        stat = METAFILE_AddSimpleProperty((GpMetafile*)graphics->image,
                EmfPlusRecordTypeSetCompositingMode, mode);
        if(stat != Ok)
            return stat;
    }
 
    graphics->compmode = mode;
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), test_BeginContainer2(), test_DrawImage_SourceCopy(), test_Get_Release_DC(), and test_properties().

◆ GdipSetCompositingQuality()

GpStatus WINGDIPAPI GdipSetCompositingQuality	(	GpGraphics *	graphics,
		CompositingQuality	quality
	)

Definition at line 6114 of file graphics.c.

{
    TRACE("(%p, %d)\n", graphics, quality);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if(graphics->compqual == quality)
        return Ok;
 
    if(graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        GpStatus stat;
 
        stat = METAFILE_AddSimpleProperty((GpMetafile*)graphics->image,
                EmfPlusRecordTypeSetCompositingQuality, quality);
        if(stat != Ok)
            return stat;
    }
 
    graphics->compqual = quality;
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), test_BeginContainer2(), test_Get_Release_DC(), and test_properties().

◆ GdipSetCustomLineCapBaseCap()

GpStatus WINGDIPAPI GdipSetCustomLineCapBaseCap	(	GpCustomLineCap *	custom,
		GpLineCap	base
	)

Definition at line 195 of file customlinecap.c.

{
    static int calls;
 
    TRACE("(%p,%u)\n", custom, base);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

Referenced by test_create_adjustable_cap().

◆ GdipSetCustomLineCapBaseInset()

GpStatus WINGDIPAPI GdipSetCustomLineCapBaseInset	(	GpCustomLineCap *	custom,
		REAL	inset
	)

Definition at line 221 of file customlinecap.c.

{
    static int calls;
 
    TRACE("(%p,%0.2f)\n", custom, inset);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetCustomLineCapStrokeCaps()

GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeCaps	(	GpCustomLineCap *	custom,
		GpLineCap	start,
		GpLineCap	end
	)

Definition at line 179 of file customlinecap.c.

{
    static int calls;
 
    TRACE("(%p,%u,%u)\n", custom, start, end);
 
    if(!custom)
        return InvalidParameter;
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetCustomLineCapStrokeJoin()

GpStatus WINGDIPAPI GdipSetCustomLineCapStrokeJoin	(	GpCustomLineCap *	custom,
		GpLineJoin	join
	)

Definition at line 235 of file customlinecap.c.

{
    TRACE("(%p, %d)\n", custom, join);
 
    if(!custom)
        return InvalidParameter;
 
    custom->join = join;
 
    return Ok;
}

Referenced by test_linejoin().

◆ GdipSetCustomLineCapWidthScale()

GpStatus WINGDIPAPI GdipSetCustomLineCapWidthScale	(	GpCustomLineCap *	custom,
		REAL	width
	)

Definition at line 248 of file customlinecap.c.

{
    TRACE("(%p,%0.2f)\n", custom, width);
 
    if(!custom)
        return InvalidParameter;
 
    custom->scale = width;
 
    return Ok;
}

Referenced by test_scale().

◆ GdipSetEffectParameters()

GpStatus WINGDIPAPI GdipSetEffectParameters	(	CGpEffect *	effect,
		const VOID *	params,
		const	UINT
	)

Definition at line 5298 of file image.c.

{
    static int calls;
 
    TRACE("(%p,%p,%u)\n", effect, params, size);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetEmpty()

GpStatus WINGDIPAPI GdipSetEmpty ( GpRegion * region )

Definition at line 1359 of file region.c.

{
    GpStatus stat;
 
    TRACE("%p\n", region);
 
    if (!region)
        return InvalidParameter;
 
    delete_element(&region->node);
    stat = init_region(region, RegionDataEmptyRect);
 
    return stat;
}

Referenced by GdipCreateRegionHrgn(), GdipMeasureCharacterRanges(), test_clipping(), test_clipping_2(), test_GdipCreateRegionRgnData(), test_get_set_clip(), test_getbounds(), test_gethrgn(), test_getregiondata(), test_isempty(), test_isequal(), test_scans(), test_string_functions(), test_transform(), and test_translate().

◆ GdipSetImageAttributesCachedBackground()

GpStatus WINGDIPAPI GdipSetImageAttributesCachedBackground	(	GpImageAttributes *	imageAttr,
		BOOL	enableFlag
	)

Definition at line 191 of file imageattributes.c.

{
    static int calls;
 
    TRACE("(%p,%i)\n", imageAttr, enableFlag);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetImageAttributesColorKeys()

GpStatus WINGDIPAPI GdipSetImageAttributesColorKeys	(	GpImageAttributes *	imageattr,
		ColorAdjustType	type,
		BOOL	enableFlag,
		ARGB	colorLow,
		ARGB	colorHigh
	)

Definition at line 129 of file imageattributes.c.

{
    TRACE("(%p,%u,%i,%08x,%08x)\n", imageattr, type, enableFlag, colorLow, colorHigh);
 
    if(!imageattr || type >= ColorAdjustTypeCount)
        return InvalidParameter;
 
    imageattr->colorkeys[type].enabled = enableFlag;
    imageattr->colorkeys[type].low = colorLow;
    imageattr->colorkeys[type].high = colorHigh;
 
    return Ok;
}

Referenced by GdipResetImageAttributes(), and test_colorkey().

◆ GdipSetImageAttributesColorMatrix()

GpStatus WINGDIPAPI GdipSetImageAttributesColorMatrix	(	GpImageAttributes *	imageattr,
		ColorAdjustType	type,
		BOOL	enableFlag,
		GDIPCONST ColorMatrix *	colorMatrix,
		GDIPCONST ColorMatrix *	grayMatrix,
		ColorMatrixFlags	flags
	)

Definition at line 144 of file imageattributes.c.

{
    TRACE("(%p,%u,%i,%p,%p,%u)\n", imageattr, type, enableFlag, colorMatrix,
        grayMatrix, flags);
 
    if(!imageattr || type >= ColorAdjustTypeCount || flags > ColorMatrixFlagsAltGray)
        return InvalidParameter;
 
    if (enableFlag)
    {
        if (!colorMatrix)
            return InvalidParameter;
 
        if (flags == ColorMatrixFlagsAltGray)
        {
            if (!grayMatrix)
                return InvalidParameter;
 
            imageattr->colormatrices[type].graymatrix = *grayMatrix;
        }
 
        imageattr->colormatrices[type].colormatrix = *colorMatrix;
        imageattr->colormatrices[type].flags = flags;
    }
 
    imageattr->colormatrices[type].enabled = enableFlag;
 
    return Ok;
}

Referenced by test_colormatrix(), and test_drawimage().

◆ GdipSetImageAttributesGamma()

GpStatus WINGDIPAPI GdipSetImageAttributesGamma	(	GpImageAttributes *	imageAttr,
		ColorAdjustType	type,
		BOOL	enableFlag,
		REAL	gamma
	)

Definition at line 204 of file imageattributes.c.

{
    TRACE("(%p,%u,%i,%0.2f)\n", imageAttr, type, enableFlag, gamma);
 
    if (!imageAttr || (enableFlag && gamma <= 0.0) || type >= ColorAdjustTypeCount)
        return InvalidParameter;
 
    imageAttr->gamma_enabled[type] = enableFlag;
    imageAttr->gamma[type] = gamma;
 
    return Ok;
}

Referenced by GdipResetImageAttributes(), and test_gamma().

◆ GdipSetImageAttributesNoOp()

GpStatus WINGDIPAPI GdipSetImageAttributesNoOp	(	GpImageAttributes *	imageAttr,
		ColorAdjustType	type,
		BOOL	enableFlag
	)

Definition at line 218 of file imageattributes.c.

{
    TRACE("(%p,%u,%i)\n", imageAttr, type, enableFlag);
 
    if (type >= ColorAdjustTypeCount)
        return InvalidParameter;
 
    imageAttr->noop[type] = enableFlag ? IMAGEATTR_NOOP_SET : IMAGEATTR_NOOP_CLEAR;
 
    return Ok;
}

Referenced by test_colormatrix().

◆ GdipSetImageAttributesOutputChannel()

GpStatus WINGDIPAPI GdipSetImageAttributesOutputChannel	(	GpImageAttributes *	imageAttr,
		ColorAdjustType	type,
		BOOL	enableFlag,
		ColorChannelFlags	channelFlags
	)

Definition at line 231 of file imageattributes.c.

{
    static int calls;
 
    TRACE("(%p,%u,%i,%x)\n", imageAttr, type, enableFlag, channelFlags);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetImageAttributesOutputChannelColorProfile()

GpStatus WINGDIPAPI GdipSetImageAttributesOutputChannelColorProfile	(	GpImageAttributes *	imageAttr,
		ColorAdjustType	type,
		BOOL	enableFlag,
		GDIPCONST WCHAR *	colorProfileFilename
	)

Definition at line 244 of file imageattributes.c.

{
    static int calls;
 
    TRACE("(%p,%u,%i,%s)\n", imageAttr, type, enableFlag, debugstr_w(colorProfileFilename));
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetImageAttributesRemapTable()

GpStatus WINGDIPAPI GdipSetImageAttributesRemapTable	(	GpImageAttributes *	imageAttr,
		ColorAdjustType	type,
		BOOL	enableFlag,
		UINT	mapSize,
		GDIPCONST ColorMap *	map
	)

Definition at line 258 of file imageattributes.c.

{
    ColorMap *new_map;
 
    TRACE("(%p,%u,%i,%u,%p)\n", imageAttr, type, enableFlag, mapSize, map);
 
    if(!imageAttr || type >= ColorAdjustTypeCount)
    return InvalidParameter;
 
    if (enableFlag)
    {
        if(!map || !mapSize)
        return InvalidParameter;
 
        new_map = heap_alloc_zero(sizeof(*map) * mapSize);
 
        if (!new_map)
            return OutOfMemory;
 
        memcpy(new_map, map, sizeof(*map) * mapSize);
 
        heap_free(imageAttr->colorremaptables[type].colormap);
 
        imageAttr->colorremaptables[type].mapsize = mapSize;
        imageAttr->colorremaptables[type].colormap = new_map;
    }
    else
    {
        heap_free(imageAttr->colorremaptables[type].colormap);
        imageAttr->colorremaptables[type].colormap = NULL;
    }
 
    imageAttr->colorremaptables[type].enabled = enableFlag;
 
    return Ok;
}

Referenced by GdipResetImageAttributes(), test_getadjustedpalette(), and test_remaptable().

◆ GdipSetImageAttributesThreshold()

GpStatus WINGDIPAPI GdipSetImageAttributesThreshold	(	GpImageAttributes *	imageAttr,
		ColorAdjustType	type,
		BOOL	enableFlag,
		REAL	threshold
	)

Definition at line 297 of file imageattributes.c.

{
    static int calls;
 
    TRACE("(%p,%u,%i,%0.2f)\n", imageAttr, type, enableFlag, threshold);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetImageAttributesToIdentity()

GpStatus WINGDIPAPI GdipSetImageAttributesToIdentity	(	GpImageAttributes *	imageAttr,
		ColorAdjustType	type
	)

Definition at line 310 of file imageattributes.c.

{
    static int calls;
 
    TRACE("(%p,%u)\n", imageAttr, type);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetImageAttributesWrapMode()

GpStatus WINGDIPAPI GdipSetImageAttributesWrapMode	(	GpImageAttributes *	imageAttr,
		WrapMode	wrap,
		ARGB	argb,
		BOOL	clamp
	)

Definition at line 176 of file imageattributes.c.

{
    TRACE("(%p,%u,%08x,%i)\n", imageAttr, wrap, argb, clamp);
 
    if(!imageAttr || wrap > WrapModeClamp)
        return InvalidParameter;
 
    imageAttr->wrap = wrap;
    imageAttr->outside_color = argb;
    imageAttr->clamp = clamp;
 
    return Ok;
}

Referenced by METAFILE_PlaybackObject(), and ZoomWnd_OnDraw().

◆ GdipSetImagePalette()

GpStatus WINGDIPAPI GdipSetImagePalette	(	GpImage *	image,
		GDIPCONST ColorPalette *	palette
	)

Definition at line 4744 of file image.c.

{
    ColorPalette *new_palette;
 
    TRACE("(%p,%p)\n", image, palette);
 
    if(!image || !palette || palette->Count > 256)
        return InvalidParameter;
 
    new_palette = heap_alloc_zero(2 * sizeof(UINT) + palette->Count * sizeof(ARGB));
    if (!new_palette) return OutOfMemory;
 
    heap_free(image->palette);
    image->palette = new_palette;
    image->palette->Flags = palette->Flags;
    image->palette->Count = palette->Count;
    memcpy(image->palette->Entries, palette->Entries, sizeof(ARGB)*palette->Count);
 
    return Ok;
}

Referenced by GdipCreateBitmapFromHBITMAP(), metafile_deserialize_image(), test_bitmapbits(), and test_palette().

◆ GdipSetInfinite()

GpStatus WINGDIPAPI GdipSetInfinite ( GpRegion * region )

Definition at line 1374 of file region.c.

{
    GpStatus stat;
 
    TRACE("%p\n", region);
 
    if (!region)
        return InvalidParameter;
 
    delete_element(&region->node);
    stat = init_region(region, RegionDataInfiniteRect);
 
    return stat;
}

Referenced by GdipResetClip(), test_gethrgn(), test_getregiondata(), and test_isequal().

◆ GdipSetInterpolationMode()

GpStatus WINGDIPAPI GdipSetInterpolationMode	(	GpGraphics *	graphics,
		InterpolationMode	mode
	)

Definition at line 6143 of file graphics.c.

{
    TRACE("(%p, %d)\n", graphics, mode);
 
    if(!graphics || mode == InterpolationModeInvalid || mode > InterpolationModeHighQualityBicubic)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (mode == InterpolationModeDefault || mode == InterpolationModeLowQuality)
        mode = InterpolationModeBilinear;
 
    if (mode == InterpolationModeHighQuality)
        mode = InterpolationModeHighQualityBicubic;
 
    if (mode == graphics->interpolation)
        return Ok;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        GpStatus stat;
 
        stat = METAFILE_AddSimpleProperty((GpMetafile*)graphics->image,
                EmfPlusRecordTypeSetInterpolationMode, mode);
        if (stat != Ok)
            return stat;
    }
 
    graphics->interpolation = mode;
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), test_BeginContainer2(), test_DrawImage(), test_DrawImage_scale(), test_DrawImage_SourceCopy(), test_GdipDrawImagePointRect(), test_Get_Release_DC(), test_get_set_interpolation(), test_properties(), test_save_restore(), and ZoomWnd_OnDraw().

◆ GdipSetLineBlend()

GpStatus WINGDIPAPI GdipSetLineBlend	(	GpLineGradient *	brush,
		GDIPCONST REAL *	factors,
		GDIPCONST REAL *	positions,
		INT	count
	)

Definition at line 1369 of file brush.c.

{
    REAL *new_blendfac, *new_blendpos;
 
    TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
 
    if(!brush || !factors || !positions || count <= 0 || brush->brush.bt != BrushTypeLinearGradient ||
       (count >= 2 && (positions[0] != 0.0f || positions[count-1] != 1.0f)))
        return InvalidParameter;
 
    new_blendfac = heap_alloc_zero(count * sizeof(REAL));
    new_blendpos = heap_alloc_zero(count * sizeof(REAL));
 
    if (!new_blendfac || !new_blendpos)
    {
        heap_free(new_blendfac);
        heap_free(new_blendpos);
        return OutOfMemory;
    }
 
    memcpy(new_blendfac, factors, count * sizeof(REAL));
    memcpy(new_blendpos, positions, count * sizeof(REAL));
 
    heap_free(brush->blendfac);
    heap_free(brush->blendpos);
 
    brush->blendcount = count;
    brush->blendfac = new_blendfac;
    brush->blendpos = new_blendpos;
 
    return Ok;
}

Referenced by GdipSetLineLinearBlend(), GdipSetLineSigmaBlend(), metafile_deserialize_brush(), and test_lineblend().

◆ GdipSetLineColors()

GpStatus WINGDIPAPI GdipSetLineColors	(	GpLineGradient *	brush,
		ARGB	color1,
		ARGB	color2
	)

Definition at line 1969 of file brush.c.

{
    TRACE("(%p, %x, %x)\n", brush, color1, color2);
 
    if(!brush || brush->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    brush->startcolor = color1;
    brush->endcolor   = color2;
 
    return Ok;
}

◆ GdipSetLineGammaCorrection()

GpStatus WINGDIPAPI GdipSetLineGammaCorrection	(	GpLineGradient *	line,
		BOOL	usegamma
	)

Definition at line 1432 of file brush.c.

{
    TRACE("(%p, %d)\n", line, usegamma);
 
    if(!line || line->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    line->gamma = usegamma;
 
    return Ok;
}

◆ GdipSetLineLinearBlend()

GpStatus WINGDIPAPI GdipSetLineLinearBlend	(	GpLineGradient *	brush,
		REAL	focus,
		REAL	scale
	)

Definition at line 2010 of file brush.c.

{
    REAL factors[3];
    REAL positions[3];
    int num_points = 0;
 
    TRACE("(%p,%.2f,%.2f)\n", brush, focus, scale);
 
    if (!brush) return InvalidParameter;
 
    if (focus != 0.0)
    {
        factors[num_points] = 0.0;
        positions[num_points] = 0.0;
        num_points++;
    }
 
    factors[num_points] = scale;
    positions[num_points] = focus;
    num_points++;
 
    if (focus != 1.0)
    {
        factors[num_points] = 0.0;
        positions[num_points] = 1.0;
        num_points++;
    }
 
    return GdipSetLineBlend(brush, factors, positions, num_points);
}

Referenced by test_linelinearblend().

◆ GdipSetLinePresetBlend()

GpStatus WINGDIPAPI GdipSetLinePresetBlend	(	GpLineGradient *	brush,
		GDIPCONST ARGB *	blend,
		GDIPCONST REAL *	positions,
		INT	count
	)

Definition at line 2042 of file brush.c.

{
    ARGB *new_color;
    REAL *new_pos;
    TRACE("(%p,%p,%p,%i)\n", brush, blend, positions, count);
 
    if (!brush || !blend || !positions || count < 2 || brush->brush.bt != BrushTypeLinearGradient ||
        positions[0] != 0.0f || positions[count-1] != 1.0f)
    {
        return InvalidParameter;
    }
 
    new_color = heap_alloc_zero(count * sizeof(ARGB));
    new_pos = heap_alloc_zero(count * sizeof(REAL));
    if (!new_color || !new_pos)
    {
        heap_free(new_color);
        heap_free(new_pos);
        return OutOfMemory;
    }
 
    memcpy(new_color, blend, sizeof(ARGB) * count);
    memcpy(new_pos, positions, sizeof(REAL) * count);
 
    heap_free(brush->pblendcolor);
    heap_free(brush->pblendpos);
 
    brush->pblendcolor = new_color;
    brush->pblendpos = new_pos;
    brush->pblendcount = count;
 
    return Ok;
}

Referenced by metafile_deserialize_brush(), and test_lineblend().

◆ GdipSetLineSigmaBlend()

GpStatus WINGDIPAPI GdipSetLineSigmaBlend	(	GpLineGradient *	line,
		REAL	focus,
		REAL	scale
	)

Definition at line 1445 of file brush.c.

{
    REAL factors[33];
    REAL positions[33];
    int num_points = 0;
    int i;
    const int precision = 16;
    REAL erf_range; /* we use values erf(-erf_range) through erf(+erf_range) */
    REAL min_erf;
    REAL scale_erf;
 
    TRACE("(%p, %0.2f, %0.2f)\n", line, focus, scale);
 
    if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0 || line->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    /* we want 2 standard deviations */
    erf_range = 2.0 / sqrt(2);
 
    /* calculate the constants we need to normalize the error function to be
        between 0.0 and scale over the range we need */
    min_erf = erf(-erf_range);
    scale_erf = scale / (-2.0 * min_erf);
 
    if (focus != 0.0)
    {
        positions[0] = 0.0;
        factors[0] = 0.0;
        for (i=1; i<precision; i++)
        {
            positions[i] = focus * i / precision;
            factors[i] = scale_erf * (erf(2 * erf_range * i / precision - erf_range) - min_erf);
        }
        num_points += precision;
    }
 
    positions[num_points] = focus;
    factors[num_points] = scale;
    num_points += 1;
 
    if (focus != 1.0)
    {
        for (i=1; i<precision; i++)
        {
            positions[i+num_points-1] = (focus + ((1.0-focus) * i / precision));
            factors[i+num_points-1] = scale_erf * (erf(erf_range - 2 * erf_range * i / precision) - min_erf);
        }
        num_points += precision;
        positions[num_points-1] = 1.0;
        factors[num_points-1] = 0.0;
    }
 
    return GdipSetLineBlend(line, factors, positions, num_points);
}

◆ GdipSetLineTransform()

GpStatus WINGDIPAPI GdipSetLineTransform	(	GpLineGradient *	brush,
		GDIPCONST GpMatrix *	matrix
	)

Definition at line 2116 of file brush.c.

{
    TRACE("(%p,%p)\n", brush,  matrix);
 
    if(!brush || !matrix)
        return InvalidParameter;
 
    brush->transform = *matrix;
 
    return Ok;
}

Referenced by metafile_deserialize_brush(), and test_transform().

◆ GdipSetLineWrapMode()

GpStatus WINGDIPAPI GdipSetLineWrapMode	(	GpLineGradient *	line,
		GpWrapMode	wrap
	)

Definition at line 1501 of file brush.c.

{
    TRACE("(%p, %d)\n", line, wrap);
 
    if(!line || wrap == WrapModeClamp || line->brush.bt != BrushTypeLinearGradient)
        return InvalidParameter;
 
    line->wrap = wrap;
 
    return Ok;
}

◆ GdipSetMatrixElements()

GpStatus WINGDIPAPI GdipSetMatrixElements	(	GpMatrix *	matrix,
		REAL	m11,
		REAL	m12,
		REAL	m21,
		REAL	m22,
		REAL	dx,
		REAL	dy
	)

Definition at line 316 of file matrix.c.

{
    TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", matrix, m11, m12,
            m21, m22, dx, dy);
 
    if(!matrix)
        return InvalidParameter;
 
    matrix->matrix[0] = m11;
    matrix->matrix[1] = m12;
    matrix->matrix[2] = m21;
    matrix->matrix[3] = m22;
    matrix->matrix[4] = dx;
    matrix->matrix[5] = dy;
 
    return Ok;
}

Referenced by create_line_brush(), create_path_gradient(), draw_cap(), GdipCreateFromHDC2(), GdipCreatePen2(), GdipCreateTextureIA(), GdipDrawImagePointsRect(), GdipPlayMetafileRecord(), GdipResetLineTransform(), GdipResetPathGradientTransform(), GdipResetPenTransform(), GdipResetTextureTransform(), GdipResetWorldTransform(), get_gdi_transform(), get_graphics_transform(), graphics_from_image(), linegradient_init_transform(), test_isidentity(), test_transform(), and test_worldtransform().

◆ GdipSetMetafileDownLevelRasterizationLimit()

GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit	(	GpMetafile *	metafile,
		UINT	limitDpi
	)

Definition at line 3956 of file metafile.c.

{
    TRACE("(%p,%u)\n", metafile, limitDpi);
 
    return Ok;
}

◆ GdipSetPageScale()

GpStatus WINGDIPAPI GdipSetPageScale	(	GpGraphics *	graphics,
		REAL	scale
	)

Definition at line 6178 of file graphics.c.

{
    GpStatus stat;
 
    TRACE("(%p, %.2f)\n", graphics, scale);
 
    if(!graphics || (scale <= 0.0))
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        stat = METAFILE_SetPageTransform((GpMetafile*)graphics->image, graphics->unit, scale);
        if (stat != Ok)
            return stat;
    }
 
    graphics->scale = scale;
 
    return Ok;
}

Referenced by create_graphics(), GdipEnumerateMetafileSrcRectDestPoints(), test_BeginContainer2(), test_clipping(), test_clipping_2(), test_Get_Release_DC(), test_getbounds(), test_pagetransform(), test_pen_thickness(), and test_transformpoints().

◆ GdipSetPageUnit()

GpStatus WINGDIPAPI GdipSetPageUnit	(	GpGraphics *	graphics,
		GpUnit	unit
	)

Definition at line 6202 of file graphics.c.

{
    GpStatus stat;
 
    TRACE("(%p, %d)\n", graphics, unit);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if(unit == UnitWorld)
        return InvalidParameter;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        stat = METAFILE_SetPageTransform((GpMetafile*)graphics->image, unit, graphics->scale);
        if (stat != Ok)
            return stat;
    }
 
    graphics->unit = unit;
 
    return Ok;
}

Referenced by create_graphics(), GdipEnumerateMetafileSrcRectDestPoints(), test_BeginContainer2(), test_clipping(), test_clipping_2(), test_container_rects(), test_font_height_scaling(), test_font_transform(), test_Get_Release_DC(), test_getbounds(), test_measured_extra_space(), test_pagetransform(), test_pen_thickness(), and test_transformpoints().

◆ GdipSetPathFillMode()

GpStatus WINGDIPAPI GdipSetPathFillMode	(	GpPath *	path,
		GpFillMode	fill
	)

Definition at line 1770 of file graphicspath.c.

{
    TRACE("(%p, %d)\n", path, fill);
 
    if(!path)
        return InvalidParameter;
 
    path->fill = fill;
 
    return Ok;
}

◆ GdipSetPathGradientBlend()

GpStatus WINGDIPAPI GdipSetPathGradientBlend	(	GpPathGradient *	brush,
		GDIPCONST REAL *	blend,
		GDIPCONST REAL *	pos,
		INT	count
	)

Definition at line 1514 of file brush.c.

{
    REAL *new_blendfac, *new_blendpos;
 
    TRACE("(%p,%p,%p,%i)\n", brush, blend, pos, count);
 
    if(!brush || !blend || !pos || count <= 0 || brush->brush.bt != BrushTypePathGradient ||
       (count >= 2 && (pos[0] != 0.0f || pos[count-1] != 1.0f)))
        return InvalidParameter;
 
    new_blendfac = heap_alloc_zero(count * sizeof(REAL));
    new_blendpos = heap_alloc_zero(count * sizeof(REAL));
 
    if (!new_blendfac || !new_blendpos)
    {
        heap_free(new_blendfac);
        heap_free(new_blendpos);
        return OutOfMemory;
    }
 
    memcpy(new_blendfac, blend, count * sizeof(REAL));
    memcpy(new_blendpos, pos, count * sizeof(REAL));
 
    heap_free(brush->blendfac);
    heap_free(brush->blendpos);
 
    brush->blendcount = count;
    brush->blendfac = new_blendfac;
    brush->blendpos = new_blendpos;
 
    return Ok;
}

Referenced by GdipSetPathGradientLinearBlend(), GdipSetPathGradientSigmaBlend(), and test_pathgradientblend().

◆ GdipSetPathGradientCenterColor()

GpStatus WINGDIPAPI GdipSetPathGradientCenterColor	(	GpPathGradient *	grad,
		ARGB	argb
	)

Definition at line 1656 of file brush.c.

{
    TRACE("(%p, %x)\n", grad, argb);
 
    if(!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->centercolor = argb;
    return Ok;
}

◆ GdipSetPathGradientCenterPoint()

GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint	(	GpPathGradient *	grad,
		GpPointF *	point
	)

Definition at line 1668 of file brush.c.

{
    TRACE("(%p, %s)\n", grad, debugstr_pointf(point));
 
    if(!grad || !point || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->center.X = point->X;
    grad->center.Y = point->Y;
 
    return Ok;
}

Referenced by GdipSetPathGradientCenterPointI(), and test_pathgradientcenterpoint().

◆ GdipSetPathGradientCenterPointI()

GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI	(	GpPathGradient *	grad,
		GpPoint *	point
	)

Definition at line 1682 of file brush.c.

{
    GpPointF ptf;
 
    TRACE("(%p, %p)\n", grad, point);
 
    if(!point)
        return InvalidParameter;
 
    ptf.X = (REAL)point->X;
    ptf.Y = (REAL)point->Y;
 
    return GdipSetPathGradientCenterPoint(grad,&ptf);
}

◆ GdipSetPathGradientFocusScales()

GpStatus WINGDIPAPI GdipSetPathGradientFocusScales	(	GpPathGradient *	grad,
		REAL	x,
		REAL	y
	)

Definition at line 1698 of file brush.c.

{
    TRACE("(%p, %.2f, %.2f)\n", grad, x, y);
 
    if(!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->focus.X = x;
    grad->focus.Y = y;
 
    return Ok;
}

◆ GdipSetPathGradientGammaCorrection()

GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection	(	GpPathGradient *	grad,
		BOOL	gamma
	)

Definition at line 1712 of file brush.c.

{
    TRACE("(%p, %d)\n", grad, gamma);
 
    if(!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->gamma = gamma;
 
    return Ok;
}

◆ GdipSetPathGradientLinearBlend()

GpStatus WINGDIPAPI GdipSetPathGradientLinearBlend	(	GpPathGradient *	brush,
		REAL	focus,
		REAL	scale
	)

Definition at line 1548 of file brush.c.

{
    REAL factors[3];
    REAL positions[3];
    int num_points = 0;
 
    TRACE("(%p,%0.2f,%0.2f)\n", brush, focus, scale);
 
    if (!brush || brush->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    if (focus != 0.0)
    {
        factors[num_points] = 0.0;
        positions[num_points] = 0.0;
        num_points++;
    }
 
    factors[num_points] = scale;
    positions[num_points] = focus;
    num_points++;
 
    if (focus != 1.0)
    {
        factors[num_points] = 0.0;
        positions[num_points] = 1.0;
        num_points++;
    }
 
    return GdipSetPathGradientBlend(brush, factors, positions, num_points);
}

◆ GdipSetPathGradientPath()

GpStatus WINGDIPAPI GdipSetPathGradientPath	(	GpPathGradient *	grad,
		GDIPCONST GpPath *	path
	)

Definition at line 1725 of file brush.c.

{
    static int calls;
 
    TRACE("(%p, %p)\n", grad, path);
 
    if (!(calls++))
        FIXME("not implemented\n");
 
    return NotImplemented;
}

◆ GdipSetPathGradientPresetBlend()

GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend	(	GpPathGradient *	brush,
		GDIPCONST ARGB *	blend,
		GDIPCONST REAL *	pos,
		INT	count
	)

Definition at line 1581 of file brush.c.

{
    ARGB *new_color;
    REAL *new_pos;
    TRACE("(%p,%p,%p,%i)\n", brush, blend, pos, count);
 
    if (!brush || !blend || !pos || count < 2 || brush->brush.bt != BrushTypePathGradient ||
        pos[0] != 0.0f || pos[count-1] != 1.0f)
    {
        return InvalidParameter;
    }
 
    new_color = heap_alloc_zero(count * sizeof(ARGB));
    new_pos = heap_alloc_zero(count * sizeof(REAL));
    if (!new_color || !new_pos)
    {
        heap_free(new_color);
        heap_free(new_pos);
        return OutOfMemory;
    }
 
    memcpy(new_color, blend, sizeof(ARGB) * count);
    memcpy(new_pos, pos, sizeof(REAL) * count);
 
    heap_free(brush->pblendcolor);
    heap_free(brush->pblendpos);
 
    brush->pblendcolor = new_color;
    brush->pblendpos = new_pos;
    brush->pblendcount = count;
 
    return Ok;
}

Referenced by test_pathgradientpresetblend().

◆ GdipSetPathGradientSigmaBlend()

GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend	(	GpPathGradient *	grad,
		REAL	focus,
		REAL	scale
	)

Definition at line 1737 of file brush.c.

{
    REAL factors[33];
    REAL positions[33];
    int num_points = 0;
    int i;
    const int precision = 16;
    REAL erf_range; /* we use values erf(-erf_range) through erf(+erf_range) */
    REAL min_erf;
    REAL scale_erf;
 
    TRACE("(%p,%0.2f,%0.2f)\n", grad, focus, scale);
 
    if(!grad || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0 || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    /* we want 2 standard deviations */
    erf_range = 2.0 / sqrt(2);
 
    /* calculate the constants we need to normalize the error function to be
        between 0.0 and scale over the range we need */
    min_erf = erf(-erf_range);
    scale_erf = scale / (-2.0 * min_erf);
 
    if (focus != 0.0)
    {
        positions[0] = 0.0;
        factors[0] = 0.0;
        for (i=1; i<precision; i++)
        {
            positions[i] = focus * i / precision;
            factors[i] = scale_erf * (erf(2 * erf_range * i / precision - erf_range) - min_erf);
        }
        num_points += precision;
    }
 
    positions[num_points] = focus;
    factors[num_points] = scale;
    num_points += 1;
 
    if (focus != 1.0)
    {
        for (i=1; i<precision; i++)
        {
            positions[i+num_points-1] = (focus + ((1.0-focus) * i / precision));
            factors[i+num_points-1] = scale_erf * (erf(erf_range - 2 * erf_range * i / precision) - min_erf);
        }
        num_points += precision;
        positions[num_points-1] = 1.0;
        factors[num_points-1] = 0.0;
    }
 
    return GdipSetPathGradientBlend(grad, factors, positions, num_points);
}

◆ GdipSetPathGradientSurroundColorsWithCount()

GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount	(	GpPathGradient *	grad,
		GDIPCONST ARGB *	argb,
		INT *	count
	)

Definition at line 1793 of file brush.c.

{
    ARGB *new_surroundcolors;
    INT i, num_colors;
 
    TRACE("(%p,%p,%p)\n", grad, argb, count);
 
    if(!grad || !argb || !count || (*count <= 0) || grad->brush.bt != BrushTypePathGradient ||
        (*count > grad->path->pathdata.Count))
        return InvalidParameter;
 
    num_colors = *count;
 
    /* If all colors are the same, only store 1 color. */
    if (*count > 1)
    {
        for (i=1; i < num_colors; i++)
            if (argb[i] != argb[i-1])
                break;
 
        if (i == num_colors)
            num_colors = 1;
    }
 
    new_surroundcolors = heap_alloc_zero(num_colors * sizeof(ARGB));
    if (!new_surroundcolors)
        return OutOfMemory;
 
    memcpy(new_surroundcolors, argb, num_colors * sizeof(ARGB));
 
    heap_free(grad->surroundcolors);
 
    grad->surroundcolors = new_surroundcolors;
    grad->surroundcolorcount = num_colors;
 
    return Ok;
}

Referenced by test_gradientsurroundcolorcount().

◆ GdipSetPathGradientTransform()

GpStatus WINGDIPAPI GdipSetPathGradientTransform	(	GpPathGradient *	grad,
		GpMatrix *	matrix
	)

Definition at line 1845 of file brush.c.

{
    TRACE("(%p,%p)\n", grad, matrix);
 
    if (!grad || !matrix || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->transform = *matrix;
 
    return Ok;
}

◆ GdipSetPathGradientWrapMode()

GpStatus WINGDIPAPI GdipSetPathGradientWrapMode	(	GpPathGradient *	grad,
		GpWrapMode	wrap
	)

Definition at line 1832 of file brush.c.

{
    TRACE("(%p, %d)\n", grad, wrap);
 
    if(!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    grad->wrap = wrap;
 
    return Ok;
}

◆ GdipSetPathMarker()

GpStatus WINGDIPAPI GdipSetPathMarker ( GpPath * path )

Definition at line 2421 of file graphicspath.c.

{
    INT count;
 
    TRACE("(%p)\n", path);
 
    if(!path)
        return InvalidParameter;
 
    count = path->pathdata.Count;
 
    /* set marker flag */
    if(count > 0)
        path->pathdata.Types[count-1] |= PathPointTypePathMarker;
 
    return Ok;
}

Referenced by test_nextmarker(), and test_nextmarkerpath().

◆ GdipSetPenBrushFill()

GpStatus WINGDIPAPI GdipSetPenBrushFill	(	GpPen *	pen,
		GpBrush *	brush
	)

Definition at line 502 of file pen.c.

{
    TRACE("(%p, %p)\n", pen, brush);
 
    if(!pen || !brush)
        return InvalidParameter;
 
    GdipDeleteBrush(pen->brush);
    return GdipCloneBrush(brush, &pen->brush);
}

Referenced by test_brushfill().

◆ GdipSetPenColor()

GpStatus WINGDIPAPI GdipSetPenColor	(	GpPen *	pen,
		ARGB	argb
	)

Definition at line 513 of file pen.c.

{
    TRACE("(%p, %x)\n", pen, argb);
 
    if(!pen)
        return InvalidParameter;
 
    if(pen->brush->bt != BrushTypeSolidColor)
        return NotImplemented;
 
    return GdipSetSolidFillColor(((GpSolidFill*)pen->brush), argb);
}

◆ GdipSetPenCompoundArray()

GpStatus WINGDIPAPI GdipSetPenCompoundArray	(	GpPen *	pen,
		GDIPCONST REAL *	dash,
		INT	count
	)

Definition at line 536 of file pen.c.

{
    FIXME("(%p, %p, %i): stub\n", pen, dash, count);
 
    if (!pen || !dash || count < 2 || count%2 == 1)
        return InvalidParameter;
 
    return NotImplemented;
}

Referenced by test_compoundarray().

◆ GdipSetPenCustomEndCap()

GpStatus WINGDIPAPI GdipSetPenCustomEndCap	(	GpPen *	pen,
		GpCustomLineCap *	customCap
	)

Definition at line 547 of file pen.c.

{
    GpCustomLineCap * cap;
    GpStatus ret;
 
    TRACE("(%p, %p)\n", pen, customCap);
 
    /* native crashes on pen == NULL, customCap != NULL */
    if(!customCap) return InvalidParameter;
 
    if((ret = GdipCloneCustomLineCap(customCap, &cap)) == Ok){
        GdipDeleteCustomLineCap(pen->customend);
        pen->endcap = LineCapCustom;
        pen->customend = cap;
    }
 
    return ret;
}

Referenced by test_customcap().

◆ GdipSetPenCustomStartCap()

GpStatus WINGDIPAPI GdipSetPenCustomStartCap	(	GpPen *	pen,
		GpCustomLineCap *	customCap
	)

Definition at line 566 of file pen.c.

{
    GpCustomLineCap * cap;
    GpStatus ret;
 
    TRACE("(%p, %p)\n", pen, customCap);
 
    /* native crashes on pen == NULL, customCap != NULL */
    if(!customCap) return InvalidParameter;
 
    if((ret = GdipCloneCustomLineCap(customCap, &cap)) == Ok){
        GdipDeleteCustomLineCap(pen->customstart);
        pen->startcap = LineCapCustom;
        pen->customstart = cap;
    }
 
    return ret;
}

Referenced by test_customcap().

◆ GdipSetPenDashArray()

GpStatus WINGDIPAPI GdipSetPenDashArray	(	GpPen *	pen,
		GDIPCONST REAL *	dash,
		INT	count
	)

Definition at line 585 of file pen.c.

{
    INT i;
    REAL sum = 0;
 
    TRACE("(%p, %p, %d)\n", pen, dash, count);
 
    if(!pen || !dash)
        return InvalidParameter;
 
    if(count <= 0)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        sum += dash[i];
        if(dash[i] < 0.0)
            return InvalidParameter;
    }
 
    if(sum == 0.0 && count)
        return InvalidParameter;
 
    heap_free(pen->dashes);
    pen->dashes = NULL;
 
    if(count > 0)
        pen->dashes = heap_alloc_zero(count * sizeof(REAL));
    if(!pen->dashes){
        pen->numdashes = 0;
        return OutOfMemory;
    }
 
    GdipSetPenDashStyle(pen, DashStyleCustom);
    memcpy(pen->dashes, dash, count * sizeof(REAL));
    pen->numdashes = count;
 
    return Ok;
}

Referenced by test_dasharray().

◆ GdipSetPenDashCap197819()

GpStatus WINGDIPAPI GdipSetPenDashCap197819	(	GpPen *	pen,
		GpDashCap	dashCap
	)

Definition at line 625 of file pen.c.

{
    TRACE("(%p, %d)\n", pen, dashCap);
 
    if(!pen)
        return InvalidParameter;
 
    pen->dashcap = dashCap;
 
    return Ok;
}

◆ GdipSetPenDashOffset()

GpStatus WINGDIPAPI GdipSetPenDashOffset	(	GpPen *	pen,
		REAL	offset
	)

Definition at line 638 of file pen.c.

{
    TRACE("(%p, %.2f)\n", pen, offset);
 
    if(!pen)
        return InvalidParameter;
 
    pen->offset = offset;
 
    return Ok;
}

Referenced by METAFILE_PlaybackObject().

◆ GdipSetPenDashStyle()

GpStatus WINGDIPAPI GdipSetPenDashStyle	(	GpPen *	pen,
		GpDashStyle	dash
	)

Definition at line 650 of file pen.c.

{
    TRACE("(%p, %d)\n", pen, dash);
 
    if(!pen)
        return InvalidParameter;
 
    if(dash != DashStyleCustom){
        heap_free(pen->dashes);
        pen->dashes = NULL;
        pen->numdashes = 0;
    }
 
    pen->dash = dash;
    pen->style &= ~(PS_ALTERNATE | PS_SOLID | PS_DASH | PS_DOT | PS_DASHDOT |
                    PS_DASHDOTDOT | PS_NULL | PS_USERSTYLE | PS_INSIDEFRAME);
    pen->style |= gdip_to_gdi_dash(dash);
 
    return Ok;
}

Referenced by GdipSetPenDashArray(), METAFILE_PlaybackObject(), test_dasharray(), and test_widen().

◆ GdipSetPenEndCap()

GpStatus WINGDIPAPI GdipSetPenEndCap	(	GpPen *	pen,
		GpLineCap	cap
	)

Definition at line 671 of file pen.c.

{
    TRACE("(%p, %d)\n", pen, cap);
 
    if(!pen)    return InvalidParameter;
 
    /* The old custom cap gets deleted even if the new style is LineCapCustom. */
    GdipDeleteCustomLineCap(pen->customend);
    pen->customend = NULL;
    pen->endcap = cap;
 
    return Ok;
}

Referenced by METAFILE_PlaybackObject(), and test_worldbounds().

◆ GdipSetPenLineCap197819()

GpStatus WINGDIPAPI GdipSetPenLineCap197819	(	GpPen *	pen,
		GpLineCap	start,
		GpLineCap	end,
		GpDashCap	dash
	)

Definition at line 686 of file pen.c.

{
    TRACE("%p, %d, %d, %d)\n", pen, start, end, dash);
 
    if(!pen)
        return InvalidParameter;
 
    GdipDeleteCustomLineCap(pen->customend);
    GdipDeleteCustomLineCap(pen->customstart);
    pen->customend = NULL;
    pen->customstart = NULL;
 
    pen->startcap = start;
    pen->endcap = end;
    pen->dashcap = dash;
 
    return Ok;
}

◆ GdipSetPenLineJoin()

GpStatus WINGDIPAPI GdipSetPenLineJoin	(	GpPen *	pen,
		GpLineJoin	join
	)

Definition at line 708 of file pen.c.

{
    TRACE("(%p, %d)\n", pen, join);
 
    if(!pen)    return InvalidParameter;
 
    pen->join = join;
    pen->style &= ~(PS_JOIN_ROUND | PS_JOIN_BEVEL | PS_JOIN_MITER);
    pen->style |= gdip_to_gdi_join(join);
 
    return Ok;
}

Referenced by METAFILE_PlaybackObject().

◆ GdipSetPenMiterLimit()

GpStatus WINGDIPAPI GdipSetPenMiterLimit	(	GpPen *	pen,
		REAL	limit
	)

Definition at line 721 of file pen.c.

{
    TRACE("(%p, %.2f)\n", pen, limit);
 
    if(!pen)
        return InvalidParameter;
 
    pen->miterlimit = limit;
 
    return Ok;
}

Referenced by METAFILE_PlaybackObject().

◆ GdipSetPenMode()

GpStatus WINGDIPAPI GdipSetPenMode	(	GpPen *	pen,
		GpPenAlignment	mode
	)

Definition at line 757 of file pen.c.

{
    TRACE("(%p, %d)\n", pen, mode);
 
    if(!pen)    return InvalidParameter;
 
    pen->align = mode;
 
    return Ok;
}

◆ GdipSetPenStartCap()

GpStatus WINGDIPAPI GdipSetPenStartCap	(	GpPen *	pen,
		GpLineCap	cap
	)

Definition at line 733 of file pen.c.

{
    TRACE("(%p, %d)\n", pen, cap);
 
    if(!pen)    return InvalidParameter;
 
    GdipDeleteCustomLineCap(pen->customstart);
    pen->customstart = NULL;
    pen->startcap = cap;
 
    return Ok;
}

Referenced by METAFILE_PlaybackObject().

◆ GdipSetPenTransform()

GpStatus WINGDIPAPI GdipSetPenTransform	(	GpPen *	pen,
		GpMatrix *	matrix
	)

Definition at line 432 of file pen.c.

{
    static int calls;
 
    TRACE("(%p,%p)\n", pen, matrix);
 
    if(!pen || !matrix)
        return InvalidParameter;
 
    if(!(calls++))
        FIXME("(%p,%p) Semi-stub\n", pen, matrix);
 
    pen->transform = *matrix;
 
    return Ok;
}

Referenced by test_transform().

◆ GdipSetPenWidth()

GpStatus WINGDIPAPI GdipSetPenWidth	(	GpPen *	pen,
		REAL	width
	)

Definition at line 746 of file pen.c.

{
    TRACE("(%p, %.2f)\n", pen, width);
 
    if(!pen)    return InvalidParameter;
 
    pen->width = width;
 
    return Ok;
}

◆ GdipSetPixelOffsetMode()

GpStatus WINGDIPAPI GdipSetPixelOffsetMode	(	GpGraphics *	graphics,
		PixelOffsetMode	mode
	)

Definition at line 6229 of file graphics.c.

{
    TRACE("(%p, %d)\n", graphics, mode);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if(graphics->pixeloffset == mode)
        return Ok;
 
    if(graphics->image && graphics->image->type == ImageTypeMetafile)
    {
        GpStatus stat;
 
        stat = METAFILE_AddSimpleProperty((GpMetafile*)graphics->image,
                EmfPlusRecordTypeSetPixelOffsetMode, mode);
        if(stat != Ok)
            return stat;
    }
 
    graphics->pixeloffset = mode;
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), test_BeginContainer2(), test_DrawImage_scale(), test_Get_Release_DC(), and test_properties().

◆ GdipSetPropertyItem()

GpStatus WINGDIPAPI GdipSetPropertyItem	(	GpImage *	image,
		GDIPCONST PropertyItem *	item
	)

Definition at line 4462 of file image.c.

{
    static int calls;
 
    if (!image || !item) return InvalidParameter;
 
    TRACE("(%p,%p:%#x,%u,%u,%p)\n", image, item, item->id, item->type, item->length, item->value);
 
    if(!(calls++))
        FIXME("not implemented\n");
 
    return Ok;
}

◆ GdipSetRenderingOrigin()

GpStatus WINGDIPAPI GdipSetRenderingOrigin	(	GpGraphics *	graphics,
		INT	x,
		INT	y
	)

Definition at line 6258 of file graphics.c.

{
    static int calls;
 
    TRACE("(%p,%i,%i)\n", graphics, x, y);
 
    if (!(calls++))
        FIXME("value is unused in rendering\n");
 
    if (!graphics)
        return InvalidParameter;
 
    graphics->origin_x = x;
    graphics->origin_y = y;
 
    return Ok;
}

◆ GdipSetSmoothingMode()

GpStatus WINGDIPAPI GdipSetSmoothingMode	(	GpGraphics *	graphics,
		SmoothingMode	mode
	)

Definition at line 6289 of file graphics.c.

{
    TRACE("(%p, %d)\n", graphics, mode);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if(graphics->smoothing == mode)
        return Ok;
 
    if(graphics->image && graphics->image->type == ImageTypeMetafile) {
         GpStatus stat;
         BOOL antialias = (mode != SmoothingModeDefault &&
                 mode != SmoothingModeNone && mode != SmoothingModeHighSpeed);
 
         stat = METAFILE_AddSimpleProperty((GpMetafile*)graphics->image,
                 EmfPlusRecordTypeSetAntiAliasMode, (mode << 1) + antialias);
         if(stat != Ok)
             return stat;
     }
 
    graphics->smoothing = mode;
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), test_BeginContainer2(), test_Get_Release_DC(), test_properties(), and ZoomWnd_OnDraw().

◆ GdipSetSolidFillColor()

GpStatus WINGDIPAPI GdipSetSolidFillColor	(	GpSolidFill *	sf,
		ARGB	argb
	)

Definition at line 1925 of file brush.c.

{
    TRACE("(%p, %x)\n", sf, argb);
 
    if(!sf)
        return InvalidParameter;
 
    sf->color = argb;
    return Ok;
}

Referenced by GdipSetPenColor(), and test_brushfill().

◆ GdipSetStringFormatAlign()

GpStatus WINGDIPAPI GdipSetStringFormatAlign	(	GpStringFormat *	format,
		StringAlignment	align
	)

Definition at line 236 of file stringformat.c.

{
    TRACE("(%p, %i)\n", format, align);
 
    if(!format)
        return InvalidParameter;
 
    format->align = align;
 
    return Ok;
}

Referenced by test_measure_string().

◆ GdipSetStringFormatDigitSubstitution()

GpStatus WINGDIPAPI GdipSetStringFormatDigitSubstitution	(	GpStringFormat *	format,
		LANGID	language,
		StringDigitSubstitute	substitute
	)

Definition at line 250 of file stringformat.c.

{
    TRACE("(%p, %x, %i)\n", format, language, substitute);
 
    if(!format)
        return InvalidParameter;
 
    format->digitlang = language;
    format->digitsub  = substitute;
 
    return Ok;
}

Referenced by test_digitsubstitution().

◆ GdipSetStringFormatFlags()

GpStatus WINGDIPAPI GdipSetStringFormatFlags	(	GpStringFormat *	format,
		INT	flags
	)

Definition at line 357 of file stringformat.c.

{
    TRACE("(%p, %x)\n", format, flags);
 
    if(!format)
        return InvalidParameter;
 
    format->attr = flags;
 
    return Ok;
}

Referenced by test_getgenericdefault(), test_getgenerictypographic(), test_measure_string(), and test_stringformatflags().

◆ GdipSetStringFormatHotkeyPrefix()

GpStatus WINGDIPAPI GdipSetStringFormatHotkeyPrefix	(	GpStringFormat *	format,
		INT	hkpx
	)

Definition at line 264 of file stringformat.c.

{
    TRACE("(%p, %i)\n", format, hkpx);
 
    if(!format || hkpx < 0 || hkpx > 2)
        return InvalidParameter;
 
    format->hkprefix = (HotkeyPrefix) hkpx;
 
    return Ok;
}

◆ GdipSetStringFormatLineAlign()

GpStatus WINGDIPAPI GdipSetStringFormatLineAlign	(	GpStringFormat *	format,
		StringAlignment	align
	)

Definition at line 277 of file stringformat.c.

{
    TRACE("(%p, %i)\n", format, align);
 
    if(!format)
        return InvalidParameter;
 
    format->line_align = align;
 
    return Ok;
}

Referenced by test_measure_string().

◆ GdipSetStringFormatMeasurableCharacterRanges()

GpStatus WINGDIPAPI GdipSetStringFormatMeasurableCharacterRanges	(	GpStringFormat *	format,
		INT	rangeCount,
		GDIPCONST CharacterRange *	ranges
	)

Definition at line 290 of file stringformat.c.

{
    CharacterRange *new_ranges;
 
    if (!(format && ranges))
        return InvalidParameter;
 
    TRACE("%p, %d, %p\n", format, rangeCount, ranges);
 
    new_ranges = heap_alloc_zero(rangeCount * sizeof(CharacterRange));
    if (!new_ranges)
        return OutOfMemory;
 
    heap_free(format->character_ranges);
    format->character_ranges = new_ranges;
    memcpy(format->character_ranges, ranges, sizeof(CharacterRange) * rangeCount);
    format->range_count = rangeCount;
 
    return Ok;
}

Referenced by test_characterrange(), test_font_height_scaling(), test_measure_string(), and test_string_functions().

◆ GdipSetStringFormatTabStops()

GpStatus WINGDIPAPI GdipSetStringFormatTabStops	(	GpStringFormat *	format,
		REAL	firsttab,
		INT	count,
		GDIPCONST REAL *	tabs
	)

Definition at line 312 of file stringformat.c.

{
    TRACE("(%p, %0.2f, %i, %p)\n", format, firsttab, count, tabs);
 
    if(!format || !tabs)
        return InvalidParameter;
 
    if(count > 0){
        if(firsttab < 0.0)  return NotImplemented;
        /* first time allocation */
        if(format->tabcount == 0){
            format->tabs = heap_alloc_zero(sizeof(REAL)*count);
            if(!format->tabs)
                return OutOfMemory;
        }
        /* reallocation */
        if((format->tabcount < count) && (format->tabcount > 0)){
            REAL *ptr;
            ptr = heap_realloc(format->tabs, sizeof(REAL)*count);
            if(!ptr)
                return OutOfMemory;
            format->tabs = ptr;
        }
        format->firsttab = firsttab;
        format->tabcount = count;
        memcpy(format->tabs, tabs, sizeof(REAL)*count);
    }
 
    return Ok;
}

Referenced by test_tabstops().

◆ GdipSetStringFormatTrimming()

GpStatus WINGDIPAPI GdipSetStringFormatTrimming	(	GpStringFormat *	format,
		StringTrimming	trimming
	)

Definition at line 344 of file stringformat.c.

{
    TRACE("(%p, %i)\n", format, trimming);
 
    if(!format)
        return InvalidParameter;
 
    format->trimming = trimming;
 
    return Ok;
}

◆ GdipSetTextContrast()

GpStatus WINGDIPAPI GdipSetTextContrast	(	GpGraphics *	graphics,
		UINT	contrast
	)

Definition at line 6318 of file graphics.c.

{
    TRACE("(%p, %d)\n", graphics, contrast);
 
    if(!graphics)
        return InvalidParameter;
 
    graphics->textcontrast = contrast;
 
    return Ok;
}

Referenced by test_BeginContainer2().

◆ GdipSetTextRenderingHint()

GpStatus WINGDIPAPI GdipSetTextRenderingHint	(	GpGraphics *	graphics,
		TextRenderingHint	hint
	)

Definition at line 6330 of file graphics.c.

{
    TRACE("(%p, %d)\n", graphics, hint);
 
    if(!graphics || hint > TextRenderingHintClearTypeGridFit)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if(graphics->texthint == hint)
        return Ok;
 
    if(graphics->image && graphics->image->type == ImageTypeMetafile) {
        GpStatus stat;
 
        stat = METAFILE_AddSimpleProperty((GpMetafile*)graphics->image,
                EmfPlusRecordTypeSetTextRenderingHint, hint);
        if(stat != Ok)
            return stat;
    }
 
    graphics->texthint = hint;
 
    return Ok;
}

Referenced by GdipPlayMetafileRecord(), test_BeginContainer2(), test_Get_Release_DC(), test_get_set_textrenderinghint(), and test_properties().

◆ GdipSetTextureTransform()

GpStatus WINGDIPAPI GdipSetTextureTransform	(	GpTexture *	texture,
		GDIPCONST GpMatrix *	matrix
	)

Definition at line 1939 of file brush.c.

{
    TRACE("(%p, %p)\n", texture, matrix);
 
    if(!texture || !matrix)
        return InvalidParameter;
 
    texture->transform = *matrix;
 
    return Ok;
}

Referenced by metafile_deserialize_brush(), and test_transform().

◆ GdipSetTextureWrapMode()

GpStatus WINGDIPAPI GdipSetTextureWrapMode	(	GpTexture *	brush,
		GpWrapMode	wrapmode
	)

Definition at line 1957 of file brush.c.

{
    TRACE("(%p, %d)\n", brush, wrapmode);
 
    if(!brush)
        return InvalidParameter;
 
    brush->imageattributes->wrap = wrapmode;
 
    return Ok;
}

Referenced by test_texturewrap().

◆ GdipSetWorldTransform()

GpStatus WINGDIPAPI GdipSetWorldTransform	(	GpGraphics *	graphics,
		GpMatrix *	matrix
	)

Definition at line 6358 of file graphics.c.

{
    GpStatus stat;
 
    TRACE("(%p, %p)\n", graphics, matrix);
 
    if(!graphics || !matrix)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    TRACE("%f,%f,%f,%f,%f,%f\n",
          matrix->matrix[0], matrix->matrix[1], matrix->matrix[2],
          matrix->matrix[3], matrix->matrix[4], matrix->matrix[5]);
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile) {
        stat = METAFILE_SetWorldTransform((GpMetafile*)graphics->image, matrix);
 
        if (stat != Ok)
            return stat;
    }
 
    graphics->worldtrans = *matrix;
 
    return Ok;
}

Referenced by METAFILE_PlaybackUpdateWorldTransform(), test_BeginContainer2(), test_clipping(), test_clipping_2(), test_DrawImage_scale(), test_font_transform(), test_Get_Release_DC(), test_isinfinite(), and test_worldtransform().

◆ GdipShearMatrix()

GpStatus WINGDIPAPI GdipShearMatrix	(	GpMatrix *	matrix,
		REAL	shearX,
		REAL	shearY,
		GpMatrixOrder	order
	)

Definition at line 335 of file matrix.c.

{
    REAL shear[6];
 
    TRACE("(%p, %.2f, %.2f, %d)\n", matrix, shearX, shearY, order);
 
    if(!matrix)
        return InvalidParameter;
 
    /* prepare transformation matrix */
    shear[0] = 1.0;
    shear[1] = shearY;
    shear[2] = shearX;
    shear[3] = 1.0;
    shear[4] = 0.0;
    shear[5] = 0.0;
 
    if(order == MatrixOrderAppend)
        matrix_multiply(matrix->matrix, shear, matrix->matrix);
    else if (order == MatrixOrderPrepend)
        matrix_multiply(shear, matrix->matrix, matrix->matrix);
    else
        return InvalidParameter;
 
    return Ok;
}

Referenced by test_font_transform(), and test_shear().

◆ GdipStartPathFigure()

GpStatus WINGDIPAPI GdipStartPathFigure ( GpPath * path )

Definition at line 1744 of file graphicspath.c.

{
    TRACE("(%p)\n", path);
 
    if(!path)
        return InvalidParameter;
 
    path->newfigure = TRUE;
 
    return Ok;
}

Referenced by test_getsubpathcount().

◆ GdipStringFormatGetGenericDefault()

GpStatus WINGDIPAPI GdipStringFormatGetGenericDefault ( GpStringFormat ** format )

Definition at line 120 of file stringformat.c.

{
    if (!format)
        return InvalidParameter;
 
    *format = &generic_default_format;
 
    return Ok;
}

Referenced by test_getgenericdefault().

◆ GdipStringFormatGetGenericTypographic()

GpStatus WINGDIPAPI GdipStringFormatGetGenericTypographic ( GpStringFormat ** format )

Definition at line 408 of file stringformat.c.

{
    if(!format)
        return InvalidParameter;
 
    *format = &generic_typographic_format;
 
    TRACE("%p => %p\n", format, *format);
 
    return Ok;
}

Referenced by test_font_transform(), and test_getgenerictypographic().

◆ GdipTestControl()

GpStatus WINGDIPAPI GdipTestControl	(	GpTestControlEnum	control,
		void *	param
	)

Definition at line 5326 of file image.c.

{
    TRACE("(%d, %p)\n", control, param);
 
    switch(control){
        case TestControlForceBilinear:
            if(param)
                FIXME("TestControlForceBilinear not handled\n");
            break;
        case TestControlNoICM:
            if(param)
                FIXME("TestControlNoICM not handled\n");
            break;
        case TestControlGetBuildNumber:
            *((DWORD*)param) = 3102;
            break;
    }
 
    return Ok;
}

Referenced by test_testcontrol().

◆ GdipTransformMatrixPoints()

GpStatus WINGDIPAPI GdipTransformMatrixPoints	(	GpMatrix *	matrix,
		GpPointF *	pts,
		INT	count
	)

Definition at line 363 of file matrix.c.

{
    REAL x, y;
    INT i;
 
    TRACE("(%p, %p, %d)\n", matrix, pts, count);
 
    if(!matrix || !pts || count <= 0)
        return InvalidParameter;
 
    for(i = 0; i < count; i++)
    {
        x = pts[i].X;
        y = pts[i].Y;
 
        pts[i].X = x * matrix->matrix[0] + y * matrix->matrix[2] + matrix->matrix[4];
        pts[i].Y = x * matrix->matrix[1] + y * matrix->matrix[3] + matrix->matrix[5];
    }
 
    return Ok;
}

Referenced by brush_fill_pixels(), draw_cap(), gdip_transform_points(), GdipDrawImagePointsRect(), GdipGetLogFontW(), GdipGetPathWorldBounds(), GdipMeasureDriverString(), GdipTransformMatrixPointsI(), GdipTransformPath(), get_font_hfont(), prepare_dc(), test_transform(), and transform_region_element().

◆ GdipTransformMatrixPointsI()

GpStatus WINGDIPAPI GdipTransformMatrixPointsI	(	GpMatrix *	matrix,
		GpPoint *	pts,
		INT	count
	)

Definition at line 386 of file matrix.c.

{
    GpPointF *ptsF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %d)\n", matrix, pts, count);
 
    if(count <= 0)
        return InvalidParameter;
 
    ptsF = heap_alloc_zero(sizeof(GpPointF) * count);
    if(!ptsF)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        ptsF[i].X = (REAL)pts[i].X;
        ptsF[i].Y = (REAL)pts[i].Y;
    }
 
    ret = GdipTransformMatrixPoints(matrix, ptsF, count);
 
    if(ret == Ok)
        for(i = 0; i < count; i++){
            pts[i].X = gdip_round(ptsF[i].X);
            pts[i].Y = gdip_round(ptsF[i].Y);
        }
    heap_free(ptsF);
 
    return ret;
}

◆ GdipTransformPath()

GpStatus WINGDIPAPI GdipTransformPath	(	GpPath *	path,
		GpMatrix *	matrix
	)

Definition at line 1782 of file graphicspath.c.

{
    TRACE("(%p, %p)\n", path, matrix);
 
    if(!path)
        return InvalidParameter;
 
    if(path->pathdata.Count == 0 || !matrix)
        return Ok;
 
    return GdipTransformMatrixPoints(matrix, path->pathdata.Points,
                                     path->pathdata.Count);
}

Referenced by brush_fill_pixels(), GdipFlattenPath(), GdipIsOutlineVisiblePathPoint(), GdipSetClipPath(), GdipWidenPath(), SOFTWARE_GdipDrawPath(), and test_flatten().

◆ GdipTransformPoints()

GpStatus WINGDIPAPI GdipTransformPoints	(	GpGraphics *	graphics,
		GpCoordinateSpace	dst_space,
		GpCoordinateSpace	src_space,
		GpPointF *	points,
		INT	count
	)

Definition at line 6960 of file graphics.c.

{
    if(!graphics || !points || count <= 0 ||
       dst_space < 0 || dst_space > CoordinateSpaceDevice ||
       src_space < 0 || src_space > CoordinateSpaceDevice)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
 
    if (src_space == dst_space) return Ok;
 
    return gdip_transform_points(graphics, dst_space, src_space, points, count);
}

Referenced by GdipEnumerateMetafileSrcRectDestPoints(), GdipIsVisiblePoint(), GdipIsVisibleRect(), GdipTransformPointsI(), METAFILE_FillRectangles(), test_clipping(), test_clipping_2(), test_container_rects(), test_font_height_scaling(), test_GdipMeasureString(), test_Get_Release_DC(), test_pen_thickness(), test_transform(), and test_transformpoints().

◆ GdipTransformPointsI()

GpStatus WINGDIPAPI GdipTransformPointsI	(	GpGraphics *	graphics,
		GpCoordinateSpace	dst_space,
		GpCoordinateSpace	src_space,
		GpPoint *	points,
		INT	count
	)

Definition at line 6978 of file graphics.c.

{
    GpPointF *pointsF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
 
    if(count <= 0)
        return InvalidParameter;
 
    pointsF = heap_alloc_zero(sizeof(GpPointF) * count);
    if(!pointsF)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        pointsF[i].X = (REAL)points[i].X;
        pointsF[i].Y = (REAL)points[i].Y;
    }
 
    ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
 
    if(ret == Ok)
        for(i = 0; i < count; i++){
            points[i].X = gdip_round(pointsF[i].X);
            points[i].Y = gdip_round(pointsF[i].Y);
        }
    heap_free(pointsF);
 
    return ret;
}

Referenced by test_transformpoints().

◆ GdipTransformRegion()

GpStatus WINGDIPAPI GdipTransformRegion	(	GpRegion *	region,
		GpMatrix *	matrix
	)

Definition at line 1480 of file region.c.

{
    TRACE("(%p, %p)\n", region, matrix);
 
    if (!region || !matrix)
        return InvalidParameter;
 
    return transform_region_element(&region->node, matrix);
}

Referenced by GdipGetClip(), GdipGetVisibleClipBounds(), GdipSetClipHrgn(), GdipSetClipRect(), GdipSetClipRegion(), get_clip_hrgn(), get_region_scans_data(), metafile_set_clip_region(), SOFTWARE_GdipFillRegion(), test_clipping(), test_getregiondata(), and test_transform().

◆ GdipTranslateClip()

GpStatus WINGDIPAPI GdipTranslateClip	(	GpGraphics *	graphics,
		REAL	dx,
		REAL	dy
	)

Definition at line 7026 of file graphics.c.

{
    TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    return GdipTranslateRegion(graphics->clip, dx, dy);
}

Referenced by test_Get_Release_DC().

◆ GdipTranslateClipI()

GpStatus WINGDIPAPI GdipTranslateClipI	(	GpGraphics *	graphics,
		INT	dx,
		INT	dy
	)

Definition at line 7042 of file graphics.c.

{
    TRACE("(%p, %d, %d)\n", graphics, dx, dy);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
}

Referenced by test_Get_Release_DC().

◆ GdipTranslateLineTransform()

GpStatus WINGDIPAPI GdipTranslateLineTransform	(	GpLineGradient *	brush,
		REAL	dx,
		REAL	dy,
		GpMatrixOrder	order
	)

Definition at line 2166 of file brush.c.

{
    TRACE("(%p,%f,%f,%d)\n", brush, dx, dy, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipTranslateMatrix(&brush->transform, dx, dy, order);
}

Referenced by test_transform().

◆ GdipTranslateMatrix()

GpStatus WINGDIPAPI GdipTranslateMatrix	(	GpMatrix *	matrix,
		REAL	offsetX,
		REAL	offsetY,
		GpMatrixOrder	order
	)

Definition at line 418 of file matrix.c.

{
    REAL translate[6];
 
    TRACE("(%p, %.2f, %.2f, %d)\n", matrix, offsetX, offsetY, order);
 
    if(!matrix)
        return InvalidParameter;
 
    translate[0] = 1.0;
    translate[1] = 0.0;
    translate[2] = 0.0;
    translate[3] = 1.0;
    translate[4] = offsetX;
    translate[5] = offsetY;
 
    if(order == MatrixOrderAppend)
        matrix_multiply(matrix->matrix, translate, matrix->matrix);
    else if (order == MatrixOrderPrepend)
        matrix_multiply(translate, matrix->matrix, matrix->matrix);
    else
        return InvalidParameter;
 
    return Ok;
}

Referenced by draw_cap(), GdipPlayMetafileRecord(), GdipTranslateLineTransform(), GdipTranslatePathGradientTransform(), GdipTranslatePenTransform(), GdipTranslateTextureTransform(), GdipTranslateWorldTransform(), linegradient_init_transform(), test_clipping(), test_clipping_2(), and test_font_transform().

◆ GdipTranslatePathGradientTransform()

GpStatus WINGDIPAPI GdipTranslatePathGradientTransform	(	GpPathGradient *	grad,
		REAL	dx,
		REAL	dy,
		GpMatrixOrder	order
	)

Definition at line 1914 of file brush.c.

{
    TRACE("(%p,%0.2f,%0.2f,%i)\n", grad, dx, dy, order);
 
    if (!grad || grad->brush.bt != BrushTypePathGradient)
        return InvalidParameter;
 
    return GdipTranslateMatrix(&grad->transform, dx, dy, order);
}

◆ GdipTranslatePenTransform()

GpStatus WINGDIPAPI GdipTranslatePenTransform	(	GpPen *	pen,
		REAL	dx,
		REAL	dy,
		GpMatrixOrder	order
	)

Definition at line 461 of file pen.c.

{
    TRACE("(%p,%0.2f,%0.2f,%u)\n", pen, dx, dy, order);
 
    if(!pen)
        return InvalidParameter;
 
    return GdipTranslateMatrix(&pen->transform, dx, dy, order);
}

Referenced by test_transform().

◆ GdipTranslateRegion()

GpStatus WINGDIPAPI GdipTranslateRegion	(	GpRegion *	region,
		REAL	dx,
		REAL	dy
	)

Definition at line 1520 of file region.c.

{
    TRACE("(%p, %f, %f)\n", region, dx, dy);
 
    if(!region)
        return InvalidParameter;
 
    translate_region_element(&region->node, dx, dy);
 
    return Ok;
}

Referenced by GdipTranslateClip(), GdipTranslateClipI(), GdipTranslateRegionI(), test_getregiondata(), and test_translate().

◆ GdipTranslateRegionI()

GpStatus WINGDIPAPI GdipTranslateRegionI	(	GpRegion *	region,
		INT	dx,
		INT	dy
	)

Definition at line 1535 of file region.c.

{
    TRACE("(%p, %d, %d)\n", region, dx, dy);
 
    return GdipTranslateRegion(region, (REAL)dx, (REAL)dy);
}

◆ GdipTranslateTextureTransform()

GpStatus WINGDIPAPI GdipTranslateTextureTransform	(	GpTexture *	brush,
		REAL	dx,
		REAL	dy,
		GpMatrixOrder	order
	)

Definition at line 2180 of file brush.c.

{
    TRACE("(%p, %.2f, %.2f, %d)\n", brush, dx, dy, order);
 
    if(!brush)
        return InvalidParameter;
 
    return GdipTranslateMatrix(&brush->transform, dx, dy, order);
}

◆ GdipTranslateWorldTransform()

GpStatus WINGDIPAPI GdipTranslateWorldTransform	(	GpGraphics *	graphics,
		REAL	dx,
		REAL	dy,
		GpMatrixOrder	order
	)

Definition at line 6386 of file graphics.c.

{
    GpStatus stat;
 
    TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
 
    if(!graphics)
        return InvalidParameter;
 
    if(graphics->busy)
        return ObjectBusy;
 
    if (graphics->image && graphics->image->type == ImageTypeMetafile) {
        stat = METAFILE_TranslateWorldTransform((GpMetafile*)graphics->image, dx, dy, order);
 
        if (stat != Ok)
            return stat;
    }
 
    return GdipTranslateMatrix(&graphics->worldtrans, dx, dy, order);
}

Referenced by test_GdipIsVisiblePoint(), test_GdipIsVisibleRect(), test_Get_Release_DC(), test_isvisiblepoint(), test_isvisiblerect(), test_transformpoints(), and test_worldtransform().

◆ GdipVectorTransformMatrixPoints()

GpStatus WINGDIPAPI GdipVectorTransformMatrixPoints	(	GpMatrix *	matrix,
		GpPointF *	pts,
		INT	count
	)

Definition at line 445 of file matrix.c.

{
    REAL x, y;
    INT i;
 
    TRACE("(%p, %p, %d)\n", matrix, pts, count);
 
    if(!matrix || !pts || count <= 0)
        return InvalidParameter;
 
    for(i = 0; i < count; i++)
    {
        x = pts[i].X;
        y = pts[i].Y;
 
        pts[i].X = x * matrix->matrix[0] + y * matrix->matrix[2];
        pts[i].Y = x * matrix->matrix[1] + y * matrix->matrix[3];
    }
 
    return Ok;
}

Referenced by GdipVectorTransformMatrixPointsI().

◆ GdipVectorTransformMatrixPointsI()

GpStatus WINGDIPAPI GdipVectorTransformMatrixPointsI	(	GpMatrix *	matrix,
		GpPoint *	pts,
		INT	count
	)

Definition at line 467 of file matrix.c.

{
    GpPointF *ptsF;
    GpStatus ret;
    INT i;
 
    TRACE("(%p, %p, %d)\n", matrix, pts, count);
 
    if(count <= 0)
        return InvalidParameter;
 
    ptsF = heap_alloc_zero(sizeof(GpPointF) * count);
    if(!ptsF)
        return OutOfMemory;
 
    for(i = 0; i < count; i++){
        ptsF[i].X = (REAL)pts[i].X;
        ptsF[i].Y = (REAL)pts[i].Y;
    }
 
    ret = GdipVectorTransformMatrixPoints(matrix, ptsF, count);
    /* store back */
    if(ret == Ok)
        for(i = 0; i < count; i++){
            pts[i].X = gdip_round(ptsF[i].X);
            pts[i].Y = gdip_round(ptsF[i].Y);
        }
    heap_free(ptsF);
 
    return ret;
}

◆ GdipWarpPath()

GpStatus WINGDIPAPI GdipWarpPath	(	GpPath *	path,
		GpMatrix *	matrix,
		GDIPCONST GpPointF *	points,
		INT	count,
		REAL	x,
		REAL	y,
		REAL	width,
		REAL	height,
		WarpMode	warpmode,
		REAL	flatness
	)

Definition at line 1796 of file graphicspath.c.

{
    FIXME("(%p,%p,%p,%i,%0.2f,%0.2f,%0.2f,%0.2f,%i,%0.2f)\n", path, matrix,
        points, count, x, y, width, height, warpmode, flatness);
 
    return NotImplemented;
}

◆ GdipWidenPath()

GpStatus WINGDIPAPI GdipWidenPath	(	GpPath *	path,
		GpPen *	pen,
		GpMatrix *	matrix,
		REAL	flatness
	)

Definition at line 2197 of file graphicspath.c.

{
    GpPath *flat_path=NULL;
    GpStatus status;
    path_list_node_t *points=NULL, *last_point=NULL;
    int i, subpath_start=0, new_length;
    BYTE type;
 
    TRACE("(%p,%p,%p,%0.2f)\n", path, pen, matrix, flatness);
 
    if (!path || !pen)
        return InvalidParameter;
 
    if (path->pathdata.Count <= 1)
        return OutOfMemory;
 
    status = GdipClonePath(path, &flat_path);
 
    if (status == Ok)
        status = GdipFlattenPath(flat_path, pen->unit == UnitPixel ? matrix : NULL, flatness);
 
    if (status == Ok && !init_path_list(&points, 314.0, 22.0))
        status = OutOfMemory;
 
    if (status == Ok)
    {
        last_point = points;
 
        if (pen->endcap > LineCapTriangle)
            FIXME("unimplemented end cap %x\n", pen->endcap);
 
        if (pen->startcap > LineCapTriangle)
            FIXME("unimplemented start cap %x\n", pen->startcap);
 
        if (pen->dashcap != DashCapFlat)
            FIXME("unimplemented dash cap %d\n", pen->dashcap);
 
        if (pen->join == LineJoinRound)
            FIXME("unimplemented line join %d\n", pen->join);
 
        if (pen->align != PenAlignmentCenter)
            FIXME("unimplemented pen alignment %d\n", pen->align);
 
        for (i=0; i < flat_path->pathdata.Count; i++)
        {
            type = flat_path->pathdata.Types[i];
 
            if ((type&PathPointTypePathTypeMask) == PathPointTypeStart)
                subpath_start = i;
 
            if ((type&PathPointTypeCloseSubpath) == PathPointTypeCloseSubpath)
            {
                if (pen->dash != DashStyleSolid)
                    widen_dashed_figure(flat_path, pen, subpath_start, i, 1, &last_point);
                else
                    widen_closed_figure(flat_path, pen, subpath_start, i, &last_point);
            }
            else if (i == flat_path->pathdata.Count-1 ||
                (flat_path->pathdata.Types[i+1]&PathPointTypePathTypeMask) == PathPointTypeStart)
            {
                if (pen->dash != DashStyleSolid)
                    widen_dashed_figure(flat_path, pen, subpath_start, i, 0, &last_point);
                else
                    widen_open_figure(flat_path->pathdata.Points, pen, subpath_start, i, pen->startcap, pen->customstart, pen->endcap, pen->customend, &last_point);
            }
        }
 
        new_length = path_list_count(points)-1;
 
        if (!lengthen_path(path, new_length))
            status = OutOfMemory;
    }
 
    if (status == Ok)
    {
        path->pathdata.Count = new_length;
 
        last_point = points->next;
        for (i = 0; i < new_length; i++)
        {
            path->pathdata.Points[i] = last_point->pt;
            path->pathdata.Types[i] = last_point->type;
            last_point = last_point->next;
        }
 
        path->fill = FillModeWinding;
    }
 
    free_path_list(points);
 
    GdipDeletePath(flat_path);
 
    if (status == Ok && pen->unit != UnitPixel)
        status = GdipTransformPath(path, matrix);
 
    return status;
}

Referenced by GdipIsOutlineVisiblePathPoint(), SOFTWARE_GdipDrawPath(), and test_widen().

◆ GdipWindingModeOutline()

GpStatus WINGDIPAPI GdipWindingModeOutline	(	GpPath *	path,
		GpMatrix *	matrix,
		REAL	flatness
	)

Definition at line 2458 of file graphicspath.c.

{
   FIXME("stub: %p, %p, %.2f\n", path, matrix, flatness);
   return NotImplemented;
}

Macros

Functions

Macro Definition Documentation

◆ GDIPCONST

◆ WINGDIPAPI

Function Documentation

◆ GdipAddPathArc()

◆ GdipAddPathArcI()

◆ GdipAddPathBezier()

◆ GdipAddPathBezierI()

◆ GdipAddPathBeziers()

◆ GdipAddPathBeziersI()

◆ GdipAddPathClosedCurve()

◆ GdipAddPathClosedCurve2()

◆ GdipAddPathClosedCurve2I()

◆ GdipAddPathClosedCurveI()

◆ GdipAddPathCurve()

◆ GdipAddPathCurve2()

◆ GdipAddPathCurve2I()

◆ GdipAddPathCurve3()

◆ GdipAddPathCurve3I()

◆ GdipAddPathCurveI()

◆ GdipAddPathEllipse()

◆ GdipAddPathEllipseI()

◆ GdipAddPathLine()

◆ GdipAddPathLine2()

◆ GdipAddPathLine2I()

◆ GdipAddPathLineI()

◆ GdipAddPathPath()

◆ GdipAddPathPie()

◆ GdipAddPathPieI()

◆ GdipAddPathPolygon()

◆ GdipAddPathPolygonI()

◆ GdipAddPathRectangle()

◆ GdipAddPathRectangleI()

◆ GdipAddPathRectangles()

◆ GdipAddPathRectanglesI()

◆ GdipAddPathString()

◆ GdipAddPathStringI()

◆ GdipBeginContainer()

◆ GdipBeginContainer2()

◆ GdipBeginContainerI()

◆ GdipBitmapApplyEffect()

◆ GdipBitmapCreateApplyEffect()

◆ GdipBitmapGetHistogram()

◆ GdipBitmapGetHistogramSize()

◆ GdipBitmapGetPixel()

◆ GdipBitmapLockBits()

◆ GdipBitmapSetPixel()

◆ GdipBitmapSetResolution()

◆ GdipBitmapUnlockBits()

◆ GdipClearPathMarkers()

◆ GdipCloneBitmapArea()

◆ GdipCloneBitmapAreaI()

◆ GdipCloneBrush()

◆ GdipCloneCustomLineCap()

◆ GdipCloneFont()

◆ GdipCloneFontFamily()

◆ GdipCloneImage()

◆ GdipCloneImageAttributes()

◆ GdipCloneMatrix()

◆ GdipClonePath()

◆ GdipClonePen()

◆ GdipCloneRegion()

◆ GdipCloneStringFormat()

◆ GdipClosePathFigure()

◆ GdipClosePathFigures()

◆ GdipCombineRegionPath()

◆ GdipCombineRegionRect()

◆ GdipCombineRegionRectI()

◆ GdipCombineRegionRegion()

◆ GdipComment()

◆ GdipConvertToEmfPlus()

◆ GdipConvertToEmfPlusToFile()

◆ GdipConvertToEmfPlusToStream()

◆ GdipCreateAdjustableArrowCap()

◆ GdipCreateBitmapFromFile()

◆ GdipCreateBitmapFromFileICM()

◆ GdipCreateBitmapFromGdiDib()

◆ GdipCreateBitmapFromGraphics()