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