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