csharp-to-cpp/apireference/graphics_8h_source.html

#ifndef _aspose_drawing_graphics_h_

#define _aspose_drawing_graphics_h_


#include "fwd.h"

#include "drawing/image.h"

#include "drawing/brushes.h"

#include "drawing/font.h"

#include "drawing/size_f.h"

#include "drawing/drawing2d/smoothing_mode.h"

#include "drawing/drawing2d/graphics_path.h"

#include "drawing/drawing2d/graphics_container.h"

#include "drawing/drawing2d/graphics_state.h"

#include "drawing/drawing2d/pixel_offset_mode.h"

#include "drawing/drawing2d/interpolation_mode.h"

#include "drawing/drawing2d/combine_mode.h"

#include "drawing/drawing2d/compositing_mode.h"

#include "drawing/drawing2d/matrix_order.h"

#include "drawing/drawing2d/matrix.h"

#include "drawing/drawing2d/coordinate_space.h"

#include "drawing/drawing2d/flush_intention.h"

#include "drawing/drawing2d/fill_mode.h"

#include "drawing/pen.h"

#include "drawing/copy_pixel_operation.h"

#include "drawing/drawing2d/compositing_quality.h"

#include "drawing/imaging/image_attributes.h"

#include "drawing/text/text_rendering_hint.h"

#include "drawing/imaging/emf_plus_record_type.h"

#include "drawing/imaging/play_record_callback.h"


#include "drawing/graphics_unit.h"

#include "drawing/string_format.h"


#ifdef ASPOSECPPLIB_BEING_BUILT

#include <src/core/SkClipStack.h>

#include <core/SkCanvas.h>

#endif


#include <memory>

#include <functional>

#include <stack>


ASPOSECPP_3RD_PARTY_CLASS(SkCanvas);

ASPOSECPP_3RD_PARTY_CLASS(SkClipStack);

ASPOSECPP_3RD_PARTY_STRUCT(SkSize);


namespace Aspose { namespace Testing { class GraphicsTest; } }

namespace Aspose { namespace Testing { namespace ReleaseAsDebug { class Test; } } }

namespace Aspose { namespace Images { namespace Pal { class GraphicsPal; } } }


namespace System { namespace Drawing { namespace Imaging { class Metafile; } } }

namespace System { namespace Drawing { namespace Drawing2D { class GraphicsContainer; } } }


namespace System { namespace Drawing {


class Region;

class Bitmap;

class Icon;

class Font;

class ASPOSECPP_SHARED_CLASS Graphics : virtual public Object

{

    RTTI_INFO(System::Drawing::Graphics, ::System::BaseTypesInfo<System::Object>);


public:

    friend class Region;

    friend class Bitmap;

    friend class Font;

    using EnumerateMetafileProc = MulticastDelegate<bool(Imaging::EmfPlusRecordType, int32_t, int32_t, IntPtr, Imaging::PlayRecordCallback)>;

    using DrawImageAbort = std::function<bool(IntPtr ptr)>;


    static ASPOSECPP_SHARED_API SharedPtr<Graphics> FromImage(const SharedPtr<Image>& image);


    ASPOSECPP_SHARED_API Drawing2D::CompositingMode get_CompositingMode();

    ASPOSECPP_SHARED_API void set_CompositingMode(Drawing2D::CompositingMode mode);


    ASPOSECPP_SHARED_API Drawing2D::CompositingQuality get_CompositingQuality();

    ASPOSECPP_SHARED_API void set_CompositingQuality(Drawing2D::CompositingQuality quality);


    ASPOSECPP_SHARED_API Drawing2D::InterpolationMode get_InterpolationMode();

    ASPOSECPP_SHARED_API void set_InterpolationMode(Drawing2D::InterpolationMode mode);


    ASPOSECPP_SHARED_API Drawing2D::PixelOffsetMode get_PixelOffsetMode();

    ASPOSECPP_SHARED_API void set_PixelOffsetMode(Drawing2D::PixelOffsetMode mode);


    ASPOSECPP_SHARED_API Drawing2D::SmoothingMode get_SmoothingMode();

    ASPOSECPP_SHARED_API void set_SmoothingMode(Drawing2D::SmoothingMode mode);


    ASPOSECPP_SHARED_API Text::TextRenderingHint get_TextRenderingHint();

    ASPOSECPP_SHARED_API void set_TextRenderingHint(Text::TextRenderingHint hint);


    ASPOSECPP_SHARED_API GraphicsUnit get_PageUnit() const;

    ASPOSECPP_SHARED_API void set_PageUnit(GraphicsUnit value);


    ASPOSECPP_SHARED_API RectangleF get_ClipBounds() const;


    ASPOSECPP_SHARED_API void Clear(Color color);


    ASPOSECPP_SHARED_API void DrawArc(const SharedPtr<Pen>& pen, int32_t x, int32_t y, int32_t width, int32_t height, int32_t startAngle, int32_t sweepAngle);

    ASPOSECPP_SHARED_API void DrawArc(const SharedPtr<Pen>& pen, float x, float y, float width, float height, float startAngle, float sweepAngle);

    ASPOSECPP_SHARED_API void DrawArc(const SharedPtr<Pen>& pen, Rectangle rect, float startAngle, float sweepAngle);

    ASPOSECPP_SHARED_API void DrawArc(const SharedPtr<Pen>& pen, RectangleF rect, float startAngle, float sweepAngle);


    ASPOSECPP_SHARED_API void DrawPie(const SharedPtr<Pen>& pen, int32_t x, int32_t y, int32_t width, int32_t height, int32_t startAngle, int32_t sweepAngle);

    ASPOSECPP_SHARED_API void DrawPie(const SharedPtr<Pen>& pen, float x, float y, float width, float height, float startAngle, float sweepAngle);

    ASPOSECPP_SHARED_API void DrawPie(const SharedPtr<Pen>& pen, Rectangle rect, float startAngle, float sweepAngle);

    ASPOSECPP_SHARED_API void DrawPie(const SharedPtr<Pen>& pen, RectangleF rect, float startAngle, float sweepAngle);


    ASPOSECPP_SHARED_API void FillPie(const SharedPtr<Brush>& brush, int x, int y, int width, int height, int startAngle, int sweepAngle);

    ASPOSECPP_SHARED_API void FillPie(const SharedPtr<Brush>& brush, float x, float y, float width, float height, float startAngle, float sweepAngle);

    ASPOSECPP_SHARED_API void FillPie(const SharedPtr<Brush>& brush, Rectangle rect, float startAngle, float sweepAngle);


    ASPOSECPP_SHARED_API void DrawRectangle(const SharedPtr<Pen>& pen, int x, int y, int width, int height);

    ASPOSECPP_SHARED_API void DrawRectangle(const SharedPtr<Pen>& pen, float x, float y, float width, float height);

    ASPOSECPP_SHARED_API void DrawRectangle(const SharedPtr<Pen>& pen, Rectangle rect);


    ASPOSECPP_SHARED_API void DrawRectangles(const SharedPtr<Pen>& pen, const ArrayPtr<Rectangle>& rects);

    ASPOSECPP_SHARED_API void DrawRectangles(const SharedPtr<Pen>& pen, const ArrayPtr<RectangleF>& rects);


    ASPOSECPP_SHARED_API void DrawPolygon(const SharedPtr<Pen>& pen, const ArrayPtr<Point>& points);

    ASPOSECPP_SHARED_API void DrawPolygon(const SharedPtr<Pen>& pen, const ArrayPtr<PointF>& points);


    ASPOSECPP_SHARED_API void FillRectangle(const SharedPtr<Brush>& brush, float x, float y, float width, float height);

    ASPOSECPP_SHARED_API void FillRectangle(const SharedPtr<Brush>& brush, int x, int y, int width, int height);

    ASPOSECPP_SHARED_API void FillRectangle(const SharedPtr<Brush>& brush, Rectangle rect);

    ASPOSECPP_SHARED_API void FillRectangle(const SharedPtr<Brush>& brush, RectangleF rect);


    ASPOSECPP_SHARED_API void FillRectangles(const SharedPtr<Brush>& brush, const ArrayPtr<Rectangle>& rects);

