Graphics


public ref class Graphics
{
  public:

    Graphics(Handle hdc);

    Graphics(Handle hdc,
             Handle hdevice);

    Graphics(System::Windows::Forms::Form^ form)

    Graphics(Image^ image);

    ~Graphics();

    //*** Properties ***

    property Brush Brush
    {
     void set(Brush currentBrush);
    }

    property Pen Pen
    {
     void set(Pen currentPen);
    }

    property Font Font
    {
     void set(Font currentFont);
    }

    property Region^ Clip
    {
     Region^ get();
     void set(Region^ clipRegion);
    }

    property Rectangle ClipBounds
    {
     Rectangle get();
    }


    property IPlusPlus::Drawing::CompositingMode CompositingMode
    {
     IPlusPlus::Drawing::CompositingMode get();
     void set(IPlusPlus::Drawing::CompositingMode value);
    }

    property IPlusPlus::Drawing::CompositingQuality CompositingQuality
    {
     IPlusPlus::Drawing::CompositingQuality get();
     void set(IPlusPlus::Drawing::CompositingQuality value);
    }

    property double DpiX
    {
     double get();
    }

    property double DpiY
    {
     double get();
    }

    property IPlusPlus::Drawing::InterpolationMode InterpolationMode
    {
     IPlusPlus::Drawing::InterpolationMode get();
     void set(IPlusPlus::Drawing::InterpolationMode value);
    }

    property bool IsClipEmpty
    {
      bool get();
    }

    property bool IsVisibleClipEmpty
    {
      bool get();
    }

    property double PageScale
    {
     double get();
     void set(double value);
    }

    property Unit PageUnit
    {
     Unit get();
     void set(Unit value);
    }

    property IPlusPlus::Drawing::PixelOffsetMode PixelOffsetMode
    {
     IPlusPlus::Drawing::PixelOffsetMode get();
     void set(IPlusPlus::Drawing::PixelOffsetMode value);
    }

    property PointL RenderingOrigin
    {
     PointL get();
     void set(PointL origin);
    }

    property IPlusPlus::Drawing::SmoothingMode SmoothingMode
    {
     IPlusPlus::Drawing::SmoothingMode get();
     void set(IPlusPlus::Drawing::SmoothingMode value);
    }
 
    property long long TextContrast
    {
     long long get();
     void set(long long value);
    }

    property IPlusPlus::Drawing::TextRenderingHint TextRenderingHint
    {
     IPlusPlus::Drawing::TextRenderingHint get();
     void set(IPlusPlus::Drawing::TextRenderingHint value);
    }

    property Transform Transform
    {
     Transform get();
     void set(Transform value);
    }

    property Rectangle VisibleClipBounds
    {
     Rectangle get();
    }


    //*** Methods ***

    void Clear(Color color);

    void DrawArc(double x,
                 double y,
                 double width,
                 double height,
                 double startAngle,
                 double sweepAngle);

    void DrawArc(Rectangle rect,
                 double startAngle,
                 double sweepAngle);

    void DrawArc(long long x,
                 long long y,
                 long long width,
                 long long height,
                 double startAngle,
                 double sweepAngle);

    void DrawArc(RectangleL rect,
                 double startAngle,
                 double sweepAngle);

    void DrawCachedBitmap(Handle cb,
                          long long x,
                          long long y);

    void DrawClosedCurve(Array<Point>^ points);

    void DrawClosedCurve(Array<Point>^ points,
                         double tension);

    void DrawClosedCurve(Array<PointL>^ points);

    void DrawClosedCurve(Array<PointL>^ points,
                         double tension);

    void DrawCurve(Array<Point>^ points);

    void DrawCurve(Array<Point>^ points,
                   double tension);

    void DrawCurve(Array<Point>^ points,
                   long long offset,
                   long long numberOfSegments,
                   double tension = 0.5f);

    void DrawCurve(Array<PointL>^ points);

    void DrawCurve(Array<PointL>^ points,
                   double tension);

    void DrawCurve(Array<PointL> points,
                   long long offset,
                   long long numberOfSegments,
                   double tension = 0.5f);

    void DrawEllipse(Rectangle rect);

    void DrawEllipse(double x,
                     double y,
                     double width,
                     double height);

    void DrawEllipse(RectangleL rect);

    void DrawEllipse(long long x,
                     long long y,
                     long long width,
                     long long height);

    void DrawImage(Image^ image,
                   Point point);

    void DrawImage(Image^ image,
                   double x,
                   double y);
    
    void DrawImage(Image^ image, 
                   Rectangle rect);

    void DrawImage(Image^ image,
                   double x,
                   double y,
                   double width,
                   double height);

    void DrawImage(Image^ image,
                   PointL point);

    void DrawImage(Image^ image,
                   long long x,
                   long long y);

    void DrawImage(Image^ image,
                   RectangleL rect);

    void DrawImage(Image^ image,
                   long long x,
                   long long y,
                   long long width,
                   long long height);
    
    void DrawImage(Image^ image,
                   Array<Point>^ destPoints);
    
    void DrawImage(Image^ image,
                   Array<PointL>^ destPoints);

    void DrawImage(Image^ image,
                   double x,
                   double y,
                   double srcx,
                   double srcy,
                   double srcwidth,
                   double srcheight,
                   Unit srcUnit);

    void DrawImage(Image^ image,
                   Rectangle destRect,
                   double srcx,
                   double srcy,
                   double srcwidth,
                   double srcheight,
                   Unit srcUnit,
                   ImageAttributes^ imageAttributes0;

    void DrawImage(Image^ image,
                   Array<Point> destPoints,
                   double srcx,
                   double srcy,
                   double srcwidth,
                   double srcheight,
                   Unit srcUnit,
                   ImageAttributes^ imageAttributes);

    void DrawImage(Image^ image,
                   long long x,
                   long long y,
                   long long srcx,
                   long long srcy,
                   long long srcwidth,
                   long long srcheight,
                   Unit srcUnit);

    void DrawImage(Image^ image,
                   RectangleL destRect,
                   long long srcx,
                   long long srcy,
                   long long srcwidth,
                   long long srcheight,
                   Unit srcUnit,
                   ImageAttributes^ imageAttributes);

    void DrawImage(Image^ image,
                   Array<PointL>^ destPoints,
                   long long srcx,
                   long long srcy,
                   long long srcwidth,
                   long long srcheight,
                   Unit srcUnit,
                   ImageAttributes^ imageAttributes);

    void DrawLine(double x1,
                  double y1,
                  double x2,
                  double y2);

    void DrawLine(Point pt1,
                  Point pt2);

    void DrawLines(Array<Point>^ points);

    void DrawLine(long long x1,
                  long long y1,
                  long long x2,
                  long long y2);

    void DrawLine(PointL pt1,
                  PointL pt2);

    void DrawLines(Array<PointL>^ points);

    void DrawPath(Path^ path);

    void DrawPie(Rectangle rect,
                 double startAngle,
                 double sweepAngle);

    void DrawPie(double x,
                 double y,
                 double width,
                 double height,
                 double startAngle,
                 double sweepAngle);

    void DrawPie(RectangleL rect,
                 double startAngle,
                 double sweepAngle);

    void DrawPie(long long x,
                 long long y,
                 long long width,
                 long long height,
                 double startAngle,
                 double sweepAngle);

    void DrawPolygon(Array<Point>^ points);

    void DrawPolygon(Array<PointL>^ points);

    void DrawRectangle(Rectangle rect);

    void DrawRectangle(double x,
                       double y,
                       double width,
                       double height);

    void DrawRectangles(Array<Rectangle>^ rects);

    void DrawRectangle(RectangleL rect);

    void DrawRectangle(long long x,
                       long long y,
                       long long width,
                       long long height);

    void DrawRectangles(Array<RectangleL>^ rects);

    void DrawSpline(double x1,
                    double y1,
                    double x2,
                    double y2,
                    double x3,
                    double y3,
                    double x4,
                    double y4);

    void DrawSpline(Point pt1,
                    Point pt2,
                    Point pt3,
                    Point pt4);

    void DrawSplines(Array<Point>^ points);

    void DrawSpline(long long x1,
                    long long y1,
                    long long x2,
                    long long y2,
                    long long x3,
                    long long y3,
                    long long x4,
                    long long y4);

    void DrawSpline(PointL pt1,
                    PointL pt2,
                    PointL pt3,
                    PointL pt4);

    void DrawSplines(Array<PointL>^ points);

    void DrawString(String^ string,
                    Point origin);

    void DrawString(String^ string,
                    Point origin,
                    StringFormat^ stringFormat);

    void DrawString(String^ string,
                    Rectangle layoutRect);

    void DrawString(String^ string,
                    Rectangle layoutRect,
                    StringFormat^ stringFormat);

    void DrawString(String^ string,
                    PointL origin);

    void DrawString(String^ string,
                    PointL origin,
                    StringFormat^ stringFormat);

    void DrawString(String^ string,
                    RectangleL layoutRect);

    void DrawString(String^ string,
                    RectangleL layoutRect,
                    StringFormat^ stringFormat);

    void ExcludeClip(Rectangle rect);

    void ExcludeClip(RectangleL rect);

    void ExcludeClip(Region^ region);

    void FillClosedCurve(Array<Point>^ points);

    void FillClosedCurve(Array<Point>^ points,
                         FillMode fillMode,
                         double tension);

    void FillClosedCurve(Array<PointL>^ points);

    void FillClosedCurve(Array<PointL>^ points,
                         FillMode fillMode,
                         double tension);

    void FillEllipse(Rectangle rect);

    void FillEllipse(double x,
                     double y,
                     double width,
                     double height);

    void FillEllipse(RectangleL rect);

    void FillEllipse(long long x,
                     long long y,
                     long long width,
                     long long height);
    
    void FillPath(Path^ path);

    void FillPie(Rectangle rect,
                 double startAngle,
                 double sweepAngle);

    void FillPie(double x,
                 double y,
                 double width,
                 double height,
                 double startAngle,
                 double sweepAngle);

    void FillPie(RectangleL rect,
                 double startAngle,
                 double sweepAngle);

    void FillPie(long long x,
                 long long y,
                 long long width,
                 long long height,
                 double startAngle,
                 double sweepAngle);

    void FillPolygon(Array<Point>^ points);

    void FillPolygon(Array<Point>^ points,
                     FillMode fillMode);

    void FillPolygon(Array<PointL>^ points);

    void FillPolygon(Array<PointL>^ points,
                     FillMode fillMode);

    void FillRectangle(Rectangle rect);

    void FillRectangle(double x,
                       double y,
                       double width,
                       double height);

    void FillRectangles(Array<Rectangle>^ rects);

    void FillRectangle(RectangleL rect);

    void FillRectangle(long long x,
                       long long y,
                       long long width,
                       long long height);

    void FillRectangles(Array<RectangleL>^ rects);

    void FillRegion(Region^ region);

    Region^ GetClip();

    Rectangle GetClipBounds();
    
    RectangleL GetClipBoundsInteger();

    Color GetNearestColor(Color color);

    Rectangle GetVisibleClipBounds();

    RectangleL GetVisibleClipBoundsInteger();

    void IntersectClip(Rectangle rect);

    void IntersectClip(RectangleL rect);

    void IntersectClip(Region^ region);

    void InvertRectangle(Rectangle rectangleToInvert);

    void InvertRegion(Region^ regionToInvert);

    bool IsVisible(long long x,
                   long long y);

    bool IsVisible(PointL point);

    bool IsVisible(long long x,
                   long long y,
                   long long width,
                   long long height);

    bool IsVisible(Rectangle rect);

    bool IsVisible(double x,
                   double y);

    bool IsVisible(Point point);

    bool IsVisible(double x,
                   double y,
                   double width,
                   double height);

    bool IsVisible(RectangleL rect);

    bool IsVisibleClipEmpty();

    Array<Region^>^ MeasureCharacterRanges(String^ string,
                                           Rectangle layoutRect,
                                           StringFormat^ stringFormat);

    Rectangle MeasureString(String^ string,
                            Rectangle layoutRect,
                            StringFormat^ stringFormat,
                            long long% codepointsFitted,
                            long long% linesFilled);

    Point MeasureString(String^ string,
                        Point layoutRectSize,
                        StringFormat^ stringFormat,
                        long long% codepointsFitted,
                        long long% linesFilled);

    Rectangle MeasureString(String^ string,
                            Point origin,
                            StringFormat^ stringFormat);

    Rectangle MeasureString(String^ string,
                            Rectangle layoutRect);

    Rectangle MeasureString(String^ string,
                            Point origin);

    void MultiplyTransform(Transform matrix,
                           unsigned order);

    void ResetClip();

    void ResetTransform();

    void RotateTransform(double angle,
                         unsigned order);

    void ScaleTransform(double sx,
                        double sy,
                        unsigned order);

    void SetRenderingOrigin(long long x, long long y);
    
    void SetClip(Graphics^ g,
                 unsigned combineMode);

    void SetClip(Rectangle rect,
                 unsigned combineMode);

    void SetClip(RectangleL rect,
                 unsigned combineMode);

    void SetClip(Path^ path,
                 unsigned combineMode);

    void SetClip(Region^ region,
                 unsigned combineMode);

    void SetTransform(Transform matrix);

    void TransformPoints(unsigned destSpace,
                         unsigned srcSpace,
                         Array<Point>^ pts);

    void TransformPoints(unsigned destSpace,
                         unsigned srcSpace,
                         Array<PointL>^ pts);

    void TranslateClip(double dx,
                       double dy);

    void TranslateClip(long long dx,
                       long long dy);

    void TranslateTransform(double dx,
                            double dy,
                            unsigned order);
};

Details

Name Space IPlusPlus::Drawing
Assembly IPlusPlus.Drawing.dll