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

   1 //
   2 // System.Drawing.Graphics.cs
   3 //
   4 // (C) 2003 Ximian, Inc.  http://www.ximian.com
   5 //
   6 // Authors:
   7 //      Gonzalo Paniagua Javier (gonzalo@ximian.com) (stubbed out)
   8 //      Alexandre Pigolkine(pigolkine@gmx.de)
   9 //              Jordi Mas i Hernandez (jordi@ximian.com)
  10 //
  11
  12 //
  13 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  14 //
  15 // Permission is hereby granted, free of charge, to any person obtaining
  16 // a copy of this software and associated documentation files (the
  17 // "Software"), to deal in the Software without restriction, including
  18 // without limitation the rights to use, copy, modify, merge, publish,
  19 // distribute, sublicense, and/or sell copies of the Software, and to
  20 // permit persons to whom the Software is furnished to do so, subject to
  21 // the following conditions:
  22 //
  23 // The above copyright notice and this permission notice shall be
  24 // included in all copies or substantial portions of the Software.
  25 //
  26 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  30 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  31 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  32 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  33 //
  34 using System;
  35 using System.Drawing.Drawing2D;
  36 using System.Drawing.Imaging;
  37 using System.Drawing.Text;
  38 using System.ComponentModel;
  39 using System.Runtime.InteropServices;
  40 using System.Text;
  41
  42 namespace System.Drawing
  43 {
  44         [ComVisible(false)]
  45         public sealed class Graphics : MarshalByRefObject, IDisposable
  46         {
  47                 internal IntPtr nativeObject = IntPtr.Zero;
  48                 private bool disposed = false;
  49                 private static float defDpiX = 0;
  50                 private static float defDpiY = 0;
  51
  52                 [ComVisible(false)]
  53                 public delegate bool EnumerateMetafileProc (EmfPlusRecordType recordType,
  54                                                             int flags,
  55                                                             int dataSize,
  56                                                             IntPtr data,
  57                                                             PlayRecordCallback callbackData);
  58
  59                 [ComVisible (false)]
  60                 public delegate bool DrawImageAbort (IntPtr callbackData);
  61
  62                 private Graphics (IntPtr nativeGraphics)
  63                 {
  64                         nativeObject = nativeGraphics;
  65                 }
  66
  67                 ~Graphics ()
  68                 {
  69                         Dispose ();
  70                 }
  71
  72                 static internal float systemDpiX {
  73                         get {
  74                                         if (defDpiX==0) {
  75                                                 Bitmap bmp = new Bitmap(1,1);
  76                                                 Graphics g = Graphics.FromImage(bmp);
  77                                         defDpiX = g.DpiX;
  78                                 }
  79                                 return defDpiX;
  80                         }
  81                 }
  82
  83                 static internal float systemDpiY {
  84                         get {
  85                                         if (defDpiY==0) {
  86                                                 Bitmap bmp = new Bitmap(1,1);
  87                                                 Graphics g = Graphics.FromImage(bmp);
  88                                         defDpiY = g.DpiY;
  89                                 }
  90                                 return defDpiY;
  91                         }
  92                 }
  93
  94                 internal IntPtr NativeObject {
  95                         get{
  96                                 return nativeObject;
  97                         }
  98
  99                         set {
 100                                 nativeObject = value;
 101                         }
 102                 }
 103
 104                 [MonoTODO]
 105                 public void AddMetafileComment (byte [] data)
 106                 {
 107                         throw new NotImplementedException ();
 108                 }
 109
 110
 111                 public GraphicsContainer BeginContainer ()
 112                 {
 113                         int state;
 114                         Status status;
 115                         status = GDIPlus.GdipBeginContainer2 (nativeObject, out state);
 116                         GDIPlus.CheckStatus (status);
 117
 118                         return new GraphicsContainer(state);
 119                 }
 120
 121                 public GraphicsContainer BeginContainer (Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit)
 122                 {
 123                         int state;
 124                         Status status;
 125                         status = GDIPlus.GdipBeginContainerI (nativeObject, dstrect, srcrect, unit, out state);
 126                         GDIPlus.CheckStatus (status);
 127
 128                         return new GraphicsContainer (state);
 129                 }
 130
 131
 132                 public GraphicsContainer BeginContainer (RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit)
 133                 {
 134                         int state;
 135                         Status status;
 136                         status = GDIPlus.GdipBeginContainer (nativeObject, dstrect, srcrect, unit, out state);
 137                         GDIPlus.CheckStatus (status);
 138
 139                         return new GraphicsContainer (state);
 140                 }
 141
 142
 143                 public void Clear (Color color)
 144                 {
 145                         Status status;
 146                         status = GDIPlus.GdipGraphicsClear (nativeObject, color.ToArgb ());                             GDIPlus.CheckStatus (status);
 147                 }
 148
 149                 public void Dispose ()
 150                 {
 151                         Status status;
 152                         if (! disposed) {
 153                                 lock (this)
 154                                 {
 155                                         status = GDIPlus.GdipDeleteGraphics (nativeObject);
 156                                         GDIPlus.CheckStatus (status);
 157                                         nativeObject = IntPtr.Zero;
 158                                         disposed = true;
 159                                 }
 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                 [MonoTODO]
 375                 public void DrawIcon (Icon icon, Rectangle targetRect)
 376                 {
 377                         throw new NotImplementedException ();
 378                 }
 379
 380                 [MonoTODO]
 381                 public void DrawIcon (Icon icon, int x, int y)
 382                 {
 383                         throw new NotImplementedException ();
 384                 }
 385
 386                 [MonoTODO]
 387                 public void DrawIconUnstretched (Icon icon, Rectangle targetRect)
 388                 {
 389                         throw new NotImplementedException ();
 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                         int graphics;
1237                         Status status = GDIPlus.GdipCreateFromHDC (hdc, out graphics);                          GDIPlus.CheckStatus (status);
1238
1239                         Graphics result = new Graphics ((IntPtr) graphics);
1240                         return result;
1241                 }
1242
1243                 [MonoTODO]
1244                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1245                 public static Graphics FromHdc (IntPtr hdc, IntPtr hdevice)
1246                 {
1247                         throw new NotImplementedException ();
1248                 }
1249
1250                 [MonoTODO]
1251                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1252                 public static Graphics FromHdcInternal (IntPtr hdc)
1253                 {
1254                         throw new NotImplementedException ();
1255                 }
1256
1257                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1258                 public static Graphics FromHwnd (IntPtr hwnd)
1259                 {
1260                         IntPtr graphics;
1261
1262                         Status status = GDIPlus.GdipCreateFromHWND (hwnd, out graphics);                                GDIPlus.CheckStatus (status);
1263
1264                         return new Graphics (graphics);
1265                 }
1266
1267                 [MonoTODO]
1268                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1269                 public static Graphics FromHwndInternal (IntPtr hwnd)
1270                 {
1271                         throw new NotImplementedException ();
1272                 }
1273
1274                 public static Graphics FromImage (Image image)
1275                 {
1276                         lock (typeof (Graphics))
1277                         {
1278                                 if (image == null) throw new ArgumentException ();
1279                                 int graphics;
1280                                 Status status = GDIPlus.GdipGetImageGraphicsContext (image.nativeObject, out graphics);
1281                                 GDIPlus.CheckStatus (status);
1282                                 Graphics result = new Graphics ((IntPtr) graphics);
1283
1284                                 if (Environment.OSVersion.Platform == (PlatformID) 128)  {
1285                                         Rectangle rect  = new Rectangle (0,0, image.Width, image.Height);
1286                                         GDIPlus.GdipSetVisibleClip_linux (result.NativeObject, ref rect);
1287                                 }
1288
1289                                 return result;
1290                         }
1291                 }
1292
1293                 internal static Graphics FromXDrawable (IntPtr drawable, IntPtr display)
1294                 {
1295                         lock (typeof (Graphics))
1296                         {
1297                                 IntPtr graphics;
1298                                 Status s = GDIPlus.GdipCreateFromXDrawable_linux (drawable, display, out graphics);
1299                                 GDIPlus.CheckStatus (s);
1300                                 return new Graphics (graphics);
1301                         }
1302                 }
1303
1304                 [MonoTODO]
1305                 public static IntPtr GetHalftonePalette ()
1306                 {
1307                         throw new NotImplementedException ();
1308                 }
1309
1310                 [MonoTODO]
1311                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1312                 public IntPtr GetHdc ()
1313                 {
1314                         int hdc;
1315                         Status status = GDIPlus.GdipGetDC (nativeObject, out hdc);
1316                         GDIPlus.CheckStatus (status);
1317
1318                         return (IntPtr) hdc;
1319                 }
1320
1321
1322                 public Color GetNearestColor (Color color)
1323                 {
1324                         int argb;
1325
1326                         Status status = GDIPlus.GdipGetNearestColor (nativeObject, out argb);
1327                         GDIPlus.CheckStatus (status);
1328
1329                         return Color.FromArgb (argb);
1330                 }
1331
1332
1333                 public void IntersectClip (Region region)
1334                 {
1335                         Status status = GDIPlus.GdipSetClipRegion (nativeObject, region.NativeObject, CombineMode.Intersect);
1336                         GDIPlus.CheckStatus (status);
1337                 }
1338
1339                 public void IntersectClip (RectangleF rect)
1340                 {
1341                         Status status = GDIPlus.GdipSetClipRect (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, CombineMode.Intersect);
1342                         GDIPlus.CheckStatus (status);
1343                 }
1344
1345                 public void IntersectClip (Rectangle rect)
1346                 {
1347                         Status status = GDIPlus.GdipSetClipRectI (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, CombineMode.Intersect);
1348                         GDIPlus.CheckStatus (status);
1349                 }
1350
1351                 public bool IsVisible (Point point)
1352                 {
1353                         bool isVisible = false;
1354
1355                         Status status = GDIPlus.GdipIsVisiblePointI (nativeObject, point.X, point.Y, out isVisible);
1356                         GDIPlus.CheckStatus (status);
1357
1358                         return isVisible;
1359                 }
1360
1361
1362                 public bool IsVisible (RectangleF rect)
1363                 {
1364                         bool isVisible = false;
1365
1366                         Status status = GDIPlus.GdipIsVisibleRect (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, out isVisible);
1367                         GDIPlus.CheckStatus (status);
1368
1369                         return isVisible;
1370                 }
1371
1372                 public bool IsVisible (PointF point)
1373                 {
1374                         bool isVisible = false;
1375
1376                         Status status = GDIPlus.GdipIsVisiblePoint (nativeObject, point.X, point.Y, out isVisible);
1377                         GDIPlus.CheckStatus (status);
1378
1379                         return isVisible;
1380                 }
1381
1382                 public bool IsVisible (Rectangle rect)
1383                 {
1384                         bool isVisible = false;
1385
1386                         Status status = GDIPlus.GdipIsVisibleRectI (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, out isVisible);
1387                         GDIPlus.CheckStatus (status);
1388
1389                         return isVisible;
1390                 }
1391
1392                 public bool IsVisible (float x, float y)
1393                 {
1394                         return IsVisible (new PointF (x, y));
1395                 }
1396
1397                 public bool IsVisible (int x, int y)
1398                 {
1399                         return IsVisible (new Point (x, y));
1400                 }
1401
1402                 public bool IsVisible (float x, float y, float width, float height)
1403                 {
1404                         return IsVisible (new RectangleF (x, y, width, height));
1405                 }
1406
1407
1408                 public bool IsVisible (int x, int y, int width, int height)
1409                 {
1410                         return IsVisible (new Rectangle (x, y, width, height));
1411                 }
1412
1413                 [MonoTODO]
1414                 public Region [] MeasureCharacterRanges (string text, Font font, RectangleF layoutRect, StringFormat stringFormat)
1415                 {
1416                         Region []       result=new Region[stringFormat.GetCharRanges.Length];
1417                         string          textFragment;
1418                         SizeF           fragmentSize;
1419
1420                         for (int i=0; i<stringFormat.GetCharRanges.Length; i++) {
1421                                 textFragment=text.Substring(stringFormat.GetCharRanges[i].First, stringFormat.GetCharRanges[i].Length);
1422                                 fragmentSize=MeasureString(textFragment, font, new SizeF(layoutRect.Width, layoutRect.Height), stringFormat);
1423                                 result[i]=new Region(new RectangleF(layoutRect.X, layoutRect.Y, layoutRect.X+fragmentSize.Width, layoutRect.Y+fragmentSize.Height));
1424                         }
1425
1426                         return(result);
1427                 }
1428
1429
1430                 public SizeF MeasureString (string text, Font font)
1431                 {
1432                         return MeasureString (text, font, new Size(0,0));
1433                 }
1434
1435
1436                 public SizeF MeasureString (string text, Font font, SizeF layoutArea)
1437                 {
1438                         int charactersFitted, linesFilled;
1439                         RectangleF boundingBox = new RectangleF ();
1440                         RectangleF rect = new RectangleF (0,0,layoutArea.Width, layoutArea.Height);
1441
1442                         Status status = GDIPlus.GdipMeasureString (nativeObject, text, text.Length,
1443                                 font.NativeObject, ref rect, IntPtr.Zero, out boundingBox,
1444                                 out charactersFitted, out linesFilled);
1445                         GDIPlus.CheckStatus (status);
1446
1447                         return new SizeF(boundingBox.Width, boundingBox.Height);
1448                 }
1449
1450
1451                 public SizeF MeasureString (string text, Font font, int width)
1452                 {
1453                         RectangleF boundingBox = new RectangleF ();
1454                         RectangleF rect = new RectangleF (0, 0, width, 999999);
1455                         int charactersFitted, linesFilled;
1456
1457                         Status status = GDIPlus.GdipMeasureString (nativeObject, text, text.Length,
1458                                 font.NativeObject, ref rect, IntPtr.Zero,
1459                                 out boundingBox, out charactersFitted, out linesFilled);
1460                         GDIPlus.CheckStatus (status);
1461
1462                         return new SizeF (boundingBox.Width, boundingBox.Height);
1463                 }
1464
1465
1466                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat)
1467                 {
1468                         int charactersFitted, linesFilled;
1469                         return MeasureString (text, font, layoutArea, stringFormat, out charactersFitted, out linesFilled);
1470                 }
1471
1472
1473                 public SizeF MeasureString (string text, Font font, int width, StringFormat format)
1474                 {
1475                         int charactersFitted, linesFilled;
1476                         return MeasureString (text, font, new SizeF (width, 999999),
1477                                 format, out charactersFitted, out linesFilled);
1478                 }
1479
1480
1481                 public SizeF MeasureString (string text, Font font, PointF origin, StringFormat stringFormat)
1482                 {
1483                         RectangleF boundingBox = new RectangleF ();
1484                         RectangleF rect = new RectangleF (origin.X, origin.Y, 0,0);
1485                         int charactersFitted, linesFilled;
1486
1487                         Status status = GDIPlus.GdipMeasureString (nativeObject, text, text.Length,
1488                                 font.NativeObject, ref rect, stringFormat.NativeObject,
1489                                 out boundingBox, out charactersFitted, out linesFilled);
1490                         GDIPlus.CheckStatus (status);
1491
1492                         return new SizeF (boundingBox.Width, boundingBox.Height);
1493                 }
1494
1495
1496                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat, out int charactersFitted, out int linesFilled)
1497                 {
1498                         RectangleF boundingBox = new RectangleF ();
1499                         RectangleF rect = new RectangleF (0,0,layoutArea.Width, layoutArea.Height);
1500                         Status status = GDIPlus.GdipMeasureString (nativeObject, text, text.Length,
1501                                 font.NativeObject, ref rect, stringFormat.NativeObject,
1502                                 out boundingBox, out charactersFitted, out linesFilled);
1503                         GDIPlus.CheckStatus (status);
1504
1505                         return new SizeF (boundingBox.Width, boundingBox.Height);
1506                 }
1507
1508                 public void MultiplyTransform (Matrix matrix)
1509                 {
1510                         MultiplyTransform (matrix, MatrixOrder.Prepend);
1511                 }
1512
1513                 public void MultiplyTransform (Matrix matrix, MatrixOrder order)
1514                 {
1515                         Status status = GDIPlus.GdipMultiplyWorldTransform (nativeObject, matrix.nativeMatrix, order);
1516                         GDIPlus.CheckStatus (status);
1517                 }
1518
1519                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1520                 public void ReleaseHdc (IntPtr hdc)
1521                 {
1522                         Status status = GDIPlus.GdipReleaseDC (nativeObject, hdc);
1523                         GDIPlus.CheckStatus (status);
1524                 }
1525
1526                 [MonoTODO]
1527                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1528                 public void ReleaseHdcInternal (IntPtr hdc)
1529                 {
1530                         throw new NotImplementedException ();
1531                 }
1532
1533
1534                 public void ResetClip ()
1535                 {
1536                         Status status = GDIPlus.GdipResetClip (nativeObject);
1537                         GDIPlus.CheckStatus (status);
1538                 }
1539
1540                 public void ResetTransform ()
1541                 {
1542                         Status status = GDIPlus.GdipResetWorldTransform (nativeObject);
1543                         GDIPlus.CheckStatus (status);
1544                 }
1545
1546                 public void Restore (GraphicsState gstate)
1547                 {
1548                         Transform = gstate.matrix.Clone ();
1549                         Status status = GDIPlus.GdipRestoreGraphics (nativeObject, gstate.nativeState);
1550                         GDIPlus.CheckStatus (status);
1551                 }
1552
1553
1554                 public void RotateTransform (float angle)
1555                 {
1556                         RotateTransform (angle, MatrixOrder.Prepend);
1557                 }
1558
1559                 public void RotateTransform (float angle, MatrixOrder order)
1560                 {
1561
1562                         Status status = GDIPlus.GdipRotateWorldTransform (nativeObject, angle, order);
1563                         GDIPlus.CheckStatus (status);
1564                 }
1565
1566                 public GraphicsState Save ()
1567                 {
1568                         GraphicsState state = new GraphicsState ();
1569                         state.matrix = Transform.Clone ();
1570                         uint saveState;
1571                         Status status = GDIPlus.GdipSaveGraphics (nativeObject, out saveState);
1572                         GDIPlus.CheckStatus (status);
1573
1574                         state.nativeState = saveState;
1575                         return state;
1576                 }
1577
1578                 public void ScaleTransform (float sx, float sy)
1579                 {
1580                         ScaleTransform (sx, sy, MatrixOrder.Prepend);
1581                 }
1582
1583                 public void ScaleTransform (float sx, float sy, MatrixOrder order)
1584                 {
1585                         Status status = GDIPlus.GdipScaleWorldTransform (nativeObject, sx, sy, order);
1586                         GDIPlus.CheckStatus (status);
1587                 }
1588
1589
1590                 public void SetClip (RectangleF rect)
1591                 {
1592                         SetClip (rect, CombineMode.Replace);
1593                 }
1594
1595
1596                 public void SetClip (GraphicsPath path)
1597                 {
1598                         SetClip (path, CombineMode.Replace);
1599                 }
1600
1601
1602                 public void SetClip (Rectangle rect)
1603                 {
1604                         SetClip (rect, CombineMode.Replace);
1605                 }
1606
1607
1608                 public void SetClip (Graphics g)
1609                 {
1610                         SetClip (g, CombineMode.Replace);
1611                 }
1612
1613
1614                 public void SetClip (Graphics g, CombineMode combineMode)
1615                 {
1616                         Status status = GDIPlus.GdipSetClipGraphics (nativeObject, g.NativeObject, combineMode);
1617                         GDIPlus.CheckStatus (status);
1618                 }
1619
1620
1621                 public void SetClip (Rectangle rect, CombineMode combineMode)
1622                 {
1623                         Status status = GDIPlus.GdipSetClipRectI (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, combineMode);
1624                         GDIPlus.CheckStatus (status);
1625                 }
1626
1627
1628                 public void SetClip (RectangleF rect, CombineMode combineMode)
1629                 {
1630                         Status status = GDIPlus.GdipSetClipRect (nativeObject, rect.X, rect.Y, rect.Width, rect.Height, combineMode);
1631                         GDIPlus.CheckStatus (status);
1632                 }
1633
1634
1635                 public void SetClip (Region region, CombineMode combineMode)
1636                 {
1637                         Status status =   GDIPlus.GdipSetClipRegion(nativeObject,  region.NativeObject, combineMode);
1638                         GDIPlus.CheckStatus (status);
1639                 }
1640
1641
1642                 public void SetClip (GraphicsPath path, CombineMode combineMode)
1643                 {
1644                         Status status = GDIPlus.GdipSetClipPath (nativeObject, path.NativeObject, combineMode);
1645                         GDIPlus.CheckStatus (status);
1646                 }
1647
1648
1649                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF [] pts)
1650                 {
1651                         IntPtr ptrPt =  GDIPlus.FromPointToUnManagedMemory (pts);
1652
1653                         Status status = GDIPlus.GdipTransformPoints (nativeObject, destSpace, srcSpace,  ptrPt, pts.Length);
1654                         GDIPlus.CheckStatus (status);
1655
1656                         GDIPlus.FromUnManagedMemoryToPoint (ptrPt, pts);
1657                 }
1658
1659
1660                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts)
1661                 {
1662                         IntPtr ptrPt =  GDIPlus.FromPointToUnManagedMemoryI (pts);
1663
1664                         Status status = GDIPlus.GdipTransformPointsI (nativeObject, destSpace, srcSpace, ptrPt, pts.Length);
1665                         GDIPlus.CheckStatus (status);
1666
1667                         GDIPlus.FromUnManagedMemoryToPointI (ptrPt, pts);
1668                 }
1669
1670
1671                 public void TranslateClip (int dx, int dy)
1672                 {
1673                         Status status = GDIPlus.GdipTranslateClipI (nativeObject, dx, dy);
1674                         GDIPlus.CheckStatus (status);
1675                 }
1676
1677
1678                 public void TranslateClip (float dx, float dy)
1679                 {
1680                         Status status = GDIPlus.GdipTranslateClip (nativeObject, dx, dy);
1681                         GDIPlus.CheckStatus (status);
1682                 }
1683
1684                 public void TranslateTransform (float dx, float dy)
1685                 {
1686                         TranslateTransform (dx, dy, MatrixOrder.Prepend);
1687                 }
1688
1689
1690                 public void TranslateTransform (float dx, float dy, MatrixOrder order)
1691                 {
1692                         Status status = GDIPlus.GdipTranslateWorldTransform (nativeObject, dx, dy, order);
1693                         GDIPlus.CheckStatus (status);
1694                 }
1695
1696                 public Region Clip {
1697                         get {
1698                                 Region reg = new Region();
1699                                 Status status = GDIPlus.GdipGetClip (nativeObject, reg.NativeObject);
1700                                 GDIPlus.CheckStatus (status);
1701                                 return reg;
1702                         }
1703                         set {
1704                                 SetClip (value, CombineMode.Replace);
1705                         }
1706                 }
1707
1708                 public RectangleF ClipBounds {
1709                         get {
1710                                 RectangleF rect = new RectangleF ();
1711                                 Status status = GDIPlus.GdipGetClipBounds (nativeObject, out rect);
1712                                 GDIPlus.CheckStatus (status);
1713                                 return rect;
1714                         }
1715                 }
1716
1717                 public CompositingMode CompositingMode {
1718                         get {
1719                                 CompositingMode mode;
1720                                 Status status = GDIPlus.GdipGetCompositingMode (nativeObject, out mode);
1721                                 GDIPlus.CheckStatus (status);
1722
1723                                 return mode;
1724                         }
1725                         set {
1726                                 Status status = GDIPlus.GdipSetCompositingMode (nativeObject, value);
1727                                 GDIPlus.CheckStatus (status);
1728                         }
1729
1730                 }
1731
1732                 public CompositingQuality CompositingQuality {
1733                         get {
1734                                 CompositingQuality quality;
1735
1736                                 Status status = GDIPlus.GdipGetCompositingQuality (nativeObject, out quality);
1737                                 GDIPlus.CheckStatus (status);
1738                                 return quality;
1739                         }
1740                         set {
1741                                 Status status = GDIPlus.GdipSetCompositingQuality (nativeObject, value);
1742                                 GDIPlus.CheckStatus (status);
1743                         }
1744                 }
1745
1746                 public float DpiX {
1747                         get {
1748                                 float x;
1749
1750                                 Status status = GDIPlus.GdipGetDpiX (nativeObject, out x);
1751                                 GDIPlus.CheckStatus (status);
1752                                 return x;
1753                         }
1754                 }
1755
1756                 public float DpiY {
1757                         get {
1758                                 float y;
1759
1760                                 Status status = GDIPlus.GdipGetDpiY (nativeObject, out y);
1761                                 GDIPlus.CheckStatus (status);
1762                                 return y;
1763                         }
1764                 }
1765
1766                 public InterpolationMode InterpolationMode {
1767                         get {
1768                                 InterpolationMode imode = InterpolationMode.Invalid;
1769                                 Status status = GDIPlus.GdipGetInterpolationMode (nativeObject, out imode);
1770                                 GDIPlus.CheckStatus (status);
1771                                 return imode;
1772                         }
1773                         set {
1774                                 Status status = GDIPlus.GdipSetInterpolationMode (nativeObject, value);
1775                                 GDIPlus.CheckStatus (status);
1776                         }
1777                 }
1778
1779                 public bool IsClipEmpty {
1780                         get {
1781                                 bool isEmpty = false;
1782
1783                                 Status status = GDIPlus.GdipIsClipEmpty (nativeObject, out isEmpty);
1784                                 GDIPlus.CheckStatus (status);
1785                                 return isEmpty;
1786                         }
1787                 }
1788
1789                 public bool IsVisibleClipEmpty {
1790                         get {
1791                                 bool isEmpty = false;
1792
1793                                 Status status = GDIPlus.GdipIsVisibleClipEmpty (nativeObject, out isEmpty);
1794                                 GDIPlus.CheckStatus (status);
1795                                 return isEmpty;
1796                         }
1797                 }
1798
1799                 public float PageScale {
1800                         get {
1801                                 float scale;
1802
1803                                 Status status = GDIPlus.GdipGetPageScale (nativeObject, out scale);
1804                                 GDIPlus.CheckStatus (status);
1805                                 return scale;
1806                         }
1807                         set {
1808                                 Status status = GDIPlus.GdipSetPageScale (nativeObject, value);
1809                                 GDIPlus.CheckStatus (status);
1810                         }
1811                 }
1812
1813                 public GraphicsUnit PageUnit {
1814                         get {
1815                                 GraphicsUnit unit;
1816
1817                                 Status status = GDIPlus.GdipGetPageUnit (nativeObject, out unit);
1818                                 GDIPlus.CheckStatus (status);
1819                                 return unit;
1820                         }
1821                         set {
1822                                 Status status = GDIPlus.GdipSetPageUnit (nativeObject, value);
1823                                 GDIPlus.CheckStatus (status);
1824                         }
1825                 }
1826
1827                 public PixelOffsetMode PixelOffsetMode {
1828                         get {
1829                                 PixelOffsetMode pixelOffset = PixelOffsetMode.Invalid;
1830
1831                                 Status status = GDIPlus.GdipGetPixelOffsetMode (nativeObject, out pixelOffset);
1832                                 GDIPlus.CheckStatus (status);
1833                                 return pixelOffset;
1834                         }
1835                         set {
1836                                 Status status = GDIPlus.GdipSetPixelOffsetMode (nativeObject, value);
1837                                 GDIPlus.CheckStatus (status);
1838                         }
1839                 }
1840
1841                 public Point RenderingOrigin {
1842                         get {
1843                                 int x, y;
1844                                 Status status = GDIPlus.GdipGetRenderingOrigin (nativeObject, out x, out y);
1845                                 GDIPlus.CheckStatus (status);
1846                                 return new Point (x, y);
1847                         }
1848
1849                         set {
1850                                 Status status = GDIPlus.GdipSetRenderingOrigin (nativeObject, value.X, value.Y);
1851                                 GDIPlus.CheckStatus (status);
1852                         }
1853                 }
1854
1855                 public SmoothingMode SmoothingMode {
1856                         get {
1857                                 SmoothingMode mode = SmoothingMode.Invalid;
1858
1859                                 Status status = GDIPlus.GdipGetSmoothingMode (nativeObject, out mode);
1860                                 GDIPlus.CheckStatus (status);
1861                                 return mode;
1862                         }
1863
1864                         set {
1865                                 Status status = GDIPlus.GdipSetSmoothingMode (nativeObject, value);
1866                                 GDIPlus.CheckStatus (status);
1867                         }
1868                 }
1869
1870                 public int TextContrast {
1871                         get {
1872                                 int contrast;
1873
1874                                 Status status = GDIPlus.GdipGetTextContrast (nativeObject, out contrast);
1875                                 GDIPlus.CheckStatus (status);
1876                                 return contrast;
1877                         }
1878
1879                         set {
1880                                 Status status = GDIPlus.GdipSetTextContrast (nativeObject, value);
1881                                 GDIPlus.CheckStatus (status);
1882                         }
1883                 }
1884
1885                 public TextRenderingHint TextRenderingHint {
1886                         get {
1887                                 TextRenderingHint hint;
1888
1889                                 Status status = GDIPlus.GdipGetTextRenderingHint (nativeObject, out hint);
1890                                 GDIPlus.CheckStatus (status);
1891                                 return hint;
1892                         }
1893
1894                         set {
1895                                 Status status = GDIPlus.GdipSetTextRenderingHint (nativeObject, value);
1896                                 GDIPlus.CheckStatus (status);
1897                         }
1898                 }
1899
1900                 public Matrix Transform {
1901                         get {
1902                                 Matrix matrix = new Matrix ();
1903                                 Status status = GDIPlus.GdipGetWorldTransform (nativeObject, matrix.nativeMatrix);
1904                                 GDIPlus.CheckStatus (status);
1905                                 return matrix;
1906                         }
1907                         set {
1908                                 Status status = GDIPlus.GdipSetWorldTransform (nativeObject, value.nativeMatrix);
1909                                 GDIPlus.CheckStatus (status);
1910                         }
1911                 }
1912
1913                 public RectangleF VisibleClipBounds {
1914                         get {
1915                                 RectangleF rect;
1916
1917                                 Status status = GDIPlus.GdipGetVisibleClipBounds (nativeObject, out rect);
1918                                 GDIPlus.CheckStatus (status);
1919                                 return rect;
1920                         }
1921                 }
1922         }
1923 }
1924