| /**************************************************************************\ |
| * |
| * 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 |