    ASPOSECPP_SHARED_API void FillRectangles(const SharedPtr<Brush>& brush, const ArrayPtr<RectangleF>& rects);


    ASPOSECPP_SHARED_API void DrawEllipse(const SharedPtr<Pen>& pen, Rectangle rect);

    ASPOSECPP_SHARED_API void DrawEllipse(const SharedPtr<Pen>& pen, RectangleF rect);

    ASPOSECPP_SHARED_API void DrawEllipse(const SharedPtr<Pen>& pen, int x, int y, int width, int height);

    ASPOSECPP_SHARED_API void DrawEllipse(const SharedPtr<Pen>& pen, float x, float y, float width, float height);


    ASPOSECPP_SHARED_API void DrawString(const String &str, const SharedPtr<Font>& font, const SharedPtr<Brush>& brush, PointF topLeft, const System::SharedPtr<System::Drawing::StringFormat>& stringFormat = nullptr);

    ASPOSECPP_SHARED_API void DrawString(const String &str, const SharedPtr<Font>& font, const SharedPtr<Brush>& brush, RectangleF layoutRectangle, const System::SharedPtr<System::Drawing::StringFormat>& stringFormat = nullptr);

    ASPOSECPP_SHARED_API void DrawString(const String &str, const SharedPtr<Font>& font, const SharedPtr<Brush>& brush, float x, float y, const System::SharedPtr<System::Drawing::StringFormat>& stringFormat = nullptr);


    ASPOSECPP_SHARED_API void FillEllipse(const SharedPtr<Brush>& brush, Rectangle rect);

    ASPOSECPP_SHARED_API void FillEllipse(const SharedPtr<Brush>& brush, RectangleF rect);

    ASPOSECPP_SHARED_API void FillEllipse(const SharedPtr<Brush>& brush, int x, int y, int width, int height);

    ASPOSECPP_SHARED_API void FillEllipse(const SharedPtr<Brush>& brush, float x, float y, float width, float height);

    ASPOSECPP_SHARED_API void FillPath(const SharedPtr<Brush>& brush, const SharedPtr<Drawing2D::GraphicsPath>& path);

    ASPOSECPP_SHARED_API void FillRegion(const SharedPtr<Brush>& brush, const SharedPtr<Region>& region);

    ASPOSECPP_SHARED_API void FillPolygon(const SharedPtr<Brush>& brush, const ArrayPtr<Point>& points, Drawing2D::FillMode fillMode = Drawing2D::FillMode::Alternate);

    ASPOSECPP_SHARED_API void FillPolygon(const SharedPtr<Brush>& brush, const ArrayPtr<PointF>& points, Drawing2D::FillMode fillMode = Drawing2D::FillMode::Alternate);


    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const System::ArrayPtr<Point>& destPoints);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const System::ArrayPtr<PointF>& destPoints,

                                        const RectangleF& srcRect, GraphicsUnit srcUnit,

                                        const Imaging::ImageAttributesPtr& imgAttributes);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const System::Details::ArrayView<PointF>& destPoints,

                                        const RectangleF& srcRect, GraphicsUnit srcUnit,

