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.Collections;\r
   7 using System.Runtime.InteropServices;\r
   8 using System.Text;\r
   9 using awt = java.awt;\r
  10 using geom = java.awt.geom;\r
  11 \r
  12 namespace System.Drawing {\r
  13         [ComVisible(false)]\r
  14         public sealed class Graphics : MarshalByRefObject, IDisposable {\r
  15                 sealed class DummyStroke : awt.Stroke {\r
  16                         #region Stroke Members\r
  17 \r
  18                         awt.Shape awt.Stroke.createStrokedShape(awt.Shape arg_0) {\r
  19                                 throw new NotImplementedException("DummyStroke");\r
  20                         }\r
  21 \r
  22                         #endregion\r
  23                 }\r
  24 \r
  25                 sealed class NormalizingPathIterator : geom.PathIterator {\r
  26 \r
  27                         #region fields\r
  28 \r
  29                         readonly geom.PathIterator _iter;\r
  30 \r
  31                         const float norm = 0.5f;\r
  32                         const float rnd = (1.0f - norm);\r
  33                         float ax = 0.0f;\r
  34                         float ay = 0.0f;\r
  35 \r
  36                         #endregion\r
  37 \r
  38                         #region ctor\r
  39 \r
  40                         public NormalizingPathIterator(geom.PathIterator iter) {\r
  41                                 _iter = iter;\r
  42                         }\r
  43 \r
  44                         #endregion\r
  45 \r
  46                         #region methods\r
  47 \r
  48                         static int GetIndex(int type) {\r
  49                                 int index;\r
  50                                 switch ((GraphicsPath.JPI)type) {\r
  51                                         case GraphicsPath.JPI.SEG_CUBICTO:\r
  52                                                 index = 4;\r
  53                                                 break;\r
  54                                         case GraphicsPath.JPI.SEG_QUADTO:\r
  55                                                 index = 2;\r
  56                                                 break;\r
  57                                         case GraphicsPath.JPI.SEG_MOVETO:\r
  58                                         case GraphicsPath.JPI.SEG_LINETO:\r
  59                                                 index = 0;\r
  60                                                 break;\r
  61                                         case GraphicsPath.JPI.SEG_CLOSE:\r
  62                                         default:\r
  63                                                 index = -1;\r
  64                                                 break;\r
  65                                 }\r
  66 \r
  67                                 return index;\r
  68                         }\r
  69 \r
  70                         #endregion\r
  71 \r
  72                         #region PathIterator Members\r
  73 \r
  74                         void geom.PathIterator.next() {\r
  75                                 _iter.next();\r
  76                         }\r
  77 \r
  78                         bool geom.PathIterator.isDone() {\r
  79                                 return _iter.isDone();\r
  80                         }\r
  81 \r
  82                         int geom.PathIterator.currentSegment(float[] point) {\r
  83                                 int type = _iter.currentSegment(point);\r
  84 \r
  85                                 int index = GetIndex(type);\r
  86                                 \r
  87                                 if (index >= 0) {\r
  88                                         float ox = point[index];\r
  89                                         float oy = point[index+1];\r
  90                                         float newax = (float) java.lang.Math.floor(ox + rnd) + norm;\r
  91                                         float neway = (float) java.lang.Math.floor(oy + rnd) + norm;\r
  92                                         point[index] = newax;\r
  93                                         point[index+1] = neway;\r
  94                                         newax -= ox;\r
  95                                         neway -= oy;\r
  96                                         switch ((GraphicsPath.JPI)type) {\r
  97                                                 case GraphicsPath.JPI.SEG_CUBICTO:\r
  98                                                         point[0] += ax;\r
  99                                                         point[1] += ay;\r
 100                                                         point[2] += newax;\r
 101                                                         point[3] += neway;\r
 102                                                         break;\r
 103                                                 case GraphicsPath.JPI.SEG_QUADTO:\r
 104                                                         point[0] += (newax + ax) / 2;\r
 105                                                         point[1] += (neway + ay) / 2;\r
 106                                                         break;\r
 107                                                         //                                                      case GraphicsPath.JPI.SEG_MOVETO:\r
 108                                                         //                                                      case GraphicsPath.JPI.SEG_LINETO:\r
 109                                                         //                                                      case GraphicsPath.JPI.SEG_CLOSE:\r
 110                                                         //                                                              break;\r
 111                                         }\r
 112                                         ax = newax;\r
 113                                         ay = neway;\r
 114                                 }\r
 115 \r
 116                                 return type;\r
 117                         }\r
 118 \r
 119                         int geom.PathIterator.currentSegment(double[] point) {\r
 120                                 int type = _iter.currentSegment(point);\r
 121 \r
 122                                 int index = GetIndex(type);\r
 123 \r
 124                                 if (index >= 0) {\r
 125                                         float ox = (float)point[index];\r
 126                                         float oy = (float)point[index+1];\r
 127                                         float newax = (float)java.lang.Math.floor(ox + rnd) + norm;\r
 128                                         float neway = (float)java.lang.Math.floor(oy + rnd) + norm;\r
 129                                         point[index] = newax;\r
 130                                         point[index+1] = neway;\r
 131                                         newax -= ox;\r
 132                                         neway -= oy;\r
 133                                         switch ((GraphicsPath.JPI)type) {\r
 134                                                 case GraphicsPath.JPI.SEG_CUBICTO:\r
 135                                                         point[0] += ax;\r
 136                                                         point[1] += ay;\r
 137                                                         point[2] += newax;\r
 138                                                         point[3] += neway;\r
 139                                                         break;\r
 140                                                 case GraphicsPath.JPI.SEG_QUADTO:\r
 141                                                         point[0] += (newax + ax) / 2;\r
 142                                                         point[1] += (neway + ay) / 2;\r
 143                                                         break;\r
 144                                                         //                                                      case GraphicsPath.JPI.SEG_MOVETO:\r
 145                                                         //                                                      case GraphicsPath.JPI.SEG_LINETO:\r
 146                                                         //                                                      case GraphicsPath.JPI.SEG_CLOSE:\r
 147                                                         //                                                              break;\r
 148                                         }\r
 149                                         ax = newax;\r
 150                                         ay = neway;\r
 151                                 }\r
 152 \r
 153                                 return type;\r
 154                         }\r
 155 \r
 156                         int geom.PathIterator.getWindingRule() {\r
 157                                 return _iter.getWindingRule();\r
 158                         }\r
 159 \r
 160                         #endregion\r
 161 \r
 162                 }\r
 163 \r
 164 \r
 165                 #region Variables\r
 166 \r
 167                 readonly awt.Graphics2D _nativeObject;\r
 168                 PixelOffsetMode _pixelOffsetMode = PixelOffsetMode.Default;\r
 169                 int _textContrast = 4;\r
 170                 TextRenderingHint _textRenderingHint;\r
 171                 readonly Image _image;\r
 172                 \r
 173                 readonly Matrix _transform;\r
 174                 GraphicsUnit _pageUnit = GraphicsUnit.Display;\r
 175                 float _pageScale = 1.0f;\r
 176 \r
 177                 readonly Region _clip;\r
 178                 readonly awt.Rectangle _windowRect;\r
 179 \r
 180                 GraphicsState _nextGraphicsState = null;\r
 181 \r
 182                 static readonly float [] _unitConversion = {\r
 183                                                                                                            1,                                                           // World\r
 184                                                                                                            1,                                                           // Display\r
 185                                                                                                            1,                                                           // Pixel\r
 186                                                                                                            DefaultScreenResolution / 72.0f,     // Point\r
 187                                                                                                            DefaultScreenResolution,                     // Inch\r
 188                                                                                                            DefaultScreenResolution / 300.0f,// Document\r
 189                                                                                                            DefaultScreenResolution / 25.4f      // Millimeter\r
 190                                                                                                    };\r
 191 \r
 192                 static int _isHeadless;\r
 193                 static internal bool IsHeadless {\r
 194                         get {\r
 195                                 if (_isHeadless == 0) {\r
 196                                         bool isHeadless = awt.GraphicsEnvironment.isHeadless();\r
 197                                         if (!isHeadless) {\r
 198                                                 try {\r
 199                                                         awt.Toolkit.getDefaultToolkit();\r
 200                                                 }\r
 201                                                 catch{\r
 202                                                         isHeadless = true;\r
 203                                                 }\r
 204                                         }\r
 205 \r
 206                                         _isHeadless = isHeadless ? 2 : 1;\r
 207                                 }\r
 208 \r
 209                                 return _isHeadless > 1;\r
 210                         }\r
 211                 }\r
 212         \r
 213                 #endregion\r
 214 \r
 215 #if INTPTR_SUPPORT\r
 216                 [ComVisible(false)]\r
 217                 public delegate bool EnumerateMetafileProc (EmfPlusRecordType recordType,\r
 218                                                             int flags,\r
 219                                                             int dataSize,\r
 220                                                             IntPtr data,\r
 221                                                             PlayRecordCallback callbackData);\r
 222                 [ComVisible (false)]\r
 223                         public delegate bool DrawImageAbort (IntPtr callbackData);              \r
 224 #endif                  \r
 225 \r
 226                 #region Constr. and Destr.\r
 227                 private Graphics (Image image) {\r
 228                         _nativeObject = (awt.Graphics2D)image.NativeObject.CurrentImage.NativeImage.getGraphics();\r
 229                         _image = image;\r
 230                         _transform = new Matrix ();\r
 231 \r
 232                         NativeObject.setStroke(new DummyStroke());\r
 233                         NativeObject.setRenderingHint(awt.RenderingHints.KEY_COLOR_RENDERING, awt.RenderingHints.VALUE_COLOR_RENDER_QUALITY);\r
 234 \r
 235                         InterpolationMode = InterpolationMode.Bilinear;\r
 236                         TextRenderingHint = TextRenderingHint.SystemDefault;\r
 237 \r
 238                         _windowRect = new awt.Rectangle(_image.Width, _image.Height);\r
 239                         _clip = new Region();\r
 240                 }\r
 241 \r
 242                 #endregion\r
 243                 \r
 244                 #region Internal Accessors\r
 245 \r
 246                 static internal float [] UnitConversion {\r
 247                         get {\r
 248                                 return _unitConversion;\r
 249                         }\r
 250                 }\r
 251                 \r
 252                 static internal int DefaultScreenResolution {\r
 253                         get {\r
 254                                 return IsHeadless ? 96 :\r
 255                                         awt.Toolkit.getDefaultToolkit().getScreenResolution();\r
 256                         }\r
 257                 }\r
 258                 \r
 259                 internal java.awt.Graphics2D NativeObject {\r
 260                         get {\r
 261                                 return _nativeObject;\r
 262                         }\r
 263                 }\r
 264                 #endregion\r
 265 \r
 266                 #region FromImage (static accessor)\r
 267                 public static Graphics FromImage (Image image) {                \r
 268                         return new Graphics(image);\r
 269                 }\r
 270                 #endregion\r
 271 \r
 272 \r
 273                 #region Workers [INTERNAL]\r
 274                 void DrawShape(Pen pen, awt.Shape shape) {\r
 275                         if (pen == null)\r
 276                                 throw new ArgumentNullException("pen");\r
 277 \r
 278                         if (StrokeFactory.CanCreateAdvancedStroke && \r
 279                                 (!pen.CanCreateBasicStroke || !NeedsNormalization)) {\r
 280                                 geom.AffineTransform oldT = NativeObject.getTransform();\r
 281                                 NativeObject.setTransform(Matrix.IdentityTransform.NativeObject);\r
 282 \r
 283                                 try {\r
 284                                         geom.AffineTransform t = GetFinalTransform();\r
 285                                         if (!oldT.isIdentity()) {\r
 286                                                 t = (geom.AffineTransform)t.clone();\r
 287                                                 t.preConcatenate(oldT);\r
 288                                         }\r
 289                                         \r
 290                                         double widthsquared = pen.GetSquaredTransformedWidth(t);\r
 291 \r
 292                                         bool antiAlias = (SmoothingMode == SmoothingMode.AntiAlias);\r
 293 \r
 294                                         bool thin = (widthsquared <= (antiAlias ? \r
 295                                                 AdvancedStroke.MinPenSizeAASquared :\r
 296                                                 AdvancedStroke.MinPenSizeSquared));\r
 297 \r
 298                                         PenFit penFit = thin ? (antiAlias ? PenFit.ThinAntiAlias : PenFit.Thin) : PenFit.NotThin;\r
 299 \r
 300                                         if (NeedsNormalization) {\r
 301 \r
 302                                                 bool normThin = \r
 303                                                         widthsquared <= AdvancedStroke.MinPenSizeSquaredNorm;\r
 304 \r
 305                                                 if (normThin) {\r
 306                                                         shape = GetNormalizedShape(shape, t);\r
 307                                                         shape = pen.GetNativeObject(\r
 308                                                                 t, null, penFit).createStrokedShape(shape);\r
 309                                                 }\r
 310                                                 else {\r
 311                                                         shape = pen.GetNativeObject(t, penFit).createStrokedShape(shape);\r
 312                                                         shape = GetNormalizedShape(shape, null);\r
 313                                                 }\r
 314                                         }\r
 315                                         else {\r
 316                                                 shape = pen.GetNativeObject(t, penFit).createStrokedShape(shape);\r
 317                                         }\r
 318 \r
 319                                         FillScaledShape(pen.Brush, shape);\r
 320                                 }\r
 321                                 finally {\r
 322                                         NativeObject.setTransform(oldT);\r
 323                                 }\r
 324                         }\r
 325                         else {\r
 326                                 awt.Stroke oldStroke = NativeObject.getStroke();\r
 327                                 NativeObject.setStroke(pen.GetNativeObject(null, PenFit.NotThin));\r
 328                                 try {\r
 329 \r
 330                                         NativeObject.setPaint(pen.Brush);\r
 331 \r
 332                                         geom.AffineTransform oldT = NativeObject.getTransform();\r
 333                                         NativeObject.transform(GetFinalTransform());\r
 334                                         try {\r
 335                                                 NativeObject.draw(shape);\r
 336                                         }\r
 337                                         finally {\r
 338                                                 NativeObject.setTransform(oldT);\r
 339                                         }\r
 340                                 }\r
 341                                 finally {\r
 342                                         NativeObject.setStroke(oldStroke);\r
 343                                 }\r
 344                         }\r
 345                 }\r
 346                 void FillShape(Brush paint, awt.Shape shape) {\r
 347                         if (paint == null)\r
 348                                 throw new ArgumentNullException("brush");\r
 349 \r
 350                         geom.AffineTransform oldT = null;\r
 351                         if (NeedsNormalization) {\r
 352                                 oldT = NativeObject.getTransform();\r
 353                                 geom.AffineTransform t = GetFinalTransform();\r
 354                                 if (!oldT.isIdentity()) {\r
 355                                         t = (geom.AffineTransform)t.clone();\r
 356                                         t.preConcatenate(oldT);\r
 357                                 }\r
 358                                 shape = GetNormalizedShape(shape, t);\r
 359                         }\r
 360                         else {\r
 361                                 geom.AffineTransform t = GetFinalTransform();\r
 362                                 if (!t.isIdentity())\r
 363                                         shape = t.createTransformedShape(shape);\r
 364                         }\r
 365 \r
 366                         if (oldT != null)\r
 367                                 NativeObject.setTransform(Matrix.IdentityTransform.NativeObject);\r
 368 \r
 369                         try {\r
 370                                 FillScaledShape(paint, shape);\r
 371                         }\r
 372                         finally {\r
 373                                 if (oldT != null)\r
 374                                         NativeObject.setTransform(oldT);\r
 375                         }\r
 376                 }\r
 377 \r
 378                 bool NeedsNormalization {\r
 379                         get {\r
 380                                 return PixelOffsetMode != PixelOffsetMode.Half &&\r
 381                                         PixelOffsetMode != PixelOffsetMode.HighQuality;\r
 382                         }\r
 383                 }\r
 384 \r
 385                 static awt.Shape GetNormalizedShape(awt.Shape shape, geom.AffineTransform t) {\r
 386                         geom.PathIterator iter = new NormalizingPathIterator(shape.getPathIterator(t));\r
 387         \r
 388                         geom.GeneralPath path = new geom.GeneralPath(iter.getWindingRule());\r
 389                         path.append(iter, false);\r
 390                         return path;\r
 391                 }\r
 392 \r
 393                 void FillScaledShape(Brush paint, awt.Shape shape) {\r
 394                         Matrix m = null;\r
 395                         if (!(paint is SolidBrush || paint is HatchBrush) && !_transform.IsIdentity) {\r
 396                                 m = paint.BrushTransform;\r
 397                                 paint.BrushMultiplyTransform( _transform );\r
 398                         }\r
 399 \r
 400                         try {\r
 401                                 NativeObject.setPaint(paint);\r
 402                                 NativeObject.fill(shape);\r
 403                         }\r
 404                         finally {\r
 405                                 if (m != null)\r
 406                                         paint.BrushTransform = m;\r
 407                         }\r
 408                 }\r
 409 \r
 410                 internal SizeF MeasureDraw (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format, bool fDraw) {                    \r
 411                         SizeF retVal = new SizeF(0,0);\r
 412                         awt.Graphics2D g = NativeObject;\r
 413                                 \r
 414                         java.awt.Font fnt = font.NativeObject;\r
 415                         if(s != null && s.Length != 0 && fnt != null) {\r
 416                                 float size = fnt.getSize();\r
 417                                 float wid = layoutRectangle.Width;\r
 418                                 float hei = layoutRectangle.Height;\r
 419                                 float x = layoutRectangle.X;\r
 420                                 float y = layoutRectangle.Y;\r
 421                                 java.text.AttributedString astr = new java.text.AttributedString(s);\r
 422                                 astr.addAttribute(java.awt.font.TextAttribute.FONT, fnt);\r
 423                                 java.text.AttributedCharacterIterator prg = astr.getIterator();\r
 424                                 java.awt.font.TextLayout textlayout = new java.awt.font.TextLayout(prg, g.getFontRenderContext());\r
 425                                 int prgStart = prg.getBeginIndex();\r
 426                                 int prgEnd = prg.getEndIndex();\r
 427                                 java.awt.font.LineBreakMeasurer lineMeasurer = new java.awt.font.LineBreakMeasurer(\r
 428                                         prg, new java.awt.font.FontRenderContext(null, false, false));\r
 429                                 lineMeasurer.setPosition(prgStart);\r
 430                                 float formatWidth = wid;\r
 431                                 \r
 432                                 //some vertical layout magic - should be reviewed\r
 433                                 //                              if(format != null)\r
 434                                 //                              {\r
 435                                 //                                      StringFormatFlags formatflag = format.FormatFlags;\r
 436                                 //                                      if(formatflag != StringFormatFlags.DirectionVertical)\r
 437                                 //                                      {\r
 438                                 //                                              if(size > (float)8 && wid > (float)13)\r
 439                                 //                                                      formatWidth = wid - (float)12;\r
 440                                 //                                              if(formatflag ==  StringFormatFlags.DirectionRightToLeft && size == (float)6)\r
 441                                 //                                                      formatWidth = wid - (float)10;\r
 442                                 //                                      }\r
 443                                 //                              }\r
 444 \r
 445                                 //now calculate number of lines and full layout height\r
 446                                 //this is required for LineAlignment calculations....\r
 447                                 int lines=0;\r
 448                                 float layHeight=0;\r
 449                                 float layPrevHeight=0;\r
 450                                 float layWidth=0;\r
 451                                 float drawPosY = y;\r
 452                                 //bool fSkipLastLine = false;\r
 453                                 java.awt.font.TextLayout layout;\r
 454                                 java.awt.geom.Rectangle2D bnds = new java.awt.geom.Rectangle2D.Float();\r
 455                                 while(lineMeasurer.getPosition() < prgEnd) {\r
 456                                         layout = lineMeasurer.nextLayout(formatWidth);\r
 457                                         lines++;\r
 458                                         bnds = bnds.createUnion(layout.getBounds());\r
 459                                         layPrevHeight = layHeight;\r
 460                                         layHeight += layout.getDescent() + layout.getLeading() + layout.getAscent();\r
 461                                         float advance;\r
 462                                         if((format != null) && \r
 463                                                 ((format.FormatFlags & StringFormatFlags.MeasureTrailingSpaces) != 0))\r
 464                                                 advance = layout.getAdvance();\r
 465                                         else\r
 466                                                 advance = layout.getVisibleAdvance();\r
 467                                         if(layWidth < advance)\r
 468                                                 layWidth = advance;\r
 469                                         if((format != null) && ((format.FormatFlags & StringFormatFlags.NoWrap) != 0))\r
 470                                                 break;\r
 471                                 }\r
 472                                 //Overhanging parts of glyphs, and unwrapped text reaching outside \r
 473                                 //the formatting rectangle are allowed to show. By default all text \r
 474                                 //and glyph parts reaching outside the formatting rectangle are clipped.\r
 475                                 if((lines == 1) && \r
 476                                         (format != null) && \r
 477                                         ((format.FormatFlags & StringFormatFlags.NoClip) != 0)) {\r
 478                                         formatWidth = layWidth;                                 \r
 479                                 }\r
 480 \r
 481                                 //Only entire lines are laid out in the formatting rectangle. By default layout \r
 482                                 //continues until the end of the text, or until no more lines are visible as a \r
 483                                 //result of clipping, whichever comes first. Note that the default settings allow \r
 484                                 //the last line to be partially obscured by a formatting rectangle that is not a \r
 485                                 //whole multiple of the line height. To ensure that only whole lines are seen, specify\r
 486                                 //this value and be careful to provide a formatting rectangle at least as tall as the \r
 487                                 //height of one line.\r
 488                                 if(format != null && ((format.FormatFlags & StringFormatFlags.LineLimit) != 0) && \r
 489                                         layHeight > hei && layPrevHeight < hei) {\r
 490                                         layHeight = layPrevHeight;\r
 491                                         lines--;\r
 492                                 }\r
 493 \r
 494                                 retVal.Height = layHeight;\r
 495                                 retVal.Width = layWidth+size/2.5f;\r
 496                                 if(!fDraw)\r
 497                                         return retVal;\r
 498 \r
 499                                 NativeObject.setPaint(brush);\r
 500                                 g.setRenderingHint(awt.RenderingHints.KEY_TEXT_ANTIALIASING, awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);\r
 501 \r
 502                                 //end measurment\r
 503 \r
 504                                 //for draw we should probably update origins\r
 505 \r
 506                                 //Vertical...\r
 507                                 if(format != null) {\r
 508                                         StringAlignment align = format.LineAlignment;\r
 509                                         if(align == StringAlignment.Center) {\r
 510                                                 drawPosY = y + (float)hei/2 - layHeight/2;\r
 511                                         }\r
 512                                         else if(align == StringAlignment.Far) {\r
 513                                                 drawPosY = (float)y + (float)hei - layHeight;\r
 514                                         }\r
 515                                         //in both cases if string is not fit - switch to near\r
 516                                         if(drawPosY < y)\r
 517                                                 drawPosY = y;\r
 518                                 }\r
 519 \r
 520                                 //Horisontal... on the fly\r
 521                                 lineMeasurer.setPosition(prgStart);\r
 522                                 float drawPosX = x;                             \r
 523                                 for(int line = 0;line < lines /*lineMeasurer.getPosition() < prgEnd*/;line++, drawPosY += layout.getDescent() + layout.getLeading()) {\r
 524                                         layout = lineMeasurer.nextLayout(formatWidth);\r
 525                                         drawPosX = x + size / (float)5;//???\r
 526                                         drawPosY += layout.getAscent();\r
 527                                         if(format != null) {\r
 528                                                 float advance;\r
 529                                                 if((format.FormatFlags & StringFormatFlags.MeasureTrailingSpaces) != 0)\r
 530                                                         advance = layout.getAdvance();\r
 531                                                 else\r
 532                                                         advance = layout.getVisibleAdvance();\r
 533                                                 \r
 534                                                 if(format.Alignment == StringAlignment.Center) {\r
 535                                                         drawPosX = (float)((double)x + ((double)formatWidth)/2 - advance/2);\r
 536                                                 }\r
 537                                                 else if(format.Alignment == StringAlignment.Far) {\r
 538                                                         drawPosX = (float)(drawPosX + formatWidth) - advance;\r
 539                                                 }\r
 540                                                 if((format.FormatFlags & StringFormatFlags.DirectionVertical ) != 0) {\r
 541                                                         java.awt.geom.AffineTransform at1 = java.awt.geom.AffineTransform.getTranslateInstance(\r
 542                                                                 drawPosX +  size / (float)5, (drawPosY - layout.getAscent()) + size / (float)5);\r
 543 \r
 544                                                         at1.rotate(Math.PI/2);\r
 545                                                         awt.Shape sha = textlayout.getOutline(at1);\r
 546                                                         geom.AffineTransform t = GetFinalTransform();\r
 547                                                         if (!t.isIdentity())\r
 548                                                                 sha = t.createTransformedShape(sha);\r
 549                                                         //g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);\r
 550                                                         g.fill(sha);\r
 551                                                         continue;\r
 552                                                 }\r
 553                                                 if((format.FormatFlags & StringFormatFlags.DirectionRightToLeft)  != 0) {\r
 554                                                         drawPosX = ((drawPosX + formatWidth) - advance) + (float)9;\r
 555                                                         layout.draw(g, drawPosX, drawPosY);\r
 556                                                 } \r
 557                                         }                                       \r
 558 \r
 559                                         geom.AffineTransform oldT = null;\r
 560                                         geom.AffineTransform ft = GetFinalTransform();\r
 561 \r
 562                                         //Draw current line\r
 563                                         try {\r
 564                                                 if (!ft.isIdentity()) {\r
 565                                                         oldT = NativeObject.getTransform();\r
 566                                                         NativeObject.transform(ft);\r
 567                                                 }\r
 568                                                 layout.draw(g, drawPosX, drawPosY);                                     \r
 569                                         }\r
 570                                         finally {\r
 571                                                 if (oldT != null)\r
 572                                                         NativeObject.setTransform(oldT);\r
 573                                         }\r
 574                                 }\r
 575                         } //not nulls\r
 576 \r
 577                         return retVal;\r
 578                 }\r
 579                 #endregion\r
 580 \r
 581                 #region Dispose\r
 582                 public void Dispose() {                 \r
 583                         NativeObject.dispose();\r
 584                 }\r
 585                 #endregion\r
 586                 \r
 587                 #region Clear\r
 588                 public void Clear (Color color) {\r
 589                         FillScaledShape(new SolidBrush( color ), _clip.NativeObject);\r
 590                 }\r
 591                 #endregion\r
 592 \r
 593                 #region DrawArc\r
 594                 public void DrawArc (Pen pen, Rectangle rect, float startAngle, float sweepAngle) {\r
 595                         DrawArc (pen, \r
 596                                 rect.X, \r
 597                                 rect.Y, \r
 598                                 rect.Width, \r
 599                                 rect.Height, \r
 600                                 startAngle, \r
 601                                 sweepAngle);\r
 602                 }\r
 603 \r
 604                 \r
 605                 public void DrawArc (Pen pen, RectangleF rect, float startAngle, float sweepAngle) {\r
 606                         DrawArc (pen, \r
 607                                 rect.X, \r
 608                                 rect.Y, \r
 609                                 rect.Width, \r
 610                                 rect.Height, \r
 611                                 startAngle, \r
 612                                 sweepAngle);\r
 613                 }\r
 614 \r
 615                 public void DrawArc (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle) {\r
 616                         DrawArc(pen,\r
 617                                 (float)x,\r
 618                                 (float)y,\r
 619                                 (float)width,\r
 620                                 (float)height,\r
 621                                 (float)startAngle,\r
 622                                 (float)sweepAngle);\r
 623                 }\r
 624 \r
 625                 public void DrawArc (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle) {\r
 626                         GraphicsPath path = new GraphicsPath();\r
 627                         path.AddArc(x, y, width, height, startAngle, sweepAngle);\r
 628                         DrawPath(pen, path);\r
 629                 }\r
 630                 #endregion\r
 631 \r
 632                 #region DrawBezier(s)\r
 633                 public void DrawBezier (Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4) {\r
 634                         DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);\r
 635                 }\r
 636 \r
 637                 public void DrawBezier (Pen pen, Point pt1, Point pt2, Point pt3, Point pt4) {\r
 638                         DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);\r
 639                 }\r
 640 \r
 641                 public void DrawBezier (Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) {\r
 642                         geom.GeneralPath path = new geom.GeneralPath();\r
 643                         path.moveTo(x1,y1);\r
 644                         path.curveTo(x2,y2,x3,y3,x4,y4);\r
 645                         DrawShape(pen, path);\r
 646                 }\r
 647 \r
 648                 public void DrawBeziers (Pen pen, Point [] points) {\r
 649                         GraphicsPath path = new GraphicsPath();\r
 650                         path.AddBeziers(points);\r
 651                         DrawPath(pen, path);\r
 652                 }\r
 653 \r
 654                 public void DrawBeziers (Pen pen, PointF [] points) {\r
 655                         GraphicsPath path = new GraphicsPath();\r
 656                         path.AddBeziers(points);\r
 657                         DrawPath(pen, path);\r
 658                 }\r
 659                 #endregion \r
 660 \r
 661                 #region DrawClosedCurve\r
 662                 public void DrawClosedCurve (Pen pen, PointF [] points) {\r
 663                         DrawClosedCurve(pen, points, 0.5f, FillMode.Alternate);\r
 664                 }\r
 665                 \r
 666                 public void DrawClosedCurve (Pen pen, Point [] points) {\r
 667                         DrawClosedCurve(pen, points, 0.5f, FillMode.Alternate);\r
 668                 }\r
 669                         \r
 670                 public void DrawClosedCurve (Pen pen, Point [] points, float tension, FillMode fillmode) {\r
 671                         GraphicsPath path = new GraphicsPath(fillmode);\r
 672                         path.AddClosedCurve(points, tension);\r
 673                         DrawPath(pen, path);\r
 674                 }\r
 675                 \r
 676                 public void DrawClosedCurve (Pen pen, PointF [] points, float tension, FillMode fillmode) {\r
 677                         GraphicsPath path = new GraphicsPath(fillmode);\r
 678                         path.AddClosedCurve(points, tension);\r
 679                         DrawPath(pen, path);\r
 680                 }\r
 681                 #endregion\r
 682 \r
 683                 #region DrawCurve\r
 684                 public void DrawCurve (Pen pen, Point [] points) {\r
 685                         DrawCurve(pen, points, 0.5f);\r
 686                 }\r
 687                 \r
 688                 public void DrawCurve (Pen pen, PointF [] points) {\r
 689                         DrawCurve(pen, points, 0.5f);\r
 690                 }\r
 691                 \r
 692                 public void DrawCurve (Pen pen, PointF [] points, float tension) {\r
 693                         DrawCurve(pen, points, 0, points.Length-1, tension);\r
 694                 }\r
 695                 \r
 696                 public void DrawCurve (Pen pen, Point [] points, float tension) {\r
 697                         DrawCurve(pen, points, 0, points.Length-1, tension);\r
 698                 }\r
 699                 \r
 700                 \r
 701                 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments) {\r
 702                         DrawCurve(pen, points, offset, numberOfSegments, 0.5f);\r
 703                 }\r
 704 \r
 705                 public void DrawCurve (Pen pen, Point [] points, int offset, int numberOfSegments, float tension) {\r
 706                         GraphicsPath path = new GraphicsPath();\r
 707                         path.AddCurve(points, offset, numberOfSegments, tension);\r
 708                         DrawPath(pen, path);\r
 709                 }\r
 710 \r
 711                 \r
 712                 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments, float tension) {\r
 713                         GraphicsPath path = new GraphicsPath();\r
 714                         path.AddCurve(points, offset, numberOfSegments, tension);\r
 715                         DrawPath(pen, path);\r
 716                 }\r
 717                 #endregion\r
 718 \r
 719                 #region DrawEllipse\r
 720                 public void DrawEllipse (Pen pen, Rectangle rect) {\r
 721                         DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);\r
 722                 }\r
 723 \r
 724                 public void DrawEllipse (Pen pen, RectangleF rect) {\r
 725                         DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);\r
 726                 }\r
 727 \r
 728                 public void DrawEllipse (Pen pen, int x, int y, int width, int height) {\r
 729                         DrawEllipse(pen,(float)x,(float)y,(float)width,(float)height);\r
 730                 }\r
 731 \r
 732                 public void DrawEllipse (Pen pen, float x, float y, float width, float height) {\r
 733                         DrawShape(pen, new geom.Ellipse2D.Float(x,y,width,height));\r
 734                 }\r
 735                 #endregion\r
 736 \r
 737                 #region DrawIcon\r
 738                 public void DrawIcon (Icon icon, Rectangle targetRect) {\r
 739                         Bitmap b = icon.ToBitmap ();\r
 740                         this.DrawImage (b, targetRect);\r
 741                 }\r
 742 \r
 743                 public void DrawIcon (Icon icon, int x, int y) {\r
 744                         Bitmap b = icon.ToBitmap ();\r
 745                         this.DrawImage (b, x, y);\r
 746                 }\r
 747 \r
 748                 public void DrawIconUnstretched (Icon icon, Rectangle targetRect) {\r
 749                         Bitmap b = icon.ToBitmap ();\r
 750                         this.DrawImageUnscaled (b, targetRect);\r
 751                 }\r
 752                 #endregion\r
 753 \r
 754                 #region DrawImage\r
 755 \r
 756                 public void DrawImage (Image image, Point point) {\r
 757                         DrawImage(image, point.X, point.Y);\r
 758                 }\r
 759 \r
 760                 public void DrawImage (Image image, PointF point) {\r
 761                         DrawImage(image, point.X, point.Y);\r
 762                 }\r
 763 \r
 764                 \r
 765                 public void DrawImage (Image image, Point [] destPoints) {\r
 766                         Matrix m = new Matrix(new Rectangle(0, 0, image.Width, image.Height), destPoints);\r
 767                         DrawImage(image, m);\r
 768                 }\r
 769 \r
 770                 public void DrawImage (Image image, PointF [] destPoints) {\r
 771                         Matrix m = new Matrix(new RectangleF(0, 0, image.Width, image.Height), destPoints);\r
 772                         DrawImage(image, m);\r
 773                 }\r
 774 \r
 775                 \r
 776                 public void DrawImage (Image image, Rectangle rect) {\r
 777                         DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height);\r
 778                 }\r
 779 \r
 780                 public void DrawImage (Image image, RectangleF rect) {\r
 781                         DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height);\r
 782                 }\r
 783 \r
 784                 \r
 785                 public void DrawImage (Image image, int x, int y) {\r
 786                         DrawImage(image, (float)x, (float)y);\r
 787                 }\r
 788 \r
 789                 public void DrawImage (Image image, float x, float y) {\r
 790                         if ((image.HorizontalResolution != DpiX) || (image.VerticalResolution != DpiY))\r
 791                                 DrawImage( image, x, y, \r
 792                                         (float)image.Width * (DpiX / image.HorizontalResolution) / _unitConversion[(int)PageUnit], \r
 793                                         (float)image.Height * (DpiY / image.VerticalResolution) / _unitConversion[(int)PageUnit]) ;\r
 794                         else\r
 795                                 DrawImage( image, x, y, \r
 796                                         (float)image.Width / _unitConversion[(int)PageUnit], \r
 797                                         (float)image.Height / _unitConversion[(int)PageUnit] );\r
 798                 }\r
 799 \r
 800                 \r
 801                 public void DrawImage (Image image, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit) {\r
 802                         DrawImage(\r
 803                                 image,\r
 804                                 new Point [] {\r
 805                                                                  new Point( destRect.X, destRect.Y),\r
 806                                                                  new Point( destRect.X + destRect.Width, destRect.Y),\r
 807                                                                  new Point( destRect.X, destRect.Y + destRect.Height)},\r
 808                                 srcRect, \r
 809                                 srcUnit);\r
 810                 }\r
 811         \r
 812                 public void DrawImage (Image image, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit) {\r
 813                         DrawImage(\r
 814                                 image,\r
 815                                 new PointF [] {\r
 816                                                                  new PointF( destRect.X, destRect.Y),\r
 817                                                                  new PointF( destRect.X + destRect.Width, destRect.Y),\r
 818                                                                  new PointF( destRect.X, destRect.Y + destRect.Height)},\r
 819                                 srcRect, \r
 820                                 srcUnit);\r
 821                 }\r
 822 \r
 823                 \r
 824                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit) {\r
 825                         DrawImage(image, destPoints, srcRect, srcUnit, null);\r
 826                 }\r
 827 \r
 828                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit) {\r
 829                         DrawImage(image, destPoints, srcRect, srcUnit, null);\r
 830                 }\r
 831 \r
 832                 [MonoTODO]\r
 833                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr) {\r
 834                         //TBD: ImageAttributes\r
 835                         if (srcUnit != GraphicsUnit.Pixel)\r
 836                                 throw new NotImplementedException();\r
 837                         // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx\r
 838 \r
 839                         Matrix mx = new Matrix(srcRect, destPoints);\r
 840 \r
 841                         Region region = new Region(srcRect);\r
 842                         DrawImage(image, mx, region);\r
 843                 }\r
 844                 \r
 845                 [MonoTODO]\r
 846                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr) {\r
 847                         //TBD: ImageAttributes\r
 848                         if (srcUnit != GraphicsUnit.Pixel)\r
 849                                 throw new NotImplementedException();\r
 850                         // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx\r
 851 \r
 852                         Matrix mx = new Matrix(srcRect, destPoints);\r
 853 \r
 854                         Region region = new Region(srcRect);\r
 855                         DrawImage(image, mx, region);\r
 856                 }\r
 857 \r
 858 \r
 859                 public void DrawImage (Image image, int x, int y, int width, int height) {\r
 860                         DrawImage(image, (float)x, (float)y, (float)width, (float)height);\r
 861                 }\r
 862 \r
 863                 public void DrawImage (Image image, float x, float y, float width, float height) {\r
 864                         Matrix mx = new Matrix();\r
 865                         mx.Translate((float)x, (float)y);\r
 866                         mx.Scale(width / (float)image.Width, height / (float)image.Height);\r
 867 \r
 868                         DrawImage( image, mx );\r
 869                 }\r
 870 \r
 871                 \r
 872                 public void DrawImage (Image image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit) {                    \r
 873                         DrawImage(image, new Rectangle(x, y, srcRect.Width, srcRect.Height), srcRect, srcUnit);\r
 874                 }\r
 875                 \r
 876                 public void DrawImage (Image image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit) {       \r
 877                         DrawImage(image, new RectangleF(x, y, srcRect.Width, srcRect.Height), srcRect, srcUnit);\r
 878                 }\r
 879 \r
 880 \r
 881                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit) {\r
 882                         DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);\r
 883                 }\r
 884 \r
 885                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit) {\r
 886                         DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);\r
 887                 }\r
 888                 \r
 889 \r
 890                 [MonoTODO]\r
 891                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr) {                     \r
 892                         //TBD: attributes\r
 893                         DrawImage(\r
 894                                 image, \r
 895                                 destRect,\r
 896                                 new Rectangle(srcX, srcY, srcWidth, srcHeight),\r
 897                                 srcUnit);\r
 898                 }\r
 899                 \r
 900                 [MonoTODO]\r
 901                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs) {\r
 902                         //TBD: attributes\r
 903                         DrawImage(\r
 904                                 image, \r
 905                                 destRect,\r
 906                                 new RectangleF(srcX, srcY, srcWidth, srcHeight),\r
 907                                 srcUnit);\r
 908                 }\r
 909                 \r
 910 \r
 911                 internal void DrawImage (Image image, Matrix m) {\r
 912                         DrawImage(image, m, null);\r
 913                 }\r
 914 \r
 915                 internal void DrawImage (Image image, Matrix m, Region clip) {\r
 916                         if (clip == null) {\r
 917                                 clip = new Region( new RectangleF( 0, 0, image.Width, image.Height ) );\r
 918                         }\r
 919 \r
 920                         geom.AffineTransform t = GetFinalTransform(_transform.NativeObject, PageUnit, 1.0f);\r
 921                         if (!t.isIdentity())\r
 922                                 m.NativeObject.preConcatenate(t);\r
 923 \r
 924                                 clip.Transform( m );\r
 925 \r
 926                         if (NeedsNormalization) {\r
 927                                 Matrix normMatrix = ComputeClipNormalization(clip.GetBounds(this));\r
 928                                 clip.Transform(normMatrix);\r
 929                         }\r
 930 \r
 931                         awt.Shape oldClip = NativeObject.getClip();\r
 932                         IntersectScaledClipWithBase(clip);\r
 933                         \r
 934                         try {\r
 935                                 Matrix mm = ComputeImageNormalization(image, m);\r
 936                                 NativeObject.drawImage(image.NativeObject.CurrentImage.NativeImage, mm.NativeObject, null);\r
 937                         }\r
 938                         finally {\r
 939                                 NativeObject.setClip( oldClip );\r
 940                         }\r
 941                 }\r
 942 \r
 943                 private static Matrix ComputeImageNormalization(Image img, Matrix m) {\r
 944                         if ( m.IsIdentity )\r
 945                                 return m;\r
 946 \r
 947                         //m.Translate( -(m.Elements[0] + m.Elements[2]) / 2.0f,  -(m.Elements[3] + m.Elements[1]) / 2.0f, MatrixOrder.Append);\r
 948                         m.Translate( \r
 949                                 -(float)(m.NativeObject.getScaleX() + m.NativeObject.getShearX()) / 2.0f,  \r
 950                                 -(float)(m.NativeObject.getScaleY() + m.NativeObject.getShearY()) / 2.0f, MatrixOrder.Append);\r
 951                         \r
 952                         PointF [] p = new PointF[] { \r
 953                                                                                    new PointF( 0, 0 ),\r
 954                                                                                    new PointF( img.Width, 0 ),\r
 955                                                                                    new PointF( 0, img.Height )};\r
 956 \r
 957                         m.TransformPoints(p);\r
 958                         for (int i=0; i < p.Length; i++) {\r
 959                                 p[i].X = (float)( p[i].X + 0.5f );\r
 960                                 p[i].Y = (float)( p[i].Y + 0.5f );\r
 961                         }\r
 962 \r
 963                         return new Matrix( new Rectangle(0, 0, img.Width, img.Height), p );\r
 964                 }\r
 965                 private static Matrix ComputeClipNormalization(RectangleF rect) {\r
 966                         PointF [] p = new PointF[] { \r
 967                                                                                    new PointF( rect.X, rect.Y ),\r
 968                                                                                    new PointF( rect.X + rect.Width, rect.Y ),\r
 969                                                                                    new PointF( rect.X, rect.Y + rect.Height )};\r
 970 \r
 971                         for (int i=0; i < p.Length; i++) {\r
 972                                 p[i].X = (float)Math.Round( p[i].X + 0.5f ) + 0.5f;\r
 973                                 p[i].Y = (float)Math.Round( p[i].Y + 0.5f ) + 0.5f;\r
 974                         }\r
 975 \r
 976                         return new Matrix( rect, p );\r
 977                 }\r
 978                 \r
 979 \r
 980 #if INTPTR_SUPPORT\r
 981                 [MonoTODO]\r
 982                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
 983                 {\r
 984                         throw new NotImplementedException();\r
 985                 }\r
 986 \r
 987                 [MonoTODO]\r
 988                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
 989                 {\r
 990                         \r
 991                         throw new NotImplementedException();\r
 992                 }\r
 993 \r
 994                 [MonoTODO]\r
 995                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)\r
 996                 {\r
 997                         throw new NotImplementedException();\r
 998                 }\r
 999 #endif\r
