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

   1 using System;\r
   2 using System.Drawing.Drawing2D;\r
   3 using System.Drawing.Imaging;\r
   4 using System.Drawing.Text;\r
   5 using System.ComponentModel;\r
   6 using System.Runtime.InteropServices;\r
   7 using System.Text;\r
   8 using awt = java.awt;\r
   9 using geom = java.awt.geom;\r
  10 \r
  11 namespace System.Drawing {\r
  12         [ComVisible(false)]\r
  13         public sealed class Graphics : MarshalByRefObject, IDisposable {\r
  14                 #region Variables\r
  15 \r
  16                 readonly awt.Graphics2D _nativeObject;\r
  17                 PixelOffsetMode _pixelOffsetMode = PixelOffsetMode.Default;\r
  18                 int _textContrast = 4;\r
  19                 readonly Image _image;\r
  20                 \r
  21                 Matrix _transform;\r
  22                 GraphicsUnit _pageUnit = GraphicsUnit.Display;\r
  23                 float _pageScale = 1.0f;\r
  24 \r
  25                 static readonly float [] _unitConversion = {\r
  26                                                                                                            1,                                                           // World\r
  27                                                                                                            1,                                                           // Display\r
  28                                                                                                            1,                                                           // Pixel\r
  29                                                                                                            DefaultScreenResolution / 72.0f,     // Point\r
  30                                                                                                            DefaultScreenResolution,                     // Inch\r
  31                                                                                                            DefaultScreenResolution / 300.0f,// Document\r
  32                                                                                                            DefaultScreenResolution / 25.4f      // Millimeter\r
  33                                                                                                    };\r
  34 \r
  35                 static internal readonly bool IsHeadless;\r
  36         \r
  37                 #endregion\r
  38 \r
  39 #if INTPTR_SUPPORT\r
  40                 [ComVisible(false)]\r
  41                 public delegate bool EnumerateMetafileProc (EmfPlusRecordType recordType,\r
  42                                                             int flags,\r
  43                                                             int dataSize,\r
  44                                                             IntPtr data,\r
  45                                                             PlayRecordCallback callbackData);\r
  46                 [ComVisible (false)]\r
  47                         public delegate bool DrawImageAbort (IntPtr callbackData);              \r
  48 #endif                  \r
  49 \r
  50                 #region Constr. and Destr.\r
  51                 private Graphics (Image image) {\r
  52                         _nativeObject = (awt.Graphics2D)image.NativeObject.getGraphics();\r
  53                         _image = image;\r
  54                         _transform = new Matrix ();\r
  55                         _nativeObject.setTransform( _transform.NativeObject );\r
  56 \r
  57                         NativeObject.setRenderingHint(awt.RenderingHints.KEY_COLOR_RENDERING, awt.RenderingHints.VALUE_COLOR_RENDER_QUALITY);\r
  58                 }\r
  59 \r
  60                 #endregion\r
  61                 \r
  62                 #region Internal Accessors\r
  63 \r
  64                 static Graphics() {\r
  65                         bool isHeadless = awt.GraphicsEnvironment.isHeadless();\r
  66                         if (!isHeadless) {\r
  67                                 try {\r
  68                                         awt.Toolkit.getDefaultToolkit();\r
  69                                 }\r
  70                                 catch{\r
  71                                         isHeadless = true;\r
  72                                 }\r
  73                         }\r
  74 \r
  75                         IsHeadless = isHeadless;\r
  76                 }\r
  77 \r
  78                 static internal int DefaultScreenResolution {\r
  79                         get {\r
  80                                 return IsHeadless ? 96 :\r
  81                                         awt.Toolkit.getDefaultToolkit().getScreenResolution();\r
  82                         }\r
  83                 }\r
  84                 \r
  85                 internal java.awt.Graphics2D NativeObject {\r
  86                         get {\r
  87                                 return _nativeObject;\r
  88                         }\r
  89                 }\r
  90                 #endregion\r
  91 \r
  92                 #region FromImage (static accessor)\r
  93                 public static Graphics FromImage (Image image) {                \r
  94                         return new Graphics(image);\r
  95                 }\r
  96                 #endregion\r
  97 \r
  98                 #region Workers [INTERNAL]\r
  99                 void InternalSetBrush(Brush b) {\r
 100                         java.awt.Graphics2D g = NativeObject;\r
 101                         g.setPaint (b);\r
 102                         SolidBrush sb = b as SolidBrush;\r
 103                         if(sb != null) {\r
 104                                 g.setColor(sb.Color.NativeObject);\r
 105                         }\r
 106                         else if(b is LinearGradientBrush) {\r
 107 #if DEBUG_GRADIENT_BRUSH\r
 108                                 if(((LinearGradientBrush)b).dPoints != null)\r
 109                                 {\r
 110                                         PointF []pts = ((LinearGradientBrush)b).dPoints;\r
 111                                         java.awt.Shape s = g.getClip();\r
 112                                         g.setClip(0,0,99999,99999);\r
 113                                         g.setPaint(new java.awt.Color(255,0,0));\r
 114                                         g.drawLine((int)pts[0].X,(int)pts[0].Y,(int)pts[1].X,(int)pts[1].Y);\r
 115                                         g.setPaint(new java.awt.Color(0,255,0));\r
 116                                         g.drawLine((int)pts[1].X,(int)pts[1].Y,(int)pts[2].X,(int)pts[2].Y);\r
 117                                         g.setPaint(new java.awt.Color(255,0,0));\r
 118                                         g.drawLine((int)pts[2].X,(int)pts[2].Y,(int)pts[3].X,(int)pts[3].Y);\r
 119                                         g.setPaint(new java.awt.Color(0,255,0));\r
 120                                         g.drawLine((int)pts[3].X,(int)pts[3].Y,(int)pts[0].X,(int)pts[0].Y);\r
 121                                         \r
 122                                         g.setClip(s);\r
 123                                 }\r
 124 #endif\r
 125                         }\r
 126                 }\r
 127 \r
 128                 void DrawShape(Pen pen, awt.Shape shape) {\r
 129                         if (pen == null)\r
 130                                 throw new ArgumentNullException("pen");\r
 131 \r
 132                         shape = ((awt.Stroke)pen).createStrokedShape(shape);\r
 133                         FillShape(pen.Brush, shape);\r
 134                 }\r
 135 \r
 136                 void FillShape(awt.Paint paint, awt.Shape shape) {\r
 137                         if (paint == null)\r
 138                                 throw new ArgumentNullException("brush");\r
 139 \r
 140                         awt.Paint old = NativeObject.getPaint();\r
 141                         NativeObject.setPaint(paint);\r
 142                         try {\r
 143                                 NativeObject.fill(shape);\r
 144                         }\r
 145                         finally {\r
 146                                 NativeObject.setPaint(old);\r
 147                         }\r
 148                 }\r
 149 \r
 150                 internal SizeF MeasureDraw (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format, bool fDraw) {                    \r
 151                         SizeF retVal = new SizeF(0,0);\r
 152                         awt.Graphics2D g = NativeObject;\r
 153                                 \r
 154                         java.awt.Font fnt = font.NativeObject;\r
 155                         if(s != null && s.Length != 0 && fnt != null) {\r
 156                                 float size = fnt.getSize();\r
 157                                 float wid = layoutRectangle.Width;\r
 158                                 float hei = layoutRectangle.Height;\r
 159                                 float x = layoutRectangle.X;\r
 160                                 float y = layoutRectangle.Y;\r
 161                                 java.text.AttributedString astr = new java.text.AttributedString(s);\r
 162                                 astr.addAttribute(java.awt.font.TextAttribute.FONT, fnt);\r
 163                                 java.text.AttributedCharacterIterator prg = astr.getIterator();\r
 164                                 java.awt.font.TextLayout textlayout = new java.awt.font.TextLayout(prg, g.getFontRenderContext());\r
 165                                 int prgStart = prg.getBeginIndex();\r
 166                                 int prgEnd = prg.getEndIndex();\r
 167                                 java.awt.font.LineBreakMeasurer lineMeasurer = new java.awt.font.LineBreakMeasurer(\r
 168                                         prg, new java.awt.font.FontRenderContext(null, false, false));\r
 169                                 lineMeasurer.setPosition(prgStart);\r
 170                                 float formatWidth = wid;\r
 171                                 \r
 172                                 //some vertical layout magic - should be reviewed\r
 173                                 //                              if(format != null)\r
 174                                 //                              {\r
 175                                 //                                      StringFormatFlags formatflag = format.FormatFlags;\r
 176                                 //                                      if(formatflag != StringFormatFlags.DirectionVertical)\r
 177                                 //                                      {\r
 178                                 //                                              if(size > (float)8 && wid > (float)13)\r
 179                                 //                                                      formatWidth = wid - (float)12;\r
 180                                 //                                              if(formatflag ==  StringFormatFlags.DirectionRightToLeft && size == (float)6)\r
 181                                 //                                                      formatWidth = wid - (float)10;\r
 182                                 //                                      }\r
 183                                 //                              }\r
 184 \r
 185                                 //now calculate number of lines and full layout height\r
 186                                 //this is required for LineAlignment calculations....\r
 187                                 int lines=0;\r
 188                                 float layHeight=0;\r
 189                                 float layPrevHeight=0;\r
 190                                 float layWidth=0;\r
 191                                 float drawPosY = y;\r
 192                                 //bool fSkipLastLine = false;\r
 193                                 java.awt.font.TextLayout layout;\r
 194                                 java.awt.geom.Rectangle2D bnds = new java.awt.geom.Rectangle2D.Float();\r
 195                                 while(lineMeasurer.getPosition() < prgEnd) {\r
 196                                         layout = lineMeasurer.nextLayout(formatWidth);\r
 197                                         lines++;\r
 198                                         bnds = bnds.createUnion(layout.getBounds());\r
 199                                         layPrevHeight = layHeight;\r
 200                                         layHeight += layout.getDescent() + layout.getLeading() + layout.getAscent();\r
 201                                         float advance;\r
 202                                         if((format != null) && \r
 203                                                 ((format.FormatFlags & StringFormatFlags.MeasureTrailingSpaces) != 0))\r
 204                                                 advance = layout.getAdvance();\r
 205                                         else\r
 206                                                 advance = layout.getVisibleAdvance();\r
 207                                         if(layWidth < advance)\r
 208                                                 layWidth = advance;\r
 209                                         if((format != null) && ((format.FormatFlags & StringFormatFlags.NoWrap) != 0))\r
 210                                                 break;\r
 211                                 }\r
 212                                 //Overhanging parts of glyphs, and unwrapped text reaching outside \r
 213                                 //the formatting rectangle are allowed to show. By default all text \r
 214                                 //and glyph parts reaching outside the formatting rectangle are clipped.\r
 215                                 if((lines == 1) && \r
 216                                         (format != null) && \r
 217                                         ((format.FormatFlags & StringFormatFlags.NoClip) != 0)) {\r
 218                                         formatWidth = layWidth;                                 \r
 219                                 }\r
 220 \r
 221                                 //Only entire lines are laid out in the formatting rectangle. By default layout \r
 222                                 //continues until the end of the text, or until no more lines are visible as a \r
 223                                 //result of clipping, whichever comes first. Note that the default settings allow \r
 224                                 //the last line to be partially obscured by a formatting rectangle that is not a \r
 225                                 //whole multiple of the line height. To ensure that only whole lines are seen, specify\r
 226                                 //this value and be careful to provide a formatting rectangle at least as tall as the \r
 227                                 //height of one line.\r
 228                                 if(format != null && ((format.FormatFlags & StringFormatFlags.LineLimit) != 0) && \r
 229                                         layHeight > hei && layPrevHeight < hei) {\r
 230                                         layHeight = layPrevHeight;\r
 231                                         lines--;\r
 232                                 }\r
 233 \r
 234                                 retVal.Height = layHeight;\r
 235                                 retVal.Width = layWidth+size/2.5f;\r
 236                                 if(!fDraw)\r
 237                                         return retVal;\r
 238 \r
 239                                 InternalSetBrush(brush);\r
 240 \r
 241                                 //end measurment\r
 242 \r
 243                                 //for draw we should probably update origins\r
 244 \r
 245                                 //Vertical...\r
 246                                 if(format != null) {\r
 247                                         StringAlignment align = format.LineAlignment;\r
 248                                         if(align == StringAlignment.Center) {\r
 249                                                 drawPosY = y + (float)hei/2 - layHeight/2;\r
 250                                         }\r
 251                                         else if(align == StringAlignment.Far) {\r
 252                                                 drawPosY = (float)y + (float)hei - layHeight;\r
 253                                         }\r
 254                                         //in both cases if string is not fit - switch to near\r
 255                                         if(drawPosY < y)\r
 256                                                 drawPosY = y;\r
 257                                 }\r
 258 \r
 259                                 //Horisontal... on the fly\r
 260                                 lineMeasurer.setPosition(prgStart);\r
 261                                 float drawPosX = x;                             \r
 262                                 for(int line = 0;line < lines /*lineMeasurer.getPosition() < prgEnd*/;line++, drawPosY += layout.getDescent() + layout.getLeading()) {\r
 263                                         layout = lineMeasurer.nextLayout(formatWidth);\r
 264                                         drawPosX = x + size / (float)5;//???\r
 265                                         drawPosY += layout.getAscent();\r
 266                                         if(format != null) {\r
 267                                                 float advance;\r
 268                                                 if((format.FormatFlags & StringFormatFlags.MeasureTrailingSpaces) != 0)\r
 269                                                         advance = layout.getAdvance();\r
 270                                                 else\r
 271                                                         advance = layout.getVisibleAdvance();\r
 272                                                 \r
 273                                                 if(format.Alignment == StringAlignment.Center) {\r
 274                                                         drawPosX = (float)((double)x + ((double)formatWidth)/2 - advance/2);\r
 275                                                 }\r
 276                                                 else if(format.Alignment == StringAlignment.Far) {\r
 277                                                         drawPosX = (float)(drawPosX + formatWidth) - advance;\r
 278                                                 }\r
 279                                                 if((format.FormatFlags & StringFormatFlags.DirectionVertical ) != 0) {\r
 280                                                         java.awt.geom.AffineTransform at1 = java.awt.geom.AffineTransform.getTranslateInstance(\r
 281                                                                 drawPosX +  size / (float)5, (drawPosY - layout.getAscent()) + size / (float)5);\r
 282 \r
 283                                                         at1.rotate(Math.PI/2);\r
 284                                                         awt.Shape sha = textlayout.getOutline(at1);\r
 285                                                         //g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);\r
 286                                                         g.fill(sha);\r
 287                                                         continue;\r
 288                                                 }\r
 289                                                 if((format.FormatFlags & StringFormatFlags.DirectionRightToLeft)  != 0) {\r
 290                                                         drawPosX = ((drawPosX + formatWidth) - advance) + (float)9;\r
 291                                                         layout.draw(g, drawPosX, drawPosY);\r
 292                                                 } \r
 293                                         }                                       \r
 294                                         //Draw current line\r
 295                                         layout.draw(g, drawPosX, drawPosY);                                     \r
 296                                 }\r
 297                         } //not nulls\r
 298 \r
 299                         return retVal;\r
 300                 }\r
 301                 #endregion\r
 302 \r
 303                 #region Dispose\r
 304                 public void Dispose() {                 \r
 305                         NativeObject.dispose();\r
 306                 }\r
 307                 #endregion\r
 308                 \r
 309                 #region Clear\r
 310                 public void Clear (Color color) {\r
 311                         geom.AffineTransform old = NativeObject.getTransform();\r
 312                         NativeObject.setTransform(new geom.AffineTransform());\r
 313                         try {\r
 314                                 FillShape(color.NativeObject, new awt.Rectangle(0,0,_image.Width,_image.Height));\r
 315                         }\r
 316                         finally {\r
 317                                 NativeObject.setTransform(old);\r
 318                         }\r
 319                 }\r
 320                 #endregion\r
 321 \r
 322                 #region DrawArc\r
 323                 public void DrawArc (Pen pen, Rectangle rect, float startAngle, float sweepAngle) {\r
 324                         DrawArc (pen, \r
 325                                 rect.X, \r
 326                                 rect.Y, \r
 327                                 rect.Width, \r
 328                                 rect.Height, \r
 329                                 startAngle, \r
 330                                 sweepAngle);\r
 331                 }\r
 332 \r
 333                 \r
 334                 public void DrawArc (Pen pen, RectangleF rect, float startAngle, float sweepAngle) {\r
 335                         DrawArc (pen, \r
 336                                 rect.X, \r
 337                                 rect.Y, \r
 338                                 rect.Width, \r
 339                                 rect.Height, \r
 340                                 startAngle, \r
 341                                 sweepAngle);\r
 342                 }\r
 343 \r
 344                 public void DrawArc (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle) {\r
 345                         DrawArc(pen,\r
 346                                 (float)x,\r
 347                                 (float)y,\r
 348                                 (float)width,\r
 349                                 (float)height,\r
 350                                 (float)startAngle,\r
 351                                 (float)sweepAngle);\r
 352                 }\r
 353 \r
 354                 public void DrawArc (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle) {\r
 355                         GraphicsPath path = new GraphicsPath();\r
 356                         path.AddArc(x, y, width, height, startAngle, sweepAngle);\r
 357                         DrawPath(pen, path);\r
 358                 }\r
 359                 #endregion\r
 360 \r
 361                 #region DrawBezier(s)\r
 362                 public void DrawBezier (Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4) {\r
 363                         DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);\r
 364                 }\r
 365 \r
 366                 public void DrawBezier (Pen pen, Point pt1, Point pt2, Point pt3, Point pt4) {\r
 367                         DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);\r
 368                 }\r
 369 \r
 370                 public void DrawBezier (Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) {\r
 371                         geom.GeneralPath path = new geom.GeneralPath();\r
 372                         path.moveTo(x1,y1);\r
 373                         path.curveTo(x2,y2,x3,y3,x4,y4);\r
 374                         DrawShape(pen, path);\r
 375                 }\r
 376 \r
 377                 public void DrawBeziers (Pen pen, Point [] points) {\r
 378                         GraphicsPath path = new GraphicsPath();\r
 379                         path.AddBeziers(points);\r
 380                         DrawPath(pen, path);\r
 381                 }\r
 382 \r
 383                 public void DrawBeziers (Pen pen, PointF [] points) {\r
 384                         GraphicsPath path = new GraphicsPath();\r
 385                         path.AddBeziers(points);\r
 386                         DrawPath(pen, path);\r
 387                 }\r
 388                 #endregion \r
 389 \r
 390                 #region DrawClosedCurve\r
 391                 public void DrawClosedCurve (Pen pen, PointF [] points) {\r
 392                         DrawClosedCurve(pen, points, 0.5f, FillMode.Alternate);\r
 393                 }\r
 394                 \r
 395                 public void DrawClosedCurve (Pen pen, Point [] points) {\r
 396                         DrawClosedCurve(pen, points, 0.5f, FillMode.Alternate);\r
 397                 }\r
 398                         \r
 399                 public void DrawClosedCurve (Pen pen, Point [] points, float tension, FillMode fillmode) {\r
 400                         GraphicsPath path = new GraphicsPath(fillmode);\r
 401                         path.AddClosedCurve(points, tension);\r
 402                         DrawPath(pen, path);\r
 403                 }\r
 404                 \r
 405                 public void DrawClosedCurve (Pen pen, PointF [] points, float tension, FillMode fillmode) {\r
 406                         GraphicsPath path = new GraphicsPath(fillmode);\r
 407                         path.AddClosedCurve(points, tension);\r
 408                         DrawPath(pen, path);\r
 409                 }\r
 410                 #endregion\r
 411 \r
 412                 #region DrawCurve\r
 413                 public void DrawCurve (Pen pen, Point [] points) {\r
 414                         DrawCurve(pen, points, 0.5f);\r
 415                 }\r
 416                 \r
 417                 public void DrawCurve (Pen pen, PointF [] points) {\r
 418                         DrawCurve(pen, points, 0.5f);\r
 419                 }\r
 420                 \r
 421                 public void DrawCurve (Pen pen, PointF [] points, float tension) {\r
 422                         DrawCurve(pen, points, 0, points.Length-1, tension);\r
 423                 }\r
 424                 \r
 425                 public void DrawCurve (Pen pen, Point [] points, float tension) {\r
 426                         DrawCurve(pen, points, 0, points.Length-1, tension);\r
 427                 }\r
 428                 \r
 429                 \r
 430                 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments) {\r
 431                         DrawCurve(pen, points, offset, numberOfSegments, 0.5f);\r
 432                 }\r
 433 \r
 434                 public void DrawCurve (Pen pen, Point [] points, int offset, int numberOfSegments, float tension) {\r
 435                         GraphicsPath path = new GraphicsPath();\r
 436                         path.AddCurve(points, offset, numberOfSegments, tension);\r
 437                         DrawPath(pen, path);\r
 438                 }\r
 439 \r
 440                 \r
 441                 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments, float tension) {\r
 442                         GraphicsPath path = new GraphicsPath();\r
 443                         path.AddCurve(points, offset, numberOfSegments, tension);\r
 444                         DrawPath(pen, path);\r
 445                 }\r
 446                 #endregion\r
 447 \r
 448                 #region DrawEllipse\r
 449                 public void DrawEllipse (Pen pen, Rectangle rect) {\r
 450                         DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);\r
 451                 }\r
 452 \r
 453                 public void DrawEllipse (Pen pen, RectangleF rect) {\r
 454                         DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);\r
 455                 }\r
 456 \r
 457                 public void DrawEllipse (Pen pen, int x, int y, int width, int height) {\r
 458                         DrawEllipse(pen,(float)x,(float)y,(float)width,(float)height);\r
 459                 }\r
 460 \r
 461                 public void DrawEllipse (Pen pen, float x, float y, float width, float height) {\r
 462                         DrawShape(pen, new geom.Ellipse2D.Float(x,y,width,height));\r
 463                 }\r
 464                 #endregion\r
 465 \r
 466                 #region DrawIcon\r
 467                 public void DrawIcon (Icon icon, Rectangle targetRect) {\r
 468                         Bitmap b = icon.ToBitmap ();\r
 469                         this.DrawImage (b, targetRect);\r
 470                 }\r
 471 \r
 472                 public void DrawIcon (Icon icon, int x, int y) {\r
 473                         Bitmap b = icon.ToBitmap ();\r
 474                         this.DrawImage (b, x, y);\r
 475                 }\r
 476 \r
 477                 public void DrawIconUnstretched (Icon icon, Rectangle targetRect) {\r
 478                         Bitmap b = icon.ToBitmap ();\r
 479                         this.DrawImageUnscaled (b, targetRect);\r
 480                 }\r
 481                 #endregion\r
 482 \r
 483                 #region DrawImage\r
 484 \r
 485                 public void DrawImage (Image image, Point point) \r
 486                 {\r
 487                         DrawImage(image, (int)point.X, (int)point.Y);\r
 488                 }\r
 489 \r
 490                 public void DrawImage (Image image, PointF point) \r
 491                 {\r
 492                         DrawImage(image, (int)point.X, (int)point.Y);\r
 493                 }\r
 494 \r
 495                 \r
 496                 public void DrawImage (Image image, Point [] destPoints) {\r
 497                         Matrix m = new Matrix(new Rectangle(0, 0, image.Width, image.Height), destPoints);\r
 498                         DrawImage(image, m);\r
 499                 }\r
 500 \r
 501                 public void DrawImage (Image image, PointF [] destPoints) \r
 502                 {\r
 503                         Matrix m = new Matrix(new RectangleF(0, 0, image.Width, image.Height), destPoints);\r
 504                         DrawImage(image, m);\r
 505                 }\r
 506 \r
 507                 \r
 508                 public void DrawImage (Image image, Rectangle rect) \r
 509                 {\r
 510                         DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height);\r
 511                 }\r
 512 \r
 513                 public void DrawImage (Image image, RectangleF rect) \r
 514                 {\r
 515                         DrawImage(image, (int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height);\r
 516                 }\r
 517 \r
 518                 \r
 519                 public void DrawImage (Image image, int x, int y) \r
 520                 {\r
 521                         float current_scale = PageScale;\r
 522                         if (current_scale != 1)\r
 523                                 PageScale = 1;\r
 524 \r
 525                         try\r
 526                         {\r
 527                                 NativeObject.drawImage(image.NativeObject, x, y, null);\r
 528                         }\r
 529                         finally\r
 530                         {\r
 531                                 if (current_scale != 1)\r
 532                                         PageScale = current_scale;\r
 533                         }\r
 534                 }\r
 535 \r
 536                 public void DrawImage (Image image, float x, float y) \r
 537                 {\r
 538                         DrawImage(image, (int)x, (int)y);\r
 539                 }\r
 540 \r
 541                 \r
 542                 public void DrawImage (Image image, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit) {\r
 543                         if (srcUnit != GraphicsUnit.Pixel)\r
 544                                 throw new NotImplementedException();\r
 545                                 // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx\r
 546 \r
 547                         float current_scale = PageScale;\r
 548                         if (current_scale != 1)\r
 549                                 PageScale = 1;\r
 550 \r
 551                         try\r
 552                         {\r
 553                                 NativeObject.drawImage(image.NativeObject,\r
 554                                         destRect.X,\r
 555                                         destRect.Y,\r
 556                                         destRect.X + destRect.Width,\r
 557                                         destRect.Y + destRect.Height,\r
 558                                         srcRect.X,\r
 559                                         srcRect.Y,\r
 560                                         srcRect.X + srcRect.Width,\r
 561                                         srcRect.Y + srcRect.Height,\r
 562                                         null);\r
 563                         }\r
 564                         finally\r
 565                         {\r
 566                                 if (current_scale != 1)\r
 567                                         PageScale = current_scale;\r
 568                         }\r
 569                 }\r
 570                 \r
 571                 public void DrawImage (Image image, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit) {\r
 572                         DrawImage(\r
 573                                 image, \r
 574                                 new Rectangle((int)destRect.X, (int)destRect.Y, (int)destRect.Width, (int)destRect.Height),\r
 575                                 new Rectangle((int)srcRect.X, (int)srcRect.Y, (int)srcRect.Width, (int)srcRect.Height),\r
 576                                 srcUnit);\r
 577                 }\r
 578 \r
 579                 \r
 580                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit) {\r
 581                         DrawImage(image, destPoints, srcRect, srcUnit, null);\r
 582                 }\r
 583 \r
 584                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit) {\r
 585                         DrawImage(image, destPoints, srcRect, srcUnit, null);\r
 586                 }\r
 587 \r
 588                 \r
 589                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr) {\r
 590                         //TBD: ImageAttributes\r
 591                         if (srcUnit != GraphicsUnit.Pixel)\r
 592                                 throw new NotImplementedException();\r
 593                                 // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx\r
 594 \r
 595                         Matrix mx = new Matrix(srcRect, destPoints);\r
 596 \r
 597                         Region region = new Region(srcRect);\r
 598                         region.Transform (mx);\r
 599                         \r
 600                         geom.Area current_clip = (geom.Area)GetNativeClip().clone();\r
 601                         IntersectClip(region);\r
 602                         try\r
 603                         {\r
 604                                 DrawImage(image, mx);\r
 605                         }\r
 606                         finally\r
 607                         {\r
 608                                 SetNativeClip(current_clip);\r
 609                         }\r
 610                 }\r
 611                 \r
 612                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr) {\r
 613                         //TBD: ImageAttributes\r
 614                         if (srcUnit != GraphicsUnit.Pixel)\r
 615                                 throw new NotImplementedException();\r
 616                                 // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx\r
 617 \r
 618                         Matrix mx = new Matrix(srcRect, destPoints);\r
 619 \r
 620                         Region region = new Region(srcRect);\r
 621                         region.Transform (mx);\r
 622                         \r
 623                         geom.Area current_clip = (geom.Area)GetNativeClip().clone();\r
 624                         IntersectClip(region);\r
 625                         try\r
 626                         {\r
 627                                 DrawImage(image, mx);\r
 628                         }\r
 629                         finally\r
 630                         {\r
 631                                 SetNativeClip(current_clip);\r
 632                         }\r
 633                 }\r
 634 \r
 635 \r
 636                 public void DrawImage (Image image, int x, int y, int width, int height) {\r
 637                         float current_scale = PageScale;\r
 638                         if (current_scale != 1)\r
 639                                 PageScale = 1;\r
 640 \r
 641                         try\r
 642                         {\r
 643                                 NativeObject.drawImage(image.NativeObject, x, y, width, height, null);\r
 644                         }\r
 645                         finally\r
 646                         {\r
 647                                 if (current_scale != 1)\r
 648                                         PageScale = current_scale;\r
 649                         }\r
 650                 }\r
 651 \r
 652                 public void DrawImage (Image image, float x, float y, float width, float height) {\r
 653                         DrawImage(image, (int)x, (int)y, (int)width, (int)height);\r
 654                 }\r
 655 \r
 656                 \r
 657                 public void DrawImage (Image image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit) {                    \r
 658                         DrawImage(image, new Rectangle(x, y, srcRect.Width, srcRect.Height), srcRect, srcUnit);\r
 659                 }\r
 660                 \r
 661                 public void DrawImage (Image image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit) {       \r
 662                         DrawImage(image, new RectangleF(x, y, srcRect.Width, srcRect.Height), srcRect, srcUnit);\r
 663                 }\r
 664 \r
 665 \r
 666                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit) {\r
 667                         DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);\r
 668                 }\r
 669 \r
 670                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit) {\r
 671                         DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);\r
 672                 }\r
 673                 \r
 674 \r
 675                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr) {                     \r
 676                         //TBD: attributes\r
 677                         DrawImage(\r
 678                                 image, \r
 679                                 destRect,\r
 680                                 new Rectangle(srcX, srcY, srcWidth, srcHeight),\r
 681                                 srcUnit);\r
 682                 }\r
 683                 \r
 684                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs) {\r
 685                         //TBD: attributes\r
 686                         DrawImage(\r
 687                                 image, \r
 688                                 destRect,\r
 689                                 new Rectangle((int)srcX, (int)srcY, (int)srcWidth, (int)srcHeight),\r
 690                                 srcUnit);\r
 691                 }\r
 692                 \r
 693 \r
 694                 internal void DrawImage (Image image, Matrix m) {\r
 695                         float current_scale = PageScale;\r
 696                         if (current_scale != 1)\r
 697                                 PageScale = 1;\r
 698 \r
 699                         try\r
 700                         {\r
 701                                 NativeObject.drawImage(image.NativeObject, m.NativeObject, null);\r
 702                         }\r
 703                         finally\r
 704                         {\r
 705                                 if (current_scale != 1)\r
 706                                         PageScale = current_scale;\r
 707                         }\r
 708                 }\r
 709                 \r
 710 \r
 711 #if INTPTR_SUPPORT\r
 712                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
 713                 {\r
 714                         throw new NotImplementedException();\r
 715                 }\r
 716 \r
 717                 \r
 718                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
 719                 {\r
 720                         \r
 721                         throw new NotImplementedException();\r
 722                 }\r
 723 \r
 724                 \r
 725                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)\r
 726                 {\r
 727                         throw new NotImplementedException();\r
 728                 }\r
 729 #endif\r
 730 \r
 731 #if INTPTR_SUPPORT              \r
 732                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)\r
 733                 {\r
 734                         throw new NotImplementedException();\r
 735                 }\r
 736 #endif\r
 737 \r
 738 #if INTPTR_SUPPORT              \r
 739                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
 740                 {\r
 741                         //TBD:units,attributes, callback\r
 742                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
 743                         g.drawImage(image.NativeObject,destRect.X,destRect.Y,destRect.Width,destRect.Height,srcX,srcY,srcWidth,srcHeight,null);\r
 744                 }\r
 745                 \r
 746                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
 747                 {\r
 748                         //TBD:units,attributes, callback\r
 749                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
 750                         g.drawImage(image.NativeObject,\r
 751                                 (int)destRect.X,\r
 752                                 (int)destRect.Y,\r
 753                                 (int)destRect.Width,\r
 754                                 (int)destRect.Height,\r
 755                                 (int)srcX,\r
 756                                 (int)srcY,\r
 757                                 (int)srcWidth,\r
 758                                 (int)srcHeight,null);\r
 759                 }\r
 760 \r
 761                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)\r
 762                 {\r
 763                         //TBD:units,attributes, callback\r
 764                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
 765                         g.drawImage(image.NativeObject,\r
 766                                 (int)destRect.X,\r
 767                                 (int)destRect.Y,\r
 768                                 (int)destRect.Width,\r
 769                                 (int)destRect.Height,\r
 770                                 (int)srcX,\r
 771                                 (int)srcY,\r
 772                                 (int)srcWidth,\r
 773                                 (int)srcHeight,null);\r
 774                 }\r
 775                 \r
 776                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)\r
 777                 {\r
 778                         //TBD:units,attributes, callback\r
 779                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
 780                         g.drawImage(image.NativeObject,\r
 781                                 destRect.X,\r
 782                                 destRect.Y,\r
 783                                 destRect.Width,\r
 784                                 destRect.Height,\r
 785                                 srcX,\r
 786                                 srcY,\r
 787                                 srcWidth,\r
 788                                 srcHeight,null);\r
 789                 }               \r
 790 #endif\r
 791                 \r
 792                 public void DrawImageUnscaled (Image image, Point point) \r
 793                 {\r
 794                         DrawImageUnscaled (image, point.X, point.Y);\r
 795                 }\r
 796                 \r
 797                 public void DrawImageUnscaled (Image image, Rectangle rect) {\r
 798                         DrawImageUnscaled (image, rect.X, rect.Y, rect.Width, rect.Height);\r
 799                 }\r
 800                 \r
 801                 public void DrawImageUnscaled (Image image, int x, int y) {\r
 802                         DrawImage (image, x, y, image.Width, image.Height);\r
 803                 }\r
 804 \r
 805                 public void DrawImageUnscaled (Image image, int x, int y, int width, int height) {\r
 806                         Image tmpImg = new Bitmap (width, height);\r
 807                         Graphics g = FromImage (tmpImg);\r
 808                         g.DrawImage (image, 0, 0, image.Width, image.Height);\r
 809                         this.DrawImage (tmpImg, x, y, width, height);\r
 810                         tmpImg.Dispose ();\r
 811                         g.Dispose ();           \r
 812                 }\r
 813                 #endregion\r
 814 \r
 815                 #region DrawLine\r
 816                 public void DrawLine (Pen pen, PointF pt1, PointF pt2) {\r
 817                         DrawLine(pen,pt1.X,pt1.Y,pt2.X,pt2.Y);\r
 818                 }\r
 819 \r
 820                 public void DrawLine (Pen pen, Point pt1, Point pt2) {\r
 821                         DrawLine(pen,(float)pt1.X,(float)pt1.Y,(float)pt2.X,(float)pt2.Y);\r
 822                 }\r
 823 \r
 824                 public void DrawLine (Pen pen, int x1, int y1, int x2, int y2) {\r
 825                         DrawLine(pen,(float)x1,(float)y1,(float)x2,(float)y2);\r
 826                 }\r
 827 \r
 828                 public void DrawLine (Pen pen, float x1, float y1, float x2, float y2) {\r
 829                         DrawShape(pen, new geom.Line2D.Float(x1,y1,x2,y2));\r
 830                 }\r
 831 \r
 832                 public void DrawLines (Pen pen, PointF [] points) {\r
 833                         GraphicsPath path = new GraphicsPath();\r
 834                         path.AddLines(points);\r
 835                         DrawShape(pen, path);\r
 836                 }\r
 837 \r
 838                 public void DrawLines (Pen pen, Point [] points) {\r
 839                         GraphicsPath path = new GraphicsPath();\r
 840                         path.AddLines(points);\r
 841                         DrawShape(pen, path);\r
 842                 }\r
 843                 #endregion\r
 844 \r
 845                 #region DrawPath\r
 846                 public void DrawPath (Pen pen, GraphicsPath path) {\r
 847                         DrawShape(pen, path);\r
 848                 }\r
 849                 #endregion\r
 850                 \r
 851                 #region DrawPie\r
 852                 public void DrawPie (Pen pen, Rectangle rect, float startAngle, float sweepAngle) {\r
 853                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);\r
 854                 }\r
 855                 \r
 856                 public void DrawPie (Pen pen, RectangleF rect, float startAngle, float sweepAngle) {\r
 857                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);\r
 858                 }\r
 859                 \r
 860                 public void DrawPie (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle) {\r
 861                         GraphicsPath path = new GraphicsPath();\r
 862                         path.AddPie(x, y, width, height, startAngle, sweepAngle);\r
 863                         DrawPath(pen, path);\r
 864                 }\r
 865                 \r
 866                 public void DrawPie (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle) {\r
 867                         DrawPie(pen,(float)x,(float)y,(float)width,(float)height,(float)startAngle,(float)sweepAngle);\r
 868                 }\r
 869                 #endregion\r
 870 \r
 871                 #region DrawPolygon\r
 872                 public void DrawPolygon (Pen pen, Point [] points) {\r
 873                         GraphicsPath path = new GraphicsPath();\r
 874                         path.AddPolygon(points);\r
 875                         DrawPath(pen, path);\r
 876                 }\r
 877 \r
 878                 public void DrawPolygon (Pen pen, PointF [] points) {\r
 879                         GraphicsPath path = new GraphicsPath();\r
 880                         path.AddPolygon(points);\r
 881                         DrawPath(pen, path);\r
 882                 }\r
 883                 #endregion\r
 884 \r
 885                 #region DrawRectangle(s)\r
 886                 internal void DrawRectangle (Pen pen, RectangleF rect) {\r
 887                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);\r
 888                 }\r
 889 \r
 890                 public void DrawRectangle (Pen pen, Rectangle rect) {\r
 891                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);\r
 892                 }\r
 893 \r
 894                 public void DrawRectangle (Pen pen, float x, float y, float width, float height) {\r
 895                         DrawShape(pen, new geom.Rectangle2D.Float(x,y,width,height));\r
 896                 }\r
 897 \r
 898                 public void DrawRectangle (Pen pen, int x, int y, int width, int height) {\r
 899                         DrawRectangle (pen,(float) x,(float) y,(float) width,(float) height);\r
 900                 }\r
 901 \r
 902                 public void DrawRectangles (Pen pen, RectangleF [] rects) {\r
 903                         foreach(RectangleF r in rects)\r
 904                                 DrawRectangle (pen, r.Left, r.Top, r.Width, r.Height);\r
 905                 }\r
 906 \r
 907                 public void DrawRectangles (Pen pen, Rectangle [] rects) {\r
 908                         foreach(Rectangle r in rects)\r
 909                                 DrawRectangle (pen, r.Left, r.Top, r.Width, r.Height);\r
 910                 }\r
 911                 #endregion\r
 912 \r
 913                 #region DrawString\r
 914                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle) {                 \r
 915                         MeasureDraw(s,font,brush,layoutRectangle,null,true);\r
 916                 }\r
 917                 \r
 918                 public void DrawString (string s, Font font, Brush brush, PointF point) {\r
 919                         MeasureDraw(s,font,brush,new RectangleF(point.X,point.Y,99999f,99999f),null,true);\r
 920                 }\r
 921                 \r
 922                 public void DrawString (string s, Font font, Brush brush, PointF point, StringFormat format) {\r
 923                         MeasureDraw(s,font,brush,new RectangleF(point.X,point.Y,99999f,99999f),format,true);\r
 924                 }\r
 925 \r
 926                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format) {\r
 927                         MeasureDraw(s,font,brush,layoutRectangle,format,true);\r
 928                 }\r
 929         \r
 930 #if false               \r
 931                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format)\r
 932                 {\r
 933                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;                      \r
 934                         //set\r
 935                         java.awt.Paint oldpaint = g.getPaint();\r
 936                         g.setPaint(brush.NativeObject);\r
 937                         java.awt.Font oldfont = g.getFont();\r
 938                         g.setFont(font.NativeObject);\r
 939                         java.awt.Shape oldb = g.getClip();\r
 940                         g.setClip(new java.awt.geom.Rectangle2D.Float(layoutRectangle.X,layoutRectangle.Y,layoutRectangle.Width,layoutRectangle.Height));\r
 941                         //draw\r
 942                         g.drawString(s,layoutRectangle.X,layoutRectangle.Y+layoutRectangle.Height);\r
 943                         //restore\r
 944                         g.setPaint(oldpaint);\r
 945                         g.setClip(oldb);\r
 946                         g.setFont(oldfont);\r
 947                 }\r
 948 #endif\r
 949                 public void DrawString (string s, Font font, Brush brush, float x, float y) {\r
 950                         MeasureDraw(s,font,brush,new RectangleF(x,y,99999f,99999f),null,true);\r
 951                 }\r
 952 \r
 953                 public void DrawString (string s, Font font, Brush brush, float x, float y, StringFormat format) {\r
 954                         MeasureDraw(s,font,brush,new RectangleF(x,y,99999f,99999f),format,true);\r
 955                 }\r
 956                 #endregion\r
 957 \r
 958                 #region Container [TODO]\r
 959                 public void EndContainer (GraphicsContainer container) {\r
 960                         throw new NotImplementedException ();\r
 961                 }\r
 962 \r
 963                 public GraphicsContainer BeginContainer () {\r
 964                         throw new NotImplementedException ();\r
 965                 }\r
 966                 \r
 967                 public GraphicsContainer BeginContainer (Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit) {\r
 968                         throw new NotImplementedException ();\r
 969                 }\r
 970 \r
 971                 \r
 972                 public GraphicsContainer BeginContainer (RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit) {\r
 973                         throw new NotImplementedException ();\r
 974                 }\r
 975 \r
 976                 #endregion\r
 977 \r
 978                 #region Metafiles Staff [TODO NotSupp]\r
 979                 public void AddMetafileComment (byte [] data) {\r
 980                         throw new NotImplementedException ();\r
 981                 }\r
 982 \r
 983 #if INTPTR_SUPPORT\r
 984                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback)\r
 985                 {\r
 986                         throw new NotImplementedException ();\r
 987                 }\r
 988 \r
 989                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback)\r
 990                 {\r
 991                         throw new NotImplementedException ();\r
 992                 }\r
 993 \r
 994                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback)\r
 995                 {\r
 996                         throw new NotImplementedException ();\r
 997                 }\r
 998 \r
 999                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback)\r