                                        const Imaging::ImageAttributesPtr& imgAttributes);

    template<std::size_t N>

    void DrawImage(const SharedPtr<Image>& image, const System::Details::StackArray<PointF, N>& destPoints,

                   const RectangleF& srcRect, GraphicsUnit srcUnit,

                   const Imaging::ImageAttributesPtr& imgAttributes)

    {

        DrawImage(image, static_cast<System::Details::ArrayView<PointF>>(destPoints), srcRect, srcUnit, imgAttributes);

    }

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, int x, int y);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, float x, float y);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Point pt);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, PointF pt);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, int x, int y, int width, int height);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, float x, float y, float width, float height);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const Rectangle & rect);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const RectangleF & rect);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr& imgAttributes);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr& imgAttributes);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr& imgAttributes, Graphics::DrawImageAbort callback);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr& imgAttributes, Graphics::DrawImageAbort callback);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr& imgAttributes, Graphics::DrawImageAbort callback, IntPtr callbackData);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr& imgAttributes, Graphics::DrawImageAbort callback, IntPtr callbackData);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const ArrayPtr<PointF>& destPoints, RectangleF srcRect, GraphicsUnit srcUnit);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const ArrayPtr<PointF>& destPoints);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const ArrayPtr<Point>& destPoints, Rectangle srcRect, GraphicsUnit srcUnit);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, const ArrayPtr<Point>& destPoints,

                                        Rectangle srcRect, GraphicsUnit srcUnit,

                                        const SharedPtr<Imaging::ImageAttributes>& imageAttr);

    ASPOSECPP_SHARED_API void DrawImage(const SharedPtr<Image>& image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit);


    ASPOSECPP_SHARED_API void DrawImageUnscaled(const SharedPtr<Image>& image, int x, int y);

    ASPOSECPP_SHARED_API void DrawImageUnscaled(const SharedPtr<Image>& image, int x, int y, int width, int height);

    ASPOSECPP_SHARED_API void DrawImageUnscaled(const SharedPtr<Image>& image, const Rectangle& rect);

    ASPOSECPP_SHARED_API void DrawImageUnscaled(const SharedPtr<Image>& image, const Point& point);


    ASPOSECPP_SHARED_API void DrawLine(const SharedPtr<Pen>& pen, Point pt1, Point pt2);

    ASPOSECPP_SHARED_API void DrawLine(const SharedPtr<Pen>& pen, PointF pt1, PointF pt2);

    ASPOSECPP_SHARED_API void DrawLine(const SharedPtr<Pen>& pen, int x1, int y1, int x2, int y2);

    ASPOSECPP_SHARED_API void DrawLine(const SharedPtr<Pen>& pen, float x1, float y1, float x2, float y2);


    ASPOSECPP_SHARED_API void DrawIcon(const SharedPtr<Icon>& icon, Rectangle targetRect);

    ASPOSECPP_SHARED_API void DrawIcon(const SharedPtr<Icon>& icon, int32_t x, int32_t y);

    ASPOSECPP_SHARED_API void DrawIconUnstretched(const SharedPtr<Icon>& icon, Rectangle targetRect);

    ASPOSECPP_SHARED_API void DrawImageUnscaledAndClipped(const SharedPtr<Image>& image, Rectangle rectangle);

    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<Region>> MeasureCharacterRanges(const System::String& text,

                                                                        const SharedPtr<Font>& font,

                                                                        RectangleF layoutRect,

                                                                        const SharedPtr<StringFormat>& stringFormat);

    ASPOSECPP_SHARED_API SizeF MeasureString(String const& str, System::SharedPtr<Font> const& font, PointF const& origin = PointF(0, 0), System::SharedPtr<StringFormat> const& stringFormat = nullptr) const;

    ASPOSECPP_SHARED_API SizeF MeasureString(String const& str, System::SharedPtr<Font> const& font, int width, System::SharedPtr<StringFormat> const& stringFormat = nullptr) const;

    ASPOSECPP_SHARED_API SizeF MeasureString(String const& str, System::SharedPtr<Font> const& font, SizeF const& layoutArea, System::SharedPtr<StringFormat> const& stringFormat, int& charactersFitted, int& linesFilled) const;

    ASPOSECPP_SHARED_API SizeF MeasureString(String const& str, System::SharedPtr<Font> const& font, SizeF const& layoutArea, System::SharedPtr<StringFormat> const& stringFormat = nullptr) const;


    ASPOSECPP_SHARED_API IntPtr GetHdc();


    ASPOSECPP_SHARED_API void ReleaseHdc();

    ASPOSECPP_SHARED_API void ReleaseHdc(IntPtr hdc);

    static ASPOSECPP_SHARED_API SharedPtr<Graphics> FromHwnd(IntPtr hwnd);

    static ASPOSECPP_SHARED_API SharedPtr<Graphics> FromHwndInternal(IntPtr hwnd);


    ASPOSECPP_SHARED_API float get_PageScale() const;

    ASPOSECPP_SHARED_API void set_PageScale(float scale);


    ASPOSECPP_SHARED_API Point get_RenderingOrigin() const;

    ASPOSECPP_SHARED_API void set_RenderingOrigin(Point point);


    ASPOSECPP_SHARED_API SharedPtr<Drawing2D::Matrix> get_Transform();

    ASPOSECPP_SHARED_API void set_Transform(const SharedPtr<Drawing2D::Matrix>& matrix);


    ASPOSECPP_SHARED_API float get_DpiX();

    ASPOSECPP_SHARED_API float get_DpiY();


    ASPOSECPP_SHARED_API SharedPtr<Region> get_Clip();

    // Graphics object.

    ASPOSECPP_SHARED_API void set_Clip(const SharedPtr<Region>& region);


    ASPOSECPP_SHARED_API void SetClip(const SharedPtr<Region>& region, Drawing2D::CombineMode combineMode = Drawing2D::CombineMode::Replace);

    ASPOSECPP_SHARED_API void SetClip(Rectangle rect, Drawing2D::CombineMode combineMode = Drawing2D::CombineMode::Replace);

    ASPOSECPP_SHARED_API void SetClip(RectangleF rect, Drawing2D::CombineMode combineMode = Drawing2D::CombineMode::Replace);

    ASPOSECPP_SHARED_API void SetClip(const SharedPtr<Graphics>& graphics,

                                      Drawing2D::CombineMode combineMode = Drawing2D::CombineMode::Replace);

    ASPOSECPP_SHARED_API void SetClip(const SharedPtr<Drawing2D::GraphicsPath>& path,

                                      Drawing2D::CombineMode combineMode = Drawing2D::CombineMode::Replace);


    ASPOSECPP_SHARED_API void ExcludeClip(Rectangle rect);

    ASPOSECPP_SHARED_API void ExcludeClip(const SharedPtr<Region>& region);

    ASPOSECPP_SHARED_API void ResetClip();


    ASPOSECPP_SHARED_API void DrawPath(const SharedPtr<Pen>& pen, const SharedPtr<Drawing2D::GraphicsPath>& path);

    ASPOSECPP_SHARED_API void DrawLines(const SharedPtr<Pen>& pen, const System::ArrayPtr<System::Drawing::Point>& points);

    ASPOSECPP_SHARED_API void DrawLines(const SharedPtr<Pen>& pen, const System::ArrayPtr<System::Drawing::PointF>& points);


    ASPOSECPP_SHARED_API void DrawBezier(const SharedPtr<Pen>& pen, const Point & pt1, const Point & pt2, const Point & pt3, const Point & pt4);

    ASPOSECPP_SHARED_API void DrawBezier(const SharedPtr<Pen>& pen, const PointF& pt1, const PointF& pt2, const PointF& pt3, const PointF& pt4);

    ASPOSECPP_SHARED_API void DrawBezier(const SharedPtr<Pen>& pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);

    ASPOSECPP_SHARED_API void DrawBeziers(const SharedPtr<Pen>& pen, const ArrayPtr<Point>& points);

    ASPOSECPP_SHARED_API void DrawBeziers(const SharedPtr<Pen>& pen, const ArrayPtr<PointF>& points);


    ASPOSECPP_SHARED_API void DrawClosedCurve(const SharedPtr<Pen>& pen, const ArrayPtr<Point>& points, float tension = 0.5f,

                                              Drawing2D::FillMode fillmode = Drawing2D::FillMode::Alternate);

    ASPOSECPP_SHARED_API void DrawClosedCurve(const SharedPtr<Pen>& pen, const ArrayPtr<PointF>& points, float tension = 0.5f,

                                              Drawing2D::FillMode fillmode = Drawing2D::FillMode::Alternate);


    ASPOSECPP_SHARED_API void DrawCurve(const SharedPtr<Pen>& pen, const ArrayPtr<Point>& points, float tension = 0.5f);

    ASPOSECPP_SHARED_API void DrawCurve(const SharedPtr<Pen>& pen, const ArrayPtr<PointF>& points, float tension = 0.5f);

    ASPOSECPP_SHARED_API void DrawCurve(const SharedPtr<Pen>& pen, const ArrayPtr<Point>& points, int32_t offset,

                                        int32_t numberOfSegments, float tension = 0.5f);

    ASPOSECPP_SHARED_API void DrawCurve(const SharedPtr<Pen>& pen, const ArrayPtr<PointF>& points, int32_t offset,

                                        int32_t numberOfSegments, float tension = 0.5f);


    ASPOSECPP_SHARED_API void FillClosedCurve(const SharedPtr<Brush>& brush, const ArrayPtr<PointF>& points,

        Drawing2D::FillMode fillmode = Drawing2D::FillMode::Alternate, float tension = 0.5f);

    ASPOSECPP_SHARED_API void FillClosedCurve(const SharedPtr<Brush>& brush, const ArrayPtr<Point>& points,

        Drawing2D::FillMode fillmode = Drawing2D::FillMode::Alternate, float tension = 0.5f);


    ASPOSECPP_SHARED_API void ResetTransform();

    ASPOSECPP_SHARED_API void ScaleTransform(float sx, float sy, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);

    ASPOSECPP_SHARED_API void RotateTransform(float angle, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);

    ASPOSECPP_SHARED_API void TranslateTransform(float dx, float dy, Drawing2D::MatrixOrder order= Drawing2D::MatrixOrder::Prepend);

    ASPOSECPP_SHARED_API void MultiplyTransform(const SharedPtr<Drawing2D::Matrix>& matrix, Drawing2D::MatrixOrder order = Drawing2D::MatrixOrder::Prepend);


    ASPOSECPP_SHARED_API void TranslateClip(int dx, int dy);

    ASPOSECPP_SHARED_API void TranslateClip(float dx, float dy);


    ASPOSECPP_SHARED_API void TransformPoints(Drawing2D::CoordinateSpace destSpace, Drawing2D::CoordinateSpace srcSpace,

                                              const ArrayPtr<System::Drawing::Point>& pts);

    ASPOSECPP_SHARED_API void TransformPoints(Drawing2D::CoordinateSpace destSpace, Drawing2D::CoordinateSpace srcSpace,

                                              const ArrayPtr<System::Drawing::PointF>& pts);


    ASPOSECPP_SHARED_API SharedPtr<Drawing2D::GraphicsState> Save();

    ASPOSECPP_SHARED_API void Restore(const SharedPtr<Drawing2D::GraphicsState>& graphicsState);

    ASPOSECPP_SHARED_API void Flush(Drawing2D::FlushIntention intention = Drawing2D::FlushIntention::Flush);


    ASPOSECPP_SHARED_API void IntersectClip(const System::SharedPtr<Region>& region);

    ASPOSECPP_SHARED_API void IntersectClip(System::Drawing::RectangleF rect);

    ASPOSECPP_SHARED_API void IntersectClip(System::Drawing::Rectangle rect);


    ASPOSECPP_SHARED_API bool IsVisible(Point point);

    ASPOSECPP_SHARED_API bool IsVisible(PointF point);

    ASPOSECPP_SHARED_API bool IsVisible(Rectangle rect);

    ASPOSECPP_SHARED_API bool IsVisible(RectangleF rect);

    ASPOSECPP_SHARED_API bool IsVisible(int32_t x, int32_t y);

    ASPOSECPP_SHARED_API bool IsVisible(float x, float y);

    ASPOSECPP_SHARED_API bool IsVisible(float x, float y, float width, float height);

    ASPOSECPP_SHARED_API bool IsVisible(int32_t x, int32_t y, int32_t width, int32_t height);


    ASPOSECPP_SHARED_API SharedPtr<Drawing2D::GraphicsContainer> BeginContainer();

    ASPOSECPP_SHARED_API SharedPtr<Drawing2D::GraphicsContainer> BeginContainer(Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit);

    ASPOSECPP_SHARED_API SharedPtr<Drawing2D::GraphicsContainer> BeginContainer(RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit);

    ASPOSECPP_SHARED_API void EndContainer(const SharedPtr<Drawing2D::GraphicsContainer>& container);


    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, const ArrayPtr<PointF>& destPoints, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, const ArrayPtr<Point>& destPoints, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, Point destPoint, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, PointF destPoint, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, Rectangle destRect, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, RectangleF destRect, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, const ArrayPtr<Point>& destPoints, Rectangle srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, const ArrayPtr<PointF>& destPoints, RectangleF srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback);

    ASPOSECPP_SHARED_API void EnumerateMetafile(const SharedPtr<Imaging::Metafile>& metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback);


    ASPOSECPP_SHARED_API void AddMetafileComment(const System::ArrayPtr<uint8_t>& data);

    ASPOSECPP_SHARED_API void CopyFromScreen(Point upperLeftSource, Point upperLeftDestination, Size blockRegionSize, CopyPixelOperation copyPixelOperation = CopyPixelOperation::SourceCopy);

    ASPOSECPP_SHARED_API void CopyFromScreen(int32_t sourceX, int32_t sourceY, int32_t destinationX, int32_t destinationY, Size blockRegionSize, CopyPixelOperation copyPixelOperation = CopyPixelOperation::SourceCopy);

    ASPOSECPP_SHARED_API int32_t get_TextContrast() const;

    ASPOSECPP_SHARED_API void set_TextContrast(int32_t value);

    ASPOSECPP_SHARED_API bool get_IsClipEmpty() const;

    ASPOSECPP_SHARED_API bool get_IsVisibleClipEmpty() const;


    ASPOSECPP_SHARED_API RectangleF get_VisibleClipBounds() const;


    ASPOSECPP_SHARED_API Color GetNearestColor(Color color);


    void Dispose() { };


    ASPOSECPP_SHARED_API ~Graphics();


    ASPOSECPP_SHARED_API SkCanvas* GetSkCanvas() const;


