| /**************************************************************************\ | |
| * | |
| * Copyright (c) 1998-2000, Microsoft Corp. All Rights Reserved. | |
| * | |
| * Module Name: | |
| * | |
| * GdiplusGraphics.h | |
| * | |
| * Abstract: | |
| * | |
| * Declarations for Graphics class | |
| * | |
| \**************************************************************************/ | |
| #ifndef _GDIPLUSGRAPHICS_H | |
| #define _GDIPLUSGRAPHICS_H | |
| /** | |
| * Represent a graphics context | |
| */ | |
| class Graphics : public GdiplusBase | |
| { | |
| public: | |
| friend class Region; | |
| friend class GraphicsPath; | |
| friend class Image; | |
| friend class Bitmap; | |
| friend class Metafile; | |
| friend class Font; | |
| friend class FontFamily; | |
| friend class FontCollection; | |
| friend class CachedBitmap; | |
| // Get a graphics context from an existing Win32 HDC or HWND | |
| static Graphics* FromHDC(IN HDC hdc) | |
| { | |
| return new Graphics(hdc); | |
| } | |
| static Graphics* FromHDC(IN HDC hdc, | |
| IN HANDLE hdevice) | |
| { | |
| return new Graphics(hdc, hdevice); | |
| } | |
| static Graphics* FromHWND(IN HWND hwnd, | |
| IN BOOL icm = FALSE) | |
| { | |
| return new Graphics(hwnd, icm); | |
| } | |
| static Graphics* FromImage(IN Image *image) | |
| { | |
| return new Graphics(image); | |
| } | |
| Graphics(IN HDC hdc) | |
| { | |
| GpGraphics *graphics = NULL; | |
| lastResult = DllExports::GdipCreateFromHDC(hdc, &graphics); | |
| SetNativeGraphics(graphics); | |
| } | |
| Graphics(IN HDC hdc, | |
| IN HANDLE hdevice) | |
| { | |
| GpGraphics *graphics = NULL; | |
| lastResult = DllExports::GdipCreateFromHDC2(hdc, hdevice, &graphics); | |
| SetNativeGraphics(graphics); | |
| } | |
| Graphics(IN HWND hwnd, | |
| IN BOOL icm = FALSE) | |
| { | |
| GpGraphics *graphics = NULL; | |
| if (icm) | |
| { | |
| lastResult = DllExports::GdipCreateFromHWNDICM(hwnd, &graphics); | |
| } | |
| else | |
| { | |
| lastResult = DllExports::GdipCreateFromHWND(hwnd, &graphics); | |
| } | |
| SetNativeGraphics(graphics); | |
| } | |
| Graphics(IN Image* image) | |
| { | |
| GpGraphics *graphics = NULL; | |
| if (image != NULL) | |
| { | |
| lastResult = DllExports::GdipGetImageGraphicsContext( | |
| image->nativeImage, &graphics); | |
| } | |
| SetNativeGraphics(graphics); | |
| } | |
| ~Graphics() | |
| { | |
| DllExports::GdipDeleteGraphics(nativeGraphics); | |
| } | |
| VOID Flush(IN FlushIntention intention = FlushIntentionFlush) | |
| { | |
| DllExports::GdipFlush(nativeGraphics, intention); | |
| } | |
| //------------------------------------------------------------------------ | |
| // Interop methods | |
| //------------------------------------------------------------------------ | |
| // Locks the graphics until ReleaseDC is called | |
| HDC GetHDC() | |
| { | |
| HDC hdc = NULL; | |
| SetStatus(DllExports::GdipGetDC(nativeGraphics, &hdc)); | |
| return hdc; | |
| } | |
| VOID ReleaseHDC(IN HDC hdc) | |
| { | |
| SetStatus(DllExports::GdipReleaseDC(nativeGraphics, hdc)); | |
| } | |
| //------------------------------------------------------------------------ | |
| // Rendering modes | |
| //------------------------------------------------------------------------ | |
| Status SetRenderingOrigin(IN INT x, IN INT y) | |
| { | |
| return SetStatus( | |
| DllExports::GdipSetRenderingOrigin( | |
| nativeGraphics, x, y | |
| ) | |
| ); | |
| } | |
| Status GetRenderingOrigin(OUT INT *x, OUT INT *y) const | |
| { | |
| return SetStatus( | |
| DllExports::GdipGetRenderingOrigin( | |
| nativeGraphics, x, y | |
| ) | |
| ); | |
| } | |
| Status SetCompositingMode(IN CompositingMode compositingMode) | |
| { | |
| return SetStatus(DllExports::GdipSetCompositingMode(nativeGraphics, | |
| compositingMode)); | |
| } | |
| CompositingMode GetCompositingMode() const | |
| { | |
| CompositingMode mode; | |
| SetStatus(DllExports::GdipGetCompositingMode(nativeGraphics, | |
| &mode)); | |
| return mode; | |
| } | |
| Status SetCompositingQuality(IN CompositingQuality compositingQuality) | |
| { | |
| return SetStatus(DllExports::GdipSetCompositingQuality( | |
| nativeGraphics, | |
| compositingQuality)); | |
| } | |
| CompositingQuality GetCompositingQuality() const | |
| { | |
| CompositingQuality quality; | |
| SetStatus(DllExports::GdipGetCompositingQuality( | |
| nativeGraphics, | |
| &quality)); | |
| return quality; | |
| } | |
| Status SetTextRenderingHint(IN TextRenderingHint newMode) | |
| { | |
| #ifndef DCR_USE_NEW_186764 | |
| /* temporarly set the high bit to warn that we are using the new definition for the flag */ | |
| newMode = (TextRenderingHint) (newMode | 0x0f000); | |
| #endif // DCR_USE_NEW_186764 | |
| return SetStatus(DllExports::GdipSetTextRenderingHint(nativeGraphics, | |
| newMode)); | |
| } | |
| TextRenderingHint GetTextRenderingHint() const | |
| { | |
| TextRenderingHint hint; | |
| SetStatus(DllExports::GdipGetTextRenderingHint(nativeGraphics, | |
| &hint)); | |
| return hint; | |
| } | |
| #ifdef DCR_USE_NEW_188922 | |
| Status SetTextContrast(IN UINT contrast) | |
| { | |
| return SetStatus(DllExports::GdipSetTextContrast(nativeGraphics, | |
| contrast)); | |
| } | |
| UINT GetTextContrast() const | |
| { | |
| UINT contrast; | |
| SetStatus(DllExports::GdipGetTextContrast(nativeGraphics, | |
| &contrast)); | |
| return contrast; | |
| } | |
| #else | |
| Status SetTextGammaValue(IN UINT gammaValue) | |
| { | |
| return SetStatus(DllExports::GdipSetTextGammaValue(nativeGraphics, | |
| gammaValue)); | |
| } | |
| UINT GetTextGammaValue() const | |
| { | |
| UINT gammaValue; | |
| SetStatus(DllExports::GdipGetTextGammaValue(nativeGraphics, | |
| &gammaValue)); | |
| return gammaValue; | |
| } | |
| #endif // DCR_USE_NEW_188922 | |
| InterpolationMode GetInterpolationMode() const | |
| { | |
| InterpolationMode mode = InterpolationModeInvalid; | |
| SetStatus(DllExports::GdipGetInterpolationMode(nativeGraphics, | |
| &mode)); | |
| return mode; | |
| } | |
| Status SetInterpolationMode(IN InterpolationMode interpolationMode) | |
| { | |
| return SetStatus(DllExports::GdipSetInterpolationMode(nativeGraphics, | |
| interpolationMode)); | |
| } | |
| SmoothingMode GetSmoothingMode() const | |
| { | |
| SmoothingMode smoothingMode = SmoothingModeInvalid; | |
| SetStatus(DllExports::GdipGetSmoothingMode(nativeGraphics, | |
| &smoothingMode)); | |
| return smoothingMode; | |
| } | |
| Status SetSmoothingMode(IN SmoothingMode smoothingMode) | |
| { | |
| return SetStatus(DllExports::GdipSetSmoothingMode(nativeGraphics, | |
| smoothingMode)); | |
| } | |
| PixelOffsetMode GetPixelOffsetMode() const | |
| { | |
| PixelOffsetMode pixelOffsetMode = PixelOffsetModeInvalid; | |
| SetStatus(DllExports::GdipGetPixelOffsetMode(nativeGraphics, | |
| &pixelOffsetMode)); | |
| return pixelOffsetMode; | |
| } | |
| Status SetPixelOffsetMode(IN PixelOffsetMode pixelOffsetMode) | |
| { | |
| return SetStatus(DllExports::GdipSetPixelOffsetMode(nativeGraphics, | |
| pixelOffsetMode)); | |
| } | |
| //------------------------------------------------------------------------ | |
| // Manipulate the current world transform | |
| //------------------------------------------------------------------------ | |
| Status SetTransform(IN const Matrix* matrix) | |
| { | |
| return SetStatus(DllExports::GdipSetWorldTransform(nativeGraphics, | |
| matrix->nativeMatrix)); | |
| } | |
| Status ResetTransform() | |
| { | |
| return SetStatus(DllExports::GdipResetWorldTransform(nativeGraphics)); | |
| } | |
| Status MultiplyTransform(IN const Matrix* matrix, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipMultiplyWorldTransform(nativeGraphics, | |
| matrix->nativeMatrix, | |
| order)); | |
| } | |
| Status TranslateTransform(IN REAL dx, | |
| IN REAL dy, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipTranslateWorldTransform(nativeGraphics, | |
| dx, dy, order)); | |
| } | |
| Status ScaleTransform(IN REAL sx, | |
| IN REAL sy, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipScaleWorldTransform(nativeGraphics, | |
| sx, sy, order)); | |
| } | |
| Status RotateTransform(IN REAL angle, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipRotateWorldTransform(nativeGraphics, | |
| angle, order)); | |
| } | |
| /** | |
| * Return the current world transform | |
| */ | |
| Status GetTransform(OUT Matrix* matrix) const | |
| { | |
| return SetStatus(DllExports::GdipGetWorldTransform(nativeGraphics, | |
| matrix->nativeMatrix)); | |
| } | |
| /** | |
| * Manipulate the current page transform | |
| */ | |
| Status SetPageUnit(IN Unit unit) | |
| { | |
| return SetStatus(DllExports::GdipSetPageUnit(nativeGraphics, | |
| unit)); | |
| } | |
| Status SetPageScale(IN REAL scale) | |
| { | |
| return SetStatus(DllExports::GdipSetPageScale(nativeGraphics, | |
| scale)); | |
| } | |
| /** | |
| * Retrieve the current page transform information | |
| * notes @ these are atomic | |
| */ | |
| Unit GetPageUnit() const | |
| { | |
| Unit unit; | |
| SetStatus(DllExports::GdipGetPageUnit(nativeGraphics, &unit)); | |
| return unit; | |
| } | |
| REAL GetPageScale() const | |
| { | |
| REAL scale; | |
| SetStatus(DllExports::GdipGetPageScale(nativeGraphics, &scale)); | |
| return scale; | |
| } | |
| REAL GetDpiX() const | |
| { | |
| REAL dpi; | |
| SetStatus(DllExports::GdipGetDpiX(nativeGraphics, &dpi)); | |
| return dpi; | |
| } | |
| REAL GetDpiY() const | |
| { | |
| REAL dpi; | |
| SetStatus(DllExports::GdipGetDpiY(nativeGraphics, &dpi)); | |
| return dpi; | |
| } | |
| /** | |
| * Transform points in the current graphics context | |
| */ | |
| // float version | |
| Status TransformPoints(IN CoordinateSpace destSpace, | |
| IN CoordinateSpace srcSpace, | |
| IN OUT PointF* pts, | |
| IN INT count) const | |
| { | |
| return SetStatus(DllExports::GdipTransformPoints(nativeGraphics, | |
| destSpace, | |
| srcSpace, | |
| pts, | |
| count)); | |
| } | |
| // integer version | |
| Status TransformPoints(IN CoordinateSpace destSpace, | |
| IN CoordinateSpace srcSpace, | |
| IN OUT Point* pts, | |
| IN INT count) const | |
| { | |
| return SetStatus(DllExports::GdipTransformPointsI(nativeGraphics, | |
| destSpace, | |
| srcSpace, | |
| pts, | |
| count)); | |
| } | |
| //------------------------------------------------------------------------ | |
| // GetNearestColor (for <= 8bpp surfaces) | |
| // Note: alpha is ignored | |
| //------------------------------------------------------------------------ | |
| Status GetNearestColor(IN OUT Color* color) const | |
| { | |
| if (color == NULL) | |
| { | |
| return SetStatus(InvalidParameter); | |
| } | |
| ARGB argb = color->GetValue(); | |
| Status status = SetStatus(DllExports::GdipGetNearestColor(nativeGraphics, &argb)); | |
| color->SetValue(argb); | |
| return status; | |
| } | |
| /** | |
| * Vector drawing methods | |
| * | |
| * @notes Do we need a set of methods that take | |
| * integer coordinate parameters? | |
| */ | |
| // float version | |
| Status DrawLine(IN const Pen* pen, | |
| IN REAL x1, | |
| IN REAL y1, | |
| IN REAL x2, | |
| IN REAL y2) | |
| { | |
| return SetStatus(DllExports::GdipDrawLine(nativeGraphics, | |
| pen->nativePen, x1, y1, x2, | |
| y2)); | |
| } | |
| Status DrawLine(IN const Pen* pen, | |
| IN const PointF& pt1, | |
| IN const PointF& pt2) | |
| { | |
| return DrawLine(pen, pt1.X, pt1.Y, pt2.X, pt2.Y); | |
| } | |
| Status DrawLines(IN const Pen* pen, | |
| IN const PointF* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawLines(nativeGraphics, | |
| pen->nativePen, | |
| points, count)); | |
| } | |
| // int version | |
| Status DrawLine(IN const Pen* pen, | |
| IN INT x1, | |
| IN INT y1, | |
| IN INT x2, | |
| IN INT y2) | |
| { | |
| return SetStatus(DllExports::GdipDrawLineI(nativeGraphics, | |
| pen->nativePen, | |
| x1, | |
| y1, | |
| x2, | |
| y2)); | |
| } | |
| Status DrawLine(IN const Pen* pen, | |
| IN const Point& pt1, | |
| IN const Point& pt2) | |
| { | |
| return DrawLine(pen, | |
| pt1.X, | |
| pt1.Y, | |
| pt2.X, | |
| pt2.Y); | |
| } | |
| Status DrawLines(IN const Pen* pen, | |
| IN const Point* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawLinesI(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count)); | |
| } | |
| // float version | |
| Status DrawArc(IN const Pen* pen, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return SetStatus(DllExports::GdipDrawArc(nativeGraphics, | |
| pen->nativePen, | |
| x, | |
| y, | |
| width, | |
| height, | |
| startAngle, | |
| sweepAngle)); | |
| } | |
| Status DrawArc(IN const Pen* pen, | |
| IN const RectF& rect, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return DrawArc(pen, rect.X, rect.Y, rect.Width, rect.Height, | |
| startAngle, sweepAngle); | |
| } | |
| // int version | |
| Status DrawArc(IN const Pen* pen, | |
| IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return SetStatus(DllExports::GdipDrawArcI(nativeGraphics, | |
| pen->nativePen, | |
| x, | |
| y, | |
| width, | |
| height, | |
| startAngle, | |
| sweepAngle)); | |
| } | |
| Status DrawArc(IN const Pen* pen, | |
| IN const Rect& rect, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return DrawArc(pen, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height, | |
| startAngle, | |
| sweepAngle); | |
| } | |
| // float version | |
| Status DrawBezier(IN const Pen* pen, | |
| IN REAL x1, | |
| IN REAL y1, | |
| IN REAL x2, | |
| IN REAL y2, | |
| IN REAL x3, | |
| IN REAL y3, | |
| IN REAL x4, | |
| IN REAL y4) | |
| { | |
| return SetStatus(DllExports::GdipDrawBezier(nativeGraphics, | |
| pen->nativePen, x1, y1, | |
| x2, y2, x3, y3, x4, y4)); | |
| } | |
| Status DrawBezier(IN const Pen* pen, | |
| IN const PointF& pt1, | |
| IN const PointF& pt2, | |
| IN const PointF& pt3, | |
| IN const PointF& pt4) | |
| { | |
| return DrawBezier(pen, | |
| pt1.X, | |
| pt1.Y, | |
| pt2.X, | |
| pt2.Y, | |
| pt3.X, | |
| pt3.Y, | |
| pt4.X, | |
| pt4.Y); | |
| } | |
| Status DrawBeziers(IN const Pen* pen, | |
| IN const PointF* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawBeziers(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count)); | |
| } | |
| // int version | |
| Status DrawBezier(IN const Pen* pen, | |
| IN INT x1, | |
| IN INT y1, | |
| IN INT x2, | |
| IN INT y2, | |
| IN INT x3, | |
| IN INT y3, | |
| IN INT x4, | |
| IN INT y4) | |
| { | |
| return SetStatus(DllExports::GdipDrawBezierI(nativeGraphics, | |
| pen->nativePen, | |
| x1, | |
| y1, | |
| x2, | |
| y2, | |
| x3, | |
| y3, | |
| x4, | |
| y4)); | |
| } | |
| Status DrawBezier(IN const Pen* pen, | |
| IN const Point& pt1, | |
| IN const Point& pt2, | |
| IN const Point& pt3, | |
| IN const Point& pt4) | |
| { | |
| return DrawBezier(pen, | |
| pt1.X, | |
| pt1.Y, | |
| pt2.X, | |
| pt2.Y, | |
| pt3.X, | |
| pt3.Y, | |
| pt4.X, | |
| pt4.Y); | |
| } | |
| Status DrawBeziers(IN const Pen* pen, | |
| IN const Point* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawBeziersI(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count)); | |
| } | |
| // float version | |
| Status DrawRectangle(IN const Pen* pen, | |
| IN const RectF& rect) | |
| { | |
| return DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height); | |
| } | |
| Status DrawRectangle(IN const Pen* pen, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height) | |
| { | |
| return SetStatus(DllExports::GdipDrawRectangle(nativeGraphics, | |
| pen->nativePen, x, y, | |
| width, height)); | |
| } | |
| Status DrawRectangles(IN const Pen* pen, | |
| IN const RectF* rects, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawRectangles(nativeGraphics, | |
| pen->nativePen, | |
| rects, count)); | |
| } | |
| // integer version | |
| Status DrawRectangle(IN const Pen* pen, | |
| IN const Rect& rect) | |
| { | |
| return DrawRectangle(pen, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height); | |
| } | |
| Status DrawRectangle(IN const Pen* pen, | |
| IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height) | |
| { | |
| return SetStatus(DllExports::GdipDrawRectangleI(nativeGraphics, | |
| pen->nativePen, | |
| x, | |
| y, | |
| width, | |
| height)); | |
| } | |
| Status DrawRectangles(IN const Pen* pen, | |
| IN const Rect* rects, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawRectanglesI(nativeGraphics, | |
| pen->nativePen, | |
| rects, | |
| count)); | |
| } | |
| // float version | |
| Status DrawEllipse(IN const Pen* pen, | |
| IN const RectF& rect) | |
| { | |
| return DrawEllipse(pen, rect.X, rect.Y, rect.Width, rect.Height); | |
| } | |
| Status DrawEllipse(IN const Pen* pen, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height) | |
| { | |
| return SetStatus(DllExports::GdipDrawEllipse(nativeGraphics, | |
| pen->nativePen, | |
| x, | |
| y, | |
| width, | |
| height)); | |
| } | |
| // integer version | |
| Status DrawEllipse(IN const Pen* pen, | |
| IN const Rect& rect) | |
| { | |
| return DrawEllipse(pen, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height); | |
| } | |
| Status DrawEllipse(IN const Pen* pen, | |
| IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height) | |
| { | |
| return SetStatus(DllExports::GdipDrawEllipseI(nativeGraphics, | |
| pen->nativePen, | |
| x, | |
| y, | |
| width, | |
| height)); | |
| } | |
| // floating point version | |
| Status DrawPie(IN const Pen* pen, | |
| IN const RectF& rect, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return DrawPie(pen, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height, | |
| startAngle, | |
| sweepAngle); | |
| } | |
| Status DrawPie(IN const Pen* pen, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return SetStatus(DllExports::GdipDrawPie(nativeGraphics, | |
| pen->nativePen, | |
| x, | |
| y, | |
| width, | |
| height, | |
| startAngle, | |
| sweepAngle)); | |
| } | |
| // integer point version | |
| Status DrawPie(IN const Pen* pen, | |
| IN const Rect& rect, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return DrawPie(pen, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height, | |
| startAngle, | |
| sweepAngle); | |
| } | |
| Status DrawPie(IN const Pen* pen, | |
| IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return SetStatus(DllExports::GdipDrawPieI(nativeGraphics, | |
| pen->nativePen, | |
| x, | |
| y, | |
| width, | |
| height, | |
| startAngle, | |
| sweepAngle)); | |
| } | |
| // float version | |
| Status DrawPolygon(IN const Pen* pen, | |
| IN const PointF* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawPolygon(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count)); | |
| } | |
| // integer version | |
| Status DrawPolygon(IN const Pen* pen, | |
| IN const Point* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawPolygonI(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count)); | |
| } | |
| // float version | |
| Status DrawPath(IN const Pen* pen, | |
| IN const GraphicsPath* path) | |
| { | |
| return SetStatus(DllExports::GdipDrawPath(nativeGraphics, | |
| pen ? pen->nativePen : NULL, | |
| path ? path->nativePath : NULL)); | |
| } | |
| // float version | |
| Status DrawCurve(IN const Pen* pen, | |
| IN const PointF* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawCurve(nativeGraphics, | |
| pen->nativePen, points, | |
| count)); | |
| } | |
| Status DrawCurve(IN const Pen* pen, | |
| IN const PointF* points, | |
| IN INT count, | |
| IN REAL tension) | |
| { | |
| return SetStatus(DllExports::GdipDrawCurve2(nativeGraphics, | |
| pen->nativePen, points, | |
| count, tension)); | |
| } | |
| Status DrawCurve(IN const Pen* pen, | |
| IN const PointF* points, | |
| IN INT count, | |
| IN INT offset, | |
| IN INT numberOfSegments, | |
| IN REAL tension = 0.5f) | |
| { | |
| return SetStatus(DllExports::GdipDrawCurve3(nativeGraphics, | |
| pen->nativePen, points, | |
| count, offset, | |
| numberOfSegments, tension)); | |
| } | |
| // integer version | |
| Status DrawCurve(IN const Pen* pen, | |
| IN const Point* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawCurveI(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count)); | |
| } | |
| Status DrawCurve(IN const Pen* pen, | |
| IN const Point* points, | |
| IN INT count, | |
| IN REAL tension) | |
| { | |
| return SetStatus(DllExports::GdipDrawCurve2I(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count, | |
| tension)); | |
| } | |
| Status DrawCurve(IN const Pen* pen, | |
| IN const Point* points, | |
| IN INT count, | |
| IN INT offset, | |
| IN INT numberOfSegments, | |
| IN REAL tension = 0.5f) | |
| { | |
| return SetStatus(DllExports::GdipDrawCurve3I(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count, | |
| offset, | |
| numberOfSegments, | |
| tension)); | |
| } | |
| // float version | |
| Status DrawClosedCurve(IN const Pen* pen, | |
| IN const PointF* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawClosedCurve(nativeGraphics, | |
| pen->nativePen, | |
| points, count)); | |
| } | |
| Status DrawClosedCurve(IN const Pen *pen, | |
| IN const PointF* points, | |
| IN INT count, | |
| IN REAL tension) | |
| { | |
| return SetStatus(DllExports::GdipDrawClosedCurve2(nativeGraphics, | |
| pen->nativePen, | |
| points, count, | |
| tension)); | |
| } | |
| // integer version | |
| Status DrawClosedCurve(IN const Pen* pen, | |
| IN const Point* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipDrawClosedCurveI(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count)); | |
| } | |
| Status DrawClosedCurve(IN const Pen *pen, | |
| IN const Point* points, | |
| IN INT count, | |
| IN REAL tension) | |
| { | |
| return SetStatus(DllExports::GdipDrawClosedCurve2I(nativeGraphics, | |
| pen->nativePen, | |
| points, | |
| count, | |
| tension)); | |
| } | |
| Status Clear(IN const Color &color) | |
| { | |
| return SetStatus(DllExports::GdipGraphicsClear( | |
| nativeGraphics, | |
| color.GetValue())); | |
| } | |
| // float version | |
| Status FillRectangle(IN const Brush* brush, | |
| IN const RectF& rect) | |
| { | |
| return FillRectangle(brush, rect.X, rect.Y, rect.Width, rect.Height); | |
| } | |
| Status FillRectangle(IN const Brush* brush, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height) | |
| { | |
| return SetStatus(DllExports::GdipFillRectangle(nativeGraphics, | |
| brush->nativeBrush, x, y, | |
| width, height)); | |
| } | |
| Status FillRectangles(IN const Brush* brush, | |
| IN const RectF* rects, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipFillRectangles(nativeGraphics, | |
| brush->nativeBrush, | |
| rects, count)); | |
| } | |
| // integer version | |
| Status FillRectangle(IN const Brush* brush, | |
| IN const Rect& rect) | |
| { | |
| return FillRectangle(brush, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height); | |
| } | |
| Status FillRectangle(IN const Brush* brush, | |
| IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height) | |
| { | |
| return SetStatus(DllExports::GdipFillRectangleI(nativeGraphics, | |
| brush->nativeBrush, | |
| x, | |
| y, | |
| width, | |
| height)); | |
| } | |
| Status FillRectangles(IN const Brush* brush, | |
| IN const Rect* rects, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipFillRectanglesI(nativeGraphics, | |
| brush->nativeBrush, | |
| rects, | |
| count)); | |
| } | |
| // float version | |
| Status FillPolygon(IN const Brush* brush, | |
| IN const PointF* points, | |
| IN INT count) | |
| { | |
| return FillPolygon(brush, points, count, FillModeAlternate); | |
| } | |
| Status FillPolygon(IN const Brush* brush, | |
| IN const PointF* points, | |
| IN INT count, | |
| IN FillMode fillMode) | |
| { | |
| return SetStatus(DllExports::GdipFillPolygon(nativeGraphics, | |
| brush->nativeBrush, | |
| points, count, fillMode)); | |
| } | |
| // integer version | |
| Status FillPolygon(IN const Brush* brush, | |
| IN const Point* points, | |
| IN INT count) | |
| { | |
| return FillPolygon(brush, points, count, FillModeAlternate); | |
| } | |
| Status FillPolygon(IN const Brush* brush, | |
| IN const Point* points, | |
| IN INT count, | |
| IN FillMode fillMode) | |
| { | |
| return SetStatus(DllExports::GdipFillPolygonI(nativeGraphics, | |
| brush->nativeBrush, | |
| points, count, | |
| fillMode)); | |
| } | |
| // float version | |
| Status FillEllipse(IN const Brush* brush, | |
| IN const RectF& rect) | |
| { | |
| return FillEllipse(brush, rect.X, rect.Y, rect.Width, rect.Height); | |
| } | |
| Status FillEllipse(IN const Brush* brush, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height) | |
| { | |
| return SetStatus(DllExports::GdipFillEllipse(nativeGraphics, | |
| brush->nativeBrush, x, y, | |
| width, height)); | |
| } | |
| // integer version | |
| Status FillEllipse(IN const Brush* brush, | |
| IN const Rect& rect) | |
| { | |
| return FillEllipse(brush, rect.X, rect.Y, rect.Width, rect.Height); | |
| } | |
| Status FillEllipse(IN const Brush* brush, | |
| IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height) | |
| { | |
| return SetStatus(DllExports::GdipFillEllipseI(nativeGraphics, | |
| brush->nativeBrush, | |
| x, | |
| y, | |
| width, | |
| height)); | |
| } | |
| // float version | |
| Status FillPie(IN const Brush* brush, | |
| IN const RectF& rect, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return FillPie(brush, rect.X, rect.Y, rect.Width, rect.Height, | |
| startAngle, sweepAngle); | |
| } | |
| Status FillPie(IN const Brush* brush, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return SetStatus(DllExports::GdipFillPie(nativeGraphics, | |
| brush->nativeBrush, x, y, | |
| width, height, startAngle, | |
| sweepAngle)); | |
| } | |
| // integer version | |
| Status FillPie(IN const Brush* brush, | |
| IN const Rect& rect, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return FillPie(brush, rect.X, rect.Y, rect.Width, rect.Height, | |
| startAngle, sweepAngle); | |
| } | |
| Status FillPie(IN const Brush* brush, | |
| IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height, | |
| IN REAL startAngle, | |
| IN REAL sweepAngle) | |
| { | |
| return SetStatus(DllExports::GdipFillPieI(nativeGraphics, | |
| brush->nativeBrush, | |
| x, | |
| y, | |
| width, | |
| height, | |
| startAngle, | |
| sweepAngle)); | |
| } | |
| Status FillPath(IN const Brush* brush, | |
| IN const GraphicsPath* path) | |
| { | |
| return SetStatus(DllExports::GdipFillPath(nativeGraphics, | |
| brush->nativeBrush, | |
| path->nativePath)); | |
| } | |
| // float version | |
| Status FillClosedCurve(IN const Brush* brush, | |
| IN const PointF* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipFillClosedCurve(nativeGraphics, | |
| brush->nativeBrush, | |
| points, count)); | |
| } | |
| Status FillClosedCurve(IN const Brush* brush, | |
| IN const PointF* points, | |
| IN INT count, | |
| IN FillMode fillMode, | |
| IN REAL tension = 0.5f) | |
| { | |
| return SetStatus(DllExports::GdipFillClosedCurve2(nativeGraphics, | |
| brush->nativeBrush, | |
| points, count, | |
| tension, fillMode)); | |
| } | |
| // integer version | |
| Status FillClosedCurve(IN const Brush* brush, | |
| IN const Point* points, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipFillClosedCurveI(nativeGraphics, | |
| brush->nativeBrush, | |
| points, | |
| count)); | |
| } | |
| Status FillClosedCurve(IN const Brush* brush, | |
| IN const Point* points, | |
| IN INT count, | |
| IN FillMode fillMode, | |
| IN REAL tension = 0.5f) | |
| { | |
| return SetStatus(DllExports::GdipFillClosedCurve2I(nativeGraphics, | |
| brush->nativeBrush, | |
| points, count, | |
| tension, fillMode)); | |
| } | |
| // float version | |
| Status FillRegion(IN const Brush* brush, | |
| IN const Region* region) | |
| { | |
| return SetStatus(DllExports::GdipFillRegion(nativeGraphics, | |
| brush->nativeBrush, | |
| region->nativeRegion)); | |
| } | |
| // DrawString and MeasureString | |
| Status | |
| DrawString( | |
| IN const WCHAR *string, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const RectF &layoutRect, | |
| IN const StringFormat *stringFormat, | |
| IN const Brush *brush | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipDrawString( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| &layoutRect, | |
| stringFormat ? stringFormat->nativeFormat : NULL, | |
| brush ? brush->nativeBrush : NULL | |
| )); | |
| } | |
| Status | |
| DrawString( | |
| const WCHAR *string, | |
| INT length, | |
| const Font *font, | |
| const PointF &origin, | |
| const Brush *brush | |
| ) | |
| { | |
| RectF rect(origin.X, origin.Y, 0.0f, 0.0f); | |
| return SetStatus(DllExports::GdipDrawString( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| &rect, | |
| NULL, | |
| brush ? brush->nativeBrush : NULL | |
| )); | |
| } | |
| Status | |
| DrawString( | |
| const WCHAR *string, | |
| INT length, | |
| const Font *font, | |
| const PointF &origin, | |
| const StringFormat *stringFormat, | |
| const Brush *brush | |
| ) | |
| { | |
| RectF rect(origin.X, origin.Y, 0.0f, 0.0f); | |
| return SetStatus(DllExports::GdipDrawString( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| &rect, | |
| stringFormat ? stringFormat->nativeFormat : NULL, | |
| brush ? brush->nativeBrush : NULL | |
| )); | |
| } | |
| Status | |
| MeasureString( | |
| IN const WCHAR *string, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const RectF &layoutRect, | |
| IN const StringFormat *stringFormat, | |
| OUT RectF *boundingBox, | |
| OUT INT *codepointsFitted = 0, | |
| OUT INT *linesFilled = 0 | |
| ) const | |
| { | |
| return SetStatus(DllExports::GdipMeasureString( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| &layoutRect, | |
| stringFormat ? stringFormat->nativeFormat : NULL, | |
| boundingBox, | |
| codepointsFitted, | |
| linesFilled | |
| )); | |
| } | |
| Status | |
| MeasureString( | |
| IN const WCHAR *string, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const SizeF &layoutRectSize, | |
| IN const StringFormat *stringFormat, | |
| OUT SizeF *size, | |
| OUT INT *codepointsFitted = 0, | |
| OUT INT *linesFilled = 0 | |
| ) const | |
| { | |
| RectF layoutRect(0, 0, layoutRectSize.Width, layoutRectSize.Height); | |
| RectF boundingBox; | |
| Status status; | |
| if (size == NULL) | |
| { | |
| return SetStatus(InvalidParameter); | |
| } | |
| status = SetStatus(DllExports::GdipMeasureString( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| &layoutRect, | |
| stringFormat ? stringFormat->nativeFormat : NULL, | |
| size ? &boundingBox : NULL, | |
| codepointsFitted, | |
| linesFilled | |
| )); | |
| if (size && status == Ok) | |
| { | |
| size->Width = boundingBox.Width; | |
| size->Height = boundingBox.Height; | |
| } | |
| return status; | |
| } | |
| Status | |
| MeasureString( | |
| IN const WCHAR *string, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const PointF &origin, | |
| IN const StringFormat *stringFormat, | |
| OUT RectF *boundingBox | |
| ) const | |
| { | |
| RectF rect(origin.X, origin.Y, 0.0f, 0.0f); | |
| return SetStatus(DllExports::GdipMeasureString( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| &rect, | |
| stringFormat ? stringFormat->nativeFormat : NULL, | |
| boundingBox, | |
| NULL, | |
| NULL | |
| )); | |
| } | |
| Status | |
| MeasureString( | |
| IN const WCHAR *string, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const RectF &layoutRect, | |
| OUT RectF *boundingBox | |
| ) const | |
| { | |
| return SetStatus(DllExports::GdipMeasureString( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| &layoutRect, | |
| NULL, | |
| boundingBox, | |
| NULL, | |
| NULL | |
| )); | |
| } | |
| Status | |
| MeasureString( | |
| IN const WCHAR *string, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const PointF &origin, | |
| OUT RectF *boundingBox | |
| ) const | |
| { | |
| RectF rect(origin.X, origin.Y, 0.0f, 0.0f); | |
| return SetStatus(DllExports::GdipMeasureString( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| &rect, | |
| NULL, | |
| boundingBox, | |
| NULL, | |
| NULL | |
| )); | |
| } | |
| #ifdef DCR_USE_NEW_174340 | |
| Status | |
| MeasureCharacterRanges( | |
| IN const WCHAR *string, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const RectF &layoutRect, | |
| IN const StringFormat *stringFormat, | |
| IN INT regionCount, | |
| OUT Region *regions | |
| ) const | |
| { | |
| if (!regions || regionCount <= 0) | |
| { | |
| return InvalidParameter; | |
| } | |
| GpRegion **nativeRegions = new GpRegion* [regionCount]; | |
| if (!nativeRegions) | |
| { | |
| return OutOfMemory; | |
| } | |
| for (INT i = 0; i < regionCount; i++) | |
| { | |
| nativeRegions[i] = regions[i].nativeRegion; | |
| } | |
| Status status = SetStatus(DllExports::GdipMeasureCharacterRanges( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| layoutRect, | |
| stringFormat ? stringFormat->nativeFormat : NULL, | |
| regionCount, | |
| nativeRegions | |
| )); | |
| delete [] nativeRegions; | |
| return status; | |
| } | |
| #endif | |
| #ifndef DCR_USE_NEW_174340 | |
| Status | |
| MeasureStringRegion( | |
| IN const WCHAR *string, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const RectF &layoutRect, | |
| IN const StringFormat *stringFormat, | |
| IN INT firstCharacterIndex, | |
| IN INT characterCount, | |
| OUT Region *region | |
| ) const | |
| { | |
| if (region == NULL) | |
| { | |
| return SetStatus(InvalidParameter); | |
| } | |
| return (SetStatus(DllExports::GdipMeasureStringRegion( | |
| nativeGraphics, | |
| string, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| layoutRect, | |
| stringFormat ? stringFormat->nativeFormat : NULL, | |
| firstCharacterIndex, | |
| characterCount, | |
| region->nativeRegion))); | |
| } | |
| #endif | |
| Status DrawDriverString( | |
| IN const UINT16 *text, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const Brush *brush, | |
| IN const PointF *positions, | |
| IN INT flags, | |
| IN const Matrix *matrix | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipDrawDriverString( | |
| nativeGraphics, | |
| text, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| brush ? brush->nativeBrush : NULL, | |
| positions, | |
| flags, | |
| matrix ? matrix->nativeMatrix : NULL | |
| )); | |
| } | |
| Status MeasureDriverString( | |
| IN const UINT16 *text, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const PointF *positions, | |
| IN INT flags, | |
| IN const Matrix *matrix, | |
| OUT RectF *boundingBox | |
| ) const | |
| { | |
| return SetStatus(DllExports::GdipMeasureDriverString( | |
| nativeGraphics, | |
| text, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| positions, | |
| flags, | |
| matrix ? matrix->nativeMatrix : NULL, | |
| boundingBox | |
| )); | |
| } | |
| #ifndef DCR_USE_NEW_168772 | |
| Status DriverStringPointToCodepoint( | |
| IN const UINT16 *text, | |
| IN INT length, | |
| IN const Font *font, | |
| IN const PointF *positions, | |
| IN INT flags, | |
| IN const Matrix *matrix, | |
| IN const PointF &hit, | |
| OUT INT *index, | |
| OUT BOOL *rightEdge, | |
| OUT REAL *distance | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipDriverStringPointToCodepoint( | |
| nativeGraphics, | |
| text, | |
| length, | |
| font ? font->nativeFont : NULL, | |
| positions, | |
| flags, | |
| matrix ? matrix->nativeMatrix : NULL, | |
| &hit, | |
| index, | |
| rightEdge, | |
| distance | |
| )); | |
| } | |
| #endif | |
| // Draw a cached bitmap on this graphics destination offset by | |
| // x, y. Note this will fail with WrongState if the CachedBitmap | |
| // native format differs from this Graphics. | |
| Status DrawCachedBitmap(IN CachedBitmap *cb, | |
| IN INT x, | |
| IN INT y) | |
| { | |
| return SetStatus(DllExports::GdipDrawCachedBitmap( | |
| nativeGraphics, | |
| cb->nativeCachedBitmap, | |
| x, y | |
| )); | |
| } | |
| /** | |
| * Draw images (both bitmap and vector) | |
| */ | |
| // float version | |
| Status DrawImage(IN Image* image, | |
| IN const PointF& point) | |
| { | |
| return DrawImage(image, point.X, point.Y); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN REAL x, | |
| IN REAL y) | |
| { | |
| return SetStatus(DllExports::GdipDrawImage(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| x, | |
| y)); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN const RectF& rect) | |
| { | |
| return DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height) | |
| { | |
| return SetStatus(DllExports::GdipDrawImageRect(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| x, | |
| y, | |
| width, | |
| height)); | |
| } | |
| // integer version | |
| Status DrawImage(IN Image* image, | |
| IN const Point& point) | |
| { | |
| return DrawImage(image, point.X, point.Y); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN INT x, | |
| IN INT y) | |
| { | |
| return SetStatus(DllExports::GdipDrawImageI(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| x, | |
| y)); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN const Rect& rect) | |
| { | |
| return DrawImage(image, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height) { | |
| return SetStatus(DllExports::GdipDrawImageRectI(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| x, | |
| y, | |
| width, | |
| height)); | |
| } | |
| /** | |
| * Affine or perspective blt | |
| * destPoints.length = 3: rect => parallelogram | |
| * destPoints[0] <=> top-left corner of the source rectangle | |
| * destPoints[1] <=> top-right corner | |
| * destPoints[2] <=> bottom-left corner | |
| * destPoints.length = 4: rect => quad | |
| * destPoints[3] <=> bottom-right corner | |
| * | |
| * @notes Perspective blt only works for bitmap images. | |
| */ | |
| Status DrawImage(IN Image* image, | |
| IN const PointF* destPoints, | |
| IN INT count) | |
| { | |
| if (count != 3 && count != 4) | |
| return SetStatus(InvalidParameter); | |
| return SetStatus(DllExports::GdipDrawImagePoints(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| destPoints, count)); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN const Point* destPoints, | |
| IN INT count) | |
| { | |
| if (count != 3 && count != 4) | |
| return SetStatus(InvalidParameter); | |
| return SetStatus(DllExports::GdipDrawImagePointsI(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| destPoints, | |
| count)); | |
| } | |
| /** | |
| * We need another set of methods similar to the ones above | |
| * that take an additional Rect parameter to specify the | |
| * portion of the source image to be drawn. | |
| */ | |
| // float version | |
| Status DrawImage(IN Image* image, | |
| IN REAL x, | |
| IN REAL y, | |
| IN REAL srcx, | |
| IN REAL srcy, | |
| IN REAL srcwidth, | |
| IN REAL srcheight, | |
| IN Unit srcUnit) | |
| { | |
| return SetStatus(DllExports::GdipDrawImagePointRect(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| x, y, | |
| srcx, srcy, | |
| srcwidth, srcheight, srcUnit)); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN const RectF& destRect, | |
| IN REAL srcx, | |
| IN REAL srcy, | |
| IN REAL srcwidth, | |
| IN REAL srcheight, | |
| IN Unit srcUnit, | |
| IN const ImageAttributes* imageAttributes = NULL, | |
| IN DrawImageAbort callback = NULL, | |
| IN VOID* callbackData = NULL) | |
| { | |
| return SetStatus(DllExports::GdipDrawImageRectRect(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| destRect.X, | |
| destRect.Y, | |
| destRect.Width, | |
| destRect.Height, | |
| srcx, srcy, | |
| srcwidth, srcheight, | |
| srcUnit, | |
| imageAttributes | |
| ? imageAttributes->nativeImageAttr | |
| : NULL, | |
| callback, | |
| callbackData)); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN const PointF* destPoints, | |
| IN INT count, | |
| IN REAL srcx, | |
| IN REAL srcy, | |
| IN REAL srcwidth, | |
| IN REAL srcheight, | |
| IN Unit srcUnit, | |
| IN const ImageAttributes* imageAttributes = NULL, | |
| IN DrawImageAbort callback = NULL, | |
| IN VOID* callbackData = NULL) | |
| { | |
| return SetStatus(DllExports::GdipDrawImagePointsRect(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| destPoints, count, | |
| srcx, srcy, | |
| srcwidth, | |
| srcheight, | |
| srcUnit, | |
| imageAttributes | |
| ? imageAttributes->nativeImageAttr | |
| : NULL, | |
| callback, | |
| callbackData)); | |
| } | |
| // integer version | |
| Status DrawImage(IN Image* image, | |
| IN INT x, | |
| IN INT y, | |
| IN INT srcx, | |
| IN INT srcy, | |
| IN INT srcwidth, | |
| IN INT srcheight, | |
| IN Unit srcUnit) | |
| { | |
| return SetStatus(DllExports::GdipDrawImagePointRectI(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| x, | |
| y, | |
| srcx, | |
| srcy, | |
| srcwidth, | |
| srcheight, | |
| srcUnit)); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN const Rect& destRect, | |
| IN INT srcx, | |
| IN INT srcy, | |
| IN INT srcwidth, | |
| IN INT srcheight, | |
| IN Unit srcUnit, | |
| IN const ImageAttributes* imageAttributes = NULL, | |
| IN DrawImageAbort callback = NULL, | |
| IN VOID* callbackData = NULL) | |
| { | |
| return SetStatus(DllExports::GdipDrawImageRectRectI(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| destRect.X, | |
| destRect.Y, | |
| destRect.Width, | |
| destRect.Height, | |
| srcx, | |
| srcy, | |
| srcwidth, | |
| srcheight, | |
| srcUnit, | |
| imageAttributes | |
| ? imageAttributes->nativeImageAttr | |
| : NULL, | |
| callback, | |
| callbackData)); | |
| } | |
| Status DrawImage(IN Image* image, | |
| IN const Point* destPoints, | |
| IN INT count, | |
| IN INT srcx, | |
| IN INT srcy, | |
| IN INT srcwidth, | |
| IN INT srcheight, | |
| IN Unit srcUnit, | |
| IN const ImageAttributes* imageAttributes = NULL, | |
| IN DrawImageAbort callback = NULL, | |
| IN VOID* callbackData = NULL) | |
| { | |
| return SetStatus(DllExports::GdipDrawImagePointsRectI(nativeGraphics, | |
| image ? image->nativeImage | |
| : NULL, | |
| destPoints, | |
| count, | |
| srcx, | |
| srcy, | |
| srcwidth, | |
| srcheight, | |
| srcUnit, | |
| imageAttributes | |
| ? imageAttributes->nativeImageAttr | |
| : NULL, | |
| callback, | |
| callbackData)); | |
| } | |
| // The following methods are for playing an EMF+ to a graphics | |
| // via the enumeration interface. Each record of the EMF+ is | |
| // sent to the callback (along with the callbackData). Then | |
| // the callback can invoke the Metafile::PlayRecord method | |
| // to play the particular record. | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const PointF & destPoint, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileDestPoint( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destPoint, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const Point & destPoint, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileDestPointI( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destPoint, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const RectF & destRect, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileDestRect( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destRect, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const Rect & destRect, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileDestRectI( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destRect, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const PointF * destPoints, | |
| IN INT count, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileDestPoints( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destPoints, | |
| count, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const Point * destPoints, | |
| IN INT count, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileDestPointsI( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destPoints, | |
| count, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const PointF & destPoint, | |
| IN const RectF & srcRect, | |
| IN Unit srcUnit, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestPoint( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destPoint, | |
| srcRect, | |
| srcUnit, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const Point & destPoint, | |
| IN const Rect & srcRect, | |
| IN Unit srcUnit, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestPointI( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destPoint, | |
| srcRect, | |
| srcUnit, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const RectF & destRect, | |
| IN const RectF & srcRect, | |
| IN Unit srcUnit, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestRect( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destRect, | |
| srcRect, | |
| srcUnit, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const Rect & destRect, | |
| IN const Rect & srcRect, | |
| IN Unit srcUnit, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestRectI( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destRect, | |
| srcRect, | |
| srcUnit, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const PointF * destPoints, | |
| IN INT count, | |
| IN const RectF & srcRect, | |
| IN Unit srcUnit, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestPoints( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destPoints, | |
| count, | |
| srcRect, | |
| srcUnit, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| Status | |
| EnumerateMetafile( | |
| IN const Metafile * metafile, | |
| IN const Point * destPoints, | |
| IN INT count, | |
| IN const Rect & srcRect, | |
| IN Unit srcUnit, | |
| IN EnumerateMetafileProc callback, | |
| IN VOID * callbackData = NULL, | |
| IN const ImageAttributes * imageAttributes = NULL | |
| ) | |
| { | |
| return SetStatus(DllExports::GdipEnumerateMetafileSrcRectDestPointsI( | |
| nativeGraphics, | |
| (const GpMetafile *)(metafile ? metafile->nativeImage:NULL), | |
| destPoints, | |
| count, | |
| srcRect, | |
| srcUnit, | |
| callback, | |
| callbackData, | |
| imageAttributes ? imageAttributes->nativeImageAttr : NULL)); | |
| } | |
| /** | |
| * Clipping region operations | |
| * | |
| * @notes Simply incredible redundancy here. | |
| */ | |
| Status SetClip(IN const Graphics* g, | |
| IN CombineMode combineMode = CombineModeReplace) | |
| { | |
| return SetStatus(DllExports::GdipSetClipGraphics(nativeGraphics, | |
| g->nativeGraphics, | |
| combineMode)); | |
| } | |
| Status SetClip(IN const RectF& rect, | |
| IN CombineMode combineMode = CombineModeReplace) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRect(nativeGraphics, | |
| rect.X, rect.Y, | |
| rect.Width, rect.Height, | |
| combineMode)); | |
| } | |
| Status SetClip(IN const Rect& rect, | |
| IN CombineMode combineMode = CombineModeReplace) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRectI(nativeGraphics, | |
| rect.X, rect.Y, | |
| rect.Width, rect.Height, | |
| combineMode)); | |
| } | |
| Status SetClip(IN const GraphicsPath* path, | |
| IN CombineMode combineMode = CombineModeReplace) | |
| { | |
| return SetStatus(DllExports::GdipSetClipPath(nativeGraphics, | |
| path->nativePath, | |
| combineMode)); | |
| } | |
| Status SetClip(IN const Region* region, | |
| IN CombineMode combineMode = CombineModeReplace) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRegion(nativeGraphics, | |
| region->nativeRegion, | |
| combineMode)); | |
| } | |
| // This is different than the other SetClip methods because it assumes | |
| // that the HRGN is already in device units, so it doesn't transform | |
| // the coordinates in the HRGN. | |
| Status SetClip(IN HRGN hRgn, | |
| IN CombineMode combineMode = CombineModeReplace) | |
| { | |
| return SetStatus(DllExports::GdipSetClipHrgn(nativeGraphics, hRgn, | |
| combineMode)); | |
| } | |
| Status IntersectClip(IN const RectF& rect) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRect(nativeGraphics, | |
| rect.X, rect.Y, | |
| rect.Width, rect.Height, | |
| CombineModeIntersect)); | |
| } | |
| Status IntersectClip(IN const Rect& rect) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRectI(nativeGraphics, | |
| rect.X, rect.Y, | |
| rect.Width, rect.Height, | |
| CombineModeIntersect)); | |
| } | |
| Status IntersectClip(IN const Region* region) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRegion(nativeGraphics, | |
| region->nativeRegion, | |
| CombineModeIntersect)); | |
| } | |
| Status ExcludeClip(IN const RectF& rect) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRect(nativeGraphics, | |
| rect.X, rect.Y, | |
| rect.Width, rect.Height, | |
| CombineModeExclude)); | |
| } | |
| Status ExcludeClip(IN const Rect& rect) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRectI(nativeGraphics, | |
| rect.X, rect.Y, | |
| rect.Width, rect.Height, | |
| CombineModeExclude)); | |
| } | |
| Status ExcludeClip(IN const Region* region) | |
| { | |
| return SetStatus(DllExports::GdipSetClipRegion(nativeGraphics, | |
| region->nativeRegion, | |
| CombineModeExclude)); | |
| } | |
| Status ResetClip() | |
| { | |
| return SetStatus(DllExports::GdipResetClip(nativeGraphics)); | |
| } | |
| Status TranslateClip(IN REAL dx, | |
| IN REAL dy) | |
| { | |
| return SetStatus(DllExports::GdipTranslateClip(nativeGraphics, dx, dy)); | |
| } | |
| Status TranslateClip(IN INT dx, | |
| IN INT dy) | |
| { | |
| return SetStatus(DllExports::GdipTranslateClipI(nativeGraphics, | |
| dx, dy)); | |
| } | |
| /** | |
| * GetClip region from graphics context | |
| */ | |
| Status GetClip(OUT Region* region) const | |
| { | |
| return SetStatus(DllExports::GdipGetClip(nativeGraphics, | |
| region->nativeRegion)); | |
| } | |
| /** | |
| * Hit testing operations | |
| */ | |
| Status GetClipBounds(OUT RectF* rect) const | |
| { | |
| return SetStatus(DllExports::GdipGetClipBounds(nativeGraphics, rect)); | |
| } | |
| Status GetClipBounds(OUT Rect* rect) const | |
| { | |
| return SetStatus(DllExports::GdipGetClipBoundsI(nativeGraphics, rect)); | |
| } | |
| BOOL IsClipEmpty() const | |
| { | |
| BOOL booln = FALSE; | |
| SetStatus(DllExports::GdipIsClipEmpty(nativeGraphics, &booln)); | |
| return booln; | |
| } | |
| Status GetVisibleClipBounds(OUT RectF *rect) const | |
| { | |
| return SetStatus(DllExports::GdipGetVisibleClipBounds(nativeGraphics, | |
| rect)); | |
| } | |
| Status GetVisibleClipBounds(OUT Rect *rect) const | |
| { | |
| return SetStatus(DllExports::GdipGetVisibleClipBoundsI(nativeGraphics, | |
| rect)); | |
| } | |
| BOOL IsVisibleClipEmpty() const | |
| { | |
| BOOL booln = FALSE; | |
| SetStatus(DllExports::GdipIsVisibleClipEmpty(nativeGraphics, &booln)); | |
| return booln; | |
| } | |
| BOOL IsVisible(IN INT x, | |
| IN INT y) const | |
| { | |
| return IsVisible(Point(x,y)); | |
| } | |
| BOOL IsVisible(IN const Point& point) const | |
| { | |
| BOOL booln = FALSE; | |
| SetStatus(DllExports::GdipIsVisiblePointI(nativeGraphics, | |
| point.X, | |
| point.Y, | |
| &booln)); | |
| return booln; | |
| } | |
| BOOL IsVisible(IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height) const | |
| { | |
| return IsVisible(Rect(x, y, width, height)); | |
| } | |
| BOOL IsVisible(IN const Rect& rect) const | |
| { | |
| BOOL booln = TRUE; | |
| SetStatus(DllExports::GdipIsVisibleRectI(nativeGraphics, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height, | |
| &booln)); | |
| return booln; | |
| } | |
| BOOL IsVisible(IN REAL x, | |
| IN REAL y) const | |
| { | |
| return IsVisible(PointF(x, y)); | |
| } | |
| BOOL IsVisible(IN const PointF& point) const | |
| { | |
| BOOL booln = FALSE; | |
| SetStatus(DllExports::GdipIsVisiblePoint(nativeGraphics, | |
| point.X, | |
| point.Y, | |
| &booln)); | |
| return booln; | |
| } | |
| BOOL IsVisible(IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height) const | |
| { | |
| return IsVisible(RectF(x, y, width, height)); | |
| } | |
| BOOL IsVisible(IN const RectF& rect) const | |
| { | |
| BOOL booln = TRUE; | |
| SetStatus(DllExports::GdipIsVisibleRect(nativeGraphics, | |
| rect.X, | |
| rect.Y, | |
| rect.Width, | |
| rect.Height, | |
| &booln)); | |
| return booln; | |
| } | |
| /** | |
| * Save/restore graphics state | |
| */ | |
| GraphicsState Save() const | |
| { | |
| GraphicsState gstate; | |
| SetStatus(DllExports::GdipSaveGraphics(nativeGraphics, &gstate)); | |
| return gstate; | |
| } | |
| Status Restore(IN GraphicsState gstate) | |
| { | |
| return SetStatus(DllExports::GdipRestoreGraphics(nativeGraphics, | |
| gstate)); | |
| } | |
| /** | |
| * Begin and end container drawing | |
| */ | |
| GraphicsContainer BeginContainer(IN const RectF &dstrect, | |
| IN const RectF &srcrect, | |
| IN Unit unit) | |
| { | |
| GraphicsContainer state; | |
| SetStatus(DllExports::GdipBeginContainer(nativeGraphics, &dstrect, | |
| &srcrect, unit, &state)); | |
| return state; | |
| } | |
| /** | |
| * Begin and end container drawing | |
| */ | |
| GraphicsContainer BeginContainer(IN const Rect &dstrect, | |
| IN const Rect &srcrect, | |
| IN Unit unit) | |
| { | |
| GraphicsContainer state; | |
| SetStatus(DllExports::GdipBeginContainerI(nativeGraphics, &dstrect, | |
| &srcrect, unit, &state)); | |
| return state; | |
| } | |
| GraphicsContainer BeginContainer() | |
| { | |
| GraphicsContainer state; | |
| SetStatus(DllExports::GdipBeginContainer2(nativeGraphics, &state)); | |
| return state; | |
| } | |
| Status EndContainer(IN GraphicsContainer state) | |
| { | |
| return SetStatus(DllExports::GdipEndContainer(nativeGraphics, state)); | |
| } | |
| // only valid when recording metafiles | |
| Status AddMetafileComment(IN const BYTE * data, | |
| IN UINT sizeData) | |
| { | |
| return SetStatus(DllExports::GdipComment(nativeGraphics, sizeData, data)); | |
| } | |
| /** | |
| * Get/SetLayout | |
| * Support for Middle East localization (right-to-left mirroring) | |
| */ | |
| GraphicsLayout GetLayout() const | |
| { | |
| GraphicsLayout layout; | |
| SetStatus(DllExports::GdipGetGraphicsLayout(nativeGraphics, &layout)); | |
| return layout; | |
| } | |
| Status SetLayout(IN const GraphicsLayout layout) | |
| { | |
| return SetStatus( | |
| DllExports::GdipSetGraphicsLayout(nativeGraphics, layout) | |
| ); | |
| } | |
| static HPALETTE GetHalftonePalette() | |
| { | |
| return DllExports::GdipCreateHalftonePalette(); | |
| } | |
| Status GetLastStatus() const | |
| { | |
| Status lastStatus = lastResult; | |
| lastResult = Ok; | |
| return lastStatus; | |
| } | |
| protected: | |
| #ifdef DCR_USE_NEW_250932 | |
| private: | |
| Graphics(const Graphics &); | |
| Graphics& operator=(const Graphics &); | |
| protected: | |
| #else | |
| Graphics(const Graphics& graphics) | |
| { | |
| graphics; | |
| SetStatus(NotImplemented); | |
| } | |
| Graphics& operator=(const Graphics& graphics) | |
| { | |
| graphics; | |
| SetStatus(NotImplemented); | |
| return *this; | |
| } | |
| #endif | |
| Graphics(GpGraphics* graphics) | |
| { | |
| lastResult = Ok; | |
| SetNativeGraphics(graphics); | |
| } | |
| VOID SetNativeGraphics(GpGraphics *graphics) | |
| { | |
| this->nativeGraphics = graphics; | |
| } | |
| Status SetStatus(Status status) const | |
| { | |
| if (status != Ok) | |
| return (lastResult = status); | |
| else | |
| return status; | |
| } | |
| // Methods necessary to subclass Graphics for extension test. | |
| GpGraphics* GetNativeGraphics() const | |
| { | |
| return this->nativeGraphics; | |
| } | |
| GpPen* GetNativePen(const Pen* pen) | |
| { | |
| return pen->nativePen; | |
| } | |
| protected: | |
| GpGraphics* nativeGraphics; | |
| mutable Status lastResult; | |
| }; | |
| //---------------------------------------------------------------------------- | |
| // Extra implementation of GraphicsPath methods that use Graphics | |
| //---------------------------------------------------------------------------- | |
| /** | |
| * Get the bounds of the path object with the given transform. | |
| * This is not always the tightest bounds. | |
| */ | |
| inline Status | |
| GraphicsPath::GetBounds( | |
| OUT RectF* bounds, | |
| IN const Matrix* matrix, | |
| IN const Pen* pen) const | |
| { | |
| GpMatrix* nativeMatrix = NULL; | |
| GpPen* nativePen = NULL; | |
| if (matrix) | |
| nativeMatrix = matrix->nativeMatrix; | |
| if (pen) | |
| nativePen = pen->nativePen; | |
| return SetStatus(DllExports::GdipGetPathWorldBounds(nativePath, bounds, | |
| nativeMatrix, nativePen)); | |
| } | |
| // integer version | |
| inline Status | |
| GraphicsPath::GetBounds( | |
| OUT Rect* bounds, | |
| IN const Matrix* matrix, | |
| IN const Pen* pen | |
| ) const | |
| { | |
| GpMatrix* nativeMatrix = NULL; | |
| GpPen* nativePen = NULL; | |
| if (matrix) | |
| nativeMatrix = matrix->nativeMatrix; | |
| if (pen) | |
| nativePen = pen->nativePen; | |
| return SetStatus(DllExports::GdipGetPathWorldBoundsI(nativePath, bounds, | |
| nativeMatrix, nativePen)); | |
| } | |
| //---------------------------------------------------------------------------- | |
| // Hit testing operations | |
| //---------------------------------------------------------------------------- | |
| inline BOOL | |
| GraphicsPath::IsVisible( | |
| IN REAL x, | |
| IN REAL y, | |
| IN const Graphics* g) const | |
| { | |
| BOOL booln = FALSE; | |
| GpGraphics* nativeGraphics = NULL; | |
| if (g) | |
| nativeGraphics = g->nativeGraphics; | |
| SetStatus(DllExports::GdipIsVisiblePathPoint(nativePath, | |
| x, y, nativeGraphics, | |
| &booln)); | |
| return booln; | |
| } | |
| inline BOOL | |
| GraphicsPath::IsVisible( | |
| IN INT x, | |
| IN INT y, | |
| IN const Graphics* g) const | |
| { | |
| BOOL booln = FALSE; | |
| GpGraphics* nativeGraphics = NULL; | |
| if (g) | |
| nativeGraphics = g->nativeGraphics; | |
| SetStatus(DllExports::GdipIsVisiblePathPointI(nativePath, | |
| x, y, nativeGraphics, | |
| &booln)); | |
| return booln; | |
| } | |
| inline BOOL | |
| GraphicsPath::IsOutlineVisible( | |
| IN REAL x, | |
| IN REAL y, | |
| IN const Pen* pen, | |
| IN const Graphics* g) const | |
| { | |
| BOOL booln = FALSE; | |
| GpGraphics* nativeGraphics = NULL; | |
| GpPen* nativePen = NULL; | |
| if(g) | |
| nativeGraphics = g->nativeGraphics; | |
| if(pen) | |
| nativePen = pen->nativePen; | |
| SetStatus(DllExports::GdipIsOutlineVisiblePathPoint(nativePath, | |
| x, y, nativePen, nativeGraphics, | |
| &booln)); | |
| return booln; | |
| } | |
| inline BOOL | |
| GraphicsPath::IsOutlineVisible( | |
| IN INT x, | |
| IN INT y, | |
| IN const Pen* pen, | |
| IN const Graphics* g) const | |
| { | |
| BOOL booln = FALSE; | |
| GpGraphics* nativeGraphics = NULL; | |
| GpPen* nativePen = NULL; | |
| if(g) | |
| nativeGraphics = g->nativeGraphics; | |
| if(pen) | |
| nativePen = pen->nativePen; | |
| SetStatus(DllExports::GdipIsOutlineVisiblePathPointI(nativePath, | |
| x, y, nativePen, nativeGraphics, | |
| &booln)); | |
| return booln; | |
| } | |
| #endif |