1000 \r
1001 #if INTPTR_SUPPORT              \r
1002                 [MonoTODO]\r
1003                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)\r
1004                 {\r
1005                         throw new NotImplementedException();\r
1006                 }\r
1007 #endif\r
1008 \r
1009 #if INTPTR_SUPPORT              \r
1010                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
1011                 {\r
1012                         //TBD:units,attributes, callback\r
1013                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
1014                         g.drawImage(image.NativeObject,destRect.X,destRect.Y,destRect.Width,destRect.Height,srcX,srcY,srcWidth,srcHeight,null);\r
1015                 }\r
1016                 \r
1017                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
1018                 {\r
1019                         //TBD:units,attributes, callback\r
1020                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
1021                         g.drawImage(image.NativeObject,\r
1022                                 (int)destRect.X,\r
1023                                 (int)destRect.Y,\r
1024                                 (int)destRect.Width,\r
1025                                 (int)destRect.Height,\r
1026                                 (int)srcX,\r
1027                                 (int)srcY,\r
1028                                 (int)srcWidth,\r
1029                                 (int)srcHeight,null);\r
1030                 }\r
1031 \r
1032                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)\r
1033                 {\r
1034                         //TBD:units,attributes, callback\r
1035                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
1036                         g.drawImage(image.NativeObject,\r
1037                                 (int)destRect.X,\r
1038                                 (int)destRect.Y,\r
1039                                 (int)destRect.Width,\r
1040                                 (int)destRect.Height,\r
1041                                 (int)srcX,\r
1042                                 (int)srcY,\r
1043                                 (int)srcWidth,\r
1044                                 (int)srcHeight,null);\r
1045                 }\r
1046                 \r
1047                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)\r
1048                 {\r
1049                         //TBD:units,attributes, callback\r
1050                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
1051                         g.drawImage(image.NativeObject,\r
1052                                 destRect.X,\r
1053                                 destRect.Y,\r
1054                                 destRect.Width,\r
1055                                 destRect.Height,\r
1056                                 srcX,\r
1057                                 srcY,\r
1058                                 srcWidth,\r
1059                                 srcHeight,null);\r
1060                 }               \r
1061 #endif\r
1062                 \r
1063                 public void DrawImageUnscaled (Image image, Point point) \r
1064                 {\r
1065                         DrawImageUnscaled (image, point.X, point.Y);\r
1066                 }\r
1067                 \r
1068                 public void DrawImageUnscaled (Image image, Rectangle rect) {\r
1069                         DrawImageUnscaled (image, rect.X, rect.Y, rect.Width, rect.Height);\r
1070                 }\r
1071                 \r
1072                 public void DrawImageUnscaled (Image image, int x, int y) {\r
1073                         DrawImage (image, x, y, image.Width, image.Height);\r
1074                 }\r
1075 \r
1076                 public void DrawImageUnscaled (Image image, int x, int y, int width, int height) {\r
1077                         Image tmpImg = new Bitmap (width, height);\r
1078                         Graphics g = FromImage (tmpImg);\r
1079                         g.DrawImage (image, 0, 0, image.Width, image.Height);\r
1080                         this.DrawImage (tmpImg, x, y, width, height);\r
1081                         tmpImg.Dispose ();\r
1082                         g.Dispose ();           \r
1083                 }\r
1084                 #endregion\r
1085 \r
1086                 #region DrawLine\r
1087                 public void DrawLine (Pen pen, PointF pt1, PointF pt2) {\r
1088                         DrawLine(pen,pt1.X,pt1.Y,pt2.X,pt2.Y);\r
1089                 }\r
1090 \r
1091                 public void DrawLine (Pen pen, Point pt1, Point pt2) {\r
1092                         DrawLine(pen,(float)pt1.X,(float)pt1.Y,(float)pt2.X,(float)pt2.Y);\r
1093                 }\r
1094 \r
1095                 public void DrawLine (Pen pen, int x1, int y1, int x2, int y2) {\r
1096                         DrawLine(pen,(float)x1,(float)y1,(float)x2,(float)y2);\r
1097                 }\r
1098 \r
1099                 public void DrawLine (Pen pen, float x1, float y1, float x2, float y2) {\r
1100                         DrawShape(pen, new geom.Line2D.Float(x1,y1,x2,y2));\r
1101                 }\r
1102 \r
1103                 public void DrawLines (Pen pen, PointF [] points) {\r
1104                         GraphicsPath path = new GraphicsPath();\r
1105                         path.AddLines(points);\r
1106                         DrawShape(pen, path);\r
1107                 }\r
1108 \r
1109                 public void DrawLines (Pen pen, Point [] points) {\r
1110                         GraphicsPath path = new GraphicsPath();\r
1111                         path.AddLines(points);\r
1112                         DrawShape(pen, path);\r
1113                 }\r
1114                 #endregion\r
1115 \r
1116                 #region DrawPath\r
1117                 public void DrawPath (Pen pen, GraphicsPath path) {\r
1118                         DrawShape(pen, path);\r
1119                 }\r
1120                 #endregion\r
1121                 \r
1122                 #region DrawPie\r
1123                 public void DrawPie (Pen pen, Rectangle rect, float startAngle, float sweepAngle) {\r
1124                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);\r
1125                 }\r
1126                 \r
1127                 public void DrawPie (Pen pen, RectangleF rect, float startAngle, float sweepAngle) {\r
1128                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);\r
1129                 }\r
1130                 \r
1131                 public void DrawPie (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle) {\r
1132                         GraphicsPath path = new GraphicsPath();\r
1133                         path.AddPie(x, y, width, height, startAngle, sweepAngle);\r
1134                         DrawPath(pen, path);\r
1135                 }\r
1136                 \r
1137                 public void DrawPie (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle) {\r
1138                         DrawPie(pen,(float)x,(float)y,(float)width,(float)height,(float)startAngle,(float)sweepAngle);\r
1139                 }\r
1140                 #endregion\r
1141 \r
1142                 #region DrawPolygon\r
1143                 public void DrawPolygon (Pen pen, Point [] points) {\r
1144                         GraphicsPath path = new GraphicsPath();\r
1145                         path.AddPolygon(points);\r
1146                         DrawPath(pen, path);\r
1147                 }\r
1148 \r
1149                 public void DrawPolygon (Pen pen, PointF [] points) {\r
1150                         GraphicsPath path = new GraphicsPath();\r
1151                         path.AddPolygon(points);\r
1152                         DrawPath(pen, path);\r
1153                 }\r
1154                 #endregion\r
1155 \r
1156                 #region DrawRectangle(s)\r
1157                 internal void DrawRectangle (Pen pen, RectangleF rect) {\r
1158                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);\r
1159                 }\r
1160 \r
1161                 public void DrawRectangle (Pen pen, Rectangle rect) {\r
1162                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);\r
1163                 }\r
1164 \r
1165                 public void DrawRectangle (Pen pen, float x, float y, float width, float height) {\r
1166                         DrawShape(pen, new geom.Rectangle2D.Float(x,y,width,height));\r
1167                 }\r
1168 \r
1169                 public void DrawRectangle (Pen pen, int x, int y, int width, int height) {\r
1170                         DrawRectangle (pen,(float) x,(float) y,(float) width,(float) height);\r
1171                 }\r
1172 \r
1173                 public void DrawRectangles (Pen pen, RectangleF [] rects) {\r
1174                         foreach(RectangleF r in rects)\r
1175                                 DrawRectangle (pen, r.Left, r.Top, r.Width, r.Height);\r
1176                 }\r
1177 \r
1178                 public void DrawRectangles (Pen pen, Rectangle [] rects) {\r
1179                         foreach(Rectangle r in rects)\r
1180                                 DrawRectangle (pen, r.Left, r.Top, r.Width, r.Height);\r
1181                 }\r
1182                 #endregion\r
1183 \r
1184                 #region DrawString\r
1185                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle) {                 \r
1186                         DrawString(s, font, brush, layoutRectangle.X, layoutRectangle.Y, layoutRectangle.Width, layoutRectangle.Height, null);\r
1187                 }\r
1188                 \r
1189                 public void DrawString (string s, Font font, Brush brush, PointF point) {\r
1190                         DrawString(s, font, brush, point.X, point.Y, float.PositiveInfinity, float.PositiveInfinity, null);\r
1191                 }\r
1192                 \r
1193                 public void DrawString (string s, Font font, Brush brush, PointF point, StringFormat format) {\r
1194                         DrawString(s, font, brush, point.X, point.Y, float.PositiveInfinity, float.PositiveInfinity, format);\r
1195                 }\r
1196 \r
1197                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format) {\r
1198                         DrawString(s, font, brush, layoutRectangle.X, layoutRectangle.Y, layoutRectangle.Width, layoutRectangle.Height, format);\r
1199                 }\r
1200 \r
1201                 public void DrawString (string s, Font font, Brush brush, float x, float y) {\r
1202                         DrawString(s, font, brush, x, y, float.PositiveInfinity, float.PositiveInfinity, null);\r
1203                 }\r
1204 \r
1205                 public void DrawString (string s, Font font, Brush brush, float x, float y, StringFormat format) {\r
1206                         DrawString(s, font, brush, x, y, float.PositiveInfinity, float.PositiveInfinity, format);\r
1207                 }\r
1208 \r
1209                 void DrawString (string s, Font font, Brush brush, \r
1210                         float x, float y, float width, float height, \r
1211                         StringFormat format) {\r
1212                         if (brush == null)\r
1213                                 throw new ArgumentNullException("brush");\r
1214 \r
1215                         if (font == null)\r
1216                                 throw new ArgumentNullException("font");\r
1217 \r
1218                         if (format != null && format.LineAlignment != StringAlignment.Near) {\r
1219 \r
1220                                 SizeF sizeF = MeasureString(s, font, format, width, height, null);\r
1221 \r
1222                                 float lineAWidth = width;\r
1223                                 float lineAHeight = height;\r
1224 \r
1225                                 if (float.IsPositiveInfinity(width))\r
1226                                         lineAWidth = lineAHeight = 0;\r
1227 \r
1228                                 float wdelta = format.IsVertical ? lineAWidth - sizeF.Width : lineAHeight - sizeF.Height;\r
1229                                 float pdelta = format.LineAlignment == StringAlignment.Center ? wdelta/2 : wdelta;\r
1230                                 if (format.IsVertical) {\r
1231                                         if (!(format.IsRightToLeft && format.LineAlignment == StringAlignment.Far))\r
1232                                                 x += pdelta;\r
1233                                         if (!float.IsPositiveInfinity(width))\r
1234                                                 width -= wdelta;\r
1235                                 }\r
1236                                 else {\r
1237                                         y += pdelta;\r
1238                                         if (!float.IsPositiveInfinity(width))\r
1239                                                 height -= wdelta;\r
1240                                 }\r
1241                         }\r
1242 \r
1243                         awt.Paint oldP = NativeObject.getPaint();\r
1244                         NativeObject.setPaint(brush);\r
1245                         try {\r
1246                                 geom.AffineTransform oldT = NativeObject.getTransform();\r
1247                                 NativeObject.transform(GetFinalTransform());\r
1248                                 try {\r
1249 \r
1250                                         bool noclip = float.IsPositiveInfinity(width) || (format != null && format.NoClip);\r
1251 \r
1252                                         awt.Shape oldClip = null;\r
1253                                         if (!noclip) {\r
1254                                                 oldClip = NativeObject.getClip();\r
1255                                                 NativeObject.clip(new geom.Rectangle2D.Float(x, y, width, height));\r
1256                                         }\r
1257                                         try {\r
1258                                                 TextLineIterator iter = new TextLineIterator(s, font, NativeObject.getFontRenderContext(), format, width, height);\r
1259                                                 NativeObject.transform(iter.Transform);\r
1260                                                 for (LineLayout layout = iter.NextLine(); layout != null; layout = iter.NextLine()) {\r
1261                                                         layout.Draw(NativeObject, x, y);\r
1262                                                 }\r
1263                                         }\r
1264                                         finally {\r
1265                                                 if (!noclip)\r
1266                                                         NativeObject.setClip(oldClip);\r
1267                                         }\r
1268                                 }\r
1269                                 finally {\r
1270                                         NativeObject.setTransform(oldT);\r
1271                                 }\r
1272                         }\r
1273                         finally {\r
1274                                 NativeObject.setPaint(oldP);\r
1275                         }\r
1276                 }\r
1277                 #endregion\r
1278 \r
1279                 #region Container\r
1280 \r
1281                 void PushGraphicsState(GraphicsState state) {\r
1282                         state.Next = _nextGraphicsState;\r
1283                         _nextGraphicsState = state;\r
1284                 }\r
1285 \r
1286                 GraphicsState PopGraphicsState() {\r
1287                         GraphicsState state = _nextGraphicsState;\r
1288                         _nextGraphicsState = _nextGraphicsState.Next;\r
1289                         return state;\r
1290                 }\r
1291 \r
1292                 bool ContainsGraphicsState(GraphicsState state) {\r
1293                         GraphicsState gs = _nextGraphicsState;\r
1294 \r
1295                         while(gs != null) {\r
1296                                 if (gs == state)\r
1297                                         return true;\r
1298 \r
1299                                 gs = gs.Next;\r
1300                         }\r
1301 \r
1302                         return false;\r
1303                 }\r
1304 \r
1305                 public void EndContainer (GraphicsContainer container) {\r
1306                         Restore(container.StateObject);\r
1307                 }\r
1308 \r
1309                 public GraphicsContainer BeginContainer () {\r
1310                         return new GraphicsContainer(Save(Matrix.IdentityTransform, true));\r
1311                 }\r
1312                 \r
1313                 public GraphicsContainer BeginContainer (Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit) {\r
1314                         Matrix containerTransfrom =\r
1315                                 new Matrix(     srcrect,\r
1316                                 new Point [] {   new Point (dstrect.X, dstrect.Y), \r
1317                                                                  new Point (dstrect.X + dstrect.Width, dstrect.Y), \r
1318                                                                  new Point (dstrect.X, dstrect.Y + dstrect.Height) });\r
1319 \r
1320                         float scale = _unitConversion[ (int)PageUnit ] / _unitConversion[ (int)unit ];\r
1321                         containerTransfrom.Scale(scale, scale);\r
1322 \r
1323                         return new GraphicsContainer(Save(containerTransfrom, true));\r
1324                 }\r
1325 \r
1326                 \r
1327                 public GraphicsContainer BeginContainer (RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit) {\r
1328                         Matrix containerTransfrom =\r
1329                                 new Matrix(     srcrect,\r
1330                                 new PointF [] {  new PointF (dstrect.X, dstrect.Y), \r
1331                                                                  new PointF (dstrect.X + dstrect.Width, dstrect.Y), \r
1332                                                                  new PointF (dstrect.X, dstrect.Y + dstrect.Height) });\r
1333 \r
1334                         float scale = _unitConversion[ (int)PageUnit ] / _unitConversion[ (int)unit ];\r
1335                         containerTransfrom.Scale(scale, scale);\r
1336 \r
1337                         return new GraphicsContainer(Save(containerTransfrom, true));\r
1338                 }\r
1339 \r
1340                 GraphicsState Save(Matrix matrix, bool resetState) {\r
1341                         GraphicsState graphicsState = new GraphicsState(this, matrix, resetState);\r
1342 \r
1343                         PushGraphicsState( graphicsState );\r
1344                         return graphicsState;\r
1345                 }\r
1346 \r
1347                 public GraphicsState Save () {\r
1348                         return Save(Matrix.IdentityTransform, false);\r
1349                 }\r
1350 \r
1351                 public void Restore (GraphicsState graphicsState) {\r
1352                         if (ContainsGraphicsState(graphicsState)) {\r
1353                                 GraphicsState gs = PopGraphicsState();\r
1354                                 while ( gs != graphicsState )\r
1355                                         gs = PopGraphicsState();\r
1356 \r
1357                                 graphicsState.RestoreState(this);\r
1358                         }\r
1359                 }\r
1360 \r
1361                 #endregion\r
1362 \r
1363                 #region Metafiles Staff\r
1364                 [MonoTODO]\r
1365                 public void AddMetafileComment (byte [] data) {\r
1366                         throw new NotImplementedException ();\r
1367                 }\r
1368 \r
1369 #if INTPTR_SUPPORT\r
1370                 [MonoTODO]\r
1371                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback)\r
1372                 {\r
1373                         throw new NotImplementedException ();\r
1374                 }\r
1375 \r
1376                 [MonoTODO]\r
1377                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback)\r
1378                 {\r
1379                         throw new NotImplementedException ();\r
1380                 }\r
1381 \r
1382                 [MonoTODO]\r
1383                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback)\r
1384                 {\r
1385                         throw new NotImplementedException ();\r
1386                 }\r
1387 \r
1388                 [MonoTODO]\r
1389                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback)\r
1390                 {\r
1391                         throw new NotImplementedException ();\r
1392                 }\r
1393 \r
1394                 [MonoTODO]\r
1395                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback)\r
1396                 {\r
1397                         throw new NotImplementedException ();\r
1398                 }\r
1399 \r
1400                 [MonoTODO]\r
1401                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback)\r
1402                 {\r
1403                         throw new NotImplementedException ();\r
1404                 }\r
1405 \r
1406                 [MonoTODO]\r
1407                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData)\r
1408                 {\r
1409                         throw new NotImplementedException ();\r
1410                 }\r
1411 \r
1412                 [MonoTODO]\r
1413                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData)\r
1414                 {\r
1415                         throw new NotImplementedException ();\r
1416                 }\r
1417 \r
1418                 [MonoTODO]\r
1419                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)\r
1420                 {\r
1421                         throw new NotImplementedException ();\r
1422                 }\r
1423 \r
1424                 [MonoTODO]\r
1425                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData)\r
1426                 {\r
1427                         throw new NotImplementedException ();\r
1428                 }\r
1429 \r
1430                 [MonoTODO]\r
1431                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)\r
1432                 {\r
1433                         throw new NotImplementedException ();\r
1434                 }\r
1435 \r
1436                 [MonoTODO]\r
1437                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData)\r
1438                 {\r
1439                         throw new NotImplementedException ();\r
1440                 }\r
1441 \r
1442                 [MonoTODO]\r
1443                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1444                 {\r
1445                         throw new NotImplementedException ();\r
1446                 }\r
1447 \r
1448                 [MonoTODO]\r
1449                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1450                 {\r
1451                         throw new NotImplementedException ();\r
1452                 }\r
1453 \r
1454                 [MonoTODO]\r
1455                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1456                 {\r
1457                         throw new NotImplementedException ();\r
1458                 }\r
1459 \r
1460                 [MonoTODO]\r
1461                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1462                 {\r
1463                         throw new NotImplementedException ();\r
1464                 }\r
1465 \r
1466                 [MonoTODO]\r
1467                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1468                 {\r
1469                         throw new NotImplementedException ();\r
1470                 }\r
1471 \r
1472                 [MonoTODO]\r
1473                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1474                 {\r
1475                         throw new NotImplementedException ();\r
1476                 }\r
1477 \r
1478                 [MonoTODO]\r
1479                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1480                 {\r
1481                         throw new NotImplementedException ();\r
1482                 }\r
1483 \r
1484                 [MonoTODO]\r
1485                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1486                 {\r
1487                         throw new NotImplementedException ();\r
1488                 }\r
1489 \r
1490                 [MonoTODO]\r
1491                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1492                 {\r
1493                         throw new NotImplementedException ();\r
1494                 }\r
1495 \r
1496                 [MonoTODO]\r
1497                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1498                 {\r
1499                         throw new NotImplementedException ();\r
1500                 }\r
1501 \r
1502                 [MonoTODO]\r
1503                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1504                 {\r
1505                         throw new NotImplementedException ();\r
1506                 }\r
1507 \r
1508                 [MonoTODO]\r
1509                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1510                 {\r
1511                         throw new NotImplementedException ();\r
1512                 }\r
1513 \r
1514                 [MonoTODO]\r
1515                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1516                 {\r
1517                         throw new NotImplementedException ();\r
1518                 }\r
1519 \r
1520                 [MonoTODO]\r
1521                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1522                 {\r
1523                         throw new NotImplementedException ();\r
1524                 }\r
1525 \r
1526                 [MonoTODO]\r
1527                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1528                 {\r
1529                         throw new NotImplementedException ();\r
1530                 }\r
1531 \r
1532                 [MonoTODO]\r
1533                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1534                 {\r
1535                         throw new NotImplementedException ();\r
1536                 }\r
1537 \r
1538                 [MonoTODO]\r
1539                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1540                 {\r
1541                         throw new NotImplementedException ();\r
1542                 }\r
1543 \r
1544                 [MonoTODO]\r
1545                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1546                 {\r
1547                         throw new NotImplementedException ();\r
1548                 }\r
1549 \r
1550                 [MonoTODO]\r
1551                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1552                 {\r
1553                         throw new NotImplementedException ();\r
1554                 }\r
1555 \r
1556                 [MonoTODO]\r
1557                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1558                 {\r
1559                         throw new NotImplementedException ();\r
1560                 }\r
1561 \r
1562                 [MonoTODO]\r
1563                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1564                 {\r
1565                         throw new NotImplementedException ();\r
1566                 }\r
1567 \r
1568                 [MonoTODO]\r
1569                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1570                 {\r
1571                         throw new NotImplementedException ();\r
1572                 }\r
1573 \r
1574                 [MonoTODO]\r
1575                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1576                 {\r
1577                         throw new NotImplementedException ();\r
1578                 }\r
1579 \r
1580                 [MonoTODO]\r
1581                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1582                 {\r
1583                         throw new NotImplementedException ();\r
1584                 }\r
1585 #endif  \r
1586                 #endregion      \r
1587 \r
1588                 #region ExcludeClip\r
1589                 void ExcludeClip(geom.Area area) {\r
1590 \r
1591                         geom.AffineTransform t = GetFinalTransform();\r
1592                         if (!t.isIdentity()) {\r
1593                                 area = (geom.Area)area.clone();\r
1594                                 area.transform(t);\r
1595                         }\r
1596 \r
1597                         _clip.NativeObject.subtract(area);\r
1598                         RestoreBaseClip();\r
1599                         NativeObject.clip(_clip);\r
1600                 }\r
1601 \r
1602                 public void ExcludeClip (Rectangle rect) {\r
1603                         ExcludeClip(new geom.Area(rect.NativeObject));\r
1604                 }\r
1605 \r
1606                 public void ExcludeClip (Region region) {\r
1607                         if (region == null)\r
1608                                 throw new ArgumentNullException("region");\r
1609                         ExcludeClip(region.NativeObject);\r
1610                 }\r
1611                 #endregion \r
1612 \r
1613                 #region FillClosedCurve\r
1614                 public void FillClosedCurve (Brush brush, PointF [] points) {\r
1615                         FillClosedCurve (brush, points, FillMode.Alternate);\r
1616                 }\r
1617 \r
1618                 \r
1619                 public void FillClosedCurve (Brush brush, Point [] points) {\r
1620                         FillClosedCurve (brush, points, FillMode.Alternate);\r
1621                 }\r
1622 \r
1623                 \r
1624                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode) {\r
1625                         FillClosedCurve (brush, points, fillmode, 0.5f);\r
1626                 }\r
1627                 \r
1628                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode) {\r
1629                         FillClosedCurve (brush, points, fillmode, 0.5f);\r
1630                 }\r
1631 \r
1632                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode, float tension) {\r
1633                         GraphicsPath path = new GraphicsPath(fillmode);\r
1634                         path.AddClosedCurve(points, tension);\r
1635                         FillPath(brush, path);\r
1636                 }\r
1637 \r
1638                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode, float tension) {\r
1639                         GraphicsPath path = new GraphicsPath(fillmode);\r
1640                         path.AddClosedCurve(points, tension);\r
1641                         FillPath(brush, path);\r
1642                 }\r
1643                 #endregion\r
1644 \r
1645                 #region FillEllipse\r
1646                 public void FillEllipse (Brush brush, Rectangle rect) {\r
1647                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);\r
1648                 }\r
1649 \r
1650                 public void FillEllipse (Brush brush, RectangleF rect) {\r
1651                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);\r
1652                 }\r
1653 \r
1654                 public void FillEllipse (Brush brush, float x, float y, float width, float height) {\r
1655                         FillShape(brush,new java.awt.geom.Ellipse2D.Float(x,y,width,height));\r
1656                 }\r
1657 \r
1658                 public void FillEllipse (Brush brush, int x, int y, int width, int height) {\r
1659                         FillEllipse (brush,(float)x,(float)y,(float)width,(float)height);\r
1660                 }\r
1661                 #endregion\r
1662 \r
1663                 #region FillPath\r
1664                 public void FillPath (Brush brush, GraphicsPath path) {\r
1665                         if (path == null)\r
1666                                 throw new ArgumentNullException("path");\r
1667 \r
1668                         FillShape(brush,path);\r
1669                 }\r
1670                 #endregion\r
1671 \r
1672                 #region FillPie\r
1673                 public void FillPie (Brush brush, Rectangle rect, float startAngle, float sweepAngle) {\r
1674                         FillPie(brush,(float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height,(float)startAngle,(float)sweepAngle);\r
1675                 }\r
1676 \r
1677                 public void FillPie (Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle) {\r
1678                         FillPie(brush,(float)x,(float)y,(float)width,(float)height,(float)startAngle,(float)sweepAngle);\r
1679                 }\r
1680 \r
1681                 public void FillPie (Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle) {\r
1682                         GraphicsPath path = new GraphicsPath();\r
1683                         path.AddPie(x, y, width, height, startAngle, sweepAngle);\r
1684                         FillPath(brush, path);\r
1685                 }\r
1686                 #endregion\r
1687 \r
1688                 #region FillPolygon\r
1689                 public void FillPolygon (Brush brush, PointF [] points) {\r
1690                         FillPolygon(brush, points, FillMode.Alternate);\r
1691                 }\r
1692 \r
1693                 public void FillPolygon (Brush brush, Point [] points) {\r
1694                         FillPolygon(brush, points, FillMode.Alternate);\r
1695                 }\r
1696 \r
1697                 public void FillPolygon (Brush brush, Point [] points, FillMode fillMode) {\r
1698                         GraphicsPath path = new GraphicsPath(fillMode);\r
1699                         path.AddPolygon(points);\r
1700                         FillPath(brush,path);\r
1701                 }\r
1702 \r
1703                 public void FillPolygon (Brush brush, PointF [] points, FillMode fillMode) {\r
1704                         GraphicsPath path = new GraphicsPath(fillMode);\r
1705                         path.AddPolygon(points);\r
1706                         FillPath(brush,path);\r
1707                 }\r
1708                 #endregion\r
1709 \r
1710                 #region FillRectangle\r
1711                 public void FillRectangle (Brush brush, RectangleF rect) {\r
1712                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);\r
1713                 }\r
1714 \r
1715                 public void FillRectangle (Brush brush, Rectangle rect) {\r
1716                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);\r
1717                 }\r
1718 \r
1719                 public void FillRectangle (Brush brush, int x, int y, int width, int height) {\r
1720                         FillRectangle(brush,(float)x,(float)y,(float)width,(float)height);\r
1721                 }\r
1722 \r
1723                 public void FillRectangle (Brush brush, float x, float y, float width, float height) {\r
1724                         FillShape(brush,new java.awt.geom.Rectangle2D.Float(x,y,width,height));\r
1725                 }\r
1726 \r
1727                 public void FillRectangles (Brush brush, Rectangle [] rects) {\r
1728                         GraphicsPath path = new GraphicsPath();\r
1729                         path.AddRectangles(rects);\r
1730                         FillPath(brush,path);\r
1731                 }\r
1732 \r
1733                 public void FillRectangles (Brush brush, RectangleF [] rects) {\r
1734                         GraphicsPath path = new GraphicsPath();\r
1735                         path.AddRectangles(rects);\r
1736                         FillPath(brush,path);\r
1737                 }\r
1738                 #endregion\r
1739 \r
1740                 #region FillRegion\r
1741                 public void FillRegion (Brush brush, Region region) {\r
1742                         FillShape(brush,region);\r
1743                 }\r
1744 \r
1745                 #endregion\r
1746 \r
1747                 public void Flush () {\r
1748                         Flush (FlushIntention.Flush);\r
1749                 }\r
1750 \r
1751                 \r
1752                 public void Flush (FlushIntention intention) {\r
1753                         if (_image != null)\r
1754                                 _image.NativeObject.CurrentImage.NativeImage.flush();\r
1755                 }\r
1756 \r
1757 #if INTPTR_SUPPORTED\r
1758                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1759                 [MonoTODO]\r
1760                 public void ReleaseHdc (IntPtr hdc)\r
1761                 {\r
1762                         throw new NotImplementedException();\r
1763                 }\r
1764 \r
1765                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1766                 [MonoTODO]\r
1767                 public void ReleaseHdcInternal (IntPtr hdc)\r
1768                 {\r
1769                         throw new NotImplementedException ();\r
1770                 }\r
1771 \r
1772                 [EditorBrowsable (EditorBrowsableState.Advanced)]               \r
1773                 [MonoTODO]\r
1774                 public static Graphics FromHdc (IntPtr hdc)\r
1775                 {\r
1776                         throw new NotImplementedException();\r
1777                 }\r
1778 \r
1779                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1780                 [MonoTODO]\r
1781                 public static Graphics FromHdc (IntPtr hdc, IntPtr hdevice)\r
1782                 {\r
1783                         throw new NotImplementedException ();\r
1784                 }\r
1785 \r
1786                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1787                 [MonoTODO]\r
1788                 public static Graphics FromHdcInternal (IntPtr hdc)\r
1789                 {\r
1790                         throw new NotImplementedException ();\r
1791                 }\r
1792 \r
1793                 [EditorBrowsable (EditorBrowsableState.Advanced)]               \r
1794                 [MonoTODO]\r
1795                 public static Graphics FromHwnd (IntPtr hwnd)\r
1796                 {\r
1797                         throw new NotImplementedException();\r
1798                 }\r
1799 \r
1800                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1801                 [MonoTODO]\r
1802                 public static Graphics FromHwndInternal (IntPtr hwnd)\r
1803                 {\r
1804                         throw new NotImplementedException ();\r
1805                 }\r
1806 \r
1807                 [MonoTODO]\r
1808                 internal static Graphics FromXDrawable (IntPtr drawable, IntPtr display)\r
1809                 {\r
1810                         throw new NotImplementedException();\r
1811                 }\r
1812 \r
1813                 [MonoTODO]\r
1814                 public static IntPtr GetHalftonePalette ()\r
1815                 {\r
1816                         throw new NotImplementedException ();\r
1817                 }\r
1818 \r
1819                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1820                 [MonoTODO]\r
1821                 public IntPtr GetHdc ()\r
1822                 {\r
1823                         throw new NotImplementedException();\r
1824                 }\r
1825 #endif\r
1826                 \r
1827                 #region GetNearestColor\r
1828                 [MonoTODO]\r
1829                 public Color GetNearestColor (Color color) {\r
1830                         throw new NotImplementedException();\r
1831                 }\r
1832                 #endregion\r
1833 \r
1834                 #region IntersectClip\r
1835                 void IntersectClip (geom.Area area) {\r
1836                         \r
1837                         geom.AffineTransform t = GetFinalTransform();\r
1838                         if (!t.isIdentity()) {\r
1839                                 area = (geom.Area)area.clone();\r
1840                                 area.transform(t);\r
1841                         }\r
1842 \r
1843                         _clip.NativeObject.intersect(area);\r
1844                         RestoreBaseClip();\r
1845                         NativeObject.clip(_clip);\r
1846                 }\r
1847 \r
1848                 public void IntersectClip (Region region) {\r
1849                         if (region == null)\r
1850                                 throw new ArgumentNullException("region");\r
1851 \r
1852                         IntersectClip(region.NativeObject);\r
1853                 }\r
1854                 \r
1855                 public void IntersectClip (RectangleF rect) {\r
1856                         IntersectClip(new geom.Area(rect.NativeObject));\r
1857                 }\r
1858 \r
1859                 public void IntersectClip (Rectangle rect) {                    \r
1860                         IntersectClip(new geom.Area(rect.NativeObject));\r
1861                 }\r
1862                 #endregion\r
1863 \r
1864                 #region IsVisible\r
1865                 public bool IsVisible (Point point) {\r
1866                         return IsVisible(point.X,point.Y);\r
1867                 }\r
1868 \r
1869                 \r
1870                 public bool IsVisible (RectangleF rect) {\r
1871                         return IsVisible ((float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height);\r
1872                 }\r
1873 \r
1874                 public bool IsVisible (PointF point) {\r
1875                         return IsVisible(point.X,point.Y);\r
1876                 }\r
1877                 \r
1878                 public bool IsVisible (Rectangle rect) {\r
1879                         return IsVisible ((float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height);\r
1880                 }\r
1881                 \r
1882                 public bool IsVisible (float x, float y) {\r
1883                         double dx = x;\r
1884                         double dy = y;\r
1885                         geom.AffineTransform t = GetFinalTransform();\r
1886                         if (!t.isIdentity()) {\r
1887                                 double[] p = new double[] {dx, dy};\r
1888                                 t.transform(p, 0, p, 0, 1);\r
1889 \r
1890                                 dx = p[0];\r
1891                                 dy = p[1];\r
1892                         }\r
1893                         if (!_clip.NativeObject.contains(dx, dy))\r
1894                                 return false;\r
1895 \r
1896                         awt.Shape clip = NativeObject.getClip();\r
1897                         if (clip == null)\r
1898                                 return true;\r
1899 \r
1900                         return clip.contains(dx, dy);\r
1901                 }\r
1902                 \r
1903                 public bool IsVisible (int x, int y) {\r
1904                         return IsVisible ((float)x,(float)y);\r
1905                 }\r
1906                 \r
1907                 public bool IsVisible (float x, float y, float width, float height) {\r
1908 \r
1909                         geom.AffineTransform t = GetFinalTransform();\r
1910                         geom.Rectangle2D r = new geom.Rectangle2D.Float(x, y, width, height);\r
1911                         \r
1912                         if (!t.isIdentity())\r
1913                                 r = t.createTransformedShape(r).getBounds2D();\r
1914                 \r
1915                         return NativeObject.hitClip(\r
1916                                         (int)(r.getX()+0.5), (int)(r.getY()+0.5),\r
1917                                         (int)(r.getWidth()+0.5), (int)(r.getHeight()+0.5))\r
1918                                 && _clip.NativeObject.intersects(r);\r
1919                 }\r
1920 \r
1921                 \r
1922                 public bool IsVisible (int x, int y, int width, int height) {\r
1923                         return IsVisible ((float)x,(float)y,(float)width,(float)height);\r
1924                 }\r
1925                 #endregion\r
1926 \r
1927                 #region MeasureCharacterRanges\r
1928                 public Region [] MeasureCharacterRanges (string text, Font font, RectangleF layoutRect, StringFormat stringFormat) {\r
1929                         if (stringFormat == null)\r
1930                                 throw new ArgumentException("stringFormat");\r
1931 \r
1932                         CharacterRange[] ranges = stringFormat.CharRanges;\r
1933                         if (ranges == null || ranges.Length == 0)\r
1934                                 return new Region[0];\r
1935 \r
1936                         GraphicsPath[] pathes = new GraphicsPath[ranges.Length];\r
1937                         for (int i = 0; i < pathes.Length; i++)\r
1938                                 pathes[i] = new GraphicsPath();\r
1939 \r
1940                         TextLineIterator iter = new TextLineIterator(text, font, NativeObject.getFontRenderContext(),\r
1941                                 stringFormat, layoutRect.Width, layoutRect.Height);\r
1942                         \r
1943                         for (LineLayout layout = iter.NextLine(); layout != null; layout = iter.NextLine()) {\r
1944 \r
1945                                 for (int i = 0; i < ranges.Length; i++) {\r
1946                                         int start = ranges[i].First;\r
1947                                         int length = ranges[i].Length;\r
1948                                         start -= iter.CharsConsumed;\r
1949                                         int limit = start + length;\r
1950                                         int layoutStart = iter.CurrentPosition - layout.CharacterCount;\r
1951                                         if (start < iter.CurrentPosition && limit > layoutStart) {\r
1952 \r
1953                                                 float layoutOffset;\r
1954                                                 if (start > layoutStart)\r
1955                                                         layoutOffset = iter.GetAdvanceBetween(layoutStart, start);\r
1956                                                 else {\r
1957                                                         layoutOffset = 0;\r
1958                                                         start = layoutStart;\r
1959                                                 }\r
1960 \r
1961                                                 float width = (limit < iter.CurrentPosition) ?\r
1962                                                         iter.GetAdvanceBetween(start, limit) :\r
1963                                                         layout.Width - layoutOffset;\r
1964 \r
1965                                                 float height = layout.Ascent + layout.Descent;\r
1966 \r
1967                                                 float x = layout.NativeX;\r
1968                                                 float y = layout.NativeY;\r
1969 \r
1970                                                 if (stringFormat.IsVertical) {\r
1971                                                         y += layoutOffset;\r
1972                                                         x -= layout.Descent;\r
1973                                                 }\r
1974                                                 else {\r
1975                                                         x += layoutOffset;\r
1976                                                         y -= layout.Ascent;\r
1977                                                 }\r
1978 \r
1979                                                 if (layout.AccumulatedHeight + height > iter.WrapHeight) {\r
1980                                                         float diff = iter.WrapHeight - layout.AccumulatedHeight;\r
1981                                                         if (stringFormat.IsVertical && stringFormat.IsRightToLeft) {\r
1982                                                                 x += diff;\r
1983                                                                 height -= diff;\r
1984                                                         }\r
1985                                                         else\r
1986                                                                 height = diff;\r
1987                                                 }\r
1988 \r
1989                                                 if (stringFormat.IsVertical)\r
1990                                                         pathes[i].AddRectangle(x + layoutRect.X, y + layoutRect.Y, height, width);\r
1991                                                 else\r
1992                                                         pathes[i].AddRectangle(x + layoutRect.X, y + layoutRect.Y, width, height);\r
1993                                         }\r
1994                                 }\r
1995                         }\r
1996 \r
1997                         geom.AffineTransform lineAlignT = iter.CalcLineAlignmentTransform();\r
1998                         if (lineAlignT != null) {\r
1999                                 for (int i = 0; i < pathes.Length; i++)\r
2000                                         pathes[i].NativeObject.transform(lineAlignT);\r
2001                         }\r
2002 \r
2003                         Region[] regions = new Region[ranges.Length];\r
2004                         for (int i = 0; i < regions.Length; i++)\r
2005                                 regions[i] = new Region(pathes[i]);\r
2006 \r
2007                         return regions;\r
2008                 }\r
2009                 #endregion\r
2010                 \r
2011                 #region MeasureString\r
2012                 public SizeF MeasureString (string text, Font font) {\r
2013                         return MeasureString(text, font, null, float.PositiveInfinity, float.PositiveInfinity, null); \r
2014                 }\r
2015 \r
2016                 \r
2017                 public SizeF MeasureString (string text, Font font, SizeF layoutArea) {\r
2018                         return MeasureString(text, font, layoutArea, null);\r
2019                 }\r
2020 \r
2021                 \r
2022                 public SizeF MeasureString (string text, Font font, int width) {\r
2023                         return MeasureString(text, font, width, null);\r
2024                 }\r
2025 \r
2026 \r
2027                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat format) {\r
2028                         return MeasureString(text, font, format, layoutArea.Width, layoutArea.Height, null);\r
2029                 }\r
2030 \r
2031                 \r
2032                 public SizeF MeasureString (string text, Font font, int width, StringFormat format) {\r
2033                         return MeasureString(text, font, format, width, float.PositiveInfinity, null);\r
2034                 }\r
2035 \r
2036                 \r
2037                 public SizeF MeasureString (string text, Font font, PointF origin, StringFormat format) {\r
2038                         return MeasureString(text, font, format, float.PositiveInfinity, float.PositiveInfinity, null);\r
2039                 }\r
2040 \r
2041                 SizeF MeasureString (string text, Font font, StringFormat format, float width, float height, int[] statistics) {\r
2042 \r
2043                         if (statistics != null) {\r
2044                                 statistics[0] = 0;\r
2045                                 statistics[1] = 0;\r
2046                         }\r
2047 \r
2048                         TextLineIterator iter = new TextLineIterator(text, font, NativeObject.getFontRenderContext(), format, width, height);\r
2049 \r
2050                         float mwidth = 0;\r
2051                         int linesFilled = 0;\r
2052                         for (LineLayout layout = iter.NextLine(); layout != null; layout = iter.NextLine()) {\r
2053 \r
2054                                 linesFilled ++;\r
2055                                 float w = layout.MeasureWidth;\r
2056 \r
2057                                 if (w > mwidth)\r
2058                                         mwidth = w;\r
2059                         }\r
2060 \r
2061                         if (linesFilled == 0)\r
2062                                 return SizeF.Empty;\r
2063 \r
2064                         float mheight = iter.AccumulatedHeight;\r
2065 \r
2066                         if (format != null) {\r
2067                                 if (format.IsVertical) {\r
2068                                         float temp = mheight;\r
2069                                         mheight = mwidth;\r
2070                                         mwidth = temp;\r
2071                                 }\r
2072                         }\r
2073 \r
2074                         if (!(format != null && format.NoClip)) {\r
2075                                 if (mwidth > width)\r
2076                                         mwidth = width;\r
2077                                 if (mheight > height)\r
2078                                         mheight = height;\r
2079                         }\r
2080 \r
2081                         if (statistics != null) {\r
2082                                 statistics[0] = linesFilled;\r
2083                                 statistics[1] = iter.CharsConsumed;\r
2084                         }\r
2085 \r
2086                         return new SizeF(mwidth, mheight);\r
2087                 }\r
2088 \r
2089                 \r
2090                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat, out int charactersFitted, out int linesFilled) {       \r
2091                         linesFilled = 0;\r
2092                         charactersFitted = 0;\r
2093 \r
2094                         int[] statistics = new int[2];\r
2095                         SizeF sz = MeasureString(text, font, stringFormat, layoutArea.Width, layoutArea.Height, statistics);\r
2096                         linesFilled = statistics[0];\r
2097                         charactersFitted = statistics[1];\r
2098                         return sz;\r
2099                 }\r
2100                 #endregion\r
2101 \r
2102                 #region MultiplyTransform\r
2103                 public void MultiplyTransform (Matrix matrix) {\r
2104                         MultiplyTransform (matrix, MatrixOrder.Prepend);\r
2105                 }\r
2106 \r
2107                 public void MultiplyTransform (Matrix matrix, MatrixOrder order) {\r
2108                         ConcatenateTransform(matrix.NativeObject, order);\r
2109                 }\r
2110                 #endregion\r
2111 \r
2112                 #region Reset (Clip and Transform)\r
2113                 public void ResetClip () {\r
2114                         _clip.MakeInfinite();\r
2115                         RestoreBaseClip();\r
2116                         NativeObject.clip(_clip);\r
2117                 }\r
2118 \r
2119                 public void ResetTransform () {\r
2120                         _transform.Reset();\r
2121                 }\r
2122                 #endregion\r
2123 \r
2124                 #region RotateTransform\r
2125                 public void RotateTransform (float angle) {\r
2126                         RotateTransform (angle, MatrixOrder.Prepend);\r
2127                 }\r
2128 \r
2129                 public void RotateTransform (float angle, MatrixOrder order) {\r
2130                         ConcatenateTransform(\r
2131                                 geom.AffineTransform.getRotateInstance(java.lang.Math.toRadians(angle)),\r
2132                                 order);\r
2133                 }\r
2134                 #endregion\r
2135 \r
2136                 #region ScaleTransform\r
2137                 public void ScaleTransform (float sx, float sy) {\r
2138                         ScaleTransform (sx, sy, MatrixOrder.Prepend);\r
2139                 }\r
2140 \r
2141                 public void ScaleTransform (float sx, float sy, MatrixOrder order) {\r
2142                         ConcatenateTransform(\r
2143                                 geom.AffineTransform.getScaleInstance(sx, sy),\r
2144                                 order);\r
2145                 }\r
2146                 #endregion\r
2147 \r
2148                 #region SetClip [Must be reviewed - more abstraction needed]\r
2149                 public void SetClip (RectangleF rect) {\r
2150                         SetClip (rect, CombineMode.Replace);\r
2151                 }\r
2152 \r
2153                 public void SetClip (GraphicsPath path) {\r
2154                         SetClip (path, CombineMode.Replace);\r
2155                 }\r
2156 \r
2157                 public void SetClip (Rectangle rect) {\r
2158                         SetClip (rect, CombineMode.Replace);\r
2159                 }\r
2160 \r
2161                 public void SetClip (Graphics g) {\r
2162                         SetClip (g, CombineMode.Replace);\r
2163                 }\r
2164 \r
2165                 public void SetClip (Graphics g, CombineMode combineMode) {\r
2166                         if(g == null)\r
2167                                 throw new NullReferenceException();\r
2168                         \r
2169                         CombineClipArea(g._clip.NativeObject, combineMode);\r
2170                 }\r
2171 \r
2172                 public void SetClip (Rectangle rect, CombineMode combineMode) {\r
2173                         SetClip(rect.X,rect.Y,rect.Width,rect.Height,combineMode);                      \r
2174                 }               \r
2175                 public void SetClip (RectangleF rect, CombineMode combineMode) {                        \r
2176                         SetClip(rect.X,rect.Y,rect.Width,rect.Height,combineMode);                      \r
2177                 }\r
2178                 \r
2179                 public void SetClip (Region region, CombineMode combineMode) {\r
2180                         if(region == null)\r
2181                                 throw new ArgumentNullException("region");\r
2182 \r
2183                         CombineClipArea((geom.Area)region.NativeObject.clone(),combineMode);\r
2184                 }\r
2185                 \r
2186                 public void SetClip (GraphicsPath path, CombineMode combineMode) {\r
2187                         if(path == null)\r
2188                                 throw new ArgumentNullException("path");\r
2189 \r
2190                         CombineClipArea(new geom.Area(path.NativeObject), combineMode);\r
2191                 }\r
2192                 #endregion\r
2193 \r
2194                 #region Clipping Staff [INTERNAL]\r
2195                 internal Region ScaledClip {\r
2196                         get {\r
2197                                 return _clip.Clone();\r
2198                         }\r
2199                         set {\r
2200                                 _clip.NativeObject.reset();\r
2201                                 _clip.NativeObject.add(value.NativeObject);\r
2202                         }\r
2203                 }\r
2204                 internal void SetClip(float x,float y,float width,float height,CombineMode combineMode) {                                       \r
2205                         CombineClipArea(new geom.Area(\r
2206                                 new geom.Rectangle2D.Float(x,y,width,height)),combineMode);\r
2207                 }\r
2208 \r
2209                 void CombineClipArea(geom.Area area, CombineMode combineMode) {\r
2210                         geom.AffineTransform t = GetFinalTransform();\r
2211                         if (!t.isIdentity())\r
2212                                 area.transform(t);\r
2213                         if (combineMode == CombineMode.Replace) {\r
2214                                 _clip.NativeObject.reset();\r
2215                                 _clip.NativeObject.add(area);\r
2216                         }\r
2217                         else {\r
2218                                 geom.Area curClip = _clip.NativeObject;\r
2219                                 switch(combineMode) {\r
2220                                         case CombineMode.Complement:\r
2221                                                 curClip.add(area);\r
2222                                                 break;\r
2223                                         case CombineMode.Exclude:\r
2224                                                 curClip.subtract(area);\r
2225                                                 break;\r
2226                                         case CombineMode.Intersect:\r
2227                                                 curClip.intersect(area);\r
2228                                                 break;\r
2229                                         case CombineMode.Union:\r
2230                                                 curClip.add(area);\r
2231                                                 break;\r
2232                                         case CombineMode.Xor:\r
2233                                                 curClip.exclusiveOr(area);\r
2234                                                 break;\r
2235                                         default:\r
2236                                                 throw new ArgumentOutOfRangeException();                                        \r
2237                                 }\r
2238                         }\r
2239 \r
2240                         RestoreBaseClip();\r
2241                         NativeObject.clip(_clip);\r
2242                 }\r
2243 \r
2244                 internal void IntersectScaledClipWithBase(awt.Shape clip) {\r
2245                         NativeObject.clip(clip);\r
2246                 }\r
2247 \r
2248                 void RestoreBaseClip() {\r
2249                         if (_nextGraphicsState == null) {\r
2250                                 NativeObject.setClip(_windowRect);\r
2251                                 return;\r
2252                         }\r
2253 \r
2254                         _nextGraphicsState.RestoreBaseClip(this);\r
2255                 }\r
2256                 \r
2257                 #endregion\r
2258                 \r
2259                 #region TransformPoints\r
2260                 [MonoTODO]\r
2261                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF [] pts) {\r
2262                         //TBD:CoordinateSpace\r
2263                         java.awt.geom.AffineTransform tr = this.Transform.NativeObject;\r
2264                         float[] fpts = new float[2];\r
2265                         for(int i = 0; i< pts.Length; i++) {\r
2266                                 fpts[0] = pts[i].X;\r
2267                                 fpts[1] = pts[i].Y;\r
2268                                 tr.transform(fpts, 0, fpts, 0, 1);\r
2269                                 pts[i].X = fpts[0];\r
2270                                 pts[i].Y = fpts[1];\r
2271                         }\r
2272                 }\r
2273 \r
2274                 [MonoTODO]\r
2275                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts) {                                               \r
2276                         //TBD:CoordinateSpace\r
2277                         java.awt.geom.AffineTransform tr = this.Transform.NativeObject;\r
2278                         float[] fpts = new float[2];\r
2279                         for(int i = 0; i< pts.Length; i++) {\r
2280                                 fpts[0] = pts[i].X;\r
2281                                 fpts[1] = pts[i].Y;\r
2282                                 tr.transform(fpts, 0, fpts, 0, 1);\r
2283                                 pts[i].X = (int)fpts[0];\r
2284                                 pts[i].Y = (int)fpts[1];\r
2285                         }\r
2286                 }\r
2287                 #endregion\r
2288 \r
2289                 #region TranslateClip\r
2290                 public void TranslateClip (int dx, int dy) {\r
2291                         TranslateClip((float)dx, (float)dy);\r
2292                 }\r
2293 \r
2294                 \r
2295                 public void TranslateClip (float dx, float dy) {\r
2296                         double x = dx;\r
2297                         double y = dy;\r
2298                         geom.AffineTransform f = GetFinalTransform();\r
2299 \r
2300                         if (!f.isIdentity()) {\r
2301                                 double[] p = new double[] {x, y};\r
2302                                 f.deltaTransform(p, 0, p, 0, 1);\r
2303 \r
2304                                 x = p[0];\r
2305                                 y = p[1];\r
2306                         }\r
2307 \r
2308                         // It seems .Net does exactly this...\r
2309                         x = Math.Floor(x+0.96875);\r
2310                         y = Math.Floor(y+0.96875);\r
2311 \r
2312                         geom.AffineTransform t = geom.AffineTransform.getTranslateInstance(x, y);\r
2313 \r
2314                         _clip.NativeObject.transform(t);\r
2315                         RestoreBaseClip();\r
2316                         NativeObject.clip(_clip);\r
2317                 }\r
2318                 #endregion\r
2319 \r
2320                 #region TranslateTransform\r
2321                 public void TranslateTransform (float dx, float dy) {\r
2322                         TranslateTransform (dx, dy, MatrixOrder.Prepend);\r
2323                 }\r
2324 \r
2325                 \r
2326                 public void TranslateTransform (float dx, float dy, MatrixOrder order) {\r
2327                         ConcatenateTransform(\r
2328                                 geom.AffineTransform.getTranslateInstance(dx, dy), \r
2329                                 order);\r
2330                 }\r
2331                 #endregion\r
2332 \r
2333                 #region Properties [Partial TODO]\r
2334                 public Region Clip {\r
2335                         get {\r
2336                                 Region r = _clip.Clone();\r
2337                                 geom.AffineTransform t = GetFinalTransform();\r
2338                                 if (!t.isIdentity())\r
2339                                         r.NativeObject.transform(t.createInverse());\r
2340 \r
2341                                 return r;\r
2342                         }\r
2343                         set {\r
2344                                 SetClip (value, CombineMode.Replace);\r
2345                         }\r
2346                 }\r
2347 \r
2348                 public RectangleF ClipBounds {\r
2349                         get {\r
2350                                 awt.Shape shape = _clip.NativeObject;\r
2351                                 if (shape == null)\r
2352                                         shape = Region.InfiniteRegion.NativeObject;\r
2353 \r
2354                                 geom.RectangularShape r = shape.getBounds2D();\r
2355                                 geom.AffineTransform t = GetFinalTransform();\r
2356                                 if (!t.isIdentity()) {\r
2357                                         geom.AffineTransform it = t.createInverse();\r
2358                                         r = it.createTransformedShape(r).getBounds2D();\r
2359                                 }\r
2360 \r
2361                                 return new RectangleF (r);\r
2362                         }\r
2363                 }\r
2364 \r
2365                 public CompositingMode CompositingMode {\r
2366                         //TBD:check this carefully\r
2367                         get {\r
2368                                 return (NativeObject.getComposite() == awt.AlphaComposite.SrcOver) ?\r
2369                                         CompositingMode.SourceOver : CompositingMode.SourceCopy;\r
2370                         }\r
2371                         set {\r
2372                                 NativeObject.setComposite(\r
2373                                         (value == CompositingMode.SourceOver) ?\r
2374                                         awt.AlphaComposite.SrcOver : awt.AlphaComposite.Src);\r
2375                         }\r
2376 \r
2377                 }\r
2378 \r
2379                 public CompositingQuality CompositingQuality {\r
2380                         get {\r
2381                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2382                                 if(hints.containsKey(awt.RenderingHints.KEY_ALPHA_INTERPOLATION)) {\r
2383                                         object value_ai = hints.get(awt.RenderingHints.KEY_ALPHA_INTERPOLATION);\r
2384 \r
2385                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED)\r
2386                                                 return CompositingQuality.HighSpeed;\r
2387                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY)\r
2388                                                 return CompositingQuality.HighQuality;\r
2389                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT)\r
2390                                                 return CompositingQuality.Default;\r
2391                                 }\r
2392 \r
2393                                 return CompositingQuality.Default;\r
2394                                         \r
2395                         }\r
2396                         set {\r
2397                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2398                                 switch (value) {\r
2399                                         case CompositingQuality.AssumeLinear:\r
2400                                         case CompositingQuality.Default:\r
2401                                         case CompositingQuality.GammaCorrected:\r
2402                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
2403                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);\r
2404                                                 break;\r
2405                                         case CompositingQuality.HighQuality:\r
2406                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
2407                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);\r
2408                                                 break;\r
2409                                         case CompositingQuality.HighSpeed:\r
2410                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
2411                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);\r
2412                                                 break;\r
2413 //                                      case CompositingQuality.Invalid:\r
2414 //                                              if(hints.containsKey(awt.RenderingHints.KEY_ALPHA_INTERPOLATION))\r
2415 //                                                      hints.remove(awt.RenderingHints.KEY_ALPHA_INTERPOLATION);\r
2416                                 }\r
2417 \r
2418                                 NativeObject.setRenderingHints(hints);\r
2419                         }\r
2420                 }\r
2421 \r
2422                 public float DpiX {\r
2423                         get {                           \r
2424                                 return DefaultScreenResolution;\r
2425                         }\r
2426                 }\r
2427 \r
2428                 public float DpiY {\r
2429                         get {\r
2430                                 //TBD: assume 72 (screen) for now\r
2431                                 return DpiX;\r
2432                         }\r
2433                 }\r
2434 \r
2435                 public InterpolationMode InterpolationMode {\r
2436                         get {                           \r
2437                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2438                                 if(hints.containsKey(awt.RenderingHints.KEY_INTERPOLATION)) {\r
2439                                         object value_i = hints.get(awt.RenderingHints.KEY_INTERPOLATION);\r
2440 \r
2441                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR)\r
2442                                                 return InterpolationMode.Bilinear;\r
2443                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC)\r
2444                                                 return InterpolationMode.Bicubic;\r
2445                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)\r
2446                                                 return InterpolationMode.NearestNeighbor;\r
2447                                 }\r
2448 \r
2449                                 return InterpolationMode.Default;\r
2450                         }\r
2451                         set {\r
2452                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2453 \r
2454                                 switch (value) {\r
2455                                         case InterpolationMode.Bicubic:\r
2456                                         case InterpolationMode.HighQualityBicubic:\r
2457                                         case InterpolationMode.Low:\r
2458                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC);\r
2459                                                 break;\r
2460                                         case InterpolationMode.High:\r
2461                                         case InterpolationMode.Bilinear:\r
2462                                         case InterpolationMode.HighQualityBilinear:\r
2463                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR);\r
2464                                                 break;\r
2465                                         case InterpolationMode.Default:\r
2466                                                 if (hints.containsKey(awt.RenderingHints.KEY_INTERPOLATION))\r
2467                                                         hints.remove(awt.RenderingHints.KEY_INTERPOLATION);\r
2468                                                 break;\r
2469                                         case InterpolationMode.NearestNeighbor:\r
2470                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);\r
2471                                                 break;\r
2472                                         case InterpolationMode.Invalid:\r
2473                                                 throw new ArgumentException();\r
2474                                         default:\r
2475                                                 throw new ArgumentOutOfRangeException();\r
2476                                 }\r
2477 \r
2478                                 NativeObject.setRenderingHints(hints);\r
2479                         }\r
2480                 }\r
2481 \r
2482                 public bool IsClipEmpty {\r
2483                         get {\r
2484                                 return _clip.IsEmpty(this);\r
2485                         }\r
2486                 }\r
2487 \r
2488                 public bool IsVisibleClipEmpty {\r
2489                         get {\r
2490                                 if (_clip.IsEmpty(this))\r
2491                                         return true;\r
2492 \r
2493                                 return VisibleClipBounds.IsEmpty;\r
2494                         }\r
2495                 }\r
2496 \r
2497                 public float PageScale {\r
2498                         get {\r
2499                                 return _pageScale;\r
2500                         }\r
2501                         set {\r
2502                                 _pageScale = value;\r
2503                         }\r
2504                 }\r
2505 \r
2506                 public GraphicsUnit PageUnit {\r
2507                         get {\r
2508                                 return _pageUnit;\r
2509                         }\r
2510                         set {\r
2511                                 _pageUnit = value;\r
2512                         }\r
2513                 }\r
2514 \r
2515                 static internal geom.AffineTransform GetFinalTransform(\r
2516                         geom.AffineTransform transform, GraphicsUnit pageUnit, float pageScale) {\r
2517                         geom.AffineTransform t = null;\r
2518                         if (pageUnit != GraphicsUnit.Display) {\r
2519                                 float scale = pageScale * _unitConversion[ (int)pageUnit ];\r
2520                                 if (Math.Abs(scale-1f) > float.Epsilon)\r
2521                                         t = geom.AffineTransform.getScaleInstance(scale, scale);\r
2522                         }\r
2523 \r
2524                         if (t != null)\r
2525                                 t.concatenate(transform);\r
2526                         else\r
2527                                 t = transform;\r
2528                         \r
2529                         return t;\r
2530                 }\r
2531 \r
2532                 geom.AffineTransform GetFinalTransform() {\r
2533                         return GetFinalTransform(_transform.NativeObject, PageUnit, PageScale);\r
2534                 }\r
2535 \r
2536                 public PixelOffsetMode PixelOffsetMode {\r
2537                         get {\r
2538                                 return _pixelOffsetMode;\r
2539                         }\r
2540                         set {\r
2541                                 _pixelOffsetMode = value;\r
2542                         }\r
2543                 }\r
2544 \r
2545                 [MonoTODO]\r
2546                 public Point RenderingOrigin {\r
2547                         get {\r
2548                                 throw new NotImplementedException();\r
2549                         }\r
2550                         set {\r
2551                                 throw new NotImplementedException();\r
2552                         }\r
2553                 }\r
2554 \r
2555                 public SmoothingMode SmoothingMode {\r
2556                         get {\r
2557                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2558                                 if(hints.containsKey(awt.RenderingHints.KEY_ANTIALIASING)) {\r
2559                                         object value_aa = hints.get(awt.RenderingHints.KEY_ANTIALIASING);\r
2560                                         if (value_aa == awt.RenderingHints.VALUE_ANTIALIAS_ON) {\r
2561                                                 if(hints.containsKey(awt.RenderingHints.KEY_RENDERING)) {\r
2562                                                         object value_render = hints.get(awt.RenderingHints.KEY_RENDERING);\r
2563                                                         if (value_render == awt.RenderingHints.VALUE_RENDER_QUALITY)\r
2564                                                                 return SmoothingMode.HighQuality;\r
2565                                                         if (value_render == awt.RenderingHints.VALUE_RENDER_SPEED)\r
2566                                                                 return SmoothingMode.HighSpeed;\r
2567                                                 }\r
2568 \r
2569                                                 return SmoothingMode.AntiAlias;\r
2570                                         }\r
2571 \r
2572                                         if (value_aa == awt.RenderingHints.VALUE_ANTIALIAS_DEFAULT)\r
2573                                                 return SmoothingMode.Default;\r
2574                                 }\r
2575                                 return SmoothingMode.None;\r
2576 \r
2577                         }\r
2578 \r
2579                         set {\r
2580                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2581 \r
2582                                 switch (value) {\r
2583                                         case SmoothingMode.None:\r
2584                                                 if(hints.containsKey(awt.RenderingHints.KEY_ANTIALIASING))\r
2585                                                         hints.remove(awt.RenderingHints.KEY_ANTIALIASING);\r
2586                                                 if(hints.containsKey(awt.RenderingHints.KEY_RENDERING))\r
2587                                                         hints.remove(awt.RenderingHints.KEY_RENDERING);\r
2588                                                 break;\r
2589                                         case SmoothingMode.AntiAlias:\r
2590                                                 hints.put(awt.RenderingHints.KEY_ANTIALIASING, awt.RenderingHints.VALUE_ANTIALIAS_ON);\r
2591                                                 break;\r
2592                                         case SmoothingMode.HighQuality:\r
2593                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_QUALITY);\r
2594                                                 goto case SmoothingMode.AntiAlias;\r
2595                                         case SmoothingMode.HighSpeed:\r
2596                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_SPEED);\r
2597                                                 goto case SmoothingMode.None;\r
2598                                         case SmoothingMode.Default:\r
2599                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_DEFAULT);\r
2600                                                 goto case SmoothingMode.AntiAlias;\r
2601                                         case SmoothingMode.Invalid:\r
2602                                                 throw new ArgumentException("Invalid parameter used.");\r
2603                                 }\r
2604 \r
2605                                 NativeObject.setRenderingHints(hints);\r
2606                         }\r
2607                 }\r
2608 \r
2609                 /// <summary>\r
2610                 /// Java does not have similar functionality\r
2611                 /// </summary>\r
2612                 public int TextContrast {\r
2613                         get {\r
2614                                 return _textContrast;\r
2615                         }\r
2616 \r
2617                         set {\r
2618                                 _textContrast = value;\r
2619                         }\r
2620                 }\r
2621 \r
2622                 public TextRenderingHint TextRenderingHint {\r
2623                         get {\r
2624                                 return _textRenderingHint;\r
2625 //                              awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2626 //                              if(hints.containsKey(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING)) {\r
2627 //                                      if(hints.get(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING) == \r
2628 //                                              java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON)\r
2629 //                                              return TextRenderingHint.AntiAlias;\r
2630 //                                      if(hints.get(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING) == \r
2631 //                                              java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_OFF)\r
2632 //                                              return TextRenderingHint.SingleBitPerPixel;\r
2633 //                              }\r
2634 //                              //return TextRenderingHint.SystemDefault;\r
2635 //                              return TextRenderingHint.SingleBitPerPixelGridFit;\r
2636                         }\r
2637 \r
2638                         set {\r
2639                                 _textRenderingHint = value;\r
2640                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2641                                 switch (value) {\r
2642                                         case TextRenderingHint.AntiAlias:\r
2643                                         case TextRenderingHint.AntiAliasGridFit:\r
2644                                         case TextRenderingHint.ClearTypeGridFit:\r
2645 //                                      case TextRenderingHint.SystemDefault:\r
2646                                                 hints.put(awt.RenderingHints.KEY_TEXT_ANTIALIASING,\r
2647                                                         awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);\r
2648                                                 break;\r
2649                                         \r
2650                                         case TextRenderingHint.SingleBitPerPixelGridFit:\r
2651                                                 hints.put(awt.RenderingHints.KEY_TEXT_ANTIALIASING,\r
2652                                                         awt.RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT);\r
2653                                                 break;\r
2654 \r
2655                                         case TextRenderingHint.SingleBitPerPixel:\r
2656                                                 hints.put(awt.RenderingHints.KEY_TEXT_ANTIALIASING,\r
2657                                                         awt.RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);\r
2658                                                 break;\r
2659 \r
2660                                         case TextRenderingHint.SystemDefault:\r
2661                                                 hints.put(awt.RenderingHints.KEY_TEXT_ANTIALIASING,\r
2662                                                         awt.RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT);\r
2663                                                 break;\r
2664                                 }\r
2665                                 \r
2666                                 NativeObject.setRenderingHints(hints);\r
2667                         }\r
2668                 }\r
2669 \r
2670                 public Matrix Transform {\r
2671                         get {\r
2672                                 return _transform.Clone();\r
2673                         }\r
2674                         set {\r
2675                                 if (value == null)\r
2676                                         throw new ArgumentNullException("matrix");\r
2677 \r
2678                                 if (!value.IsInvertible)\r
2679                                         throw new ArgumentException("Invalid parameter used.");\r
2680 \r
2681                                 value.CopyTo(_transform);\r
2682                         }\r
2683                 }\r
2684 \r
2685                 internal Matrix BaseTransform {\r
2686                         get {\r
2687                                 return new Matrix(NativeObject.getTransform());\r
2688                         }\r
2689                         set {\r
2690                                 NativeObject.setTransform(value.NativeObject);\r
2691                         }\r
2692                 }\r
2693 \r
2694                 internal void PrependBaseTransform(geom.AffineTransform t) {\r
2695                         NativeObject.transform(t);\r
2696                 }\r
2697 \r
2698                 internal awt.Shape VisibleShape {\r
2699                         get {\r
2700                                 return _windowRect;\r
2701                         }\r
2702                 }\r
2703 \r
2704                 public RectangleF VisibleClipBounds {\r
2705                         get {\r
2706                                 if (_clip.IsEmpty(this))\r
2707                                         return RectangleF.Empty;\r
2708 \r
2709                                 geom.Rectangle2D r = _clip.NativeObject.getBounds2D();\r
2710                                 awt.Shape clip = NativeObject.getClip();\r
2711                                 geom.Rectangle2D clipBounds = (clip != null) ? clip.getBounds2D() : _windowRect;\r
2712                                 geom.Rectangle2D.intersect(r, clipBounds, r);\r
2713                                 if ((r.getWidth() <= 0) || (r.getHeight() <= 0))\r
2714                                         return RectangleF.Empty;\r
2715 \r
2716                                 geom.AffineTransform t = GetFinalTransform();\r
2717                                 if (!t.isIdentity()) {\r
2718                                         geom.AffineTransform it = t.createInverse();\r
2719                                         r = it.createTransformedShape(r).getBounds2D();\r
2720                                 }\r
2721 \r
2722                                 return new RectangleF (r);\r
2723                         }\r
2724                 }\r
2725 \r
2726                 void ConcatenateTransform(geom.AffineTransform transform, MatrixOrder order) {\r
2727                         geom.AffineTransform at = _transform.NativeObject;\r
2728                         Matrix.Multiply(at, transform, order);\r
2729                 }\r
2730                 #endregion\r
2731         }\r
2732 }\r
2733 \r