private:

    std::unique_ptr<SkCanvas> m_sk_canvas;

    std::unique_ptr<SkClipStack> m_sk_clip_stack;


    friend class Aspose::Testing::GraphicsTest;

    friend class Aspose::Testing::ReleaseAsDebug::Test;

    friend class Aspose::Images::Pal::GraphicsPal;

    ASPOSECPP_SHARED_API Graphics(std::unique_ptr<SkCanvas> canvas, float hRes = 96.0f, float vRes = 96.0f);

    ASPOSECPP_SHARED_API MEMBER_FUNCTION_MAKE_OBJECT_DECLARATION(

        Graphics,

        CODEPORTING_ARGS(std::unique_ptr<SkCanvas> canvas, float hRes = 96.0f, float vRes = 96.0f)

    );


    void SaveState(int id);

    void RestoreState(int id);

    void ResetState(const SharedPtr<Drawing2D::Matrix>& matrix);


    struct State

    {

        State();


        Drawing2D::InterpolationMode m_interpolation_mode;

        Drawing2D::CompositingQuality m_compositing_quality;

        Drawing2D::CompositingMode m_compositing_mode;

        Drawing2D::SmoothingMode m_smoothing_mode;

        Text::TextRenderingHint m_text_rendering_hint;

        GraphicsUnit m_page_unit;

        float m_page_scale;

        Point m_rendering_origin;

        int32_t m_text_contrast;


        Drawing2D::PixelOffsetMode m_pixel_offset_mode;

        SharedPtr<Drawing2D::Matrix> m_transform_matrix;

        SharedPtr<Drawing2D::Matrix> m_base_transform_matrix;

    } m_current_state;


    const float m_horizontal_resolution; //only default 96dpi is supported

    const float m_vertical_resolution; //only default 96dpi is supported


    std::stack<std::pair<int, State>> m_states;


    SkRect ToSkRect(const Drawing::RectangleF& rect, GraphicsUnit unit);


    SharedPtr<Drawing2D::Matrix> CalculateWorldMatrix(bool apply_shift = false, bool calc_scale = true) const;

    SharedPtr<Drawing2D::Matrix> CalculateBaseMatrix() const;

    PointF CalculateWorldScale() const;


    static float ConvertToPixelSize(float size, float dpi, GraphicsUnit unit);


    static SizeF CorrectSize(const SizeF& size, const PointF& scale, const SizeF& layout, float font_size,

                             const System::SharedPtr<StringFormat>& format);


private:

    void DrawArcImpl(const SharedPtr<Pen>& pen, float x, float y, float width, float height, float startAngle, float sweepAngle);

    void DrawPieImpl(const SharedPtr<Pen>& pen, float x, float y, float width, float height, float startAngle, float sweepAngle);

    void FillPieImpl(const SharedPtr<Brush>& brush, float x, float y, float width, float height, float startAngle, float sweepAngle);

    void DrawEllipseImpl(const SharedPtr<Pen>& pen, float x, float y, float width, float height);

};


}}


#endif // _aspose_drawing_graphics_h_

System::Drawing::Bitmap
Represents a GDI+ bitmap image. Objects of this class should only be allocated using System::MakeObje...
Definition: bitmap.h:64

System::Drawing::Color
Represents a color. This type should be allocated on stack and passed to functions by value or by ref...
Definition: color.h:24

System::Drawing::Font
Represents a particular format for text, including font face, size, and style. Objects of this class ...
Definition: font.h:33

System::Drawing::Graphics
Represents a drawing surface. Objects of this class should only be allocated using System::MakeObject...
Definition: graphics.h:68

System::Drawing::Graphics::FillEllipse
void FillEllipse(const SharedPtr< Brush > &brush, int x, int y, int width, int height)
Fills the interior of the ellipse specified by the bounding rectangle using the specified brush.

System::Drawing::Graphics::get_VisibleClipBounds
RectangleF get_VisibleClipBounds() const
Returns the RectangleF object that represents a bounding rectangle of the visible clipping region of ...

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, const ArrayPtr< Point > &destPoints, Rectangle srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::set_CompositingQuality
void set_CompositingQuality(Drawing2D::CompositingQuality quality)
Sets a value that specifies the quality level to use when compositing images.

System::Drawing::Graphics::DrawRectangles
void DrawRectangles(const SharedPtr< Pen > &pen, const ArrayPtr< RectangleF > &rects)
Draws a series of rectangles using the specified pen.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit)
Draws the specified region of the specified image at the specified location.

System::Drawing::Graphics::IsVisible
bool IsVisible(Point point)
Determines whether the specified point is contained within the visible clip region of the current Gra...

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const ArrayPtr< PointF > &destPoints, RectangleF srcRect, GraphicsUnit srcUnit)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawBeziers
void DrawBeziers(const SharedPtr< Pen > &pen, const ArrayPtr< Point > &points)
Draws a series of Bezier splines using the specified pen.

System::Drawing::Graphics::DrawEllipse
void DrawEllipse(const SharedPtr< Pen > &pen, Rectangle rect)
Draws the specified ellipse using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::IsVisible
bool IsVisible(float x, float y)
NOT IMPLEMENTED.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, const ArrayPtr< PointF > &destPoints, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::FillRegion
void FillRegion(const SharedPtr< Brush > &brush, const SharedPtr< Region > &region)
Fills the interiors of the specified region using the specified brush.

System::Drawing::Graphics::DrawImageUnscaledAndClipped
void DrawImageUnscaledAndClipped(const SharedPtr< Image > &image, Rectangle rectangle)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawBezier
void DrawBezier(const SharedPtr< Pen > &pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
NOT IMPLEMENTED.

System::Drawing::Graphics::EnumerateMetafileProc
MulticastDelegate< bool(Imaging::EmfPlusRecordType, int32_t, int32_t, IntPtr, Imaging::PlayRecordCallback)> EnumerateMetafileProc
The type of a callback fuction object used as an argument for EnumerateMetafile method.
Definition: graphics.h:77

System::Drawing::Graphics::DrawString
void DrawString(const String &str, const SharedPtr< Font > &font, const SharedPtr< Brush > &brush, RectangleF layoutRectangle, const System::SharedPtr< System::Drawing::StringFormat > &stringFormat=nullptr)
Draws the specified string in the specified rectangle using the specified font and brush.

System::Drawing::Graphics::GetHdc
IntPtr GetHdc()
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit)
Draws the specified region of the specified image to the specified rectangle.

System::Drawing::Graphics::DrawLine
void DrawLine(const SharedPtr< Pen > &pen, int x1, int y1, int x2, int y2)
Draws the specified line using the specified pen.

