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 //
  10 using System;
  11 using System.Drawing.Drawing2D;
  12 using System.Drawing.Imaging;
  13 using System.Drawing.Text;
  14 using System.Runtime.InteropServices;
  15
  16 namespace System.Drawing
  17 {
  18         [ComVisible(false)]
  19         public sealed class Graphics : MarshalByRefObject, IDisposable
  20         {
  21                 internal IntPtr nativeObject = IntPtr.Zero;
  22
  23                 public delegate bool EnumerateMetafileProc (EmfPlusRecordType recordType,
  24                                                             int flags,
  25                                                             int dataSize,
  26                                                             IntPtr data,
  27                                                             PlayRecordCallback callbackData);
  28
  29                 public delegate bool DrawImageAbort (IntPtr callbackData);
  30
  31                 private Graphics (IntPtr nativeGraphics)
  32                 {
  33                         nativeObject = nativeGraphics;
  34                 }
  35
  36                 [MonoTODO]
  37                 public void AddMetafileComment (byte [] data)
  38                 {
  39                         throw new NotImplementedException ();
  40                 }
  41
  42                 [MonoTODO]
  43                 public GraphicsContainer BeginContainer ()
  44                 {
  45                         throw new NotImplementedException ();
  46                 }
  47
  48                 [MonoTODO]
  49                 public GraphicsContainer BeginContainer (Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit)
  50                 {
  51                         throw new NotImplementedException ();
  52                 }
  53
  54                 [MonoTODO]
  55                 public GraphicsContainer BeginContainer (RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit)
  56                 {
  57                         throw new NotImplementedException ();
  58                 }
  59
  60
  61                 public void Clear (Color color)
  62                 {
  63                         Status status = GDIPlus.GdipGraphicsClear(nativeObject, color.ToArgb());
  64
  65                         if (status != Status.Ok)
  66                                 throw new Exception ("Error calling GDIPlus.GdipGraphicsClear:" +status);
  67                 }
  68
  69                 [MonoTODO]
  70                 public void Dispose ()
  71                 {
  72                 }
  73
  74                 [MonoTODO]
  75                 public void DrawArc (Pen pen, Rectangle rect, float startAngle, float sweepAngle)
  76                 {
  77                         DrawArc (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
  78                 }
  79
  80                 [MonoTODO]
  81                 public void DrawArc (Pen pen, RectangleF rect, float startAngle, float sweepAngle)
  82                 {
  83                         DrawArc (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
  84                 }
  85
  86                 [MonoTODO]
  87                 public void DrawArc (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
  88                 {
  89                         GDIPlus.GdipDrawArc (nativeObject, pen.nativeObject,
  90                                         x, y, width, height, startAngle, sweepAngle);
  91                 }
  92
  93                 public void DrawArc (Pen pen, int x, int y, int width, int height, float startAngle, float sweepAngle)
  94                 {
  95                         GDIPlus.GdipDrawArcI (nativeObject, pen.nativeObject,
  96                                         x, y, width, height, startAngle, sweepAngle);
  97                 }
  98
  99                 public void DrawBezier (Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4)
 100                 {
 101                         GDIPlus.GdipDrawBezier (nativeObject, pen.nativeObject,
 102                                         pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
 103                 }
 104
 105                 public void DrawBezier (Pen pen, Point pt1, Point pt2, Point pt3, Point pt4)
 106                 {
 107                         GDIPlus.GdipDrawBezierI (nativeObject, pen.nativeObject,
 108                                         pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
 109                 }
 110
 111                 public void DrawBezier (Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4)
 112                 {
 113                         GDIPlus.GdipDrawBezier (nativeObject, pen.nativeObject, x1, y1, x2, y2, x3, y3, x4, y4);
 114                 }
 115
 116                 [MonoTODO]
 117                 public void DrawBeziers (Pen pen, Point [] points)
 118                 {
 119                         int length = points.Length;
 120
 121                         if (length < 3)
 122                                 return;
 123
 124                         for (int i = 0; i < length; i += 3) {
 125                                 Point p1 = points [i];
 126                                 Point p2 = points [i + 1];
 127                                 Point p3 = points [i + 2];
 128                                 Point p4 = points [i + 3];
 129
 130                                 GDIPlus.GdipDrawBezier (nativeObject, pen.nativeObject,
 131                                                         p1.X, p1.Y, p2.X, p2.Y,
 132                                                         p3.X, p3.Y, p4.X, p4.Y);
 133                         }
 134                 }
 135
 136                 [MonoTODO]
 137                 public void DrawBeziers (Pen pen, PointF [] points)
 138                 {
 139                         int length = points.Length;
 140
 141                         if (length < 3)
 142                                 return;
 143
 144                         for (int i = 0; i < length; i += 3) {
 145                                 PointF p1 = points [i];
 146                                 PointF p2 = points [i + 1];
 147                                 PointF p3 = points [i + 2];
 148                                 PointF p4 = points [i + 3];
 149
 150                                 GDIPlus.GdipDrawBezier (nativeObject, pen.nativeObject,
 151                                                         p1.X, p1.Y, p2.X, p2.Y,
 152                                                         p3.X, p3.Y, p4.X, p4.Y);
 153                         }
 154                 }
 155
 156                 [MonoTODO]
 157                 public void DrawClosedCurve (Pen pen, PointF [] points)
 158                 {
 159                         throw new NotImplementedException ();
 160                 }
 161
 162                 [MonoTODO]
 163                 public void DrawClosedCurve (Pen pen, Point [] points)
 164                 {
 165                         throw new NotImplementedException ();
 166                 }
 167
 168                 [MonoTODO]
 169                 public void DrawClosedCurve (Pen pen, Point [] points, float tension, FillMode fillmode)
 170                 {
 171                         throw new NotImplementedException ();
 172                 }
 173
 174                 [MonoTODO]
 175                 public void DrawClosedCurve (Pen pen, PointF [] points, float tension, FillMode fillmode)
 176                 {
 177                         throw new NotImplementedException ();
 178                 }
 179
 180                 [MonoTODO]
 181                 public void DrawCurve (Pen pen, Point [] points)
 182                 {
 183                         throw new NotImplementedException ();
 184                 }
 185
 186                 [MonoTODO]
 187                 public void DrawCurve (Pen pen, PointF [] points)
 188                 {
 189                         throw new NotImplementedException ();
 190                 }
 191
 192                 [MonoTODO]
 193                 public void DrawCurve (Pen pen, PointF [] points, float tension)
 194                 {
 195                         throw new NotImplementedException ();
 196                 }
 197
 198                 [MonoTODO]
 199                 public void DrawCurve (Pen pen, Point [] points, float tension)
 200                 {
 201                         throw new NotImplementedException ();
 202                 }
 203
 204                 [MonoTODO]
 205                 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments)
 206                 {
 207                         throw new NotImplementedException ();
 208                 }
 209
 210                 [MonoTODO]
 211                 public void DrawCurve (Pen pen, Point [] points, int offset, int numberOfSegments, float tension)
 212                 {
 213                         throw new NotImplementedException ();
 214                 }
 215
 216                 [MonoTODO]
 217                 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments, float tension)
 218                 {
 219                         throw new NotImplementedException ();
 220                 }
 221
 222                 public void DrawEllipse (Pen pen, Rectangle rect)
 223                 {
 224                         DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);
 225                 }
 226
 227                 public void DrawEllipse (Pen pen, RectangleF rect)
 228                 {
 229                         DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);
 230                 }
 231
 232                 public void DrawEllipse (Pen pen, int x, int y, int width, int height)
 233                 {
 234                         GDIPlus.GdipDrawEllipseI (nativeObject, pen.nativeObject, x, y, width, height);
 235                 }
 236
 237                 public void DrawEllipse (Pen pen, float x, float y, float width, float height)
 238                 {
 239                         GDIPlus.GdipDrawEllipse (nativeObject, pen.nativeObject, x, y, width, height);
 240                 }
 241
 242                 [MonoTODO]
 243                 public void DrawIcon (Icon icon, Rectangle targetRect)
 244                 {
 245                         throw new NotImplementedException ();
 246                 }
 247
 248                 [MonoTODO]
 249                 public void DrawIcon (Icon icon, int x, int y)
 250                 {
 251                         throw new NotImplementedException ();
 252                 }
 253
 254                 [MonoTODO]
 255                 public void DrawIconUnstretched (Icon icon, Rectangle targetRect)
 256                 {
 257                         throw new NotImplementedException ();
 258                 }
 259
 260                 [MonoTODO]
 261                 public void DrawImage (Image image, RectangleF rect)
 262                 {
 263                         throw new NotImplementedException ();
 264                 }
 265
 266
 267                 public void DrawImage (Image image, PointF point)
 268                 {
 269                         Status status = GDIPlus.GdipDrawImage(nativeObject, image.NativeObject, point.X, point.Y);
 270
 271                         if (status != Status.Ok)
 272                                 throw new Exception ("Error calling GDIPlus.DrawImage (Image image, PointF point):" +status);
 273                 }
 274
 275                 [MonoTODO]
 276                 public void DrawImage (Image image, Point [] destPoints)
 277                 {
 278                         throw new NotImplementedException ();
 279                 }
 280
 281                 [MonoTODO]
 282                 public void DrawImage (Image image, Point point)
 283                 {
 284                         throw new NotImplementedException ();
 285                 }
 286
 287                 [MonoTODO]
 288                 public void DrawImage (Image image, Rectangle rect)
 289                 {
 290                         throw new NotImplementedException ();
 291                 }
 292
 293                 [MonoTODO]
 294                 public void DrawImage (Image image, PointF [] destPoints)
 295                 {
 296                         throw new NotImplementedException ();
 297                 }
 298
 299                 [MonoTODO]
 300                 public void DrawImage (Image image, int x, int y)
 301                 {
 302                         throw new NotImplementedException ();
 303                 }
 304
 305                 [MonoTODO]
 306                 public void DrawImage (Image image, float x, float y)
 307                 {
 308                         throw new NotImplementedException ();
 309                 }
 310
 311                 [MonoTODO]
 312                 public void DrawImage (Image image, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit)
 313                 {
 314                         throw new NotImplementedException ();
 315                 }
 316
 317                 [MonoTODO]
 318                 public void DrawImage (Image image, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit)
 319                 {
 320                         throw new NotImplementedException ();
 321                 }
 322
 323                 [MonoTODO]
 324                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit)
 325                 {
 326                         throw new NotImplementedException ();
 327                 }
 328
 329                 [MonoTODO]
 330                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit)
 331                 {
 332                         throw new NotImplementedException ();
 333                 }
 334
 335                 [MonoTODO]
 336                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr)
 337                 {
 338                         throw new NotImplementedException ();
 339                 }
 340
 341                 [MonoTODO]
 342                 public void DrawImage (Image image, float x, float y, float width, float height)
 343                 {
 344                         throw new NotImplementedException ();
 345                 }
 346
 347                 [MonoTODO]
 348                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr)
 349                 {
 350                         throw new NotImplementedException ();
 351                 }
 352
 353                 [MonoTODO]
 354                 public void DrawImage (Image image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit)
 355                 {
 356                         throw new NotImplementedException ();
 357                 }
 358
 359                 [MonoTODO]
 360                 public void DrawImage (Image image, int x, int y, int width, int height)
 361                 {
 362                         GDIPlus.GdipDrawImageRectI (nativeObject, image.nativeObject, x, y, width, height);
 363                 }
 364
 365                 [MonoTODO]
 366                 public void DrawImage (Image image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit)
 367                 {
 368                         throw new NotImplementedException ();
 369                 }
 370
 371                 [MonoTODO]
 372                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
 373                 {
 374                         throw new NotImplementedException ();
 375                 }
 376
 377                 [MonoTODO]
 378                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
 379                 {
 380                         throw new NotImplementedException ();
 381                 }
 382
 383                 [MonoTODO]
 384                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)
 385                 {
 386                         throw new NotImplementedException ();
 387                 }
 388
 389                 [MonoTODO]
 390                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit)
 391                 {
 392                         throw new NotImplementedException ();
 393                 }
 394
 395                 [MonoTODO]
 396                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)
 397                 {
 398                         throw new NotImplementedException ();
 399                 }
 400
 401                 [MonoTODO]
 402                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit)
 403                 {
 404                         throw new NotImplementedException ();
 405                 }
 406
 407                 [MonoTODO]
 408                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs)
 409                 {
 410                         throw new NotImplementedException ();
 411                 }
 412
 413                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr)
 414                 {
 415                         Status status =  GDIPlus.GdipDrawImageRectRectI(nativeObject, image.NativeObject, //aki
 416                                                                 destRect.X, destRect.Y, destRect.Width, destRect.Height,
 417                                                                 srcX, srcY, srcWidth, srcHeight,
 418                                                                 srcUnit, imageAttr.NativeObject, IntPtr.Zero, 0);
 419
 420                         if (status != Status.Ok)
 421                                 throw new Exception ("Error calling GDIPlus.DrawImage(Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr)" +status);
 422                 }
 423
 424                 [MonoTODO]
 425                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
 426                 {
 427                         throw new NotImplementedException ();
 428                 }
 429
 430                 [MonoTODO]
 431                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs, DrawImageAbort callback)
 432                 {
 433                         throw new NotImplementedException ();
 434                 }
 435
 436                 [MonoTODO]
 437                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs, DrawImageAbort callback, IntPtr callbackData)
 438                 {
 439                         throw new NotImplementedException ();
 440                 }
 441
 442                 [MonoTODO]
 443                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs, DrawImageAbort callback, IntPtr callbackData)
 444                 {
 445                         throw new NotImplementedException ();
 446                 }
 447
 448                 [MonoTODO]
 449                 public void DrawImageUnscaled (Image image, Point point)
 450                 {
 451                         throw new NotImplementedException ();
 452                 }
 453
 454                 [MonoTODO]
 455                 public void DrawImageUnscaled (Image image, Rectangle rect)
 456                 {
 457                         throw new NotImplementedException ();
 458                 }
 459
 460                 [MonoTODO]
 461                 public void DrawImageUnscaled (Image image, int x, int y)
 462                 {
 463                         throw new NotImplementedException ();
 464                 }
 465
 466                 [MonoTODO]
 467                 public void DrawImageUnscaled (Image image, int x, int y, int width, int height)
 468                 {
 469                         throw new NotImplementedException ();
 470                 }
 471
 472                 public void DrawLine (Pen pen, PointF pt1, PointF pt2)
 473                 {
 474                         GDIPlus.GdipDrawLine (
 475                                 nativeObject, pen.nativeObject,
 476                                 pt1.X, pt1.Y,
 477                                 pt2.X, pt2.Y);
 478                 }
 479
 480                 public void DrawLine (Pen pen, Point pt1, Point pt2)
 481                 {
 482                         GDIPlus.GdipDrawLine (
 483                                 nativeObject, pen.nativeObject,
 484                                 pt1.X, pt1.Y,
 485                                 pt2.X, pt2.Y);
 486                 }
 487
 488                 public void DrawLine (Pen pen, int x1, int y1, int x2, int y2)
 489                 {
 490                         GDIPlus.GdipDrawLineI (nativeObject, pen.nativeObject, x1, y1, x2, y2);
 491                 }
 492
 493                 public void DrawLine (Pen pen, float x1, float y1, float x2, float y2)
 494                 {
 495                         GDIPlus.GdipDrawLine (nativeObject, pen.nativeObject, x1, y1, x2, y2);
 496                 }
 497
 498                 public void DrawLines (Pen pen, PointF [] points)
 499                 {
 500                         GDIPlus.GdipDrawLines (nativeObject, pen.nativeObject, points, points.Length);
 501                 }
 502
 503                 public void DrawLines (Pen pen, Point [] points)
 504                 {
 505                         GDIPlus.GdipDrawLinesI (nativeObject, pen.nativeObject, points, points.Length);
 506                 }
 507
 508                 [MonoTODO]
 509                 public void DrawPath (Pen pen, GraphicsPath path)
 510                 {
 511                         throw new NotImplementedException ();
 512                 }
 513
 514                 [MonoTODO]
 515                 public void DrawPie (Pen pen, Rectangle rect, float startAngle, float sweepAngle)
 516                 {
 517                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
 518                 }
 519
 520                 [MonoTODO]
 521                 public void DrawPie (Pen pen, RectangleF rect, float startAngle, float sweepAngle)
 522                 {
 523                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
 524                 }
 525
 526                 [MonoTODO]
 527                 public void DrawPie (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle)
 528                 {
 529                         GDIPlus.GdipDrawPie (nativeObject, pen.nativeObject, x, y, width, height, startAngle, sweepAngle);
 530                 }
 531
 532                 [MonoTODO]
 533                 public void DrawPie (Pen pen, int x, int y, int width, int height, float startAngle, float sweepAngle)
 534                 {
 535                         GDIPlus.GdipDrawPieI (nativeObject, pen.nativeObject, x, y, width, height, startAngle, sweepAngle);
 536                 }
 537
 538                 public void DrawPolygon (Pen pen, Point [] points)
 539                 {
 540                         GDIPlus.GdipDrawPolygonI (nativeObject, pen.nativeObject, points, points.Length);
 541                 }
 542
 543                 public void DrawPolygon (Pen pen, PointF [] points)
 544                 {
 545                         GDIPlus.GdipDrawPolygon (nativeObject, pen.nativeObject, points, points.Length);
 546                 }
 547
 548                 public void DrawRectangle (Pen pen, RectangleF rect)
 549                 {
 550                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);
 551                 }
 552
 553                 public void DrawRectangle (Pen pen, Rectangle rect)
 554                 {
 555                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);
 556                 }
 557
 558                 public void DrawRectangle (Pen pen, float x, float y, float width, float height)
 559                 {
 560                         GDIPlus.GdipDrawRectangle (nativeObject, pen.nativeObject, x, y, width, height);
 561                 }
 562
 563                 public void DrawRectangle (Pen pen, int x, int y, int width, int height)
 564                 {
 565                         GDIPlus.GdipDrawRectangleI (nativeObject, pen.nativeObject, x, y, width, height);
 566                 }
 567
 568                 public void DrawRectangles (Pen pen, RectangleF [] rects)
 569                 {
 570                         foreach (RectangleF rc in rects)
 571                                 DrawRectangle (pen, rc.Left, rc.Top, rc.Width, rc.Height);
 572                 }
 573
 574                 public void DrawRectangles (Pen pen, Rectangle [] rects)
 575                 {
 576                         foreach (RectangleF rc in rects)
 577                                 DrawRectangle(pen, rc.Left, rc.Top, rc.Width, rc.Height);
 578                 }
 579
 580                 [MonoTODO("Ignores the font")]
 581                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle)
 582                 {
 583                         GDIPlus.GdipDrawString (nativeObject, s, s.Length, IntPtr.Zero, ref layoutRectangle, IntPtr.Zero, brush.nativeObject);
 584                 }
 585
 586                 [MonoTODO("This ignores the font")]
 587                 public void DrawString (string s, Font font, Brush brush, PointF point)
 588                 {
 589                         RectangleF rc = new RectangleF (point.X, point.Y, 0, 0);
 590                         GDIPlus.GdipDrawString (nativeObject, s, s.Length, IntPtr.Zero, ref rc, IntPtr.Zero, brush.nativeObject);
 591                 }
 592
 593                 [MonoTODO ("This ignores the font and format")]
 594                 public void DrawString (string s, Font font, Brush brush, PointF point, StringFormat format)
 595                 {
 596                         RectangleF rc = new RectangleF (point.X, point.Y, 0, 0);
 597                         GDIPlus.GdipDrawString (nativeObject, s, s.Length, IntPtr.Zero, ref rc, IntPtr.Zero, brush.nativeObject);
 598                 }
 599
 600                 [MonoTODO ("This ignores the font and the format")]
 601                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format)
 602                 {
 603                         GDIPlus.GdipDrawString (nativeObject, s, s.Length, IntPtr.Zero, ref layoutRectangle, IntPtr.Zero, brush.nativeObject);
 604                 }
 605
 606                 [MonoTODO("This ignores the font")]
 607                 public void DrawString (string s, Font font, Brush brush, float x, float y)
 608                 {
 609                         Console.WriteLine("DrawString!");
 610                         RectangleF rc = new RectangleF (x, y, 0, 0);
 611
 612                         Status status = GDIPlus.GdipDrawString (nativeObject, s, s.Length, IntPtr.Zero,
 613                                 ref rc, IntPtr.Zero, brush.nativeObject);
 614
 615                         if (status != Status.Ok)
 616                                 throw new Exception ("Error calling GDIPlus.GdipDrawString(string s, Font font, Brush brush, float x, float y):" +s);
 617                 }
 618
 619                 [MonoTODO]
 620                 public void DrawString (string s, Font font, Brush brush, float x, float y, StringFormat format)
 621                 {
 622                         //throw new NotImplementedException ();
 623                 }
 624
 625                 [MonoTODO]
 626                 public void EndContainer (GraphicsContainer container)
 627                 {
 628                         throw new NotImplementedException ();
 629                 }
 630
 631                 [MonoTODO]
 632                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback)
 633                 {
 634                         throw new NotImplementedException ();
 635                 }
 636
 637                 [MonoTODO]
 638                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback)
 639                 {
 640                         throw new NotImplementedException ();
 641                 }
 642
 643                 [MonoTODO]
 644                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback)
 645                 {
 646                         throw new NotImplementedException ();
 647                 }
 648
 649                 [MonoTODO]
 650                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback)
 651                 {
 652                         throw new NotImplementedException ();
 653                 }
 654
 655                 [MonoTODO]
 656                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback)
 657                 {
 658                         throw new NotImplementedException ();
 659                 }
 660
 661                 [MonoTODO]
 662                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback)
 663                 {
 664                         throw new NotImplementedException ();
 665                 }
 666
 667                 [MonoTODO]
 668                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData)
 669                 {
 670                         throw new NotImplementedException ();
 671                 }
 672
 673                 [MonoTODO]
 674                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData)
 675                 {
 676                         throw new NotImplementedException ();
 677                 }
 678
 679                 [MonoTODO]
 680                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)
 681                 {
 682                         throw new NotImplementedException ();
 683                 }
 684
 685                 [MonoTODO]
 686                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData)
 687                 {
 688                         throw new NotImplementedException ();
 689                 }
 690
 691                 [MonoTODO]
 692                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)
 693                 {
 694                         throw new NotImplementedException ();
 695                 }
 696
 697                 [MonoTODO]
 698                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData)
 699                 {
 700                         throw new NotImplementedException ();
 701                 }
 702
 703                 [MonoTODO]
 704                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 705                 {
 706                         throw new NotImplementedException ();
 707                 }
 708
 709                 [MonoTODO]
 710                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 711                 {
 712                         throw new NotImplementedException ();
 713                 }
 714
 715                 [MonoTODO]
 716                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 717                 {
 718                         throw new NotImplementedException ();
 719                 }
 720
 721                 [MonoTODO]
 722                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 723                 {
 724                         throw new NotImplementedException ();
 725                 }
 726
 727                 [MonoTODO]
 728                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 729                 {
 730                         throw new NotImplementedException ();
 731                 }
 732
 733                 [MonoTODO]
 734                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
 735                 {
 736                         throw new NotImplementedException ();
 737                 }
 738
 739                 [MonoTODO]
 740                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 741                 {
 742                         throw new NotImplementedException ();
 743                 }
 744
 745                 [MonoTODO]
 746                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 747                 {
 748                         throw new NotImplementedException ();
 749                 }
 750
 751                 [MonoTODO]
 752                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 753                 {
 754                         throw new NotImplementedException ();
 755                 }
 756
 757                 [MonoTODO]
 758                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 759                 {
 760                         throw new NotImplementedException ();
 761                 }
 762
 763                 [MonoTODO]
 764                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 765                 {
 766                         throw new NotImplementedException ();
 767                 }
 768
 769                 [MonoTODO]
 770                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 771                 {
 772                         throw new NotImplementedException ();
 773                 }
 774
 775                 [MonoTODO]
 776                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
 777                 {
 778                         throw new NotImplementedException ();
 779                 }
 780
 781                 [MonoTODO]
 782                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
 783                 {
 784                         throw new NotImplementedException ();
 785                 }
 786
 787                 [MonoTODO]
 788                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
 789                 {
 790                         throw new NotImplementedException ();
 791                 }
 792
 793                 [MonoTODO]
 794                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
 795                 {
 796                         throw new NotImplementedException ();
 797                 }
 798
 799                 [MonoTODO]
 800                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
 801                 {
 802                         throw new NotImplementedException ();
 803                 }
 804
 805                 [MonoTODO]
 806                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
 807                 {
 808                         throw new NotImplementedException ();
 809                 }
 810
 811                 [MonoTODO]
 812                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 813                 {
 814                         throw new NotImplementedException ();
 815                 }
 816
 817                 [MonoTODO]
 818                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 819                 {
 820                         throw new NotImplementedException ();
 821                 }
 822
 823                 [MonoTODO]
 824                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 825                 {
 826                         throw new NotImplementedException ();
 827                 }
 828
 829                 [MonoTODO]
 830                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 831                 {
 832                         throw new NotImplementedException ();
 833                 }
 834
 835                 [MonoTODO]
 836                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 837                 {
 838                         throw new NotImplementedException ();
 839                 }
 840
 841                 [MonoTODO]
 842                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
 843                 {
 844                         throw new NotImplementedException ();
 845                 }
 846
 847                 [MonoTODO]
 848                 public void ExcludeClip (Rectangle rect)
 849                 {
 850                         throw new NotImplementedException ();
 851                 }
 852
 853                 [MonoTODO]
 854                 public void ExcludeClip (Region region)
 855                 {
 856                         throw new NotImplementedException ();
 857                 }
 858
 859                 [MonoTODO]
 860                 public void FillClosedCurve (Brush brush, PointF [] points)
 861                 {
 862                         throw new NotImplementedException ();
 863                 }
 864
 865                 [MonoTODO]
 866                 public void FillClosedCurve (Brush brush, Point [] points)
 867                 {
 868                         throw new NotImplementedException ();
 869                 }
 870
 871                 [MonoTODO]
 872                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode)
 873                 {
 874                         throw new NotImplementedException ();
 875                 }
 876
 877                 [MonoTODO]
 878                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode)
 879                 {
 880                         throw new NotImplementedException ();
 881                 }
 882
 883                 [MonoTODO]
 884                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode, float tension)
 885                 {
 886                         throw new NotImplementedException ();
 887                 }
 888
 889                 [MonoTODO]
 890                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode, float tension)
 891                 {
 892                         throw new NotImplementedException ();
 893                 }
 894
 895                 public void FillEllipse (Brush brush, Rectangle rect)
 896                 {
 897                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);
 898                 }
 899
 900                 public void FillEllipse (Brush brush, RectangleF rect)
 901                 {
 902                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);
 903                 }
 904
 905                 public void FillEllipse (Brush brush, float x, float y, float width, float height)
 906                 {
 907                         GDIPlus.GdipFillEllipse (nativeObject, brush.nativeObject, x, y, width, height);
 908                 }
 909
 910                 public void FillEllipse (Brush brush, int x, int y, int width, int height)
 911                 {
 912                         GDIPlus.GdipFillEllipseI (nativeObject, brush.nativeObject, x, y, width, height);
 913                 }
 914
 915                 [MonoTODO]
 916                 public void FillPath (Brush brush, GraphicsPath path)
 917                 {
 918                         throw new NotImplementedException ();
 919                 }
 920
 921                 [MonoTODO]
 922                 public void FillPie (Brush brush, Rectangle rect, float startAngle, float sweepAngle)
 923                 {
 924                         throw new NotImplementedException ();
 925                 }
 926
 927                 [MonoTODO]
 928                 public void FillPie (Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle)
 929                 {
 930                         throw new NotImplementedException ();
 931                 }
 932
 933                 [MonoTODO]
 934                 public void FillPie (Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle)
 935                 {
 936                         throw new NotImplementedException ();
 937                 }
 938
 939                 public void FillPolygon (Brush brush, PointF [] points)
 940                 {
 941                         GDIPlus.GdipFillPolygon2 (nativeObject, brush.nativeObject, points, points.Length);
 942                 }
 943
 944                 public void FillPolygon (Brush brush, Point [] points)
 945                 {
 946                         GDIPlus.GdipFillPolygon2I (nativeObject, brush.nativeObject, points, points.Length);
 947                 }
 948
 949                 public void FillPolygon (Brush brush, Point [] points, FillMode fillMode)
 950                 {
 951                         GDIPlus.GdipFillPolygonI (nativeObject, brush.nativeObject, points, points.Length, fillMode);
 952                 }
 953
 954                 public void FillPolygon (Brush brush, PointF [] points, FillMode fillMode)
 955                 {
 956                         GDIPlus.GdipFillPolygon (nativeObject, brush.nativeObject, points, points.Length, fillMode);
 957                 }
 958
 959                 public void FillRectangle (Brush brush, RectangleF rect)
 960                 {
 961                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);
 962                 }
 963
 964                 public void FillRectangle (Brush brush, Rectangle rect)
 965                 {
 966                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);
 967                 }
 968
 969                 public void FillRectangle (Brush brush, int x, int y, int width, int height)
 970                 {
 971                         GDIPlus.GdipFillRectangle (nativeObject, brush.nativeObject, (float)x, (float)y, (float)width, (float)height);
 972                 }
 973
 974                 public void FillRectangle (Brush brush, float x, float y, float width, float height)
 975                 {
 976                         GDIPlus.GdipFillRectangle (nativeObject, brush.nativeObject, x, y, width, height);
 977                 }
 978
 979                 public void FillRectangles (Brush brush, Rectangle [] rects)
 980                 {
 981                         foreach (Rectangle rc in rects)
 982                                 FillRectangle(brush, rc);
 983                 }
 984
 985                 public void FillRectangles (Brush brush, RectangleF [] rects)
 986                 {
 987                         foreach (RectangleF rc in rects)
 988                                 FillRectangle(brush, rc);
 989                 }
 990
 991                 [MonoTODO]
 992                 public void FillRegion (Brush brush, Region region)
 993                 {
 994                         throw new NotImplementedException ();
 995                 }
 996
 997                 [MonoTODO]
 998                 public void Flush ()
 999                 {
1000                         Flush(FlushIntention.Flush);
1001                 }
1002
1003                 [MonoTODO]
1004                 public void Flush (FlushIntention intention)
1005                 {
1006                         throw new NotImplementedException ();
1007                 }
1008
1009                 [MonoTODO]
1010                 public static Graphics FromHdc (IntPtr hdc)
1011                 {
1012                         int graphics;
1013                         GDIPlus.GdipCreateFromHDC (hdc, out graphics);
1014                         Graphics result = new Graphics ((IntPtr)graphics);
1015                         return result;
1016                 }
1017
1018                 [MonoTODO]
1019                 public static Graphics FromHdc (IntPtr hdc, IntPtr hdevice)
1020                 {
1021                         throw new NotImplementedException ();
1022                 }
1023
1024                 [MonoTODO]
1025                 public static Graphics FromHdcInternal (IntPtr hdc)
1026                 {
1027                         throw new NotImplementedException ();
1028                 }
1029
1030                 [MonoTODO]
1031                 public static Graphics FromHwnd (IntPtr hwnd)
1032                 {
1033                         Graphics result = new Graphics(IntPtr.Zero);
1034                         return result;
1035                 }
1036
1037                 [MonoTODO]
1038                 public static Graphics FromHwndInternal (IntPtr hwnd)
1039                 {
1040                         throw new NotImplementedException ();
1041                 }
1042
1043                 [MonoTODO]
1044                 public static Graphics FromImage (Image image)
1045                 {
1046                         if (image == null) throw new ArgumentException ();
1047                         int graphics;
1048                         GDIPlus.GdipGetImageGraphicsContext (image.nativeObject, out graphics);
1049                         Graphics result = new Graphics ((IntPtr)graphics);
1050                         return result;
1051                 }
1052
1053                 [MonoTODO]
1054                 public static IntPtr GetHalftonePalette ()
1055                 {
1056                         throw new NotImplementedException ();
1057                 }
1058
1059                 [MonoTODO]
1060                 public IntPtr GetHdc ()
1061                 {
1062                         int hdc;
1063                         GDIPlus.GdipGetDC (nativeObject, out hdc);
1064                         return (IntPtr)hdc;
1065                 }
1066
1067                 [MonoTODO]
1068                 public Color GetNearestColor (Color color)
1069                 {
1070                         throw new NotImplementedException ();
1071                 }
1072
1073                 [MonoTODO]
1074                 public void IntersectClip (Region region)
1075                 {
1076                         throw new NotImplementedException ();
1077                 }
1078
1079                 [MonoTODO]
1080                 public void IntersectClip (RectangleF rect)
1081                 {
1082                         throw new NotImplementedException ();
1083                 }
1084
1085                 [MonoTODO]
1086                 public void IntersectClip (Rectangle rect)
1087                 {
1088                         throw new NotImplementedException ();
1089                 }
1090
1091                 [MonoTODO]
1092                 public bool IsVisible (Point point)
1093                 {
1094                         throw new NotImplementedException ();
1095                 }
1096
1097                 [MonoTODO]
1098                 public bool IsVisible (RectangleF rect)
1099                 {
1100                         throw new NotImplementedException ();
1101                 }
1102
1103                 [MonoTODO]
1104                 public bool IsVisible (PointF point)
1105                 {
1106                         throw new NotImplementedException ();
1107                 }
1108
1109                 [MonoTODO]
1110                 public bool IsVisible (Rectangle rect)
1111                 {
1112                         throw new NotImplementedException ();
1113                 }
1114
1115                 [MonoTODO]
1116                 public bool IsVisible (float x, float y)
1117                 {
1118                         throw new NotImplementedException ();
1119                 }
1120
1121                 [MonoTODO]
1122                 public bool IsVisible (int x, int y)
1123                 {
1124                         throw new NotImplementedException ();
1125                 }
1126
1127                 [MonoTODO]
1128                 public bool IsVisible (float x, float y, float width, float height)
1129                 {
1130                         throw new NotImplementedException ();
1131                 }
1132
1133                 [MonoTODO]
1134                 public bool IsVisible (int x, int y, int width, int height)
1135                 {
1136                         throw new NotImplementedException ();
1137                 }
1138
1139                 [MonoTODO]
1140                 public Region [] MeasureCharacterRanges (string text, Font font, RectangleF layoutRect, StringFormat stringFormat)
1141                 {
1142                         throw new NotImplementedException ();
1143                 }
1144
1145                 [MonoTODO]
1146                 public SizeF MeasureString (string text, Font font)
1147                 {
1148                         throw new NotImplementedException ();
1149                 }
1150
1151                 [MonoTODO]
1152                 public SizeF MeasureString (string text, Font font, SizeF layoutArea)
1153                 {
1154                         throw new NotImplementedException ();
1155                 }
1156
1157                 [MonoTODO]
1158                 public SizeF MeasureString (string text, Font font, int width)
1159                 {
1160                         throw new NotImplementedException ();
1161                 }
1162
1163                 [MonoTODO]
1164                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat)
1165                 {
1166                         throw new NotImplementedException ();
1167                 }
1168
1169                 [MonoTODO]
1170                 public SizeF MeasureString (string text, Font font, int width, StringFormat format)
1171                 {
1172                         throw new NotImplementedException ();
1173                 }
1174
1175                 [MonoTODO]
1176                 public SizeF MeasureString (string text, Font font, PointF origin, StringFormat stringFormat)
1177                 {
1178                         throw new NotImplementedException ();
1179                 }
1180
1181                 [MonoTODO]
1182                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat, out int charactersFitted, out int linesFilled)
1183                 {
1184                         throw new NotImplementedException ();
1185                 }
1186
1187                 public void MultiplyTransform (Matrix matrix)
1188                 {
1189                         MultiplyTransform (matrix, MatrixOrder.Prepend);
1190                 }
1191
1192                 public void MultiplyTransform (Matrix matrix, MatrixOrder order)
1193                 {
1194                         GDIPlus.GdipMultiplyWorldTransform (nativeObject, matrix.nativeMatrix, order);
1195                 }
1196
1197                 [MonoTODO]
1198                 public void ReleaseHdc (IntPtr hdc)
1199                 {
1200                         GDIPlus.GdipReleaseDC (nativeObject, hdc);
1201                 }
1202
1203                 [MonoTODO]
1204                 public void ReleaseHdcInternal (IntPtr hdc)
1205                 {
1206                         throw new NotImplementedException ();
1207                 }
1208
1209                 [MonoTODO]
1210                 public void ResetClip ()
1211                 {
1212                         throw new NotImplementedException ();
1213                 }
1214
1215                 public void ResetTransform ()
1216                 {
1217                         GDIPlus.GdipResetWorldTransform (nativeObject);
1218                 }
1219
1220                 [MonoTODO]
1221                 public void Restore (GraphicsState gstate)
1222                 {
1223                         Transform = gstate.matrix.Clone();
1224                         GDIPlus.GdipRestoreGraphics (nativeObject, gstate.nativeState);
1225                 }
1226
1227                 [MonoTODO]
1228                 public void RotateTransform (float angle)
1229                 {
1230                         RotateTransform(angle, MatrixOrder.Prepend);
1231                 }
1232
1233                 [MonoTODO]
1234                 public void RotateTransform (float angle, MatrixOrder order)
1235                 {
1236                         //transform.Rotate(angle, order);
1237                         GDIPlus.GdipRotateWorldTransform (nativeObject, angle, order);
1238                 }
1239
1240                 [MonoTODO]
1241                 public GraphicsState Save ()
1242                 {
1243                         //return implementation.Save();
1244                         GraphicsState state = new GraphicsState();
1245                         state.matrix = Transform.Clone();
1246                         uint saveState;
1247                         GDIPlus.GdipSaveGraphics (nativeObject, out saveState);
1248                         state.nativeState = saveState;
1249                         return state;
1250                 }
1251
1252                 public void ScaleTransform (float sx, float sy)
1253                 {
1254                         ScaleTransform (sx, sy, MatrixOrder.Prepend);
1255                 }
1256
1257                 public void ScaleTransform (float sx, float sy, MatrixOrder order)
1258                 {
1259                         GDIPlus.GdipScaleWorldTransform (nativeObject, sx, sy, order);
1260                 }
1261
1262                 [MonoTODO]
1263                 public void SetClip (RectangleF rect)
1264                 {
1265                         throw new NotImplementedException ();
1266                 }
1267
1268                 [MonoTODO]
1269                 public void SetClip (GraphicsPath path)
1270                 {
1271                         throw new NotImplementedException ();
1272                 }
1273
1274                 [MonoTODO]
1275                 public void SetClip (Rectangle rect)
1276                 {
1277                         throw new NotImplementedException ();
1278                 }
1279
1280                 [MonoTODO]
1281                 public void SetClip (Graphics g)
1282                 {
1283                         throw new NotImplementedException ();
1284                 }
1285
1286                 [MonoTODO]
1287                 public void SetClip (Graphics g, CombineMode combineMode)
1288                 {
1289                         throw new NotImplementedException ();
1290                 }
1291
1292                 [MonoTODO]
1293                 public void SetClip (Rectangle rect, CombineMode combineMode)
1294                 {
1295                         throw new NotImplementedException ();
1296                 }
1297
1298                 [MonoTODO]
1299                 public void SetClip (RectangleF rect, CombineMode combineMode)
1300                 {
1301                         throw new NotImplementedException ();
1302                 }
1303
1304                 [MonoTODO]
1305                 public void SetClip (Region region, CombineMode combineMode)
1306                 {
1307                         throw new NotImplementedException ();
1308                 }
1309
1310                 [MonoTODO]
1311                 public void SetClip (GraphicsPath path, CombineMode combineMode)
1312                 {
1313                         throw new NotImplementedException ();
1314                 }
1315
1316                 [MonoTODO]
1317                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF [] pts)
1318                 {
1319                         throw new NotImplementedException ();
1320                 }
1321
1322                 [MonoTODO]
1323                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts)
1324                 {
1325                         throw new NotImplementedException ();
1326                 }
1327
1328                 [MonoTODO]
1329                 public void TranslateClip (int dx, int dy)
1330                 {
1331                         throw new NotImplementedException ();
1332                 }
1333
1334                 [MonoTODO]
1335                 public void TranslateClip (float dx, float dy)
1336                 {
1337                         throw new NotImplementedException ();
1338                 }
1339
1340                 public void TranslateTransform (float dx, float dy)
1341                 {
1342                         TranslateTransform (dx, dy, MatrixOrder.Prepend);
1343                 }
1344
1345                 [MonoTODO]
1346                 public void TranslateTransform (float dx, float dy, MatrixOrder order)
1347                 {
1348                         //transform.Translate(dx, dy, order);
1349                         GDIPlus.GdipTranslateWorldTransform (nativeObject, dx, dy, order);
1350                 }
1351
1352                 public Region Clip {
1353                         get {
1354                                 throw new NotImplementedException ();
1355                         }
1356                         set {
1357                                 //throw new NotImplementedException ();
1358                         }
1359                 }
1360
1361                 public RectangleF ClipBounds {
1362                         get {
1363                                 throw new NotImplementedException ();
1364                         }
1365                 }
1366
1367                 public CompositingMode CompositingMode {
1368                         get {
1369                                 throw new NotImplementedException ();
1370                         }
1371                         set {
1372                                 throw new NotImplementedException ();
1373                         }
1374
1375                 }
1376
1377                 public CompositingQuality CompositingQuality {
1378                         get {
1379                                 throw new NotImplementedException ();
1380                         }
1381                         set {
1382                                 throw new NotImplementedException ();
1383                         }
1384                 }
1385
1386                 public float DpiX {
1387                         get {
1388                                 throw new NotImplementedException ();
1389                         }
1390                 }
1391
1392                 public float DpiY {
1393                         get {
1394                                 throw new NotImplementedException ();
1395                         }
1396                 }
1397
1398                 public InterpolationMode InterpolationMode {
1399                         get {
1400                                 throw new NotImplementedException ();
1401                         }
1402                         set {
1403                                 throw new NotImplementedException ();
1404                         }
1405                 }
1406
1407                 public bool IsClipEmpty {
1408                         get {
1409                                 throw new NotImplementedException ();
1410                         }
1411                 }
1412
1413                 public bool IsVisibleClipEmpty {
1414                         get {
1415                                 throw new NotImplementedException ();
1416                         }
1417                 }
1418
1419                 public float PageScale {
1420                         get {
1421                                 throw new NotImplementedException ();
1422                         }
1423                         set {
1424                                 throw new NotImplementedException ();
1425                         }
1426                 }
1427
1428                 public GraphicsUnit PageUnit {
1429                         get {
1430                                 throw new NotImplementedException ();
1431                         }
1432                         set {
1433                                 throw new NotImplementedException ();
1434                         }
1435                 }
1436
1437                 public PixelOffsetMode PixelOffsetMode {
1438                         get {
1439                                 throw new NotImplementedException ();
1440                         }
1441                         set {
1442                                 throw new NotImplementedException ();
1443                         }
1444                 }
1445
1446                 public Point RenderingOrigin {
1447                         get {
1448                                 int x, y;
1449                                 GDIPlus.GdipGetRenderingOrigin (
1450                                         nativeObject, out x, out y);
1451
1452                                 return new Point (x, y);
1453                         }
1454
1455                         set {
1456                                 GDIPlus.GdipSetRenderingOrigin (nativeObject, value.X, value.Y);
1457                         }
1458                 }
1459
1460                 public SmoothingMode SmoothingMode {
1461                         get {
1462                                 throw new NotImplementedException ();
1463                         }
1464                         set {
1465                                 throw new NotImplementedException ();
1466                         }
1467                 }
1468
1469                 public int TextContrast {
1470                         get {
1471                                 throw new NotImplementedException ();
1472                         }
1473                         set {
1474                                 throw new NotImplementedException ();
1475                         }
1476                 }
1477
1478                 public TextRenderingHint TextRenderingHint {
1479                         get {
1480                                 throw new NotImplementedException ();
1481                         }
1482                         set {
1483                                 throw new NotImplementedException ();
1484                         }
1485                 }
1486
1487                 public Matrix Transform {
1488                         get {
1489                                 Matrix matrix = new Matrix ();
1490                                 GDIPlus.GdipGetWorldTransform (nativeObject, matrix.nativeMatrix);
1491
1492                                 return matrix;
1493                         }
1494                         set {
1495                                 GDIPlus.GdipSetWorldTransform (nativeObject, value.nativeMatrix);
1496                         }
1497                 }
1498
1499                 public RectangleF VisibleClipBounds {
1500                         get {
1501                                 throw new NotImplementedException ();
1502                         }
1503                 }
1504         }
1505 }
1506