1000                 {\r
1001                         throw new NotImplementedException ();\r
1002                 }\r
1003 \r
1004                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback)\r
1005                 {\r
1006                         throw new NotImplementedException ();\r
1007                 }\r
1008 \r
1009                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback)\r
1010                 {\r
1011                         throw new NotImplementedException ();\r
1012                 }\r
1013 \r
1014                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData)\r
1015                 {\r
1016                         throw new NotImplementedException ();\r
1017                 }\r
1018 \r
1019                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData)\r
1020                 {\r
1021                         throw new NotImplementedException ();\r
1022                 }\r
1023 \r
1024                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)\r
1025                 {\r
1026                         throw new NotImplementedException ();\r
1027                 }\r
1028 \r
1029                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData)\r
1030                 {\r
1031                         throw new NotImplementedException ();\r
1032                 }\r
1033 \r
1034                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)\r
1035                 {\r
1036                         throw new NotImplementedException ();\r
1037                 }\r
1038 \r
1039                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData)\r
1040                 {\r
1041                         throw new NotImplementedException ();\r
1042                 }\r
1043 \r
1044                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1045                 {\r
1046                         throw new NotImplementedException ();\r
1047                 }\r
1048 \r
1049                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1050                 {\r
1051                         throw new NotImplementedException ();\r
1052                 }\r
1053 \r
1054                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1055                 {\r
1056                         throw new NotImplementedException ();\r
1057                 }\r
1058 \r
1059                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1060                 {\r
1061                         throw new NotImplementedException ();\r
1062                 }\r
1063 \r
1064                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1065                 {\r
1066                         throw new NotImplementedException ();\r
1067                 }\r
1068 \r
1069                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1070                 {\r
1071                         throw new NotImplementedException ();\r
1072                 }\r
1073 \r
1074                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1075                 {\r
1076                         throw new NotImplementedException ();\r
1077                 }\r
1078 \r
1079                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1080                 {\r
1081                         throw new NotImplementedException ();\r
1082                 }\r
1083 \r
1084                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1085                 {\r
1086                         throw new NotImplementedException ();\r
1087                 }\r
1088 \r
1089                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1090                 {\r
1091                         throw new NotImplementedException ();\r
1092                 }\r
1093 \r
1094                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1095                 {\r
1096                         throw new NotImplementedException ();\r
1097                 }\r
1098 \r
1099                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1100                 {\r
1101                         throw new NotImplementedException ();\r
1102                 }\r
1103 \r
1104                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1105                 {\r
1106                         throw new NotImplementedException ();\r
1107                 }\r
1108 \r
1109                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1110                 {\r
1111                         throw new NotImplementedException ();\r
1112                 }\r
1113 \r
1114                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1115                 {\r
1116                         throw new NotImplementedException ();\r
1117                 }\r
1118 \r
1119                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1120                 {\r
1121                         throw new NotImplementedException ();\r
1122                 }\r
1123 \r
1124                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1125                 {\r
1126                         throw new NotImplementedException ();\r
1127                 }\r
1128 \r
1129                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1130                 {\r
1131                         throw new NotImplementedException ();\r
1132                 }\r
1133 \r
1134                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1135                 {\r
1136                         throw new NotImplementedException ();\r
1137                 }\r
1138 \r
1139                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1140                 {\r
1141                         throw new NotImplementedException ();\r
1142                 }\r
1143 \r
1144                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1145                 {\r
1146                         throw new NotImplementedException ();\r
1147                 }\r
1148 \r
1149                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1150                 {\r
1151                         throw new NotImplementedException ();\r
1152                 }\r
1153 \r
1154                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1155                 {\r
1156                         throw new NotImplementedException ();\r
1157                 }\r
1158 \r
1159                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1160                 {\r
1161                         throw new NotImplementedException ();\r
1162                 }\r
1163 #endif  \r
1164                 #endregion      \r
1165 \r
1166                 #region ExcludeClip\r
1167                 public void ExcludeClip (Rectangle rect) {\r
1168                         geom.Area clip = GetNativeClip();\r
1169                         clip.subtract(new geom.Area(rect.NativeObject));\r
1170                         SetNativeClip(clip);\r
1171                 }\r
1172 \r
1173                 public void ExcludeClip (Region region) {\r
1174                         geom.Area clip = GetNativeClip();\r
1175                         clip.subtract(region.NativeObject);\r
1176                         SetNativeClip(clip);\r
1177                 }\r
1178                 #endregion \r
1179 \r
1180                 #region FillClosedCurve\r
1181                 public void FillClosedCurve (Brush brush, PointF [] points) {\r
1182                         FillClosedCurve (brush, points, FillMode.Alternate);\r
1183                 }\r
1184 \r
1185                 \r
1186                 public void FillClosedCurve (Brush brush, Point [] points) {\r
1187                         FillClosedCurve (brush, points, FillMode.Alternate);\r
1188                 }\r
1189 \r
1190                 \r
1191                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode) {\r
1192                         FillClosedCurve (brush, points, fillmode, 0.5f);\r
1193                 }\r
1194                 \r
1195                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode) {\r
1196                         FillClosedCurve (brush, points, fillmode, 0.5f);\r
1197                 }\r
1198 \r
1199                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode, float tension) {\r
1200                         GraphicsPath path = new GraphicsPath(fillmode);\r
1201                         path.AddClosedCurve(points, tension);\r
1202                         FillPath(brush, path);\r
1203                 }\r
1204 \r
1205                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode, float tension) {\r
1206                         GraphicsPath path = new GraphicsPath(fillmode);\r
1207                         path.AddClosedCurve(points, tension);\r
1208                         FillPath(brush, path);\r
1209                 }\r
1210                 #endregion\r
1211 \r
1212                 #region FillEllipse\r
1213                 public void FillEllipse (Brush brush, Rectangle rect) {\r
1214                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);\r
1215                 }\r
1216 \r
1217                 public void FillEllipse (Brush brush, RectangleF rect) {\r
1218                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);\r
1219                 }\r
1220 \r
1221                 public void FillEllipse (Brush brush, float x, float y, float width, float height) {\r
1222                         FillShape(brush,new java.awt.geom.Ellipse2D.Float(x,y,width,height));\r
1223                 }\r
1224 \r
1225                 public void FillEllipse (Brush brush, int x, int y, int width, int height) {\r
1226                         FillEllipse (brush,(float)x,(float)y,(float)width,(float)height);\r
1227                 }\r
1228                 #endregion\r
1229 \r
1230                 #region FillPath\r
1231                 public void FillPath (Brush brush, GraphicsPath path) {\r
1232                         FillShape(brush,path);\r
1233                 }\r
1234                 #endregion\r
1235 \r
1236                 #region FillPie\r
1237                 public void FillPie (Brush brush, Rectangle rect, float startAngle, float sweepAngle) {\r
1238                         FillPie(brush,(float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height,(float)startAngle,(float)sweepAngle);\r
1239                 }\r
1240 \r
1241                 public void FillPie (Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle) {\r
1242                         FillPie(brush,(float)x,(float)y,(float)width,(float)height,(float)startAngle,(float)sweepAngle);\r
1243                 }\r
1244 \r
1245                 public void FillPie (Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle) {\r
1246                         GraphicsPath path = new GraphicsPath();\r
1247                         path.AddPie(x, y, width, height, startAngle, sweepAngle);\r
1248                         FillPath(brush, path);\r
1249                 }\r
1250                 #endregion\r
1251 \r
1252                 #region FillPolygon\r
1253                 public void FillPolygon (Brush brush, PointF [] points) {\r
1254                         FillPolygon(brush, points, FillMode.Alternate);\r
1255                 }\r
1256 \r
1257                 public void FillPolygon (Brush brush, Point [] points) {\r
1258                         FillPolygon(brush, points, FillMode.Alternate);\r
1259                 }\r
1260 \r
1261                 public void FillPolygon (Brush brush, Point [] points, FillMode fillMode) {\r
1262                         GraphicsPath path = new GraphicsPath(fillMode);\r
1263                         path.AddPolygon(points);\r
1264                         FillPath(brush,path);\r
1265                 }\r
1266 \r
1267                 public void FillPolygon (Brush brush, PointF [] points, FillMode fillMode) {\r
1268                         GraphicsPath path = new GraphicsPath(fillMode);\r
1269                         path.AddPolygon(points);\r
1270                         FillPath(brush,path);\r
1271                 }\r
1272                 #endregion\r
1273 \r
1274                 #region FillRectangle\r
1275                 public void FillRectangle (Brush brush, RectangleF rect) {\r
1276                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);\r
1277                 }\r
1278 \r
1279                 public void FillRectangle (Brush brush, Rectangle rect) {\r
1280                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);\r
1281                 }\r
1282 \r
1283                 public void FillRectangle (Brush brush, int x, int y, int width, int height) {\r
1284                         FillRectangle(brush,(float)x,(float)y,(float)width,(float)height);\r
1285                 }\r
1286 \r
1287                 public void FillRectangle (Brush brush, float x, float y, float width, float height) {\r
1288                         FillShape(brush,new java.awt.geom.Rectangle2D.Float(x,y,width,height));\r
1289                 }\r
1290 \r
1291                 public void FillRectangles (Brush brush, Rectangle [] rects) {\r
1292                         GraphicsPath path = new GraphicsPath();\r
1293                         path.AddRectangles(rects);\r
1294                         FillPath(brush,path);\r
1295                 }\r
1296 \r
1297                 public void FillRectangles (Brush brush, RectangleF [] rects) {\r
1298                         GraphicsPath path = new GraphicsPath();\r
1299                         path.AddRectangles(rects);\r
1300                         FillPath(brush,path);\r
1301                 }\r
1302                 #endregion\r
1303 \r
1304                 #region FillRegion\r
1305                 public void FillRegion (Brush brush, Region region) {\r
1306                         FillShape(brush,region);\r
1307                 }\r
1308 \r
1309                 #endregion\r
1310 \r
1311                 public void Flush () {\r
1312                         Flush (FlushIntention.Flush);\r
1313                 }\r
1314 \r
1315                 \r
1316                 public void Flush (FlushIntention intention) {\r
1317                         if (_image != null)\r
1318                                 _image.NativeObject.flush();\r
1319                 }\r
1320 \r
1321 #if INTPTR_SUPPORTED\r
1322                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1323                 public void ReleaseHdc (IntPtr hdc)\r
1324                 {\r
1325                         throw new NotImplementedException();\r
1326                 }\r
1327 \r
1328                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1329                 public void ReleaseHdcInternal (IntPtr hdc)\r
1330                 {\r
1331                         throw new NotImplementedException ();\r
1332                 }\r
1333 \r
1334                 [EditorBrowsable (EditorBrowsableState.Advanced)]               \r
1335                 public static Graphics FromHdc (IntPtr hdc)\r
1336                 {\r
1337                         throw new NotImplementedException();\r
1338                 }\r
1339 \r
1340                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1341                 public static Graphics FromHdc (IntPtr hdc, IntPtr hdevice)\r
1342                 {\r
1343                         throw new NotImplementedException ();\r
1344                 }\r
1345 \r
1346                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1347                 public static Graphics FromHdcInternal (IntPtr hdc)\r
1348                 {\r
1349                         throw new NotImplementedException ();\r
1350                 }\r
1351 \r
1352                 [EditorBrowsable (EditorBrowsableState.Advanced)]               \r
1353                 public static Graphics FromHwnd (IntPtr hwnd)\r
1354                 {\r
1355                         throw new NotImplementedException();\r
1356                 }\r
1357 \r
1358                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1359                 public static Graphics FromHwndInternal (IntPtr hwnd)\r
1360                 {\r
1361                         throw new NotImplementedException ();\r
1362                 }\r
1363 \r
1364                 internal static Graphics FromXDrawable (IntPtr drawable, IntPtr display)\r
1365                 {\r
1366                         throw new NotImplementedException();\r
1367                 }\r
1368 \r
1369                 public static IntPtr GetHalftonePalette ()\r
1370                 {\r
1371                         throw new NotImplementedException ();\r
1372                 }\r
1373 \r
1374                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1375                 public IntPtr GetHdc ()\r
1376                 {\r
1377                         throw new NotImplementedException();\r
1378                 }\r
1379 #endif\r
1380                 \r
1381                 #region GetNearestColor [TODO]\r
1382                 public Color GetNearestColor (Color color) {\r
1383                         throw new NotImplementedException();\r
1384                 }\r
1385                 #endregion\r
1386 \r
1387                 #region IntersectClip\r
1388                 void IntersectClip (geom.Area area) {\r
1389                         geom.Area clip = GetNativeClip();\r
1390                         clip.intersect(area);\r
1391                         SetNativeClip(clip);\r
1392                 }\r
1393 \r
1394                 public void IntersectClip (Region region) {\r
1395                         if (region == null)\r
1396                                 throw new ArgumentNullException("region");\r
1397 \r
1398                         IntersectClip(region.NativeObject);\r
1399                 }\r
1400                 \r
1401                 public void IntersectClip (RectangleF rect) {\r
1402                         IntersectClip(new geom.Area(rect.NativeObject));\r
1403                 }\r
1404 \r
1405                 public void IntersectClip (Rectangle rect) {                    \r
1406                         IntersectClip(new geom.Area(rect.NativeObject));\r
1407                 }\r
1408                 #endregion\r
1409 \r
1410                 #region IsVisible\r
1411                 public bool IsVisible (Point point) {\r
1412                         return IsVisible(point.X,point.Y);\r
1413                 }\r
1414 \r
1415                 \r
1416                 public bool IsVisible (RectangleF rect) {\r
1417                         return IsVisible ((float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height);\r
1418                 }\r
1419 \r
1420                 public bool IsVisible (PointF point) {\r
1421                         return IsVisible(point.X,point.Y);\r
1422                 }\r
1423                 \r
1424                 public bool IsVisible (Rectangle rect) {\r
1425                         return IsVisible ((float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height);\r
1426                 }\r
1427                 \r
1428                 public bool IsVisible (float x, float y) {\r
1429                         java.awt.Graphics2D g = NativeObject;\r
1430                         java.awt.Shape s = g.getClip();\r
1431                         if (s == null)\r
1432                                 return true;\r
1433                         else                            \r
1434                                 return s.contains(x,y);\r
1435                 }\r
1436                 \r
1437                 public bool IsVisible (int x, int y) {\r
1438                         return IsVisible ((float)x,(float)y);\r
1439                 }\r
1440                 \r
1441                 public bool IsVisible (float x, float y, float width, float height) {\r
1442                         java.awt.Graphics2D g = NativeObject;\r
1443                         java.awt.Shape s = g.getClip();\r
1444                         if (s == null)\r
1445                                 return true;\r
1446                         else                            \r
1447                                 return s.contains(x,y,width,height);\r
1448                 }\r
1449 \r
1450                 \r
1451                 public bool IsVisible (int x, int y, int width, int height) {\r
1452                         return IsVisible ((float)x,(float)y,(float)width,(float)height);\r
1453                 }\r
1454                 #endregion\r
1455 \r
1456                 #region MeasureCharacterRanges [TODO]\r
1457                 public Region [] MeasureCharacterRanges (string text, Font font, RectangleF layoutRect, StringFormat stringFormat) {\r
1458                         throw new NotImplementedException();\r
1459                 }\r
1460                 #endregion\r
1461                 \r
1462                 #region MeasureString [1 method still TODO]\r
1463                 public SizeF MeasureString (string text, Font font) {\r
1464                         return MeasureDraw(text,font,null,new RectangleF(0,0,99999f,99999f),null,false);\r
1465                 }\r
1466 \r
1467                 \r
1468                 public SizeF MeasureString (string text, Font font, SizeF layoutArea) {\r
1469                         return MeasureDraw(text,font,null,new RectangleF(0,0,layoutArea.Width,layoutArea.Height),null,false);\r
1470                 }\r
1471 \r
1472                 \r
1473                 public SizeF MeasureString (string text, Font font, int width) {\r
1474                         return MeasureDraw(text,font,null,new RectangleF(0,0,(float)width,99999f),null,false);\r
1475                 }\r
1476 \r
1477 \r
1478                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat format) {\r
1479                         return MeasureDraw(text,font,null,new RectangleF(0,0,layoutArea.Width,layoutArea.Height),format,false);\r
1480                 }\r
1481 \r
1482                 \r
1483                 public SizeF MeasureString (string text, Font font, int width, StringFormat format) {\r
1484                         return MeasureDraw(text,font,null,new RectangleF(0,0,(float)width,99999f),format,false);\r
1485                 }\r
1486 \r
1487                 \r
1488                 public SizeF MeasureString (string text, Font font, PointF origin, StringFormat format) {\r
1489                         //TBD: MeasureDraw still not dealing with clipping region of dc\r
1490                         return MeasureDraw(text,font,null,new RectangleF(origin.X,origin.Y,99999f,99999f),format,false);\r
1491                 }\r
1492 \r
1493                 \r
1494                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat, out int charactersFitted, out int linesFilled) {       \r
1495                         //TBD: charcount\r
1496                         throw new NotImplementedException();\r
1497                 }\r
1498                 #endregion\r
1499 \r
1500                 #region MultiplyTransform\r
1501                 public void MultiplyTransform (Matrix matrix) {\r
1502                         MultiplyTransform (matrix, MatrixOrder.Prepend);\r
1503                 }\r
1504 \r
1505                 public void MultiplyTransform (Matrix matrix, MatrixOrder order) {\r
1506                         ConcatenateTransform(matrix.NativeObject, order);\r
1507                 }\r
1508                 #endregion\r
1509 \r
1510                 #region Reset (Clip and Transform)\r
1511                 public void ResetClip () {\r
1512                         java.awt.Graphics2D g = NativeObject;\r
1513                         g.setClip(null);\r
1514 \r
1515                 }\r
1516 \r
1517                 public void ResetTransform () {\r
1518                         NativeObject.setTransform(new java.awt.geom.AffineTransform(1,0,0,1,0,0));\r
1519                 }\r
1520                 #endregion\r
1521 \r
1522                 public GraphicsState Save () {\r
1523                         throw new NotImplementedException();\r
1524                 }\r
1525 \r
1526                 public void Restore (GraphicsState gstate) {\r
1527                         throw new NotImplementedException();\r
1528                 }\r
1529 \r
1530                 #region RotateTransform\r
1531                 public void RotateTransform (float angle) {\r
1532                         RotateTransform (angle, MatrixOrder.Prepend);\r
1533                 }\r
1534 \r
1535                 public void RotateTransform (float angle, MatrixOrder order) {\r
1536                         ConcatenateTransform(\r
1537                                 geom.AffineTransform.getRotateInstance(java.lang.Math.toRadians(angle)),\r
1538                                 order);\r
1539                 }\r
1540                 #endregion\r
1541 \r
1542                 #region ScaleTransform\r
1543                 public void ScaleTransform (float sx, float sy) {\r
1544                         ScaleTransform (sx, sy, MatrixOrder.Prepend);\r
1545                 }\r
1546 \r
1547                 public void ScaleTransform (float sx, float sy, MatrixOrder order) {\r
1548                         ConcatenateTransform(\r
1549                                 geom.AffineTransform.getScaleInstance(sx, sy),\r
1550                                 order);\r
1551                 }\r
1552                 #endregion\r
1553 \r
1554                 #region SetClip [Must be reviewed - more abstraction needed]\r
1555                 public void SetClip (RectangleF rect) {\r
1556                         SetClip (rect, CombineMode.Replace);\r
1557                 }\r
1558 \r
1559                 public void SetClip (GraphicsPath path) {\r
1560                         SetClip (path, CombineMode.Replace);\r
1561                 }\r
1562 \r
1563                 public void SetClip (Rectangle rect) {\r
1564                         SetClip (rect, CombineMode.Replace);\r
1565                 }\r
1566 \r
1567                 public void SetClip (Graphics g) {\r
1568                         SetClip (g, CombineMode.Replace);\r
1569                 }\r
1570 \r
1571                 public void SetClip (Graphics g, CombineMode combineMode) {\r
1572                         if(g == null)\r
1573                                 throw new NullReferenceException();\r
1574                         \r
1575                         SetNativeClip(\r
1576                                 CombineClipArea(g.GetNativeClip(),\r
1577                                 combineMode));\r
1578                 }\r
1579 \r
1580                 public void SetClip (Rectangle rect, CombineMode combineMode) {\r
1581                         SetClip(rect.X,rect.Y,rect.Width,rect.Height,combineMode);                      \r
1582                 }               \r
1583                 public void SetClip (RectangleF rect, CombineMode combineMode) {                        \r
1584                         SetClip(rect.X,rect.Y,rect.Width,rect.Height,combineMode);                      \r
1585                 }\r
1586                 \r
1587                 public void SetClip (Region region, CombineMode combineMode) {\r
1588                         if(region == null)\r
1589                                 throw new ArgumentNullException("region");\r
1590 \r
1591                         if(region == Region.InfiniteRegion) {\r
1592                                 SetNativeClip(null);\r
1593                                 return;\r
1594                         }\r
1595 \r
1596                         SetNativeClip(CombineClipArea(region.NativeObject,combineMode));\r
1597                 }\r
1598                 \r
1599                 public void SetClip (GraphicsPath path, CombineMode combineMode) {\r
1600                         if(path == null)\r
1601                                 throw new ArgumentNullException("path");\r
1602 \r
1603                         SetNativeClip(CombineClipArea(new java.awt.geom.Area(path.NativeObject),combineMode));\r
1604                 }\r
1605                 #endregion\r
1606 \r
1607                 #region Clipping Staff [INTERNAL]\r
1608                 internal void SetClip(float x,float y,float width,float height,CombineMode combineMode) {                                       \r
1609                         SetNativeClip(CombineClipArea(new geom.Area(\r
1610                                 new geom.Rectangle2D.Float(x,y,width,height)),combineMode));\r
1611                 }\r
1612 \r
1613                 geom.Area CombineClipArea(java.awt.geom.Area area, CombineMode combineMode) {\r
1614                         if (combineMode == CombineMode.Replace)\r
1615                                 return area;\r
1616 \r
1617                         geom.Area curClip = GetNativeClip();\r
1618                         switch(combineMode) {\r
1619                                 case CombineMode.Complement:\r
1620                                         curClip.add(area);\r
1621                                         break;\r
1622                                 case CombineMode.Exclude:\r
1623                                         curClip.subtract(area);\r
1624                                         break;\r
1625                                 case CombineMode.Intersect:\r
1626                                         curClip.intersect(area);\r
1627                                         break;\r
1628                                 case CombineMode.Union:\r
1629                                         curClip.add(area);\r
1630                                         break;\r
1631                                 case CombineMode.Xor:\r
1632                                         curClip.exclusiveOr(area);\r
1633                                         break;\r
1634                                 default:\r
1635                                         throw new ArgumentOutOfRangeException();                                        \r
1636                         }\r
1637                         \r
1638                         return curClip;\r
1639                 }\r
1640                 \r
1641                 void SetNativeClip(awt.Shape s) {\r
1642                         NativeObject.setClip(s);\r
1643                 }\r
1644 \r
1645                 geom.Area GetNativeClip() {\r
1646                         awt.Shape clip = NativeObject.getClip();\r
1647                         return clip != null ? new geom.Area(clip) : (geom.Area)Region.InfiniteRegion.NativeObject.clone();\r
1648                 }\r
1649                 #endregion\r
1650                 \r
1651                 #region TransformPoints\r
1652                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF [] pts) {\r
1653                         //TBD:CoordinateSpace\r
1654                         java.awt.Graphics2D g = NativeObject;\r
1655                         java.awt.geom.AffineTransform tr = g.getTransform();\r
1656                         float[] fpts = new float[2];\r
1657                         for(int i = 0; i< pts.Length; i++) {\r
1658                                 fpts[0] = pts[i].X;\r
1659                                 fpts[1] = pts[i].Y;\r
1660                                 tr.transform(fpts, 0, fpts, 0, 1);\r
1661                                 pts[i].X = fpts[0];\r
1662                                 pts[i].Y = fpts[1];\r
1663                         }\r
1664                 }\r
1665 \r
1666                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts) {                                               \r
1667                         //TBD:CoordinateSpace\r
1668                         java.awt.Graphics2D g = NativeObject;\r
1669                         java.awt.geom.AffineTransform tr = g.getTransform();\r
1670                         float[] fpts = new float[2];\r
1671                         for(int i = 0; i< pts.Length; i++) {\r
1672                                 fpts[0] = pts[i].X;\r
1673                                 fpts[1] = pts[i].Y;\r
1674                                 tr.transform(fpts, 0, fpts, 0, 1);\r
1675                                 pts[i].X = (int)fpts[0];\r
1676                                 pts[i].Y = (int)fpts[1];\r
1677                         }\r
1678                 }\r
1679                 #endregion\r
1680 \r
1681                 #region TranslateClip\r
1682                 public void TranslateClip (int dx, int dy) {\r
1683                         TranslateClip((float)dx, (float)dy);\r
1684                 }\r
1685 \r
1686                 \r
1687                 public void TranslateClip (float dx, float dy) {\r
1688                         geom.Area clip = GetNativeClip();\r
1689                         clip.transform(geom.AffineTransform.getTranslateInstance(dx, dy));\r
1690                         SetNativeClip(clip);\r
1691                 }\r
1692                 #endregion\r
1693 \r
1694                 #region TranslateTransform\r
1695                 public void TranslateTransform (float dx, float dy) {\r
1696                         TranslateTransform (dx, dy, MatrixOrder.Prepend);\r
1697                 }\r
1698 \r
1699                 \r
1700                 public void TranslateTransform (float dx, float dy, MatrixOrder order) {\r
1701                         ConcatenateTransform(\r
1702                                 geom.AffineTransform.getTranslateInstance(dx, dy), \r
1703                                 order);\r
1704                 }\r
1705                 #endregion\r
1706 \r
1707                 #region Properties [Partial TODO]\r
1708                 public Region Clip {\r
1709                         get {\r
1710                                 java.awt.Graphics2D g = NativeObject;\r
1711                                 java.awt.Shape s = g.getClip();                         \r
1712                                 if(s != null) {\r
1713                                         return new Region(new java.awt.geom.Area(s));\r
1714                                 }\r
1715                                 else {\r
1716                                         return Region.InfiniteRegion.Clone();\r
1717                                 }\r
1718                         }\r
1719                         set {\r
1720                                 SetClip (value, CombineMode.Replace);\r
1721                         }\r
1722                 }\r
1723 \r
1724                 public RectangleF ClipBounds {\r
1725                         get {\r
1726                                 java.awt.Graphics2D g = NativeObject;\r
1727                                 java.awt.Rectangle r = g.getClipBounds();\r
1728                                 RectangleF rect = new RectangleF ((float)r.getX(),(float)r.getY(),(float)r.getWidth(),(float)r.getHeight());\r
1729                                 return rect;\r
1730                         }\r
1731                 }\r
1732 \r
1733                 public CompositingMode CompositingMode {\r
1734                         //TBD:check this carefully\r
1735                         get {\r
1736                                 return (NativeObject.getComposite() == awt.AlphaComposite.SrcOver) ?\r
1737                                         CompositingMode.SourceOver : CompositingMode.SourceCopy;\r
1738                         }\r
1739                         set {\r
1740                                 NativeObject.setComposite(\r
1741                                         (value == CompositingMode.SourceOver) ?\r
1742                                         awt.AlphaComposite.SrcOver : awt.AlphaComposite.Src);\r
1743                         }\r
1744 \r
1745                 }\r
1746 \r
1747                 public CompositingQuality CompositingQuality {\r
1748                         get {\r
1749                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
1750                                 if(hints.containsKey(awt.RenderingHints.KEY_ALPHA_INTERPOLATION)) {\r
1751                                         object value_ai = hints.get(awt.RenderingHints.KEY_ALPHA_INTERPOLATION);\r
1752 \r
1753                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED)\r
1754                                                 return CompositingQuality.HighSpeed;\r
1755                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY)\r
1756                                                 return CompositingQuality.HighQuality;\r
1757                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT)\r
1758                                                 return CompositingQuality.Default;\r
1759                                 }\r
1760 \r
1761                                 return CompositingQuality.Default;\r
1762                                         \r
1763                         }\r
1764                         set {\r
1765                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
1766                                 switch (value) {\r
1767                                         case CompositingQuality.AssumeLinear:\r
1768                                         case CompositingQuality.Default:\r
1769                                         case CompositingQuality.GammaCorrected:\r
1770                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
1771                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);\r
1772                                                 break;\r
1773                                         case CompositingQuality.HighQuality:\r
1774                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
1775                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);\r
1776                                                 break;\r
1777                                         case CompositingQuality.HighSpeed:\r
1778                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
1779                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);\r
1780                                                 break;\r
1781 //                                      case CompositingQuality.Invalid:\r
1782 //                                              if(hints.containsKey(awt.RenderingHints.KEY_ALPHA_INTERPOLATION))\r
1783 //                                                      hints.remove(awt.RenderingHints.KEY_ALPHA_INTERPOLATION);\r
1784                                 }\r
1785 \r
1786                                 NativeObject.setRenderingHints(hints);\r
1787                         }\r
1788                 }\r
1789 \r
1790                 public float DpiX {\r
1791                         get {                           \r
1792                                 return DefaultScreenResolution;\r
1793                         }\r
1794                 }\r
1795 \r
1796                 public float DpiY {\r
1797                         get {\r
1798                                 //TBD: assume 72 (screen) for now\r
1799                                 return DpiX;\r
1800                         }\r
1801                 }\r
1802 \r
1803                 public InterpolationMode InterpolationMode {\r
1804                         get {                           \r
1805                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
1806                                 if(hints.containsKey(awt.RenderingHints.KEY_INTERPOLATION)) {\r
1807                                         object value_i = hints.get(awt.RenderingHints.KEY_INTERPOLATION);\r
1808 \r
1809                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR)\r
1810                                                 return InterpolationMode.Bilinear;\r
1811                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC)\r
1812                                                 return InterpolationMode.Bicubic;\r
1813                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)\r
1814                                                 return InterpolationMode.NearestNeighbor;\r
1815                                 }\r
1816 \r
1817                                 return InterpolationMode.Default;\r
1818                         }\r
1819                         set {\r
1820                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
1821 \r
1822                                 switch (value) {\r
1823                                         case InterpolationMode.Bicubic:\r
1824                                         case InterpolationMode.HighQualityBicubic:\r
1825                                         case InterpolationMode.Low:\r
1826                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC);\r
1827                                                 break;\r
1828                                         case InterpolationMode.High:\r
1829                                         case InterpolationMode.Bilinear:\r
1830                                         case InterpolationMode.HighQualityBilinear:\r
1831                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR);\r
1832                                                 break;\r
1833                                         case InterpolationMode.Default:\r
1834                                                 if (hints.containsKey(awt.RenderingHints.KEY_INTERPOLATION))\r
1835                                                         hints.remove(awt.RenderingHints.KEY_INTERPOLATION);\r
1836                                                 break;\r
1837                                         case InterpolationMode.NearestNeighbor:\r
1838                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);\r
1839                                                 break;\r
1840                                         case InterpolationMode.Invalid:\r
1841                                                 throw new ArgumentException();\r
1842                                         default:\r
1843                                                 throw new ArgumentOutOfRangeException();\r
1844                                 }\r
1845 \r
1846                                 NativeObject.setRenderingHints(hints);\r
1847                         }\r
1848                 }\r
1849 \r
1850                 public bool IsClipEmpty {\r
1851                         get {\r
1852                                 java.awt.Graphics2D g = NativeObject;\r
1853                                 awt.Shape clip = g.getClip();\r
1854                                 if (clip == null)\r
1855                                         return false;\r
1856                                 return new geom.Area(clip).isEmpty();\r
1857                         }\r
1858                 }\r
1859 \r
1860                 public bool IsVisibleClipEmpty {\r
1861                         get {\r
1862                                 awt.Shape clip = NativeObject.getClip();\r
1863                                 if (clip == null)\r
1864                                         return false;\r
1865                                 return !clip.intersects(0, 0, _image.Width, _image.Height);\r
1866                         }\r
1867                 }\r
1868 \r
1869                 public float PageScale {\r
1870                         get {\r
1871                                 return _pageScale;\r
1872                         }\r
1873                         set {\r
1874                                 _pageScale = value;\r
1875                                 UpdateInternalTransform();\r
1876                         }\r
1877                 }\r
1878 \r
1879                 public GraphicsUnit PageUnit {\r
1880                         get {\r
1881                                 return _pageUnit;\r
1882                         }\r
1883                         set {\r
1884                                 _pageUnit = value;\r
1885                                 UpdateInternalTransform();\r
1886                         }\r
1887                 }\r
1888 \r
1889                 internal void UpdateInternalTransform()\r
1890                 {\r
1891                         float new_scale = _pageScale * _unitConversion[ (int)PageUnit ];\r
1892                         Matrix mx = _transform.Clone();\r
1893 \r
1894                         mx.Scale( new_scale, new_scale, MatrixOrder.Prepend );\r
1895                         mx.Translate(\r
1896                                 mx.OffsetX * new_scale - mx.OffsetX,\r
1897                                 mx.OffsetY * new_scale - mx.OffsetY, MatrixOrder.Append);\r
1898 \r
1899                         java.awt.Graphics2D g = NativeObject;\r
1900                         g.setTransform( mx.NativeObject );\r
1901                 }\r
1902 \r
1903                 public PixelOffsetMode PixelOffsetMode {\r
1904                         get {\r
1905                                 return _pixelOffsetMode;\r
1906                         }\r
1907                         set {\r
1908                                 _pixelOffsetMode = value;\r
1909                         }\r
1910                 }\r
1911 \r
1912                 public Point RenderingOrigin {\r
1913                         get {\r
1914                                 throw new NotImplementedException();\r
1915                         }\r
1916                         set {\r
1917                                 throw new NotImplementedException();\r
1918                         }\r
1919                 }\r
1920 \r
1921                 public SmoothingMode SmoothingMode {\r
1922                         get {\r
1923                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
1924                                 if(hints.containsKey(awt.RenderingHints.KEY_ANTIALIASING)) {\r
1925                                         object value_aa = hints.get(awt.RenderingHints.KEY_ANTIALIASING);\r
1926                                         if (value_aa == awt.RenderingHints.VALUE_ANTIALIAS_ON) {\r
1927                                                 if(hints.containsKey(awt.RenderingHints.KEY_RENDERING)) {\r
1928                                                         object value_render = hints.get(awt.RenderingHints.KEY_RENDERING);\r
1929                                                         if (value_render == awt.RenderingHints.VALUE_RENDER_QUALITY)\r
1930                                                                 return SmoothingMode.HighQuality;\r
1931                                                         if (value_render == awt.RenderingHints.VALUE_RENDER_SPEED)\r
1932                                                                 return SmoothingMode.HighSpeed;\r
1933                                                 }\r
1934 \r
1935                                                 return SmoothingMode.AntiAlias;\r
1936                                         }\r
1937 \r
1938                                         if (value_aa == awt.RenderingHints.VALUE_ANTIALIAS_DEFAULT)\r
1939                                                 return SmoothingMode.Default;\r
1940                                 }\r
1941                                 return SmoothingMode.None;\r
1942 \r
1943                         }\r
1944 \r
1945                         set {\r
1946                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
1947 \r
1948                                 switch (value) {\r
1949                                         case SmoothingMode.None:\r
1950                                         case SmoothingMode.Invalid:\r
1951                                                 if(hints.containsKey(awt.RenderingHints.KEY_ANTIALIASING))\r
1952                                                         hints.remove(awt.RenderingHints.KEY_ANTIALIASING);\r
1953                                                 if(hints.containsKey(awt.RenderingHints.KEY_RENDERING))\r
1954                                                         hints.remove(awt.RenderingHints.KEY_RENDERING);\r
1955                                                 break;\r
1956                                         case SmoothingMode.AntiAlias:\r
1957                                                 hints.put(awt.RenderingHints.KEY_ANTIALIASING, awt.RenderingHints.VALUE_ANTIALIAS_ON);\r
1958                                                 break;\r
1959                                         case SmoothingMode.HighQuality:\r
1960                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_QUALITY);\r
1961                                                 goto case SmoothingMode.AntiAlias;\r
1962                                         case SmoothingMode.HighSpeed:\r
1963                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_SPEED);\r
1964                                                 goto case SmoothingMode.AntiAlias;\r
1965                                         case SmoothingMode.Default:\r
1966                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_DEFAULT);\r
1967                                                 goto case SmoothingMode.AntiAlias;\r
1968                                 }\r
1969 \r
1970                                 NativeObject.setRenderingHints(hints);\r
1971                         }\r
1972                 }\r
1973 \r
1974                 /// <summary>\r
1975                 /// Java does not have similar functionality\r
1976                 /// </summary>\r
1977                 public int TextContrast {\r
1978                         get {\r
1979                                 return _textContrast;\r
1980                         }\r
1981 \r
1982                         set {\r
1983                                 _textContrast = value;\r
1984                         }\r
1985                 }\r
1986 \r
1987                 public TextRenderingHint TextRenderingHint {\r
1988                         get {\r
1989                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
1990                                 if(hints.containsKey(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING)) {\r
1991                                         if(hints.get(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING) == \r
1992                                                 java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON)\r
1993                                                 return TextRenderingHint.AntiAlias;\r
1994                                         if(hints.get(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING) == \r
1995                                                 java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_OFF)\r
1996                                                 return TextRenderingHint.SingleBitPerPixel;\r
1997                                 }\r
1998                                 return TextRenderingHint.SystemDefault;\r
1999                         }\r
2000 \r
2001                         set {\r
2002                                 // TODO implement\r
2003                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2004                                 switch (value) {\r
2005                                         case TextRenderingHint.AntiAlias:\r
2006                                         case TextRenderingHint.AntiAliasGridFit:\r
2007                                         case TextRenderingHint.ClearTypeGridFit:\r
2008                                         case TextRenderingHint.SingleBitPerPixel:\r
2009                                         case TextRenderingHint.SingleBitPerPixelGridFit:\r
2010                                         case TextRenderingHint.SystemDefault:\r
2011                                                 break;\r
2012                                 }\r
2013                         }\r
2014                 }\r
2015 \r
2016                 public Matrix Transform {\r
2017                         get {\r
2018                                 return _transform;\r
2019                         }\r
2020                         set {\r
2021                                 _transform = value.Clone();\r
2022                                 UpdateInternalTransform();\r
2023                         }\r
2024                 }\r
2025 \r
2026                 public RectangleF VisibleClipBounds {\r
2027                         get {\r
2028                                 RectangleF bounds = ClipBounds;\r
2029                                 bounds.Intersect(new RectangleF(0, 0, _image.Width, _image.Height));\r
2030                                 return bounds;\r
2031                         }\r
2032                 }\r
2033 \r
2034                 void ConcatenateTransform(geom.AffineTransform transform, MatrixOrder order) {\r
2035                         geom.AffineTransform at = _transform.NativeObject;\r
2036                         Matrix.Multiply(at, transform, order);\r
2037 \r
2038                         UpdateInternalTransform();\r
2039                 }\r
2040                 #endregion\r
2041         }\r
2042 }\r
2043 \r