System::Drawing::Graphics::Dispose
void Dispose()
Releases all operating system resources acquired by the current object.
Definition: graphics.h:988

System::Drawing::Graphics::get_PageUnit
GraphicsUnit get_PageUnit() const
Returns measurement units used for page coordinates on the surface represented by the current object.

System::Drawing::Graphics::FillEllipse
void FillEllipse(const SharedPtr< Brush > &brush, float x, float y, float width, float height)
Fills the interior of the ellipse specified by the bounding rectangle using the specified brush.

System::Drawing::Graphics::MeasureString
SizeF MeasureString(String const &str, System::SharedPtr< Font > const &font, SizeF const &layoutArea, System::SharedPtr< StringFormat > const &stringFormat=nullptr) const
Returns a size of the specified string when drawn in the specified font in the specified format.

System::Drawing::Graphics::EndContainer
void EndContainer(const SharedPtr< Drawing2D::GraphicsContainer > &container)
Closes the current container and restores the state of this object from the state of saved container.

System::Drawing::Graphics::DrawArc
void DrawArc(const SharedPtr< Pen > &pen, RectangleF rect, float startAngle, float sweepAngle)
Draws the specified arc using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::FillPath
void FillPath(const SharedPtr< Brush > &brush, const SharedPtr< Drawing2D::GraphicsPath > &path)
Fills the interiors of the specified path using the specified brush.

System::Drawing::Graphics::DrawArc
void DrawArc(const SharedPtr< Pen > &pen, Rectangle rect, float startAngle, float sweepAngle)
Draws the specified arc using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::DrawString
void DrawString(const String &str, const SharedPtr< Font > &font, const SharedPtr< Brush > &brush, PointF topLeft, const System::SharedPtr< System::Drawing::StringFormat > &stringFormat=nullptr)
Draws the specified string at the specified location using the specified font and brush.

System::Drawing::Graphics::set_TextContrast
void set_TextContrast(int32_t value)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImageUnscaled
void DrawImageUnscaled(const SharedPtr< Image > &image, int x, int y, int width, int height)
Draws a specified image using its original physical size at a specified location.

System::Drawing::Graphics::FillPie
void FillPie(const SharedPtr< Brush > &brush, float x, float y, float width, float height, float startAngle, float sweepAngle)
Fills the specified pie using the specified brush on the surface represented by the current object.

System::Drawing::Graphics::Save
SharedPtr< Drawing2D::GraphicsState > Save()
Saves the current state of this object and returns the saved state.

System::Drawing::Graphics::DrawBeziers
void DrawBeziers(const SharedPtr< Pen > &pen, const ArrayPtr< PointF > &points)
Draws a series of Bezier splines using the specified pen.

System::Drawing::Graphics::set_Clip
void set_Clip(const SharedPtr< Region > &region)
Sets a region that limits the drawing area of the drawing surface represented by the current.

System::Drawing::Graphics::get_SmoothingMode
Drawing2D::SmoothingMode get_SmoothingMode()
Returns a value that indicates a soothing mode used during rendering on the surface represented by th...

System::Drawing::Graphics::get_TextContrast
int32_t get_TextContrast() const
NOT IMPLEMENTED.

System::Drawing::Graphics::set_Transform
void set_Transform(const SharedPtr< Drawing2D::Matrix > &matrix)
Sets the geometric world transformation for the current Graphics object.

System::Drawing::Graphics::set_PageScale
void set_PageScale(float scale)
Sets the scaling between world units and page units for the current Graphics object.

System::Drawing::Graphics::FillRectangle
void FillRectangle(const SharedPtr< Brush > &brush, float x, float y, float width, float height)
Fills the specified rectangle with the specified brush.

System::Drawing::Graphics::get_CompositingMode
Drawing2D::CompositingMode get_CompositingMode()
Returns a value that indicates how composited images are drawn on the surface represented by the curr...

System::Drawing::Graphics::DrawRectangle
void DrawRectangle(const SharedPtr< Pen > &pen, float x, float y, float width, float height)
Draws the specified rectangle using the specified pen on the surface represented by the current objec...

System::Drawing::Graphics::FillRectangles
void FillRectangles(const SharedPtr< Brush > &brush, const ArrayPtr< Rectangle > &rects)
Fills a series of rectangles using the specified brush.

System::Drawing::Graphics::DrawPolygon
void DrawPolygon(const SharedPtr< Pen > &pen, const ArrayPtr< PointF > &points)
Draws a polygon using the specified pen.

System::Drawing::Graphics::DrawClosedCurve
void DrawClosedCurve(const SharedPtr< Pen > &pen, const ArrayPtr< Point > &points, float tension=0.5f, Drawing2D::FillMode fillmode=Drawing2D::FillMode::Alternate)
Draws a closed spline using the specified pen.

System::Drawing::Graphics::FillPie
void FillPie(const SharedPtr< Brush > &brush, Rectangle rect, float startAngle, float sweepAngle)
Fills the specified pie using the specified brush on the surface represented by the current object.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, float x, float y, float width, float height)
Draws the specified image to the specified rectangle.

System::Drawing::Graphics::DrawEllipse
void DrawEllipse(const SharedPtr< Pen > &pen, RectangleF rect)
Draws the specified ellipse using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::IntersectClip
void IntersectClip(System::Drawing::RectangleF rect)
Updates the clip region of this object to the intersection of the current clip and the specified clip...

System::Drawing::Graphics::FillPolygon
void FillPolygon(const SharedPtr< Brush > &brush, const ArrayPtr< PointF > &points, Drawing2D::FillMode fillMode=Drawing2D::FillMode::Alternate)
Fills the interiors of the specified polygon using the specified brush.

System::Drawing::Graphics::BeginContainer
SharedPtr< Drawing2D::GraphicsContainer > BeginContainer(Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit)
Saves a container with the current state of this object, opens and uses a new container and returns t...

System::Drawing::Graphics::GetSkCanvas
SkCanvas * GetSkCanvas() const

System::Drawing::Graphics::FillRectangle
void FillRectangle(const SharedPtr< Brush > &brush, int x, int y, int width, int height)
Fills the specified rectangle with the specified brush.

System::Drawing::Graphics::SetClip
void SetClip(Rectangle rect, Drawing2D::CombineMode combineMode=Drawing2D::CombineMode::Replace)
Sets the clipping region of drawing surface represented by the current Graphics object to the result ...

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, int x, int y, int width, int height)
Draws the specified image to the specified rectangle.

System::Drawing::Graphics::Flush
void Flush(Drawing2D::FlushIntention intention=Drawing2D::FlushIntention::Flush)
Triggers the immediate execution of all pending draw operations.

System::Drawing::Graphics::ReleaseHdc
void ReleaseHdc()
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawPolygon
void DrawPolygon(const SharedPtr< Pen > &pen, const ArrayPtr< Point > &points)
Draws a polygon using the specified pen.

System::Drawing::Graphics::set_CompositingMode
void set_CompositingMode(Drawing2D::CompositingMode mode)
Sets a value that specifies how composited images are drawn on the surface represented by the current...

System::Drawing::Graphics::FillPie
void FillPie(const SharedPtr< Brush > &brush, int x, int y, int width, int height, int startAngle, int sweepAngle)
Fills the specified pie using the specified brush on the surface represented by the current object.

System::Drawing::Graphics::set_PixelOffsetMode
void set_PixelOffsetMode(Drawing2D::PixelOffsetMode mode)
Sets a value that specifies how the pixels should be offset during rendering on the surface represent...

System::Drawing::Graphics::get_Clip
SharedPtr< Region > get_Clip()
Returns a Region object that represents a region that limits the drawing area of the drawing surface ...

System::Drawing::Graphics::set_SmoothingMode
void set_SmoothingMode(Drawing2D::SmoothingMode mode)
Sets a value that specifies a soothing mode used during rendering on the surface represented by the c...

System::Drawing::Graphics::get_Transform
SharedPtr< Drawing2D::Matrix > get_Transform()
Returns the geometric world transformation for the current Graphics object.

System::Drawing::Graphics::IntersectClip
void IntersectClip(System::Drawing::Rectangle rect)
Updates the clip region of this object to the intersection of the current clip and the specified clip...

