mcs/class/System.Drawing/System.Drawing/Graphics.cs

   1 //
   2 // System.Drawing.Graphics.cs
   3 //
   4 // Authors:
   5 //      Gonzalo Paniagua Javier (gonzalo@ximian.com) (stubbed out)
   6 //      Alexandre Pigolkine(pigolkine@gmx.de)
   7 //      Jordi Mas i Hernandez (jordi@ximian.com)
   8 //
   9 // Copyright (C) 2003 Ximian, Inc. (http://www.ximian.com)
  10 //
  11 // Copyright (C) 2004 Novell, Inc. (http://www.novell.com)
  12 //
  13 // Permission is hereby granted, free of charge, to any person obtaining
  14 // a copy of this software and associated documentation files (the
  15 // "Software"), to deal in the Software without restriction, including
  16 // without limitation the rights to use, copy, modify, merge, publish,
  17 // distribute, sublicense, and/or sell copies of the Software, and to
  18 // permit persons to whom the Software is furnished to do so, subject to
  19 // the following conditions:
  20 //
  21 // The above copyright notice and this permission notice shall be
  22 // included in all copies or substantial portions of the Software.
  23 //
  24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31 //
  32 using System;
  33 using System.Drawing.Drawing2D;
  34 using System.Drawing.Imaging;
  35 using System.Drawing.Text;
  36 using System.ComponentModel;
  37 using System.Runtime.InteropServices;
  38 using System.Text;
  39
  40 namespace System.Drawing
  41 {
  42         [ComVisible(false)]
  43         public sealed class Graphics : MarshalByRefObject, IDisposable
  44         {
  45                 internal IntPtr nativeObject = IntPtr.Zero;
  46                 private bool disposed = false;
  47                 private static float defDpiX = 0;
  48                 private static float defDpiY = 0;
  49                 private static IntPtr display = IntPtr.Zero;
  50
  51                 // We use X Drawable on Linux.
  52                 private static bool use_x_drawable = (Environment.OSVersion.Platform == (PlatformID) 128);
  53
  54                 [ComVisible(false)]
  55                 public delegate bool EnumerateMetafileProc (EmfPlusRecordType recordType,
  56                                                             int flags,
  57                                                             int dataSize,
  58                                                             IntPtr data,
  59                                                             PlayRecordCallback callbackData);
  60
  61                 [ComVisible (false)]
  62                 public delegate bool DrawImageAbort (IntPtr callbackData);
  63
  64                 private Graphics (IntPtr nativeGraphics)
  65                 {
  66                         nativeObject = nativeGraphics;
  67                 }
  68
  69                 ~Graphics ()
  70                 {
  71                         Dispose ();
  72                 }
  73
  74                 static internal float systemDpiX {
  75                         get {
  76                                 if (defDpiX == 0) {
  77                                         Bitmap bmp = new Bitmap (1, 1);
  78                                         Graphics g = Graphics.FromImage (bmp);
  79                                         defDpiX = g.DpiX;
  80                                 }
  81                                 return defDpiX;
  82                         }
  83                 }
  84
  85                 static internal float systemDpiY {
  86                         get {
  87                                 if (defDpiY == 0) {
  88                                         Bitmap bmp = new Bitmap (1, 1);
  89                                         Graphics g = Graphics.FromImage (bmp);
  90                                         defDpiY = g.DpiY;
  91                                 }
  92                                 return defDpiY;
  93                         }
  94                 }
  95
  96                 internal IntPtr NativeObject {
  97                         get {
  98                                 return nativeObject;
  99                         }
 100
 101                         set {
 102                                 nativeObject = value;
 103                         }
 104                 }
 105
 106                 [MonoTODO]
 107                 public void AddMetafileComment (byte [] data)
 108                 {
 109                         throw new NotImplementedException ();
 110                 }
 111
 112
 113                 public GraphicsContainer BeginContainer ()
 114                 {
 115                         int state;
 116                         Status status;
 117                         status = GDIPlus.GdipBeginContainer2 (nativeObject, out state);
 118                         GDIPlus.CheckStatus (status);
 119
 120                         return new GraphicsContainer(state);
 121                 }
 122
 123                 public GraphicsContainer BeginContainer (Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit)
 124                 {
 125                         int state;
 126                         Status status;
 127                         status = GDIPlus.GdipBeginContainerI (nativeObject, dstrect, srcrect, unit, out state);
 128                         GDIPlus.CheckStatus (status);
 129
 130                         return new GraphicsContainer (state);
 131                 }
 132
 133
 134                 public GraphicsContainer BeginContainer (RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit)
 135                 {
 136                         int state;
 137                         Status status;
 138                         status = GDIPlus.GdipBeginContainer (nativeObject, dstrect, srcrect, unit, out state);
 139                         GDIPlus.CheckStatus (status);
 140
 141                         return new GraphicsContainer (state);
 142                 }
 143
 144
 145                 public void Clear (Color color)
 146                 {
 147                         Status status;
 148                         status = GDIPlus.GdipGraphicsClear (nativeObject, color.ToArgb ());
 149                         GDIPlus.CheckStatus (status);
 150                 }
 151
 152                 public void Dispose ()
 153                 {
 154                         Status status;
 155                         if (! disposed) {
 156                                 status = GDIPlus.GdipDeleteGraphics (nativeObject);
 157                                 nativeObject = IntPtr.Zero;
 158                                 GDIPlus.CheckStatus (status);
 159                                 disposed = true;
 160                         }
 161                 }
 162
 163
 164                 public void DrawArc (Pen pen, Rectangle rect, float startAngle, float sweepAngle)
 165                 {
 166                         DrawArc (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
 167                 }
 168
 169
 170                 public void DrawArc (Pen pen, RectangleF rect, float startAngle, float sweepAngle)
 171                 {
 172                         DrawArc (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
 173                 }
 174
 175
 176                 public void DrawArc (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
 177                 {
 178                         Status status;
 179                         status = GDIPlus.GdipDrawArc (nativeObject, pen.nativeObject,
 180                                         x, y, width, height, startAngle, sweepAngle);
 181                         GDIPlus.CheckStatus (status);
 182                 }
 183
 184                 // Microsoft documentation states that the signature for this member should be
 185                 // public void DrawArc( Pen pen,  int x,  int y,  int width,  int height,   int startAngle,
 186                 // int sweepAngle. However, GdipDrawArcI uses also float for the startAngle and sweepAngle params
 187                 public void DrawArc (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle)
 188                 {
 189                         Status status;
 190                         status = GDIPlus.GdipDrawArcI (nativeObject, pen.nativeObject,
 191                                                 x, y, width, height, startAngle, sweepAngle);
 192                         GDIPlus.CheckStatus (status);
 193                 }
 194
 195                 public void DrawBezier (Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4)
 196                 {
 197                         Status status;
 198                         status = GDIPlus.GdipDrawBezier (nativeObject, pen.nativeObject,
 199                                                         pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X,
 200                                                         pt3.Y, pt4.X, pt4.Y);
 201                         GDIPlus.CheckStatus (status);
 202                 }
 203
 204                 public void DrawBezier (Pen pen, Point pt1, Point pt2, Point pt3, Point pt4)
 205                 {
 206                         Status status;
 207                         status = GDIPlus.GdipDrawBezierI (nativeObject, pen.nativeObject,
 208                                                         pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X,
 209                                                         pt3.Y, pt4.X, pt4.Y);
 210                         GDIPlus.CheckStatus (status);
 211                 }
 212
 213                 public void DrawBezier (Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
 214                 {
 215                         Status status;
 216                         status = GDIPlus.GdipDrawBezier (nativeObject, pen.nativeObject, x1,
 217                                                         y1, x2, y2, x3, y3, x4, y4);
 218                         GDIPlus.CheckStatus (status);
 219                 }
 220
 221                 public void DrawBeziers (Pen pen, Point [] points)
 222                 {
 223                         int length = points.Length;
 224                         Status status;
 225
 226                         if (length < 3)
 227                                 return;
 228
 229                         for (int i = 0; i < length; i += 3) {
 230                                 Point p1 = points [i];
 231                                 Point p2 = points [i + 1];
 232                                 Point p3 = points [i + 2];
 233                                 Point p4 = points [i + 3];
 234
 235                                 status = GDIPlus.GdipDrawBezier (nativeObject,
 236                                                         pen.nativeObject,
 237                                                         p1.X, p1.Y, p2.X, p2.Y,
 238                                                         p3.X, p3.Y, p4.X, p4.Y);
 239                                 GDIPlus.CheckStatus (status);
 240                         }
 241                 }
 242
 243                 public void DrawBeziers (Pen pen, PointF [] points)
 244                 {
 245                         int length = points.Length;
 246                         Status status;
 247
 248                         if (length < 3)
 249                                 return;
 250
 251                         for (int i = 0; i < length; i += 3) {
 252                                 PointF p1 = points [i];
 253                                 PointF p2 = points [i + 1];
 254                                 PointF p3 = points [i + 2];
 255                                 PointF p4 = points [i + 3];
 256
 257                                 status = GDIPlus.GdipDrawBezier (nativeObject,
 258                                                         pen.nativeObject,
 259                                                         p1.X, p1.Y, p2.X, p2.Y,
 260                                                         p3.X, p3.Y, p4.X, p4.Y);
 261                                 GDIPlus.CheckStatus (status);
 262                         }
 263                 }
 264
 265
 266                 public void DrawClosedCurve (Pen pen, PointF [] points)
 267                 {
 268                         Status status;
 269                         status = GDIPlus.GdipDrawClosedCurve (nativeObject, pen.nativeObject, points, points.Length);
 270                         GDIPlus.CheckStatus (status);
 271                 }
 272
 273                 public void DrawClosedCurve (Pen pen, Point [] points)
 274                 {
 275                         Status status;
 276                         status = GDIPlus.GdipDrawClosedCurveI (nativeObject, pen.nativeObject, points, points.Length);
 277                         GDIPlus.CheckStatus (status);
 278                 }
 279
 280                 public void DrawClosedCurve (Pen pen, Point [] points, float tension, FillMode fillmode)
 281                 {
 282                         Status status;
 283                         status = GDIPlus.GdipDrawClosedCurve2I (nativeObject, pen.nativeObject, points, points.Length, tension);
 284                         GDIPlus.CheckStatus (status);
 285                 }
 286
 287                 public void DrawClosedCurve (Pen pen, PointF [] points, float tension, FillMode fillmode)
 288                 {
 289                         Status status;
 290                         status = GDIPlus.GdipDrawClosedCurve2 (nativeObject, pen.nativeObject, points, points.Length, tension);
 291                         GDIPlus.CheckStatus (status);
 292                 }
 293
 294                 public void DrawCurve (Pen pen, Point [] points)
 295                 {
 296                         Status status;
 297                         status = GDIPlus.GdipDrawCurveI (nativeObject, pen.nativeObject, points, points.Length);
 298                         GDIPlus.CheckStatus (status);
 299                 }
 300
 301                 public void DrawCurve (Pen pen, PointF [] points)
 302                 {
 303                         Status status;
 304                         status = GDIPlus.GdipDrawCurve (nativeObject, pen.nativeObject, points, points.Length);
 305                         GDIPlus.CheckStatus (status);
 306                 }
 307
 308                 public void DrawCurve (Pen pen, PointF [] points, float tension)
 309                 {
 310                         Status status;
 311                         status = GDIPlus.GdipDrawCurve2 (nativeObject, pen.nativeObject, points, points.Length, tension);
 312                         GDIPlus.CheckStatus (status);
 313                 }
 314
 315                 public void DrawCurve (Pen pen, Point [] points, float tension)
 316                 {
 317                         Status status;
 318                         status = GDIPlus.GdipDrawCurve2I (nativeObject, pen.nativeObject, points, points.Length, tension);
 319                         GDIPlus.CheckStatus (status);
 320                 }
 321
 322
 323                 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments)
 324                 {
 325                         Status status;
 326                         status = GDIPlus.GdipDrawCurve3 (nativeObject, pen.nativeObject,
 327                                                         points, points.Length, offset,
 328                                                         numberOfSegments, 0.5f);
 329                         GDIPlus.CheckStatus (status);
 330                 }
 331
 332                 public void DrawCurve (Pen pen, Point [] points, int offset, int numberOfSegments, float tension)
 333                 {
 334                         Status status;
 335                         status = GDIPlus.GdipDrawCurve3I (nativeObject, pen.nativeObject,
 336                                                         points, points.Length, offset,
 337                                                         numberOfSegments, tension);
 338                         GDIPlus.CheckStatus (status);
 339                 }
 340
 341
 342                 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments, float tension)
 343                 {
 344                         Status status;
 345                         status = GDIPlus.GdipDrawCurve3 (nativeObject, pen.nativeObject,
 346                                                         points, points.Length, offset,
 347                                                         numberOfSegments, tension);
 348                         GDIPlus.CheckStatus (status);
 349                 }
 350
 351                 public void DrawEllipse (Pen pen, Rectangle rect)
 352                 {
 353                         DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);
 354                 }
 355
 356                 public void DrawEllipse (Pen pen, RectangleF rect)
 357                 {
 358                         DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);
 359                 }
 360
 361                 public void DrawEllipse (Pen pen, int x, int y, int width, int height)
 362                 {
 363                         Status status;
 364                         status = GDIPlus.GdipDrawEllipseI (nativeObject, pen.nativeObject, x, y, width, height);
 365                         GDIPlus.CheckStatus (status);
 366                 }
 367
 368                 public void DrawEllipse (Pen pen, float x, float y, float width, float height)
 369                 {
 370                         Status status = GDIPlus.GdipDrawEllipse (nativeObject, pen.nativeObject, x, y, width, height);
 371                         GDIPlus.CheckStatus (status);
 372                 }
 373
 374                 public void DrawIcon (Icon icon, Rectangle targetRect)
 375                 {
 376                         Image img = icon.ToBitmap ();
 377                         DrawImage (img, targetRect);
 378                 }
 379
 380                 public void DrawIcon (Icon icon, int x, int y)
 381                 {
 382                         Image img = icon.ToBitmap ();
 383                         DrawImage (img, x, y);
 384                 }
 385
 386                 public void DrawIconUnstretched (Icon icon, Rectangle targetRect)
 387                 {
 388                         Image img = icon.ToBitmap ();
 389                         DrawImageUnscaled (img, targetRect);
 390                 }
 391
 392                 public void DrawImage (Image image, RectangleF rect)
 393                 {
 394                         Status status = GDIPlus.GdipDrawImageRect(nativeObject, image.NativeObject, rect.X, rect.Y, rect.Width, rect.Height);
 395                         GDIPlus.CheckStatus (status);
 396                 }
 397
 398
 399                 public void DrawImage (Image image, PointF point)
 400                 {
 401                         Status status = GDIPlus.GdipDrawImage (nativeObject, image.NativeObject, point.X, point.Y);
 402                         GDIPlus.CheckStatus (status);
 403                 }
 404
 405
 406                 public void DrawImage (Image image, Point [] destPoints)
 407                 {
 408                         Status status = GDIPlus.GdipDrawImagePointsI (nativeObject, image.NativeObject, destPoints, destPoints.Length);
 409                         GDIPlus.CheckStatus (status);
 410                 }
 411
 412
 413                 public void DrawImage (Image image, Point point)
 414                 {
 415                         DrawImage (image, point.X, point.Y);
 416                 }
 417
 418
 419                 public void DrawImage (Image image, Rectangle rect)
 420                 {
 421                         DrawImage (image, rect.X, rect.Y, rect.Width, rect.Height);
 422                 }
 423
 424
 425                 public void DrawImage (Image image, PointF [] destPoints)
 426                 {
 427                         Status status = GDIPlus.GdipDrawImagePoints (nativeObject, image.NativeObject, destPoints, destPoints.Length);
 428                         GDIPlus.CheckStatus (status);
 429                 }
 430
 431
 432                 public void DrawImage (Image image, int x, int y)
 433                 {
 434                         Status status = GDIPlus.GdipDrawImageI (nativeObject, image.NativeObject, x, y);
 435                         GDIPlus.CheckStatus (status);
 436                 }
 437
 438
 439                 public void DrawImage (Image image, float x, float y)
 440                 {
 441                         Status status = GDIPlus.GdipDrawImage (nativeObject, image.NativeObject, x, y);
 442                         GDIPlus.CheckStatus (status);
 443                 }
 444
 445
 446                 public void DrawImage (Image image, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit)
 447                 {
 448                         Status status = GDIPlus.GdipDrawImageRectRectI (nativeObject, image.NativeObject,
 449                                 destRect.X, destRect.Y, destRect.Width, destRect.Height,
 450                                 srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height,
 451                                 srcUnit, IntPtr.Zero, null, IntPtr.Zero);
 452                         GDIPlus.CheckStatus (status);
 453                 }
 454
 455                 public void DrawImage (Image image, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit)
 456                 {
 457                         Status status = GDIPlus.GdipDrawImageRectRect (nativeObject, image.NativeObject,
 458                                 destRect.X, destRect.Y, destRect.Width, destRect.Height,
 459                                 srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height,
 460                                 srcUnit, IntPtr.Zero, null, IntPtr.Zero);
 461                         GDIPlus.CheckStatus (status);
 462                 }
 463
 464
 465                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit)
 466                 {
 467                         Status status = GDIPlus.GdipDrawImagePointsRectI (nativeObject, image.NativeObject,
 468                                 destPoints, destPoints.Length , srcRect.X, srcRect.Y,
 469                                 srcRect.Width, srcRect.Height, srcUnit, IntPtr.Zero,
 470                                 null, IntPtr.Zero);
 471                         GDIPlus.CheckStatus (status);
 472                 }
 473
 474
 475                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit)
 476                 {
 477
 478                         Status status = GDIPlus.GdipDrawImagePointsRect (nativeObject, image.NativeObject,
 479                                 destPoints, destPoints.Length , srcRect.X, srcRect.Y,
 480                                 srcRect.Width, srcRect.Height, srcUnit, IntPtr.Zero,
 481                                 null, IntPtr.Zero);
 482                         GDIPlus.CheckStatus (status);
 483                 }
 484
 485
 486                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit,
 487                                 ImageAttributes imageAttr)
 488                 {
 489                         Status status = GDIPlus.GdipDrawImagePointsRectI (nativeObject, image.NativeObject,
 490                                 destPoints, destPoints.Length , srcRect.X, srcRect.Y,
 491                                 srcRect.Width, srcRect.Height, srcUnit,
 492                                 imageAttr.NativeObject, null, IntPtr.Zero);
 493                         GDIPlus.CheckStatus (status);
 494                 }
 495
 496                 public void DrawImage (Image image, float x, float y, float width, float height)
 497                 {
 498                         Status status = GDIPlus.GdipDrawImageRect(nativeObject, image.NativeObject, x, y,
 499                            width, height);
 500                         GDIPlus.CheckStatus (status);
 501                 }
 502
 503
 504                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit,
 505                                 ImageAttributes imageAttr)
 506                 {
 507                         Status status = GDIPlus.GdipDrawImagePointsRect (nativeObject, image.NativeObject,
 508                                 destPoints, destPoints.Length , srcRect.X, srcRect.Y,
 509                                 srcRect.Width, srcRect.Height, srcUnit,
 510                                 imageAttr.NativeObject, null, IntPtr.Zero);
 511                         GDIPlus.CheckStatus (status);
 512                 }
 513
 514
 515                 public void DrawImage (Image image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit)
 516                 {
 517                         Status status = GDIPlus.GdipDrawImagePointRectI(nativeObject, image.NativeObject, x, y, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit);
 518                         GDIPlus.CheckStatus (status);
 519                 }
 520
 521                 public void DrawImage (Image image, int x, int y, int width, int height)
 522                 {
 523                         Status status = GDIPlus.GdipDrawImageRectI (nativeObject, image.nativeObject, x, y, width, height);
 524                         GDIPlus.CheckStatus (status);
 525                 }
 526
 527                 public void DrawImage (Image image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit)
 528                 {
 529                         Status status = GDIPlus.GdipDrawImagePointRect (nativeObject, image.nativeObject, x, y, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, srcUnit);
 530                         GDIPlus.CheckStatus (status);
 531                 }
 532
 533
 534                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
 535                 {
 536                         Status status = GDIPlus.GdipDrawImagePointsRect (nativeObject, image.NativeObject,
 537                                 destPoints, destPoints.Length , srcRect.X, srcRect.Y,
 538                                 srcRect.Width, srcRect.Height, srcUnit,
 539                                 imageAttr.NativeObject, callback, IntPtr.Zero);
 540                         GDIPlus.CheckStatus (status);
 541                 }
 542
 543
 544                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
 545                 {
 546
 547                         Status status = GDIPlus.GdipDrawImagePointsRectI (nativeObject, image.NativeObject,
 548                                 destPoints, destPoints.Length , srcRect.X, srcRect.Y,
 549                                 srcRect.Width, srcRect.Height, srcUnit,
 550                                 imageAttr.NativeObject, callback, IntPtr.Zero);
 551                         GDIPlus.CheckStatus (status);
 552                 }
 553
 554
 555                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)
 556                 {
 557
 558                         Status status = GDIPlus.GdipDrawImagePointsRectI (nativeObject, image.NativeObject,
 559                                 destPoints, destPoints.Length , srcRect.X, srcRect.Y,
 560                                 srcRect.Width, srcRect.Height, srcUnit,
 561                                 imageAttr.NativeObject, callback, (IntPtr) callbackData);
 562                         GDIPlus.CheckStatus (status);
 563                 }
 564
 565
 566                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit)
 567                 {
 568                         Status status = GDIPlus.GdipDrawImageRectRect (nativeObject, image.NativeObject,
 569                                 destRect.X, destRect.Y, destRect.Width, destRect.Height,
 570                                 srcX, srcY, srcWidth, srcHeight, srcUnit, IntPtr.Zero,
 571                                 null, IntPtr.Zero);
 572                         GDIPlus.CheckStatus (status);
 573                 }
 574
 575                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)
 576                 {
 577                         Status status = GDIPlus.GdipDrawImagePointsRect (nativeObject, image.NativeObject,
 578                                 destPoints, destPoints.Length , srcRect.X, srcRect.Y,
 579                                 srcRect.Width, srcRect.Height, srcUnit,
 580                                 imageAttr.NativeObject, callback, (IntPtr) callbackData);
 581                         GDIPlus.CheckStatus (status);
 582                 }
 583
 584
 585                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit)
 586                 {
 587                         Status status = GDIPlus.GdipDrawImageRectRectI (nativeObject, image.NativeObject,
 588                                 destRect.X, destRect.Y, destRect.Width, destRect.Height,
 589                                 srcX, srcY, srcWidth, srcHeight, srcUnit, IntPtr.Zero,
 590                                 null, IntPtr.Zero);
 591                         GDIPlus.CheckStatus (status);
 592                 }
 593
 594
 595                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs)
 596                 {
 597                         Status status = GDIPlus.GdipDrawImageRectRect (nativeObject, image.NativeObject,
 598                                 destRect.X, destRect.Y, destRect.Width, destRect.Height,
 599                                 srcX, srcY, srcWidth, srcHeight, srcUnit,
 600                                 imageAttrs.NativeObject, null, IntPtr.Zero);
 601                         GDIPlus.CheckStatus (status);
 602                 }
 603
 604                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr)
 605                 {
 606                         Status status = GDIPlus.GdipDrawImageRectRectI (nativeObject, image.NativeObject,
 607                                         destRect.X, destRect.Y, destRect.Width,
 608                                         destRect.Height, srcX, srcY, srcWidth, srcHeight,
 609                                         srcUnit, imageAttr.NativeObject, null, IntPtr.Zero);
 610                         GDIPlus.CheckStatus (status);
 611                 }
 612
 613                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
 614                 {
 615                         Status status = GDIPlus.GdipDrawImageRectRectI (nativeObject, image.NativeObject,
 616                                         destRect.X, destRect.Y, destRect.Width,
 617                                         destRect.Height, srcX, srcY, srcWidth, srcHeight,
 618                                         srcUnit, imageAttr.NativeObject, callback,
 619                                         IntPtr.Zero);
 620                         GDIPlus.CheckStatus (status);
 621                 }
 622
 623                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
 624                 {
 625                         Status status = GDIPlus.GdipDrawImageRectRect (nativeObject, image.NativeObject,
 626                                         destRect.X, destRect.Y, destRect.Width,
 627                                         destRect.Height, srcX, srcY, srcWidth, srcHeight,
 628                                         srcUnit, imageAttr.NativeObject,
 629                                         callback, IntPtr.Zero);
 630                         GDIPlus.CheckStatus (status);
 631                 }
 632
 633
 634                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)
 635                 {
 636                         Status status = GDIPlus.GdipDrawImageRectRect (nativeObject, image.NativeObject,
 637                                 destRect.X, destRect.Y, destRect.Width, destRect.Height,
 638                                 srcX, srcY, srcWidth, srcHeight, srcUnit,
 639                                 imageAttr.NativeObject, callback, callbackData);
 640                         GDIPlus.CheckStatus (status);
 641                 }
 642
 643
 644                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)
 645                 {
 646                         Status status = GDIPlus.GdipDrawImageRectRect (nativeObject, image.NativeObject,
 647                                 destRect.X, destRect.Y, destRect.Width, destRect.Height,
 648                                 srcX, srcY, srcWidth, srcHeight, srcUnit,
 649                                 imageAttr.NativeObject, callback, callbackData);
 650                         GDIPlus.CheckStatus (status);
 651                 }
 652
 653                 public void DrawImageUnscaled (Image image, Point point)
 654                 {
 655                         DrawImageUnscaled (image, point.X, point.Y);
 656                 }
 657
 658                 public void DrawImageUnscaled (Image image, Rectangle rect)
 659                 {
 660                         DrawImageUnscaled (image, rect.X, rect.Y, rect.Width, rect.Height);
 661                 }
 662
 663                 public void DrawImageUnscaled (Image image, int x, int y)
 664                 {
 665                         DrawImage (image, x, y, image.Width, image.Height);
 666                 }
 667
 668                 public void DrawImageUnscaled (Image image, int x, int y, int width, int height)
 669                 {
 670                         Image tmpImg = new Bitmap (width, height);
 671                         Graphics g = FromImage (tmpImg);
 672                         g.DrawImage (image, 0, 0, image.Width, image.Height);
 673                         this.DrawImage (tmpImg, x, y, width, height);
 674                         tmpImg.Dispose ();
 675                         g.Dispose ();
 676                 }
 677
 678                 public void DrawLine (Pen pen, PointF pt1, PointF pt2)
 679                 {
 680                         Status status = GDIPlus.GdipDrawLine (nativeObject, pen.nativeObject,
 681                                                 pt1.X, pt1.Y, pt2.X, pt2.Y);
 682                         GDIPlus.CheckStatus (status);
 683                 }
 684
 685                 public void DrawLine (Pen pen, Point pt1, Point pt2)
 686                 {
 687                         Status status = GDIPlus.GdipDrawLineI (nativeObject, pen.nativeObject,
 688                                                 pt1.X, pt1.Y, pt2.X, pt2.Y);
 689                         GDIPlus.CheckStatus (status);
 690                 }
 691
 692                 public void DrawLine (Pen pen, int x1, int y1, int x2, int y2)
 693                 {
 694                         Status status = GDIPlus.GdipDrawLineI (nativeObject, pen.nativeObject, x1, y1, x2, y2);
 695                         GDIPlus.CheckStatus (status);
 696                 }
 697
 698                 public void DrawLine (Pen pen, float x1, float y1, float x2, float y2)
 699                 {
 700                         Status status = GDIPlus.GdipDrawLine (nativeObject, pen.nativeObject, x1, y1, x2, y2);
 701                         GDIPlus.CheckStatus (status);
 702                 }
 703
 704                 public void DrawLines (Pen pen, PointF [] points)
 705                 {
 706                         Status status = GDIPlus.GdipDrawLines (nativeObject, pen.nativeObject, points, points.Length);
 707                         GDIPlus.CheckStatus (status);
 708                 }
 709
 710                 public void DrawLines (Pen pen, Point [] points)
 711                 {
 712                         Status status = GDIPlus.GdipDrawLinesI (nativeObject, pen.nativeObject, points, points.Length);
 713                         GDIPlus.CheckStatus (status);
 714                 }
 715
 716                 public void DrawPath (Pen pen, GraphicsPath path)
 717                 {
 718                         Status status = GDIPlus.GdipDrawPath (nativeObject, pen.nativeObject, path.nativePath);
 719                         GDIPlus.CheckStatus (status);
 720                 }
 721
 722                 public void DrawPie (Pen pen, Rectangle rect, float startAngle, float sweepAngle)
 723                 {
 724                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
 725                 }
 726
 727                 public void DrawPie (Pen pen, RectangleF rect, float startAngle, float sweepAngle)
 728                 {
 729                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
 730                 }
 731
 732                 public void DrawPie (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
 733                 {
 734                         Status status = GDIPlus.GdipDrawPie (nativeObject, pen.nativeObject, x, y, width, height, startAngle, sweepAngle);
 735                         GDIPlus.CheckStatus (status);
 736                 }
 737
 738                 // Microsoft documentation states that the signature for this member should be
 739                 // public void DrawPie(Pen pen, int x,  int y,  int width,   int height,   int startAngle
 740                 // int sweepAngle. However, GdipDrawPieI uses also float for the startAngle and sweepAngle params
 741                 public void DrawPie (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle)
 742                 {
 743                         Status status = GDIPlus.GdipDrawPieI (nativeObject, pen.nativeObject, x, y, width, height, startAngle, sweepAngle);
 744                         GDIPlus.CheckStatus (status);
 745                 }
 746
 747                 public void DrawPolygon (Pen pen, Point [] points)
 748                 {
 749                         Status status = GDIPlus.GdipDrawPolygonI (nativeObject, pen.nativeObject, points, points.Length);
 750                         GDIPlus.CheckStatus (status);
 751                 }
 752
 753                 public void DrawPolygon (Pen pen, PointF [] points)
 754                 {
 755                         Status status = GDIPlus.GdipDrawPolygon (nativeObject, pen.nativeObject, points, points.Length);
 756                         GDIPlus.CheckStatus (status);
 757                 }
 758
 759                 internal void DrawRectangle (Pen pen, RectangleF rect)
 760                 {
 761                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);
 762                 }
 763
 764                 public void DrawRectangle (Pen pen, Rectangle rect)
 765                 {
 766                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);
 767                 }
 768
 769                 public void DrawRectangle (Pen pen, float x, float y, float width, float height)
 770                 {
 771                         Status status = GDIPlus.GdipDrawRectangle (nativeObject, pen.nativeObject, x, y, width, height);
 772                         GDIPlus.CheckStatus (status);
 773                 }
 774
 775                 public void DrawRectangle (Pen pen, int x, int y, int width, int height)
 776                 {
 777                         Status status = GDIPlus.GdipDrawRectangleI (nativeObject, pen.nativeObject, x, y, width, height);
 778                         GDIPlus.CheckStatus (status);
 779                 }
 780
 781                 public void DrawRectangles (Pen pen, RectangleF [] rects)
 782                 {
 783                         Status status = GDIPlus.GdipDrawRectangles (nativeObject, pen.nativeObject, rects, rects.Length);
 784                         GDIPlus.CheckStatus (status);
 785                 }
 786
 787                 public void DrawRectangles (Pen pen, Rectangle [] rects)
 788                 {
 789                         Status status = GDIPlus.GdipDrawRectanglesI (nativeObject, pen.nativeObject, rects, rects.Length);
 790                         GDIPlus.CheckStatus (status);
 791                 }
 792
 793                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle)
 794                 {
 795                         Status status = GDIPlus.GdipDrawString (nativeObject, s, s.Length, font.NativeObject, ref layoutRectangle, IntPtr.Zero, brush.nativeObject);
 796                         GDIPlus.CheckStatus (status);
 797                 }
 798
 799                 public void DrawString (string s, Font font, Brush brush, PointF point)
 800                 {
 801                         RectangleF rc = new RectangleF (point.X, point.Y, 0, 0);
 802                         Status status = GDIPlus.GdipDrawString (nativeObject, s, s.Length, font.NativeObject, ref rc, IntPtr.Zero, brush.nativeObject);
 803                         GDIPlus.CheckStatus (status);
 804                 }
 805
 806                 public void DrawString (string s, Font font, Brush brush, PointF point, StringFormat format)
 807                 {
 808                         RectangleF rc = new RectangleF (point.X, point.Y, 0, 0);
 809                         Status status = GDIPlus.GdipDrawString (nativeObject, s, s.Length, font.NativeObject, ref rc, format.NativeObject, brush.nativeObject);
 810                         GDIPlus.CheckStatus (status);
 811                 }
 812
 813                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format)
 814                 {
 815                         Status status = GDIPlus.GdipDrawString (nativeObject, s, s.Length, font.NativeObject, ref layoutRectangle, format.NativeObject, brush.nativeObject);
 816                         GDIPlus.CheckStatus (status);
 817                 }
 818
 819                 public void DrawString (string s, Font font, Brush brush, float x, float y)
 820                 {
 821                         RectangleF rc = new RectangleF (x, y, 0, 0);
 822
 823                         Status status = GDIPlus.GdipDrawString (nativeObject, s, s.Length, font.NativeObject,
 824                                 ref rc, IntPtr.Zero, brush.nativeObject);
 825                         GDIPlus.CheckStatus (status);
 826                 }
 827
 828                 public void DrawString (string s, Font font, Brush brush, float x, float y, StringFormat format)
 829                 {
 830                         RectangleF rc = new RectangleF (x, y, 0, 0);
 831
 832                         Status status = GDIPlus.GdipDrawString (nativeObject, s, s.Length, font.NativeObject,
 833                                 ref rc, format.NativeObject, brush.nativeObject);
 834                         GDIPlus.CheckStatus (status);
 835                 }
 836
 837
 838                 public void EndContainer (GraphicsContainer container)
 839                 {
 840                         Status status = GDIPlus.GdipEndContainer(nativeObject, container.NativeObject);
 841                         GDIPlus.CheckStatus (status);
 842                 }
 843
 844                 [MonoTODO]
 845                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback)
 846                 {
 847                         throw new NotImplementedException ();
 848                 }
 849
 850                 [MonoTODO]
 851                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback)
 852                 {
 853                         throw new NotImplementedException ();
 854                 }
 855
 856                 [MonoTODO]
 857                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback)
 858                 {
 859                         throw new NotImplementedException ();
 860                 }
 861
 862                 [MonoTODO]
 863                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback)
 864                 {
 865                         throw new NotImplementedException ();
 866                 }
 867
 868                 [MonoTODO]
 869                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback)
 870                 {
 871                         throw new NotImplementedException ();
 872                 }
 873
 874                 [MonoTODO]
 875                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback)
 876                 {
 877                         throw new NotImplementedException ();
 878                 }
 879
 880                 [MonoTODO]
 881                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData)
 882                 {
 883                         throw new NotImplementedException ();
 884                 }
 885
 886                 [MonoTODO]
 887                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData)
 888                 {
 889                         throw new NotImplementedException ();
 890                 }
 891
 892                 [MonoTODO]
 893                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)
 894                 {
 895                         throw new NotImplementedException ();
 896                 }
 897
 898                 [MonoTODO]
 899                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData)
 900                 {
 901                         throw new NotImplementedException ();
 902                 }
 903
 904                 [MonoTODO]
 905                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)
 906                 {
 907                         throw new NotImplementedException ();
 908                 }
 909
 910                 [MonoTODO]
 911                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData)
 912                 {
 913                         throw new NotImplementedException ();
 914                 }
 915
 916                 [MonoTODO]
 917                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 918                 {
 919                         throw new NotImplementedException ();
 920                 }
 921
 922                 [MonoTODO]
 923                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 924                 {
 925                         throw new NotImplementedException ();
 926                 }
 927
 928                 [MonoTODO]
 929                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 930                 {
 931                         throw new NotImplementedException ();
 932                 }
 933
 934                 [MonoTODO]
 935                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 936                 {
 937                         throw new NotImplementedException ();
 938                 }
 939
 940                 [MonoTODO]
 941                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 942                 {
 943                         throw new NotImplementedException ();
 944                 }
 945
 946                 [MonoTODO]
 947                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 948                 {
 949                         throw new NotImplementedException ();
 950                 }
 951
 952                 [MonoTODO]
 953                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 954                 {
 955                         throw new NotImplementedException ();
 956                 }
 957
 958                 [MonoTODO]
 959                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 960                 {
 961                         throw new NotImplementedException ();
 962                 }
 963
 964                 [MonoTODO]
 965                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 966                 {
 967                         throw new NotImplementedException ();
 968                 }
 969
 970                 [MonoTODO]
 971                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 972                 {
 973                         throw new NotImplementedException ();
 974                 }
 975
 976                 [MonoTODO]
 977                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 978                 {
 979                         throw new NotImplementedException ();
 980                 }
 981
 982                 [MonoTODO]
 983                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 984                 {
 985                         throw new NotImplementedException ();
 986                 }
 987
 988                 [MonoTODO]
 989                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
 990                 {
 991                         throw new NotImplementedException ();
 992                 }
 993
 994                 [MonoTODO]
 995                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
 996                 {
 997                         throw new NotImplementedException ();
 998                 }
 999