System::Drawing::Graphics::~Graphics
~Graphics()

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const System::ArrayPtr< Point > &destPoints)
NOT IMPLEMENTED.

System::Drawing::Graphics::TranslateClip
void TranslateClip(int dx, int dy)
NOT IMPLEMENTED.

System::Drawing::Graphics::TranslateTransform
void TranslateTransform(float dx, float dy, Drawing2D::MatrixOrder order=Drawing2D::MatrixOrder::Prepend)
Applies the specified translation vector to the world transformation matrix of the current Graphics o...

System::Drawing::Graphics::FromHwnd
static SharedPtr< Graphics > FromHwnd(IntPtr hwnd)
NOT IMPLEMENTED.

System::Drawing::Graphics::IsVisible
bool IsVisible(PointF point)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, float x, float y)
Draws the specified image at the specified location.

System::Drawing::Graphics::GetNearestColor
Color GetNearestColor(Color color)
NOT IMPLEMENTED.

System::Drawing::Graphics::FillRectangle
void FillRectangle(const SharedPtr< Brush > &brush, Rectangle rect)
Fills the specified rectangle with the specified brush.

System::Drawing::Graphics::IsVisible
bool IsVisible(int32_t x, int32_t y, int32_t width, int32_t height)
NOT IMPLEMENTED.

System::Drawing::Graphics::MultiplyTransform
void MultiplyTransform(const SharedPtr< Drawing2D::Matrix > &matrix, Drawing2D::MatrixOrder order=Drawing2D::MatrixOrder::Prepend)
Multiplies the world transformation matrix of the current Graphics object by the specified matrix.

System::Drawing::Graphics::set_RenderingOrigin
void set_RenderingOrigin(Point point)
Sets a Point object that specifies the rendering origin of the current Graphics object for dithering ...

System::Drawing::Graphics::DrawPie
void DrawPie(const SharedPtr< Pen > &pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
Draws the specified pie using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::DrawArc
void DrawArc(const SharedPtr< Pen > &pen, int32_t x, int32_t y, int32_t width, int32_t height, int32_t startAngle, int32_t sweepAngle)
Draws the specified arc using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::FillRectangle
void FillRectangle(const SharedPtr< Brush > &brush, RectangleF rect)
Fills the specified rectangle with the specified brush.

System::Drawing::Graphics::DrawCurve
void DrawCurve(const SharedPtr< Pen > &pen, const ArrayPtr< PointF > &points, int32_t offset, int32_t numberOfSegments, float tension=0.5f)
Draws a spline using the specified pen.

System::Drawing::Graphics::DrawLines
void DrawLines(const SharedPtr< Pen > &pen, const System::ArrayPtr< System::Drawing::Point > &points)
Draws a series of line segments using the specified pen.

System::Drawing::Graphics::IsVisible
bool IsVisible(int32_t x, int32_t y)
NOT IMPLEMENTED.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, const ArrayPtr< Point > &destPoints, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit)
Draws the specified region of the specified image at the specified location.

System::Drawing::Graphics::set_PageUnit
void set_PageUnit(GraphicsUnit value)
Sets measurement units used for page coordinates on the surface represented by the current object.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes, Graphics::DrawImageAbort callback, IntPtr callbackData)
NOT IMPLEMENTED.

System::Drawing::Graphics::FillClosedCurve
void FillClosedCurve(const SharedPtr< Brush > &brush, const ArrayPtr< PointF > &points, Drawing2D::FillMode fillmode=Drawing2D::FillMode::Alternate, float tension=0.5f)
Draws a closed spline using the specified brush.

System::Drawing::Graphics::DrawLine
void DrawLine(const SharedPtr< Pen > &pen, PointF pt1, PointF pt2)
Draws the specified line using the specified pen.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes, Graphics::DrawImageAbort callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::ExcludeClip
void ExcludeClip(const SharedPtr< Region > &region)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawIcon
void DrawIcon(const SharedPtr< Icon > &icon, int32_t x, int32_t y)
NOT IMPLEMENTED.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, Rectangle destRect, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawEllipse
void DrawEllipse(const SharedPtr< Pen > &pen, float x, float y, float width, float height)
Draws the specified ellipse using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::Restore
void Restore(const SharedPtr< Drawing2D::GraphicsState > &graphicsState)
Restores the state of this object from the saved state.

System::Drawing::Graphics::DrawString
void DrawString(const String &str, const SharedPtr< Font > &font, const SharedPtr< Brush > &brush, float x, float y, const System::SharedPtr< System::Drawing::StringFormat > &stringFormat=nullptr)
Draws the specified string at the specified location using the specified font and brush.

System::Drawing::Graphics::MeasureString
SizeF MeasureString(String const &str, System::SharedPtr< Font > const &font, PointF const &origin=PointF(0, 0), System::SharedPtr< StringFormat > const &stringFormat=nullptr) const
Returns a size of the specified string when drawn in the specified font in the specified format.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, Point destPoint, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawEllipse
void DrawEllipse(const SharedPtr< Pen > &pen, int x, int y, int width, int height)
Draws the specified ellipse using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Point pt)
Draws the specified image at the specified location.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const ArrayPtr< Point > &destPoints, Rectangle srcRect, GraphicsUnit srcUnit)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes)
Draws the specified region of the specified image to the specified rectangle.

System::Drawing::Graphics::MeasureString
SizeF MeasureString(String const &str, System::SharedPtr< Font > const &font, int width, System::SharedPtr< StringFormat > const &stringFormat=nullptr) const
Returns a size of the specified string when drawn in the specified font in the specified format.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const System::ArrayPtr< PointF > &destPoints, const RectangleF &srcRect, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes)
Draws the specified region of the specified image at the specified location.

System::Drawing::Graphics::DrawImageUnscaled
void DrawImageUnscaled(const SharedPtr< Image > &image, const Rectangle &rect)
Draws a specified image using its original physical size at a specified location.

System::Drawing::Graphics::TranslateClip
void TranslateClip(float dx, float dy)
NOT IMPLEMENTED.

System::Drawing::Graphics::MeasureCharacterRanges
ArrayPtr< SharedPtr< Region > > MeasureCharacterRanges(const System::String &text, const SharedPtr< Font > &font, RectangleF layoutRect, const SharedPtr< StringFormat > &stringFormat)
Returns an array of regions each of which bounds character positions in the specified string.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, PointF destPoint, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const System::Details::ArrayView< PointF > &destPoints, const RectangleF &srcRect, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes)
Draws the specified region of the specified image at the specified location.

System::Drawing::Graphics::DrawImageUnscaled
void DrawImageUnscaled(const SharedPtr< Image > &image, const Point &point)
Draws a specified image using its original physical size at a specified location.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes, Graphics::DrawImageAbort callback, IntPtr callbackData)
NOT IMPLEMENTED.

System::Drawing::Graphics::IntersectClip
void IntersectClip(const System::SharedPtr< Region > &region)
Updates the clip region of this object to the intersection of the current clip and the specified clip...

System::Drawing::Graphics::BeginContainer
SharedPtr< Drawing2D::GraphicsContainer > BeginContainer(RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit)
Saves a container with the current state of this object, opens and uses a new container and returns t...

System::Drawing::Graphics::get_PixelOffsetMode
Drawing2D::PixelOffsetMode get_PixelOffsetMode()
Returns a value that indicates how the pixels are offset during rendering on the surface represented ...

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const ArrayPtr< Point > &destPoints, Rectangle srcRect, GraphicsUnit srcUnit, const SharedPtr< Imaging::ImageAttributes > &imageAttr)
Draws the specified region of the specified image at the specified location.

System::Drawing::Graphics::DrawLines
void DrawLines(const SharedPtr< Pen > &pen, const System::ArrayPtr< System::Drawing::PointF > &points)
Draws a series of line segments using the specified pen.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, const ArrayPtr< PointF > &destPoints, RectangleF srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawPath
void DrawPath(const SharedPtr< Pen > &pen, const SharedPtr< Drawing2D::GraphicsPath > &path)
Draws the specified path using the specified pen.

System::Drawing::Graphics::get_TextRenderingHint
Text::TextRenderingHint get_TextRenderingHint()
Returns a value that indicates the quality of text rendering.

System::Drawing::Graphics::get_IsVisibleClipEmpty
bool get_IsVisibleClipEmpty() const
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const RectangleF &rect)
Draws the specified image at the specified location.

System::Drawing::Graphics::get_DpiY
float get_DpiY()
Returns the vertical resolution.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes)
Draws the specified region of the specified image to the specified rectangle.

System::Drawing::Graphics::CopyFromScreen
void CopyFromScreen(int32_t sourceX, int32_t sourceY, int32_t destinationX, int32_t destinationY, Size blockRegionSize, CopyPixelOperation copyPixelOperation=CopyPixelOperation::SourceCopy)
NOT IMPLEMENTED.

System::Drawing::Graphics::TransformPoints
void TransformPoints(Drawing2D::CoordinateSpace destSpace, Drawing2D::CoordinateSpace srcSpace, const ArrayPtr< System::Drawing::Point > &pts)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit)
Draws the specified region of the specified image at the specified location.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes, Graphics::DrawImageAbort callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, PointF pt)
Draws the specified image at the specified location.

System::Drawing::Graphics::FromImage
static SharedPtr< Graphics > FromImage(const SharedPtr< Image > &image)
Creates a new Graphics object from the specified image.

System::Drawing::Graphics::get_IsClipEmpty
bool get_IsClipEmpty() const
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const Rectangle &rect)
Draws the specified image at the specified location.

System::Drawing::Graphics::DrawIconUnstretched
void DrawIconUnstretched(const SharedPtr< Icon > &icon, Rectangle targetRect)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawRectangle
void DrawRectangle(const SharedPtr< Pen > &pen, Rectangle rect)
Draws the specified rectangle using the specified pen on the surface represented by the current objec...

System::Drawing::Graphics::ReleaseHdc
void ReleaseHdc(IntPtr hdc)
NOT IMPLEMENTED.

System::Drawing::Graphics::SetClip
void SetClip(const SharedPtr< Graphics > &graphics, Drawing2D::CombineMode combineMode=Drawing2D::CombineMode::Replace)
NOT IMPLEMENTED.

System::Drawing::Graphics::FromHwndInternal
static SharedPtr< Graphics > FromHwndInternal(IntPtr hwnd)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawRectangle
void DrawRectangle(const SharedPtr< Pen > &pen, int x, int y, int width, int height)
Draws the specified rectangle using the specified pen on the surface represented by the current objec...

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::AddMetafileComment
void AddMetafileComment(const System::ArrayPtr< uint8_t > &data)
NOT IMPLEMENTED.

System::Drawing::Graphics::get_DpiX
float get_DpiX()
Returns the horizontal resolution.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, RectangleF destRect, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::IsVisible
bool IsVisible(RectangleF rect)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawCurve
void DrawCurve(const SharedPtr< Pen > &pen, const ArrayPtr< Point > &points, float tension=0.5f)
Draws a spline using the specified pen.

System::Drawing::Graphics::FillEllipse
void FillEllipse(const SharedPtr< Brush > &brush, RectangleF rect)
Fills the interior of the ellipse specified by the bounding rectangle using the specified brush.

System::Drawing::Graphics::DrawCurve
void DrawCurve(const SharedPtr< Pen > &pen, const ArrayPtr< PointF > &points, float tension=0.5f)
Draws a spline using the specified pen.

System::Drawing::Graphics::IsVisible
bool IsVisible(Rectangle rect)
NOT IMPLEMENTED.

System::Drawing::Graphics::BeginContainer
SharedPtr< Drawing2D::GraphicsContainer > BeginContainer()
Saves a container with the current state of this object, opens and uses a new container and returns t...

System::Drawing::Graphics::DrawLine
void DrawLine(const SharedPtr< Pen > &pen, float x1, float y1, float x2, float y2)
Draws the specified line using the specified pen.

System::Drawing::Graphics::get_RenderingOrigin
Point get_RenderingOrigin() const
Returns a Point object that represents the rendering origin of the current Graphics object for dither...

System::Drawing::Graphics::TransformPoints
void TransformPoints(Drawing2D::CoordinateSpace destSpace, Drawing2D::CoordinateSpace srcSpace, const ArrayPtr< System::Drawing::PointF > &pts)
NOT IMPLEMENTED.

System::Drawing::Graphics::ResetClip
void ResetClip()
Resets the clip region for this graphics to an infinite region.

System::Drawing::Graphics::get_ClipBounds
RectangleF get_ClipBounds() const
Returns a rectangle that bounds the clipping area of the surface represented by the current object.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit)
Draws the specified region of the specified image to the specified rectangle.

System::Drawing::Graphics::FillPolygon
void FillPolygon(const SharedPtr< Brush > &brush, const ArrayPtr< Point > &points, Drawing2D::FillMode fillMode=Drawing2D::FillMode::Alternate)
Fills the interiors of the specified polygon using the specified brush.

System::Drawing::Graphics::DrawPie
void DrawPie(const SharedPtr< Pen > &pen, Rectangle rect, float startAngle, float sweepAngle)
Draws the specified pie using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::get_InterpolationMode
Drawing2D::InterpolationMode get_InterpolationMode()
Returns a value that indicates the interpolation mode associated with the current object.

System::Drawing::Graphics::DrawArc
void DrawArc(const SharedPtr< Pen > &pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
Draws the specified arc using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const ArrayPtr< PointF > &destPoints)
NOT IMPLEMENTED.

System::Drawing::Graphics::Clear
void Clear(Color color)
Clears the drawing surface represented by the current object and fills it with the specified color.

System::Drawing::Graphics::ResetTransform
void ResetTransform()
Resets the world transformation matrix of the current object so that it becomes an identity matrix.

System::Drawing::Graphics::MeasureString
SizeF MeasureString(String const &str, System::SharedPtr< Font > const &font, SizeF const &layoutArea, System::SharedPtr< StringFormat > const &stringFormat, int &charactersFitted, int &linesFilled) const
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawCurve
void DrawCurve(const SharedPtr< Pen > &pen, const ArrayPtr< Point > &points, int32_t offset, int32_t numberOfSegments, float tension=0.5f)
Draws a spline using the specified pen.

System::Drawing::Graphics::FillEllipse
void FillEllipse(const SharedPtr< Brush > &brush, Rectangle rect)
Fills the interior of the ellipse specified by the bounding rectangle using the specified brush.

System::Drawing::Graphics::FillClosedCurve
void FillClosedCurve(const SharedPtr< Brush > &brush, const ArrayPtr< Point > &points, Drawing2D::FillMode fillmode=Drawing2D::FillMode::Alternate, float tension=0.5f)
Draws a closed spline using the specified brush.

System::Drawing::Graphics::set_InterpolationMode
void set_InterpolationMode(Drawing2D::InterpolationMode mode)
Sets a value that indicates the interpolation mode associated with the current object.

System::Drawing::Graphics::IsVisible
bool IsVisible(float x, float y, float width, float height)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImageUnscaled
void DrawImageUnscaled(const SharedPtr< Image > &image, int x, int y)
Draws the specified image using its original physical size at the specified location.

System::Drawing::Graphics::SetClip
void SetClip(const SharedPtr< Drawing2D::GraphicsPath > &path, Drawing2D::CombineMode combineMode=Drawing2D::CombineMode::Replace)
Sets the clipping region of drawing surface represented by the current Graphics object to the result ...

System::Drawing::Graphics::RotateTransform
void RotateTransform(float angle, Drawing2D::MatrixOrder order=Drawing2D::MatrixOrder::Prepend)
Applies the specified rotation to the world transformation matrix of the current Graphics object in t...

System::Drawing::Graphics::SetClip
void SetClip(const SharedPtr< Region > &region, Drawing2D::CombineMode combineMode=Drawing2D::CombineMode::Replace)
Sets the clipping region of drawing surface represented by the current Graphics object to the result ...

System::Drawing::Graphics::DrawLine
void DrawLine(const SharedPtr< Pen > &pen, Point pt1, Point pt2)
Draws the specified line using the specified pen.

System::Drawing::Graphics::set_TextRenderingHint
void set_TextRenderingHint(Text::TextRenderingHint hint)
Sets a value that specifies the quality of text rendering.