1000                 [MonoTODO]
1001                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
1002                 {
1003                         throw new NotImplementedException ();
1004                 }
1005
1006                 [MonoTODO]
1007                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
1008                 {
1009                         throw new NotImplementedException ();
1010                 }
1011
1012                 [MonoTODO]
1013                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
1014                 {
1015                         throw new NotImplementedException ();
1016                 }
1017
1018                 [MonoTODO]
1019                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
1020                 {
1021                         throw new NotImplementedException ();
1022                 }
1023
1024                 [MonoTODO]
1025                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
1026                 {
1027                         throw new NotImplementedException ();
1028                 }
1029
1030                 [MonoTODO]
1031                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
1032                 {
1033                         throw new NotImplementedException ();
1034                 }
1035
1036                 [MonoTODO]
1037                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
1038                 {
1039                         throw new NotImplementedException ();
1040                 }
1041
1042                 [MonoTODO]
1043                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
1044                 {
1045                         throw new NotImplementedException ();
1046                 }
1047
1048                 [MonoTODO]
1049                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
1050                 {
1051                         throw new NotImplementedException ();
1052                 }
1053
1054                 [MonoTODO]
1055                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
1056                 {
1057                         throw new NotImplementedException ();
1058                 }
1059
1060                 public void ExcludeClip (Rectangle rect)
1061                 {
1062                         Status status = GDIPlus.GdipSetClipRectI (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, CombineMode.Exclude);
1063                         GDIPlus.CheckStatus (status);
1064                 }
1065
1066                 public void ExcludeClip (Region region)
1067                 {
1068                         Status status = GDIPlus.GdipSetClipRegion (nativeObject, region.NativeObject, CombineMode.Exclude);
1069                         GDIPlus.CheckStatus (status);
1070                 }
1071
1072
1073                 public void FillClosedCurve (Brush brush, PointF [] points)
1074                 {
1075                        Status status = GDIPlus.GdipFillClosedCurve (nativeObject, brush.NativeObject, points, points.Length);
1076                         GDIPlus.CheckStatus (status);
1077                 }
1078
1079
1080                 public void FillClosedCurve (Brush brush, Point [] points)
1081                 {
1082                         Status status = GDIPlus.GdipFillClosedCurveI (nativeObject, brush.NativeObject, points, points.Length);
1083                         GDIPlus.CheckStatus (status);
1084                 }
1085
1086
1087                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode)
1088                 {
1089                         FillClosedCurve (brush, points, fillmode, 0.5f);
1090                 }
1091
1092                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode)
1093                 {
1094                         FillClosedCurve (brush, points, fillmode, 0.5f);
1095                 }
1096
1097                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode, float tension)
1098                 {
1099                         Status status = GDIPlus.GdipFillClosedCurve2 (nativeObject, brush.NativeObject, points, points.Length, tension, fillmode);
1100                         GDIPlus.CheckStatus (status);
1101                 }
1102
1103                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode, float tension)
1104                 {
1105                         Status status = GDIPlus.GdipFillClosedCurve2I (nativeObject, brush.NativeObject, points, points.Length, tension, fillmode);
1106                         GDIPlus.CheckStatus (status);
1107                 }
1108
1109                 public void FillEllipse (Brush brush, Rectangle rect)
1110                 {
1111                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);
1112                 }
1113
1114                 public void FillEllipse (Brush brush, RectangleF rect)
1115                 {
1116                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);
1117                 }
1118
1119                 public void FillEllipse (Brush brush, float x, float y, float width, float height)
1120                 {
1121                         Status status = GDIPlus.GdipFillEllipse (nativeObject, brush.nativeObject, x, y, width, height);
1122                         GDIPlus.CheckStatus (status);
1123                 }
1124
1125                 public void FillEllipse (Brush brush, int x, int y, int width, int height)
1126                 {
1127                         Status status = GDIPlus.GdipFillEllipseI (nativeObject, brush.nativeObject, x, y, width, height);
1128                         GDIPlus.CheckStatus (status);
1129                 }
1130
1131                 public void FillPath (Brush brush, GraphicsPath path)
1132                 {
1133                         Status status = GDIPlus.GdipFillPath (nativeObject, brush.NativeObject,  path.NativeObject);
1134                         GDIPlus.CheckStatus (status);
1135                 }
1136
1137                 public void FillPie (Brush brush, Rectangle rect, float startAngle, float sweepAngle)
1138                 {
1139                         Status status = GDIPlus.GdipFillPie (nativeObject, brush.NativeObject, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
1140                         GDIPlus.CheckStatus (status);
1141                 }
1142
1143                 public void FillPie (Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle)
1144                 {
1145                         Status status = GDIPlus.GdipFillPieI (nativeObject, brush.NativeObject, x, y, width, height, startAngle, sweepAngle);
1146                         GDIPlus.CheckStatus (status);
1147                 }
1148
1149                 public void FillPie (Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle)
1150                 {
1151                         Status status = GDIPlus.GdipFillPie (nativeObject, brush.NativeObject, x, y, width, height, startAngle, sweepAngle);
1152                         GDIPlus.CheckStatus (status);
1153                 }
1154
1155                 public void FillPolygon (Brush brush, PointF [] points)
1156                 {
1157                         Status status = GDIPlus.GdipFillPolygon2 (nativeObject, brush.nativeObject, points, points.Length);
1158                         GDIPlus.CheckStatus (status);
1159                 }
1160
1161                 public void FillPolygon (Brush brush, Point [] points)
1162                 {
1163                         Status status = GDIPlus.GdipFillPolygon2I (nativeObject, brush.nativeObject, points, points.Length);
1164                         GDIPlus.CheckStatus (status);
1165                 }
1166
1167                 public void FillPolygon (Brush brush, Point [] points, FillMode fillMode)
1168                 {
1169                         Status status = GDIPlus.GdipFillPolygonI (nativeObject, brush.nativeObject, points, points.Length, fillMode);
1170                         GDIPlus.CheckStatus (status);
1171                 }
1172
1173                 public void FillPolygon (Brush brush, PointF [] points, FillMode fillMode)
1174                 {
1175                         Status status = GDIPlus.GdipFillPolygon (nativeObject, brush.nativeObject, points, points.Length, fillMode);
1176                         GDIPlus.CheckStatus (status);
1177                 }
1178
1179                 public void FillRectangle (Brush brush, RectangleF rect)
1180                 {
1181                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);
1182                 }
1183
1184                 public void FillRectangle (Brush brush, Rectangle rect)
1185                 {
1186                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);
1187                 }
1188
1189                 public void FillRectangle (Brush brush, int x, int y, int width, int height)
1190                 {
1191                         Status status = GDIPlus.GdipFillRectangleI (nativeObject, brush.nativeObject, x, y, width, height);
1192                         GDIPlus.CheckStatus (status);
1193                 }
1194
1195                 public void FillRectangle (Brush brush, float x, float y, float width, float height)
1196                 {
1197                         Status status = GDIPlus.GdipFillRectangle (nativeObject, brush.nativeObject, x, y, width, height);
1198                         GDIPlus.CheckStatus (status);
1199                 }
1200
1201                 public void FillRectangles (Brush brush, Rectangle [] rects)
1202                 {
1203                         Status status = GDIPlus.GdipFillRectanglesI (nativeObject, brush.nativeObject, rects, rects.Length);
1204                         GDIPlus.CheckStatus (status);
1205                 }
1206
1207                 public void FillRectangles (Brush brush, RectangleF [] rects)
1208                 {
1209                         Status status = GDIPlus.GdipFillRectangles (nativeObject, brush.nativeObject, rects, rects.Length);
1210                         GDIPlus.CheckStatus (status);
1211                 }
1212
1213
1214                 public void FillRegion (Brush brush, Region region)
1215                 {
1216                         Status status = GDIPlus.GdipFillRegion (nativeObject, brush.NativeObject, region.NativeObject);
1217                         GDIPlus.CheckStatus(status);
1218                 }
1219
1220
1221                 public void Flush ()
1222                 {
1223                         Flush (FlushIntention.Flush);
1224                 }
1225
1226
1227                 public void Flush (FlushIntention intention)
1228                 {
1229                         Status status = GDIPlus.GdipFlush (nativeObject, intention);
1230                         GDIPlus.CheckStatus (status);
1231                 }
1232
1233                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1234                 public static Graphics FromHdc (IntPtr hdc)
1235                 {
1236                         IntPtr graphics;
1237                         Status status = GDIPlus.GdipCreateFromHDC (hdc, out graphics);
1238                         GDIPlus.CheckStatus (status);
1239                         return new Graphics (graphics);
1240                 }
1241
1242                 [MonoTODO]
1243                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1244                 public static Graphics FromHdc (IntPtr hdc, IntPtr hdevice)
1245                 {
1246                         throw new NotImplementedException ();
1247                 }
1248
1249                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1250                 public static Graphics FromHdcInternal (IntPtr hdc)
1251                 {
1252                         display = hdc;
1253                         return null;
1254                 }
1255
1256                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1257                 public static Graphics FromHwnd (IntPtr hwnd)
1258                 {
1259                         IntPtr graphics;
1260
1261                         if (use_x_drawable) {
1262                                 if (display == IntPtr.Zero) {
1263                                         display = GDIPlus.XOpenDisplay (IntPtr.Zero);
1264                                 }
1265
1266                                 return FromXDrawable (hwnd, display);
1267                         }
1268
1269                         Status status = GDIPlus.GdipCreateFromHWND (hwnd, out graphics);
1270                         GDIPlus.CheckStatus (status);
1271
1272                         return new Graphics (graphics);
1273                 }
1274
1275                 [MonoTODO]
1276                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1277                 public static Graphics FromHwndInternal (IntPtr hwnd)
1278                 {
1279                         throw new NotImplementedException ();
1280                 }
1281
1282                 public static Graphics FromImage (Image image)
1283                 {
1284                         if (image == null) throw new ArgumentException ();
1285
1286                         int graphics;
1287                         Status status = GDIPlus.GdipGetImageGraphicsContext (image.nativeObject, out graphics);
1288                         GDIPlus.CheckStatus (status);
1289                         Graphics result = new Graphics ((IntPtr) graphics);
1290
1291                         if (Environment.OSVersion.Platform == (PlatformID) 128)  {
1292                                 Rectangle rect  = new Rectangle (0,0, image.Width, image.Height);
1293                                 GDIPlus.GdipSetVisibleClip_linux (result.NativeObject, ref rect);
1294                         }
1295
1296                         return result;
1297                 }
1298
1299                 internal static Graphics FromXDrawable (IntPtr drawable, IntPtr display)
1300                 {
1301                         IntPtr graphics;
1302                         Status s = GDIPlus.GdipCreateFromXDrawable_linux (drawable, display, out graphics);
1303                         GDIPlus.CheckStatus (s);
1304                         return new Graphics (graphics);
1305                 }
1306
1307                 [MonoTODO]
1308                 public static IntPtr GetHalftonePalette ()
1309                 {
1310                         throw new NotImplementedException ();
1311                 }
1312
1313                 [MonoTODO]
1314                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1315                 public IntPtr GetHdc ()
1316                 {
1317                         int hdc;
1318                         Status status = GDIPlus.GdipGetDC (nativeObject, out hdc);
1319                         GDIPlus.CheckStatus (status);
1320
1321                         return (IntPtr) hdc;
1322                 }
1323
1324
1325                 public Color GetNearestColor (Color color)
1326                 {
1327                         int argb;
1328
1329                         Status status = GDIPlus.GdipGetNearestColor (nativeObject, out argb);
1330                         GDIPlus.CheckStatus (status);
1331
1332                         return Color.FromArgb (argb);
1333                 }
1334
1335
1336                 public void IntersectClip (Region region)
1337                 {
1338                         Status status = GDIPlus.GdipSetClipRegion (nativeObject, region.NativeObject, CombineMode.Intersect);
1339                         GDIPlus.CheckStatus (status);
1340                 }
1341
1342                 public void IntersectClip (RectangleF rect)
1343                 {
1344                         Status status = GDIPlus.GdipSetClipRect (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, CombineMode.Intersect);
1345                         GDIPlus.CheckStatus (status);
1346                 }
1347
1348                 public void IntersectClip (Rectangle rect)
1349                 {
1350                         Status status = GDIPlus.GdipSetClipRectI (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, CombineMode.Intersect);
1351                         GDIPlus.CheckStatus (status);
1352                 }
1353
1354                 public bool IsVisible (Point point)
1355                 {
1356                         bool isVisible = false;
1357
1358                         Status status = GDIPlus.GdipIsVisiblePointI (nativeObject, point.X, point.Y, out isVisible);
1359                         GDIPlus.CheckStatus (status);
1360
1361                         return isVisible;
1362                 }
1363
1364
1365                 public bool IsVisible (RectangleF rect)
1366                 {
1367                         bool isVisible = false;
1368
1369                         Status status = GDIPlus.GdipIsVisibleRect (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, out isVisible);
1370                         GDIPlus.CheckStatus (status);
1371
1372                         return isVisible;
1373                 }
1374
1375                 public bool IsVisible (PointF point)
1376                 {
1377                         bool isVisible = false;
1378
1379                         Status status = GDIPlus.GdipIsVisiblePoint (nativeObject, point.X, point.Y, out isVisible);
1380                         GDIPlus.CheckStatus (status);
1381
1382                         return isVisible;
1383                 }
1384
1385                 public bool IsVisible (Rectangle rect)
1386                 {
1387                         bool isVisible = false;
1388
1389                         Status status = GDIPlus.GdipIsVisibleRectI (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, out isVisible);
1390                         GDIPlus.CheckStatus (status);
1391
1392                         return isVisible;
1393                 }
1394
1395                 public bool IsVisible (float x, float y)
1396                 {
1397                         return IsVisible (new PointF (x, y));
1398                 }
1399
1400                 public bool IsVisible (int x, int y)
1401                 {
1402                         return IsVisible (new Point (x, y));
1403                 }
1404
1405                 public bool IsVisible (float x, float y, float width, float height)
1406                 {
1407                         return IsVisible (new RectangleF (x, y, width, height));
1408                 }
1409
1410
1411                 public bool IsVisible (int x, int y, int width, int height)
1412                 {
1413                         return IsVisible (new Rectangle (x, y, width, height));
1414                 }
1415
1416
1417                 public Region [] MeasureCharacterRanges (string text, Font font, RectangleF layoutRect, StringFormat stringFormat)
1418                 {
1419                         Status status;
1420                         int regcount = stringFormat.GetMeasurableCharacterRangeCount ();
1421                         IntPtr[] native_regions = new IntPtr [regcount];
1422                         Region[] regions = new Region [regcount];
1423
1424                         for (int i = 0; i < regcount; i++) {
1425                                 regions[i] = new Region ();
1426                                 native_regions[i] = regions[i].NativeObject;
1427                         }
1428
1429                         status =  GDIPlus.GdipMeasureCharacterRanges (nativeObject, text, text.Length,
1430                                 font.NativeObject, ref layoutRect, stringFormat.NativeObject,
1431                                 regcount, out native_regions[0]);
1432
1433                         GDIPlus.CheckStatus (status);
1434
1435                         return regions;
1436                 }
1437
1438
1439                 public SizeF MeasureString (string text, Font font)
1440                 {
1441                         return MeasureString (text, font, new Size(0,0));
1442                 }
1443
1444
1445                 public SizeF MeasureString (string text, Font font, SizeF layoutArea)
1446                 {
1447                         int charactersFitted, linesFilled;
1448                         RectangleF boundingBox = new RectangleF ();
1449                         RectangleF rect = new RectangleF (0,0,layoutArea.Width, layoutArea.Height);
1450
1451                         Status status = GDIPlus.GdipMeasureString (nativeObject, text, text.Length,
1452                                 font.NativeObject, ref rect, IntPtr.Zero, out boundingBox,
1453                                 out charactersFitted, out linesFilled);
1454                         GDIPlus.CheckStatus (status);
1455
1456                         return new SizeF(boundingBox.Width, boundingBox.Height);
1457                 }
1458
1459
1460                 public SizeF MeasureString (string text, Font font, int width)
1461                 {
1462                         RectangleF boundingBox = new RectangleF ();
1463                         RectangleF rect = new RectangleF (0, 0, width, 999999);
1464                         int charactersFitted, linesFilled;
1465
1466                         Status status = GDIPlus.GdipMeasureString (nativeObject, text, text.Length,
1467                                 font.NativeObject, ref rect, IntPtr.Zero,
1468                                 out boundingBox, out charactersFitted, out linesFilled);
1469                         GDIPlus.CheckStatus (status);
1470
1471                         return new SizeF (boundingBox.Width, boundingBox.Height);
1472                 }
1473
1474
1475                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat)
1476                 {
1477                         int charactersFitted, linesFilled;
1478                         return MeasureString (text, font, layoutArea, stringFormat, out charactersFitted, out linesFilled);
1479                 }
1480
1481
1482                 public SizeF MeasureString (string text, Font font, int width, StringFormat format)
1483                 {
1484                         int charactersFitted, linesFilled;
1485                         return MeasureString (text, font, new SizeF (width, 999999),
1486                                 format, out charactersFitted, out linesFilled);
1487                 }
1488
1489
1490                 public SizeF MeasureString (string text, Font font, PointF origin, StringFormat stringFormat)
1491                 {
1492                         RectangleF boundingBox = new RectangleF ();
1493                         RectangleF rect = new RectangleF (origin.X, origin.Y, 0,0);
1494                         int charactersFitted, linesFilled;
1495
1496                         Status status = GDIPlus.GdipMeasureString (nativeObject, text, text.Length,
1497                                 font.NativeObject, ref rect, stringFormat.NativeObject,
1498                                 out boundingBox, out charactersFitted, out linesFilled);
1499                         GDIPlus.CheckStatus (status);
1500
1501                         return new SizeF (boundingBox.Width, boundingBox.Height);
1502                 }
1503
1504
1505                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat, out int charactersFitted, out int linesFilled)
1506                 {
1507                         RectangleF boundingBox = new RectangleF ();
1508                         RectangleF rect = new RectangleF (0,0,layoutArea.Width, layoutArea.Height);
1509                         Status status = GDIPlus.GdipMeasureString (nativeObject, text, text.Length,
1510                                 font.NativeObject, ref rect, stringFormat.NativeObject,
1511                                 out boundingBox, out charactersFitted, out linesFilled);
1512                         GDIPlus.CheckStatus (status);
1513
1514                         return new SizeF (boundingBox.Width, boundingBox.Height);
1515                 }
1516
1517                 public void MultiplyTransform (Matrix matrix)
1518                 {
1519                         MultiplyTransform (matrix, MatrixOrder.Prepend);
1520                 }
1521
1522                 public void MultiplyTransform (Matrix matrix, MatrixOrder order)
1523                 {
1524                         Status status = GDIPlus.GdipMultiplyWorldTransform (nativeObject, matrix.nativeMatrix, order);
1525                         GDIPlus.CheckStatus (status);
1526                 }
1527
1528                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1529                 public void ReleaseHdc (IntPtr hdc)
1530                 {
1531                         Status status = GDIPlus.GdipReleaseDC (nativeObject, hdc);
1532                         GDIPlus.CheckStatus (status);
1533                 }
1534
1535                 [MonoTODO]
1536                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1537                 public void ReleaseHdcInternal (IntPtr hdc)
1538                 {
1539                         throw new NotImplementedException ();
1540                 }
1541
1542
1543                 public void ResetClip ()
1544                 {
1545                         Status status = GDIPlus.GdipResetClip (nativeObject);
1546                         GDIPlus.CheckStatus (status);
1547                 }
1548
1549                 public void ResetTransform ()
1550                 {
1551                         Status status = GDIPlus.GdipResetWorldTransform (nativeObject);
1552                         GDIPlus.CheckStatus (status);
1553                 }
1554
1555                 public void Restore (GraphicsState gstate)
1556                 {
1557                         Transform = gstate.matrix.Clone ();
1558                         Status status = GDIPlus.GdipRestoreGraphics (nativeObject, gstate.nativeState);
1559                         GDIPlus.CheckStatus (status);
1560                 }
1561
1562
1563                 public void RotateTransform (float angle)
1564                 {
1565                         RotateTransform (angle, MatrixOrder.Prepend);
1566                 }
1567
1568                 public void RotateTransform (float angle, MatrixOrder order)
1569                 {
1570
1571                         Status status = GDIPlus.GdipRotateWorldTransform (nativeObject, angle, order);
1572                         GDIPlus.CheckStatus (status);
1573                 }
1574
1575                 public GraphicsState Save ()
1576                 {
1577                         GraphicsState state = new GraphicsState ();
1578                         state.matrix = Transform.Clone ();
1579                         uint saveState;
1580                         Status status = GDIPlus.GdipSaveGraphics (nativeObject, out saveState);
1581                         GDIPlus.CheckStatus (status);
1582
1583                         state.nativeState = saveState;
1584                         return state;
1585                 }
1586
1587                 public void ScaleTransform (float sx, float sy)
1588                 {
1589                         ScaleTransform (sx, sy, MatrixOrder.Prepend);
1590                 }
1591
1592                 public void ScaleTransform (float sx, float sy, MatrixOrder order)
1593                 {
1594                         Status status = GDIPlus.GdipScaleWorldTransform (nativeObject, sx, sy, order);
1595                         GDIPlus.CheckStatus (status);
1596                 }
1597
1598
1599                 public void SetClip (RectangleF rect)
1600                 {
1601                         SetClip (rect, CombineMode.Replace);
1602                 }
1603
1604
1605                 public void SetClip (GraphicsPath path)
1606                 {
1607                         SetClip (path, CombineMode.Replace);
1608                 }
1609
1610
1611                 public void SetClip (Rectangle rect)
1612                 {
1613                         SetClip (rect, CombineMode.Replace);
1614                 }
1615
1616
1617                 public void SetClip (Graphics g)
1618                 {
1619                         SetClip (g, CombineMode.Replace);
1620                 }
1621
1622
1623                 public void SetClip (Graphics g, CombineMode combineMode)
1624                 {
1625                         Status status = GDIPlus.GdipSetClipGraphics (nativeObject, g.NativeObject, combineMode);
1626                         GDIPlus.CheckStatus (status);
1627                 }
1628
1629
1630                 public void SetClip (Rectangle rect, CombineMode combineMode)
1631                 {
1632                         Status status = GDIPlus.GdipSetClipRectI (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, combineMode);
1633                         GDIPlus.CheckStatus (status);
1634                 }
1635
1636
1637                 public void SetClip (RectangleF rect, CombineMode combineMode)
1638                 {
1639                         Status status = GDIPlus.GdipSetClipRect (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, combineMode);
1640                         GDIPlus.CheckStatus (status);
1641                 }
1642
1643
1644                 public void SetClip (Region region, CombineMode combineMode)
1645                 {
1646                         Status status =   GDIPlus.GdipSetClipRegion(nativeObject,  region.NativeObject, combineMode);
1647                         GDIPlus.CheckStatus (status);
1648                 }
1649
1650
1651                 public void SetClip (GraphicsPath path, CombineMode combineMode)
1652                 {
1653                         Status status = GDIPlus.GdipSetClipPath (nativeObject, path.NativeObject, combineMode);
1654                         GDIPlus.CheckStatus (status);
1655                 }
1656
1657
1658                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF [] pts)
1659                 {
1660                         IntPtr ptrPt =  GDIPlus.FromPointToUnManagedMemory (pts);
1661
1662                         Status status = GDIPlus.GdipTransformPoints (nativeObject, destSpace, srcSpace,  ptrPt, pts.Length);
1663                         GDIPlus.CheckStatus (status);
1664
1665                         GDIPlus.FromUnManagedMemoryToPoint (ptrPt, pts);
1666                 }
1667
1668
1669                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts)
1670                 {
1671                         IntPtr ptrPt =  GDIPlus.FromPointToUnManagedMemoryI (pts);
1672
1673                         Status status = GDIPlus.GdipTransformPointsI (nativeObject, destSpace, srcSpace, ptrPt, pts.Length);
1674                         GDIPlus.CheckStatus (status);
1675
1676                         GDIPlus.FromUnManagedMemoryToPointI (ptrPt, pts);
1677                 }
1678
1679
1680                 public void TranslateClip (int dx, int dy)
1681                 {
1682                         Status status = GDIPlus.GdipTranslateClipI (nativeObject, dx, dy);
1683                         GDIPlus.CheckStatus (status);
1684                 }
1685
1686
1687                 public void TranslateClip (float dx, float dy)
1688                 {
1689                         Status status = GDIPlus.GdipTranslateClip (nativeObject, dx, dy);
1690                         GDIPlus.CheckStatus (status);
1691                 }
1692
1693                 public void TranslateTransform (float dx, float dy)
1694                 {
1695                         TranslateTransform (dx, dy, MatrixOrder.Prepend);
1696                 }
1697
1698
1699                 public void TranslateTransform (float dx, float dy, MatrixOrder order)
1700                 {
1701                         Status status = GDIPlus.GdipTranslateWorldTransform (nativeObject, dx, dy, order);
1702                         GDIPlus.CheckStatus (status);
1703                 }
1704
1705                 public Region Clip {
1706                         get {
1707                                 Region reg = new Region();
1708                                 Status status = GDIPlus.GdipGetClip (nativeObject, reg.NativeObject);
1709                                 GDIPlus.CheckStatus (status);
1710                                 return reg;
1711                         }
1712                         set {
1713                                 SetClip (value, CombineMode.Replace);
1714                         }
1715                 }
1716
1717                 public RectangleF ClipBounds {
1718                         get {
1719                                 RectangleF rect = new RectangleF ();
1720                                 Status status = GDIPlus.GdipGetClipBounds (nativeObject, out rect);
1721                                 GDIPlus.CheckStatus (status);
1722                                 return rect;
1723                         }
1724                 }
1725
1726                 public CompositingMode CompositingMode {
1727                         get {
1728                                 CompositingMode mode;
1729                                 Status status = GDIPlus.GdipGetCompositingMode (nativeObject, out mode);
1730                                 GDIPlus.CheckStatus (status);
1731
1732                                 return mode;
1733                         }
1734                         set {
1735                                 Status status = GDIPlus.GdipSetCompositingMode (nativeObject, value);
1736                                 GDIPlus.CheckStatus (status);
1737                         }
1738
1739                 }
1740
1741                 public CompositingQuality CompositingQuality {
1742                         get {
1743                                 CompositingQuality quality;
1744
1745                                 Status status = GDIPlus.GdipGetCompositingQuality (nativeObject, out quality);
1746                                 GDIPlus.CheckStatus (status);
1747                                 return quality;
1748                         }
1749                         set {
1750                                 Status status = GDIPlus.GdipSetCompositingQuality (nativeObject, value);
1751                                 GDIPlus.CheckStatus (status);
1752                         }
1753                 }
1754
1755                 public float DpiX {
1756                         get {
1757                                 float x;
1758
1759                                 Status status = GDIPlus.GdipGetDpiX (nativeObject, out x);
1760                                 GDIPlus.CheckStatus (status);
1761                                 return x;
1762                         }
1763                 }
1764
1765                 public float DpiY {
1766                         get {
1767                                 float y;
1768
1769                                 Status status = GDIPlus.GdipGetDpiY (nativeObject, out y);
1770                                 GDIPlus.CheckStatus (status);
1771                                 return y;
1772                         }
1773                 }
1774
1775                 public InterpolationMode InterpolationMode {
1776                         get {
1777                                 InterpolationMode imode = InterpolationMode.Invalid;
1778                                 Status status = GDIPlus.GdipGetInterpolationMode (nativeObject, out imode);
1779                                 GDIPlus.CheckStatus (status);
1780                                 return imode;
1781                         }
1782                         set {
1783                                 Status status = GDIPlus.GdipSetInterpolationMode (nativeObject, value);
1784                                 GDIPlus.CheckStatus (status);
1785                         }
1786                 }
1787
1788                 public bool IsClipEmpty {
1789                         get {
1790                                 bool isEmpty = false;
1791
1792                                 Status status = GDIPlus.GdipIsClipEmpty (nativeObject, out isEmpty);
1793                                 GDIPlus.CheckStatus (status);
1794                                 return isEmpty;
1795                         }
1796                 }
1797
1798                 public bool IsVisibleClipEmpty {
1799                         get {
1800                                 bool isEmpty = false;
1801
1802                                 Status status = GDIPlus.GdipIsVisibleClipEmpty (nativeObject, out isEmpty);
1803                                 GDIPlus.CheckStatus (status);
1804                                 return isEmpty;
1805                         }
1806                 }
1807
1808                 public float PageScale {
1809                         get {
1810                                 float scale;
1811
1812                                 Status status = GDIPlus.GdipGetPageScale (nativeObject, out scale);
1813                                 GDIPlus.CheckStatus (status);
1814                                 return scale;
1815                         }
1816                         set {
1817                                 Status status = GDIPlus.GdipSetPageScale (nativeObject, value);
1818                                 GDIPlus.CheckStatus (status);
1819                         }
1820                 }
1821
1822                 public GraphicsUnit PageUnit {
1823                         get {
1824                                 GraphicsUnit unit;
1825
1826                                 Status status = GDIPlus.GdipGetPageUnit (nativeObject, out unit);
1827                                 GDIPlus.CheckStatus (status);
1828                                 return unit;
1829                         }
1830                         set {
1831                                 Status status = GDIPlus.GdipSetPageUnit (nativeObject, value);
1832                                 GDIPlus.CheckStatus (status);
1833                         }
1834                 }
1835
1836                 public PixelOffsetMode PixelOffsetMode {
1837                         get {
1838                                 PixelOffsetMode pixelOffset = PixelOffsetMode.Invalid;
1839
1840                                 Status status = GDIPlus.GdipGetPixelOffsetMode (nativeObject, out pixelOffset);
1841                                 GDIPlus.CheckStatus (status);
1842                                 return pixelOffset;
1843                         }
1844                         set {
1845                                 Status status = GDIPlus.GdipSetPixelOffsetMode (nativeObject, value);
1846                                 GDIPlus.CheckStatus (status);
1847                         }
1848                 }
1849
1850                 public Point RenderingOrigin {
1851                         get {
1852                                 int x, y;
1853                                 Status status = GDIPlus.GdipGetRenderingOrigin (nativeObject, out x, out y);
1854                                 GDIPlus.CheckStatus (status);
1855                                 return new Point (x, y);
1856                         }
1857
1858                         set {
1859                                 Status status = GDIPlus.GdipSetRenderingOrigin (nativeObject, value.X, value.Y);
1860                                 GDIPlus.CheckStatus (status);
1861                         }
1862                 }
1863
1864                 public SmoothingMode SmoothingMode {
1865                         get {
1866                                 SmoothingMode mode = SmoothingMode.Invalid;
1867
1868                                 Status status = GDIPlus.GdipGetSmoothingMode (nativeObject, out mode);
1869                                 GDIPlus.CheckStatus (status);
1870                                 return mode;
1871                         }
1872
1873                         set {
1874                                 Status status = GDIPlus.GdipSetSmoothingMode (nativeObject, value);
1875                                 GDIPlus.CheckStatus (status);
1876                         }
1877                 }
1878
1879                 public int TextContrast {
1880                         get {
1881                                 int contrast;
1882
1883                                 Status status = GDIPlus.GdipGetTextContrast (nativeObject, out contrast);
1884                                 GDIPlus.CheckStatus (status);
1885                                 return contrast;
1886                         }
1887
1888                         set {
1889                                 Status status = GDIPlus.GdipSetTextContrast (nativeObject, value);
1890                                 GDIPlus.CheckStatus (status);
1891                         }
1892                 }
1893
1894                 public TextRenderingHint TextRenderingHint {
1895                         get {
1896                                 TextRenderingHint hint;
1897
1898                                 Status status = GDIPlus.GdipGetTextRenderingHint (nativeObject, out hint);
1899                                 GDIPlus.CheckStatus (status);
1900                                 return hint;
1901                         }
1902
1903                         set {
1904                                 Status status = GDIPlus.GdipSetTextRenderingHint (nativeObject, value);
1905                                 GDIPlus.CheckStatus (status);
1906                         }
1907                 }
1908
1909                 public Matrix Transform {
1910                         get {
1911                                 Matrix matrix = new Matrix ();
1912                                 Status status = GDIPlus.GdipGetWorldTransform (nativeObject, matrix.nativeMatrix);
1913                                 GDIPlus.CheckStatus (status);
1914                                 return matrix;
1915                         }
1916                         set {
1917                                 Status status = GDIPlus.GdipSetWorldTransform (nativeObject, value.nativeMatrix);
1918                                 GDIPlus.CheckStatus (status);
1919                         }
1920                 }
1921
1922                 public RectangleF VisibleClipBounds {
1923                         get {
1924                                 RectangleF rect;
1925
1926                                 Status status = GDIPlus.GdipGetVisibleClipBounds (nativeObject, out rect);
1927                                 GDIPlus.CheckStatus (status);
1928                                 return rect;
1929                         }
1930                 }
1931         }
1932 }
1933