System::Drawing::Graphics::SetClip
void SetClip(RectangleF rect, Drawing2D::CombineMode combineMode=Drawing2D::CombineMode::Replace)
Sets the clipping region of drawing surface represented by the current Graphics object to the result ...

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, const System::Details::StackArray< PointF, N > &destPoints, const RectangleF &srcRect, GraphicsUnit srcUnit, const Imaging::ImageAttributesPtr &imgAttributes)
Draws the specified region of the specified image at the specified location.
Definition: graphics.h:412

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, int x, int y)
Draws the specified image at the specified location.

System::Drawing::Graphics::get_PageScale
float get_PageScale() const
Returns the scaling between world units and page units for the current Graphics object.

System::Drawing::Graphics::DrawPie
void DrawPie(const SharedPtr< Pen > &pen, RectangleF rect, float startAngle, float sweepAngle)
Draws the specified pie using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::DrawIcon
void DrawIcon(const SharedPtr< Icon > &icon, Rectangle targetRect)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawPie
void DrawPie(const SharedPtr< Pen > &pen, int32_t x, int32_t y, int32_t width, int32_t height, int32_t startAngle, int32_t sweepAngle)
Draws the specified pie using the specified pen on the surface represented by the current object.

System::Drawing::Graphics::EnumerateMetafile
void EnumerateMetafile(const SharedPtr< Imaging::Metafile > &metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, Graphics::EnumerateMetafileProc callback)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImageAbort
std::function< bool(IntPtr ptr)> DrawImageAbort
The type of a callback fuction object used as an argument for DrawImage method.
Definition: graphics.h:79

System::Drawing::Graphics::DrawBezier
void DrawBezier(const SharedPtr< Pen > &pen, const PointF &pt1, const PointF &pt2, const PointF &pt3, const PointF &pt4)
NOT IMPLEMENTED.

System::Drawing::Graphics::CopyFromScreen
void CopyFromScreen(Point upperLeftSource, Point upperLeftDestination, Size blockRegionSize, CopyPixelOperation copyPixelOperation=CopyPixelOperation::SourceCopy)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawImage
void DrawImage(const SharedPtr< Image > &image, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit)
Draws the specified region of the specified image at the specified location.

System::Drawing::Graphics::ScaleTransform
void ScaleTransform(float sx, float sy, Drawing2D::MatrixOrder order=Drawing2D::MatrixOrder::Prepend)
Applies the specified scale vector to the world transformation matrix of the current object.

System::Drawing::Graphics::get_CompositingQuality
Drawing2D::CompositingQuality get_CompositingQuality()
Returns a value that indicates the quality level used when compositing images.

System::Drawing::Graphics::FillRectangles
void FillRectangles(const SharedPtr< Brush > &brush, const ArrayPtr< RectangleF > &rects)
Fills a series of rectangles using the specified brush.

System::Drawing::Graphics::DrawClosedCurve
void DrawClosedCurve(const SharedPtr< Pen > &pen, const ArrayPtr< PointF > &points, float tension=0.5f, Drawing2D::FillMode fillmode=Drawing2D::FillMode::Alternate)
Draws a closed spline using the specified pen.

System::Drawing::Graphics::ExcludeClip
void ExcludeClip(Rectangle rect)
NOT IMPLEMENTED.

System::Drawing::Graphics::DrawRectangles
void DrawRectangles(const SharedPtr< Pen > &pen, const ArrayPtr< Rectangle > &rects)
Draws a series of rectangles using the specified pen.

System::Drawing::Graphics::DrawBezier
void DrawBezier(const SharedPtr< Pen > &pen, const Point &pt1, const Point &pt2, const Point &pt3, const Point &pt4)
NOT IMPLEMENTED.

System::Drawing::PointF
Represents a pair of single-precision floating point X and Y coordinates of a point on a 2-dimensiona...
Definition: point_f.h:14

System::Drawing::Point
Represents a pair of integer X and Y coordinates of a point on a 2-dimensional plane....
Definition: point.h:15

System::Drawing::RectangleF
Represents a rectangular area of an image defined as single-precision floating point X and Y coordina...
Definition: rectangle_f.h:15

System::Drawing::Rectangle
Represents a rectangular area of an image defined as integer X and Y coordinates of its upper left co...
Definition: rectangle.h:19

System::Drawing::Region
Represents the interior of a graphic shape. Objects of this class should only be allocated using Syst...
Definition: region.h:42

System::Drawing::SizeF
Represents a pair of single-precision floating point values that represent width and height of an ima...
Definition: size_f.h:14

System::Drawing::Size
Represents a pair of integer values that represent width and height of an image. This type should be ...
Definition: size.h:14

System::Object
Base class that enables using methods available for System.Object class in C#. All non-trivial classe...
Definition: object.h:62

System::SmartPtr< Object >

System::String
String class used across the library. Is a substitute for C# System.String when translating code....
Definition: string.h:122

System::Drawing::Drawing2D::SmoothingMode
SmoothingMode
Specifies what type of soothing (antialiasing) is applied to lines, curves and edges of filled areas.
Definition: smoothing_mode.h:9

System::Drawing::Drawing2D::FillMode
FillMode
Specifies how to fill the interior of a closed path.
Definition: fill_mode.h:9

System::Drawing::Drawing2D::FillMode::Alternate
@ Alternate
Alternate fill mode.

System::Drawing::Drawing2D::CombineMode
CombineMode
Specifies how clipping regions are combined.
Definition: combine_mode.h:7

System::Drawing::Drawing2D::CombineMode::Replace
@ Replace
One clipping region is replaced by another.

System::Drawing::Drawing2D::InterpolationMode
InterpolationMode
Specifies an algorithm to use when images are rotated or scaled.
Definition: interpolation_mode.h:13

System::Drawing::Drawing2D::CoordinateSpace
CoordinateSpace
Specifies how to evaluate coordinates.
Definition: coordinate_space.h:9

System::Drawing::Drawing2D::PixelOffsetMode
PixelOffsetMode
Specifies how pixels are offset when being rendered.
Definition: pixel_offset_mode.h:9

System::Drawing::Drawing2D::CompositingQuality
CompositingQuality
Specifies the quality level to be used during compositing.
Definition: compositing_quality.h:9

System::Drawing::Drawing2D::FlushIntention
FlushIntention
Specifies if commands in the graphics stack are terminated immediately or executed as soon as possibl...
Definition: flush_intention.h:8

System::Drawing::Drawing2D::FlushIntention::Flush
@ Flush
Terminate immadiately.

System::Drawing::Drawing2D::MatrixOrder
MatrixOrder
Specifies the order of matrix transform operations.
Definition: matrix_order.h:7

System::Drawing::Drawing2D::MatrixOrder::Prepend
@ Prepend
The new operation is applied before the old operation.

System::Drawing::Drawing2D::CompositingMode
CompositingMode
Specifies how source colors and background colors are combined.
Definition: compositing_mode.h:7

System::Drawing::Imaging::ColorAdjustType::Bitmap
@ Bitmap
Defines color adjustment information for Bitmap objects.

System::Drawing::Imaging::PlayRecordCallback
MulticastDelegate< void(EmfPlusRecordType, int32_t, int32_t, IntPtr)> PlayRecordCallback
A delegate used as a parameter in EnumerateMetafileProc function object.
Definition: play_record_callback.h:13

System::Drawing::Imaging::EmfPlusRecordType
EmfPlusRecordType
Represents the methods that can be used with a metafile to read and write graphic commands.
Definition: emf_plus_record_type.h:8

System::Drawing::Text::TextRenderingHint
TextRenderingHint
Specifies the quality of text rendering.
Definition: text_rendering_hint.h:9

System::Drawing::CopyPixelOperation
CopyPixelOperation
Specifies how the source color in a pixel copying operation is combined with the destination color to...
Definition: copy_pixel_operation.h:11

System::Drawing::CopyPixelOperation::SourceCopy
@ SourceCopy
The source region is copied directly to the destination region.

System::Drawing::GraphicsUnit
GraphicsUnit
Represents a unit of measure.
Definition: graphics_unit.h:10

System
Definition: db_command.h:9