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                 \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                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr) {\r
 846                         //TBD: ImageAttributes\r
 847                         if (srcUnit != GraphicsUnit.Pixel)\r
 848                                 throw new NotImplementedException();\r
 849                         // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx\r
 850 \r
 851                         Matrix mx = new Matrix(srcRect, destPoints);\r
 852 \r
 853                         Region region = new Region(srcRect);\r
 854                         DrawImage(image, mx, region);\r
 855                 }\r
 856 \r
 857 \r
 858                 public void DrawImage (Image image, int x, int y, int width, int height) {\r
 859                         DrawImage(image, (float)x, (float)y, (float)width, (float)height);\r
 860                 }\r
 861 \r
 862                 public void DrawImage (Image image, float x, float y, float width, float height) {\r
 863                         Matrix mx = new Matrix();\r
 864                         mx.Translate((float)x, (float)y);\r
 865                         mx.Scale(width / (float)image.Width, height / (float)image.Height);\r
 866 \r
 867                         DrawImage( image, mx );\r
 868                 }\r
 869 \r
 870                 \r
 871                 public void DrawImage (Image image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit) {                    \r
 872                         DrawImage(image, new Rectangle(x, y, srcRect.Width, srcRect.Height), srcRect, srcUnit);\r
 873                 }\r
 874                 \r
 875                 public void DrawImage (Image image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit) {       \r
 876                         DrawImage(image, new RectangleF(x, y, srcRect.Width, srcRect.Height), srcRect, srcUnit);\r
 877                 }\r
 878 \r
 879 \r
 880                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit) {\r
 881                         DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);\r
 882                 }\r
 883 \r
 884                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit) {\r
 885                         DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);\r
 886                 }\r
 887                 \r
 888 \r
 889                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr) {                     \r
 890                         //TBD: attributes\r
 891                         DrawImage(\r
 892                                 image, \r
 893                                 destRect,\r
 894                                 new Rectangle(srcX, srcY, srcWidth, srcHeight),\r
 895                                 srcUnit);\r
 896                 }\r
 897                 \r
 898                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs) {\r
 899                         //TBD: attributes\r
 900                         DrawImage(\r
 901                                 image, \r
 902                                 destRect,\r
 903                                 new RectangleF(srcX, srcY, srcWidth, srcHeight),\r
 904                                 srcUnit);\r
 905                 }\r
 906                 \r
 907 \r
 908                 internal void DrawImage (Image image, Matrix m) {\r
 909                         DrawImage(image, m, null);\r
 910                 }\r
 911 \r
 912                 internal void DrawImage (Image image, Matrix m, Region clip) {\r
 913                         if (clip == null) {\r
 914                                 clip = new Region( new RectangleF( 0, 0, image.Width, image.Height ) );\r
 915                         }\r
 916 \r
 917                         geom.AffineTransform t = GetFinalTransform(_transform.NativeObject, PageUnit, 1.0f);\r
 918                         if (!t.isIdentity())\r
 919                                 m.NativeObject.preConcatenate(t);\r
 920 \r
 921                                 clip.Transform( m );\r
 922 \r
 923                         if (NeedsNormalization) {\r
 924                                 Matrix normMatrix = ComputeClipNormalization(clip.GetBounds(this));\r
 925                                 clip.Transform(normMatrix);\r
 926                         }\r
 927 \r
 928                         awt.Shape oldClip = NativeObject.getClip();\r
 929                         IntersectScaledClipWithBase(clip);\r
 930                         \r
 931                         try {\r
 932                                 Matrix mm = ComputeImageNormalization(image, m);\r
 933                                 NativeObject.drawImage(image.NativeObject.CurrentImage.NativeImage, mm.NativeObject, null);\r
 934                         }\r
 935                         finally {\r
 936                                 NativeObject.setClip( oldClip );\r
 937                         }\r
 938                 }\r
 939 \r
 940                 private static Matrix ComputeImageNormalization(Image img, Matrix m) {\r
 941                         if ( m.IsIdentity )\r
 942                                 return m;\r
 943 \r
 944                         //m.Translate( -(m.Elements[0] + m.Elements[2]) / 2.0f,  -(m.Elements[3] + m.Elements[1]) / 2.0f, MatrixOrder.Append);\r
 945                         m.Translate( \r
 946                                 -(float)(m.NativeObject.getScaleX() + m.NativeObject.getShearX()) / 2.0f,  \r
 947                                 -(float)(m.NativeObject.getScaleY() + m.NativeObject.getShearY()) / 2.0f, MatrixOrder.Append);\r
 948                         \r
 949                         PointF [] p = new PointF[] { \r
 950                                                                                    new PointF( 0, 0 ),\r
 951                                                                                    new PointF( img.Width, 0 ),\r
 952                                                                                    new PointF( 0, img.Height )};\r
 953 \r
 954                         m.TransformPoints(p);\r
 955                         for (int i=0; i < p.Length; i++) {\r
 956                                 p[i].X = (float)( p[i].X + 0.5f );\r
 957                                 p[i].Y = (float)( p[i].Y + 0.5f );\r
 958                         }\r
 959 \r
 960                         return new Matrix( new Rectangle(0, 0, img.Width, img.Height), p );\r
 961                 }\r
 962                 private static Matrix ComputeClipNormalization(RectangleF rect) {\r
 963                         PointF [] p = new PointF[] { \r
 964                                                                                    new PointF( rect.X, rect.Y ),\r
 965                                                                                    new PointF( rect.X + rect.Width, rect.Y ),\r
 966                                                                                    new PointF( rect.X, rect.Y + rect.Height )};\r
 967 \r
 968                         for (int i=0; i < p.Length; i++) {\r
 969                                 p[i].X = (float)Math.Round( p[i].X + 0.5f ) + 0.5f;\r
 970                                 p[i].Y = (float)Math.Round( p[i].Y + 0.5f ) + 0.5f;\r
 971                         }\r
 972 \r
 973                         return new Matrix( rect, p );\r
 974                 }\r
 975                 \r
 976 \r
 977 #if INTPTR_SUPPORT\r
 978                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
 979                 {\r
 980                         throw new NotImplementedException();\r
 981                 }\r
 982 \r
 983                 \r
 984                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
 985                 {\r
 986                         \r
 987                         throw new NotImplementedException();\r
 988                 }\r
 989 \r
 990                 \r
 991                 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)\r
 992                 {\r
 993                         throw new NotImplementedException();\r
 994                 }\r
 995 #endif\r
 996 \r
 997 #if INTPTR_SUPPORT              \r
 998                 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)\r
 999                 {\r
1000                         throw new NotImplementedException();\r
1001                 }\r
1002 #endif\r
1003 \r
1004 #if INTPTR_SUPPORT              \r
1005                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
1006                 {\r
1007                         //TBD:units,attributes, callback\r
1008                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
1009                         g.drawImage(image.NativeObject,destRect.X,destRect.Y,destRect.Width,destRect.Height,srcX,srcY,srcWidth,srcHeight,null);\r
1010                 }\r
1011                 \r
1012                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)\r
1013                 {\r
1014                         //TBD:units,attributes, callback\r
1015                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
1016                         g.drawImage(image.NativeObject,\r
1017                                 (int)destRect.X,\r
1018                                 (int)destRect.Y,\r
1019                                 (int)destRect.Width,\r
1020                                 (int)destRect.Height,\r
1021                                 (int)srcX,\r
1022                                 (int)srcY,\r
1023                                 (int)srcWidth,\r
1024                                 (int)srcHeight,null);\r
1025                 }\r
1026 \r
1027                 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)\r
1028                 {\r
1029                         //TBD:units,attributes, callback\r
1030                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
1031                         g.drawImage(image.NativeObject,\r
1032                                 (int)destRect.X,\r
1033                                 (int)destRect.Y,\r
1034                                 (int)destRect.Width,\r
1035                                 (int)destRect.Height,\r
1036                                 (int)srcX,\r
1037                                 (int)srcY,\r
1038                                 (int)srcWidth,\r
1039                                 (int)srcHeight,null);\r
1040                 }\r
1041                 \r
1042                 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)\r
1043                 {\r
1044                         //TBD:units,attributes, callback\r
1045                         java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;\r
1046                         g.drawImage(image.NativeObject,\r
1047                                 destRect.X,\r
1048                                 destRect.Y,\r
1049                                 destRect.Width,\r
1050                                 destRect.Height,\r
1051                                 srcX,\r
1052                                 srcY,\r
1053                                 srcWidth,\r
1054                                 srcHeight,null);\r
1055                 }               \r
1056 #endif\r
1057                 \r
1058                 public void DrawImageUnscaled (Image image, Point point) \r
1059                 {\r
1060                         DrawImageUnscaled (image, point.X, point.Y);\r
1061                 }\r
1062                 \r
1063                 public void DrawImageUnscaled (Image image, Rectangle rect) {\r
1064                         DrawImageUnscaled (image, rect.X, rect.Y, rect.Width, rect.Height);\r
1065                 }\r
1066                 \r
1067                 public void DrawImageUnscaled (Image image, int x, int y) {\r
1068                         DrawImage (image, x, y, image.Width, image.Height);\r
1069                 }\r
1070 \r
1071                 public void DrawImageUnscaled (Image image, int x, int y, int width, int height) {\r
1072                         Image tmpImg = new Bitmap (width, height);\r
1073                         Graphics g = FromImage (tmpImg);\r
1074                         g.DrawImage (image, 0, 0, image.Width, image.Height);\r
1075                         this.DrawImage (tmpImg, x, y, width, height);\r
1076                         tmpImg.Dispose ();\r
1077                         g.Dispose ();           \r
1078                 }\r
1079                 #endregion\r
1080 \r
1081                 #region DrawLine\r
1082                 public void DrawLine (Pen pen, PointF pt1, PointF pt2) {\r
1083                         DrawLine(pen,pt1.X,pt1.Y,pt2.X,pt2.Y);\r
1084                 }\r
1085 \r
1086                 public void DrawLine (Pen pen, Point pt1, Point pt2) {\r
1087                         DrawLine(pen,(float)pt1.X,(float)pt1.Y,(float)pt2.X,(float)pt2.Y);\r
1088                 }\r
1089 \r
1090                 public void DrawLine (Pen pen, int x1, int y1, int x2, int y2) {\r
1091                         DrawLine(pen,(float)x1,(float)y1,(float)x2,(float)y2);\r
1092                 }\r
1093 \r
1094                 public void DrawLine (Pen pen, float x1, float y1, float x2, float y2) {\r
1095                         DrawShape(pen, new geom.Line2D.Float(x1,y1,x2,y2));\r
1096                 }\r
1097 \r
1098                 public void DrawLines (Pen pen, PointF [] points) {\r
1099                         GraphicsPath path = new GraphicsPath();\r
1100                         path.AddLines(points);\r
1101                         DrawShape(pen, path);\r
1102                 }\r
1103 \r
1104                 public void DrawLines (Pen pen, Point [] points) {\r
1105                         GraphicsPath path = new GraphicsPath();\r
1106                         path.AddLines(points);\r
1107                         DrawShape(pen, path);\r
1108                 }\r
1109                 #endregion\r
1110 \r
1111                 #region DrawPath\r
1112                 public void DrawPath (Pen pen, GraphicsPath path) {\r
1113                         DrawShape(pen, path);\r
1114                 }\r
1115                 #endregion\r
1116                 \r
1117                 #region DrawPie\r
1118                 public void DrawPie (Pen pen, Rectangle rect, float startAngle, float sweepAngle) {\r
1119                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);\r
1120                 }\r
1121                 \r
1122                 public void DrawPie (Pen pen, RectangleF rect, float startAngle, float sweepAngle) {\r
1123                         DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);\r
1124                 }\r
1125                 \r
1126                 public void DrawPie (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle) {\r
1127                         GraphicsPath path = new GraphicsPath();\r
1128                         path.AddPie(x, y, width, height, startAngle, sweepAngle);\r
1129                         DrawPath(pen, path);\r
1130                 }\r
1131                 \r
1132                 public void DrawPie (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle) {\r
1133                         DrawPie(pen,(float)x,(float)y,(float)width,(float)height,(float)startAngle,(float)sweepAngle);\r
1134                 }\r
1135                 #endregion\r
1136 \r
1137                 #region DrawPolygon\r
1138                 public void DrawPolygon (Pen pen, Point [] points) {\r
1139                         GraphicsPath path = new GraphicsPath();\r
1140                         path.AddPolygon(points);\r
1141                         DrawPath(pen, path);\r
1142                 }\r
1143 \r
1144                 public void DrawPolygon (Pen pen, PointF [] points) {\r
1145                         GraphicsPath path = new GraphicsPath();\r
1146                         path.AddPolygon(points);\r
1147                         DrawPath(pen, path);\r
1148                 }\r
1149                 #endregion\r
1150 \r
1151                 #region DrawRectangle(s)\r
1152                 internal void DrawRectangle (Pen pen, RectangleF rect) {\r
1153                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);\r
1154                 }\r
1155 \r
1156                 public void DrawRectangle (Pen pen, Rectangle rect) {\r
1157                         DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);\r
1158                 }\r
1159 \r
1160                 public void DrawRectangle (Pen pen, float x, float y, float width, float height) {\r
1161                         DrawShape(pen, new geom.Rectangle2D.Float(x,y,width,height));\r
1162                 }\r
1163 \r
1164                 public void DrawRectangle (Pen pen, int x, int y, int width, int height) {\r
1165                         DrawRectangle (pen,(float) x,(float) y,(float) width,(float) height);\r
1166                 }\r
1167 \r
1168                 public void DrawRectangles (Pen pen, RectangleF [] rects) {\r
1169                         foreach(RectangleF r in rects)\r
1170                                 DrawRectangle (pen, r.Left, r.Top, r.Width, r.Height);\r
1171                 }\r
1172 \r
1173                 public void DrawRectangles (Pen pen, Rectangle [] rects) {\r
1174                         foreach(Rectangle r in rects)\r
1175                                 DrawRectangle (pen, r.Left, r.Top, r.Width, r.Height);\r
1176                 }\r
1177                 #endregion\r
1178 \r
1179                 #region DrawString\r
1180                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle) {                 \r
1181                         DrawString(s, font, brush, layoutRectangle.X, layoutRectangle.Y, layoutRectangle.Width, layoutRectangle.Height, null);\r
1182                 }\r
1183                 \r
1184                 public void DrawString (string s, Font font, Brush brush, PointF point) {\r
1185                         DrawString(s, font, brush, point.X, point.Y, float.PositiveInfinity, float.PositiveInfinity, null);\r
1186                 }\r
1187                 \r
1188                 public void DrawString (string s, Font font, Brush brush, PointF point, StringFormat format) {\r
1189                         DrawString(s, font, brush, point.X, point.Y, float.PositiveInfinity, float.PositiveInfinity, format);\r
1190                 }\r
1191 \r
1192                 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format) {\r
1193                         DrawString(s, font, brush, layoutRectangle.X, layoutRectangle.Y, layoutRectangle.Width, layoutRectangle.Height, format);\r
1194                 }\r
1195 \r
1196                 public void DrawString (string s, Font font, Brush brush, float x, float y) {\r
1197                         DrawString(s, font, brush, x, y, float.PositiveInfinity, float.PositiveInfinity, null);\r
1198                 }\r
1199 \r
1200                 public void DrawString (string s, Font font, Brush brush, float x, float y, StringFormat format) {\r
1201                         DrawString(s, font, brush, x, y, float.PositiveInfinity, float.PositiveInfinity, format);\r
1202                 }\r
1203 \r
1204                 void DrawString (string s, Font font, Brush brush, \r
1205                         float x, float y, float width, float height, \r
1206                         StringFormat format) {\r
1207                         if (brush == null)\r
1208                                 throw new ArgumentNullException("brush");\r
1209 \r
1210                         if (font == null)\r
1211                                 throw new ArgumentNullException("font");\r
1212 \r
1213                         if (format != null && format.LineAlignment != StringAlignment.Near) {\r
1214 \r
1215                                 SizeF sizeF = MeasureString(s, font, format, width, height, null);\r
1216 \r
1217                                 float lineAWidth = width;\r
1218                                 float lineAHeight = height;\r
1219 \r
1220                                 if (float.IsPositiveInfinity(width))\r
1221                                         lineAWidth = lineAHeight = 0;\r
1222 \r
1223                                 float wdelta = format.IsVertical ? lineAWidth - sizeF.Width : lineAHeight - sizeF.Height;\r
1224                                 float pdelta = format.LineAlignment == StringAlignment.Center ? wdelta/2 : wdelta;\r
1225                                 if (format.IsVertical) {\r
1226                                         if (!(format.IsRightToLeft && format.LineAlignment == StringAlignment.Far))\r
1227                                                 x += pdelta;\r
1228                                         if (!float.IsPositiveInfinity(width))\r
1229                                                 width -= wdelta;\r
1230                                 }\r
1231                                 else {\r
1232                                         y += pdelta;\r
1233                                         if (!float.IsPositiveInfinity(width))\r
1234                                                 height -= wdelta;\r
1235                                 }\r
1236                         }\r
1237 \r
1238                         awt.Paint oldP = NativeObject.getPaint();\r
1239                         NativeObject.setPaint(brush);\r
1240                         try {\r
1241                                 geom.AffineTransform oldT = NativeObject.getTransform();\r
1242                                 NativeObject.transform(GetFinalTransform());\r
1243                                 try {\r
1244 \r
1245                                         bool noclip = float.IsPositiveInfinity(width) || (format != null && format.NoClip);\r
1246 \r
1247                                         awt.Shape oldClip = null;\r
1248                                         if (!noclip) {\r
1249                                                 oldClip = NativeObject.getClip();\r
1250                                                 NativeObject.clip(new geom.Rectangle2D.Float(x, y, width, height));\r
1251                                         }\r
1252                                         try {\r
1253                                                 TextLineIterator iter = new TextLineIterator(s, font, NativeObject.getFontRenderContext(), format, width, height);\r
1254                                                 NativeObject.transform(iter.Transform);\r
1255                                                 for (LineLayout layout = iter.NextLine(); layout != null; layout = iter.NextLine()) {\r
1256                                                         layout.Draw(NativeObject, x, y);\r
1257                                                 }\r
1258                                         }\r
1259                                         finally {\r
1260                                                 if (!noclip)\r
1261                                                         NativeObject.setClip(oldClip);\r
1262                                         }\r
1263                                 }\r
1264                                 finally {\r
1265                                         NativeObject.setTransform(oldT);\r
1266                                 }\r
1267                         }\r
1268                         finally {\r
1269                                 NativeObject.setPaint(oldP);\r
1270                         }\r
1271                 }\r
1272                 #endregion\r
1273 \r
1274                 #region Container\r
1275 \r
1276                 void PushGraphicsState(GraphicsState state) {\r
1277                         state.Next = _nextGraphicsState;\r
1278                         _nextGraphicsState = state;\r
1279                 }\r
1280 \r
1281                 GraphicsState PopGraphicsState() {\r
1282                         GraphicsState state = _nextGraphicsState;\r
1283                         _nextGraphicsState = _nextGraphicsState.Next;\r
1284                         return state;\r
1285                 }\r
1286 \r
1287                 bool ContainsGraphicsState(GraphicsState state) {\r
1288                         GraphicsState gs = _nextGraphicsState;\r
1289 \r
1290                         while(gs != null) {\r
1291                                 if (gs == state)\r
1292                                         return true;\r
1293 \r
1294                                 gs = gs.Next;\r
1295                         }\r
1296 \r
1297                         return false;\r
1298                 }\r
1299 \r
1300                 public void EndContainer (GraphicsContainer container) {\r
1301                         Restore(container.StateObject);\r
1302                 }\r
1303 \r
1304                 public GraphicsContainer BeginContainer () {\r
1305                         return new GraphicsContainer(Save(Matrix.IdentityTransform, true));\r
1306                 }\r
1307                 \r
1308                 public GraphicsContainer BeginContainer (Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit) {\r
1309                         Matrix containerTransfrom =\r
1310                                 new Matrix(     srcrect,\r
1311                                 new Point [] {   new Point (dstrect.X, dstrect.Y), \r
1312                                                                  new Point (dstrect.X + dstrect.Width, dstrect.Y), \r
1313                                                                  new Point (dstrect.X, dstrect.Y + dstrect.Height) });\r
1314 \r
1315                         float scale = _unitConversion[ (int)PageUnit ] / _unitConversion[ (int)unit ];\r
1316                         containerTransfrom.Scale(scale, scale);\r
1317 \r
1318                         return new GraphicsContainer(Save(containerTransfrom, true));\r
1319                 }\r
1320 \r
1321                 \r
1322                 public GraphicsContainer BeginContainer (RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit) {\r
1323                         Matrix containerTransfrom =\r
1324                                 new Matrix(     srcrect,\r
1325                                 new PointF [] {  new PointF (dstrect.X, dstrect.Y), \r
1326                                                                  new PointF (dstrect.X + dstrect.Width, dstrect.Y), \r
1327                                                                  new PointF (dstrect.X, dstrect.Y + dstrect.Height) });\r
1328 \r
1329                         float scale = _unitConversion[ (int)PageUnit ] / _unitConversion[ (int)unit ];\r
1330                         containerTransfrom.Scale(scale, scale);\r
1331 \r
1332                         return new GraphicsContainer(Save(containerTransfrom, true));\r
1333                 }\r
1334 \r
1335                 GraphicsState Save(Matrix matrix, bool resetState) {\r
1336                         GraphicsState graphicsState = new GraphicsState(this, matrix, resetState);\r
1337 \r
1338                         PushGraphicsState( graphicsState );\r
1339                         return graphicsState;\r
1340                 }\r
1341 \r
1342                 public GraphicsState Save () {\r
1343                         return Save(Matrix.IdentityTransform, false);\r
1344                 }\r
1345 \r
1346                 public void Restore (GraphicsState graphicsState) {\r
1347                         if (ContainsGraphicsState(graphicsState)) {\r
1348                                 GraphicsState gs = PopGraphicsState();\r
1349                                 while ( gs != graphicsState )\r
1350                                         gs = PopGraphicsState();\r
1351 \r
1352                                 graphicsState.RestoreState(this);\r
1353                         }\r
1354                 }\r
1355 \r
1356                 #endregion\r
1357 \r
1358                 #region Metafiles Staff [TODO NotSupp]\r
1359                 public void AddMetafileComment (byte [] data) {\r
1360                         throw new NotImplementedException ();\r
1361                 }\r
1362 \r
1363 #if INTPTR_SUPPORT\r
1364                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback)\r
1365                 {\r
1366                         throw new NotImplementedException ();\r
1367                 }\r
1368 \r
1369                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback)\r
1370                 {\r
1371                         throw new NotImplementedException ();\r
1372                 }\r
1373 \r
1374                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback)\r
1375                 {\r
1376                         throw new NotImplementedException ();\r
1377                 }\r
1378 \r
1379                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback)\r
1380                 {\r
1381                         throw new NotImplementedException ();\r
1382                 }\r
1383 \r
1384                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback)\r
1385                 {\r
1386                         throw new NotImplementedException ();\r
1387                 }\r
1388 \r
1389                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback)\r
1390                 {\r
1391                         throw new NotImplementedException ();\r
1392                 }\r
1393 \r
1394                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData)\r
1395                 {\r
1396                         throw new NotImplementedException ();\r
1397                 }\r
1398 \r
1399                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData)\r
1400                 {\r
1401                         throw new NotImplementedException ();\r
1402                 }\r
1403 \r
1404                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)\r
1405                 {\r
1406                         throw new NotImplementedException ();\r
1407                 }\r
1408 \r
1409                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData)\r
1410                 {\r
1411                         throw new NotImplementedException ();\r
1412                 }\r
1413 \r
1414                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)\r
1415                 {\r
1416                         throw new NotImplementedException ();\r
1417                 }\r
1418 \r
1419                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData)\r
1420                 {\r
1421                         throw new NotImplementedException ();\r
1422                 }\r
1423 \r
1424                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1425                 {\r
1426                         throw new NotImplementedException ();\r
1427                 }\r
1428 \r
1429                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1430                 {\r
1431                         throw new NotImplementedException ();\r
1432                 }\r
1433 \r
1434                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1435                 {\r
1436                         throw new NotImplementedException ();\r
1437                 }\r
1438 \r
1439                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1440                 {\r
1441                         throw new NotImplementedException ();\r
1442                 }\r
1443 \r
1444                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1445                 {\r
1446                         throw new NotImplementedException ();\r
1447                 }\r
1448 \r
1449                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)\r
1450                 {\r
1451                         throw new NotImplementedException ();\r
1452                 }\r
1453 \r
1454                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1455                 {\r
1456                         throw new NotImplementedException ();\r
1457                 }\r
1458 \r
1459                 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1460                 {\r
1461                         throw new NotImplementedException ();\r
1462                 }\r
1463 \r
1464                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1465                 {\r
1466                         throw new NotImplementedException ();\r
1467                 }\r
1468 \r
1469                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1470                 {\r
1471                         throw new NotImplementedException ();\r
1472                 }\r
1473 \r
1474                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1475                 {\r
1476                         throw new NotImplementedException ();\r
1477                 }\r
1478 \r
1479                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1480                 {\r
1481                         throw new NotImplementedException ();\r
1482                 }\r
1483 \r
1484                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1485                 {\r
1486                         throw new NotImplementedException ();\r
1487                 }\r
1488 \r
1489                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1490                 {\r
1491                         throw new NotImplementedException ();\r
1492                 }\r
1493 \r
1494                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1495                 {\r
1496                         throw new NotImplementedException ();\r
1497                 }\r
1498 \r
1499                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1500                 {\r
1501                         throw new NotImplementedException ();\r
1502                 }\r
1503 \r
1504                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1505                 {\r
1506                         throw new NotImplementedException ();\r
1507                 }\r
1508 \r
1509                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)\r
1510                 {\r
1511                         throw new NotImplementedException ();\r
1512                 }\r
1513 \r
1514                 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1515                 {\r
1516                         throw new NotImplementedException ();\r
1517                 }\r
1518 \r
1519                 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1520                 {\r
1521                         throw new NotImplementedException ();\r
1522                 }\r
1523 \r
1524                 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1525                 {\r
1526                         throw new NotImplementedException ();\r
1527                 }\r
1528 \r
1529                 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1530                 {\r
1531                         throw new NotImplementedException ();\r
1532                 }\r
1533 \r
1534                 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1535                 {\r
1536                         throw new NotImplementedException ();\r
1537                 }\r
1538 \r
1539                 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)\r
1540                 {\r
1541                         throw new NotImplementedException ();\r
1542                 }\r
1543 #endif  \r
1544                 #endregion      \r
1545 \r
1546                 #region ExcludeClip\r
1547                 void ExcludeClip(geom.Area area) {\r
1548 \r
1549                         geom.AffineTransform t = GetFinalTransform();\r
1550                         if (!t.isIdentity()) {\r
1551                                 area = (geom.Area)area.clone();\r
1552                                 area.transform(t);\r
1553                         }\r
1554 \r
1555                         _clip.NativeObject.subtract(area);\r
1556                         RestoreBaseClip();\r
1557                         NativeObject.clip(_clip);\r
1558                 }\r
1559 \r
1560                 public void ExcludeClip (Rectangle rect) {\r
1561                         ExcludeClip(new geom.Area(rect.NativeObject));\r
1562                 }\r
1563 \r
1564                 public void ExcludeClip (Region region) {\r
1565                         if (region == null)\r
1566                                 throw new ArgumentNullException("region");\r
1567                         ExcludeClip(region.NativeObject);\r
1568                 }\r
1569                 #endregion \r
1570 \r
1571                 #region FillClosedCurve\r
1572                 public void FillClosedCurve (Brush brush, PointF [] points) {\r
1573                         FillClosedCurve (brush, points, FillMode.Alternate);\r
1574                 }\r
1575 \r
1576                 \r
1577                 public void FillClosedCurve (Brush brush, Point [] points) {\r
1578                         FillClosedCurve (brush, points, FillMode.Alternate);\r
1579                 }\r
1580 \r
1581                 \r
1582                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode) {\r
1583                         FillClosedCurve (brush, points, fillmode, 0.5f);\r
1584                 }\r
1585                 \r
1586                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode) {\r
1587                         FillClosedCurve (brush, points, fillmode, 0.5f);\r
1588                 }\r
1589 \r
1590                 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode, float tension) {\r
1591                         GraphicsPath path = new GraphicsPath(fillmode);\r
1592                         path.AddClosedCurve(points, tension);\r
1593                         FillPath(brush, path);\r
1594                 }\r
1595 \r
1596                 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode, float tension) {\r
1597                         GraphicsPath path = new GraphicsPath(fillmode);\r
1598                         path.AddClosedCurve(points, tension);\r
1599                         FillPath(brush, path);\r
1600                 }\r
1601                 #endregion\r
1602 \r
1603                 #region FillEllipse\r
1604                 public void FillEllipse (Brush brush, Rectangle rect) {\r
1605                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);\r
1606                 }\r
1607 \r
1608                 public void FillEllipse (Brush brush, RectangleF rect) {\r
1609                         FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);\r
1610                 }\r
1611 \r
1612                 public void FillEllipse (Brush brush, float x, float y, float width, float height) {\r
1613                         FillShape(brush,new java.awt.geom.Ellipse2D.Float(x,y,width,height));\r
1614                 }\r
1615 \r
1616                 public void FillEllipse (Brush brush, int x, int y, int width, int height) {\r
1617                         FillEllipse (brush,(float)x,(float)y,(float)width,(float)height);\r
1618                 }\r
1619                 #endregion\r
1620 \r
1621                 #region FillPath\r
1622                 public void FillPath (Brush brush, GraphicsPath path) {\r
1623                         if (path == null)\r
1624                                 throw new ArgumentNullException("path");\r
1625 \r
1626                         FillShape(brush,path);\r
1627                 }\r
1628                 #endregion\r
1629 \r
1630                 #region FillPie\r
1631                 public void FillPie (Brush brush, Rectangle rect, float startAngle, float sweepAngle) {\r
1632                         FillPie(brush,(float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height,(float)startAngle,(float)sweepAngle);\r
1633                 }\r
1634 \r
1635                 public void FillPie (Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle) {\r
1636                         FillPie(brush,(float)x,(float)y,(float)width,(float)height,(float)startAngle,(float)sweepAngle);\r
1637                 }\r
1638 \r
1639                 public void FillPie (Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle) {\r
1640                         GraphicsPath path = new GraphicsPath();\r
1641                         path.AddPie(x, y, width, height, startAngle, sweepAngle);\r
1642                         FillPath(brush, path);\r
1643                 }\r
1644                 #endregion\r
1645 \r
1646                 #region FillPolygon\r
1647                 public void FillPolygon (Brush brush, PointF [] points) {\r
1648                         FillPolygon(brush, points, FillMode.Alternate);\r
1649                 }\r
1650 \r
1651                 public void FillPolygon (Brush brush, Point [] points) {\r
1652                         FillPolygon(brush, points, FillMode.Alternate);\r
1653                 }\r
1654 \r
1655                 public void FillPolygon (Brush brush, Point [] points, FillMode fillMode) {\r
1656                         GraphicsPath path = new GraphicsPath(fillMode);\r
1657                         path.AddPolygon(points);\r
1658                         FillPath(brush,path);\r
1659                 }\r
1660 \r
1661                 public void FillPolygon (Brush brush, PointF [] points, FillMode fillMode) {\r
1662                         GraphicsPath path = new GraphicsPath(fillMode);\r
1663                         path.AddPolygon(points);\r
1664                         FillPath(brush,path);\r
1665                 }\r
1666                 #endregion\r
1667 \r
1668                 #region FillRectangle\r
1669                 public void FillRectangle (Brush brush, RectangleF rect) {\r
1670                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);\r
1671                 }\r
1672 \r
1673                 public void FillRectangle (Brush brush, Rectangle rect) {\r
1674                         FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);\r
1675                 }\r
1676 \r
1677                 public void FillRectangle (Brush brush, int x, int y, int width, int height) {\r
1678                         FillRectangle(brush,(float)x,(float)y,(float)width,(float)height);\r
1679                 }\r
1680 \r
1681                 public void FillRectangle (Brush brush, float x, float y, float width, float height) {\r
1682                         FillShape(brush,new java.awt.geom.Rectangle2D.Float(x,y,width,height));\r
1683                 }\r
1684 \r
1685                 public void FillRectangles (Brush brush, Rectangle [] rects) {\r
1686                         GraphicsPath path = new GraphicsPath();\r
1687                         path.AddRectangles(rects);\r
1688                         FillPath(brush,path);\r
1689                 }\r
1690 \r
1691                 public void FillRectangles (Brush brush, RectangleF [] rects) {\r
1692                         GraphicsPath path = new GraphicsPath();\r
1693                         path.AddRectangles(rects);\r
1694                         FillPath(brush,path);\r
1695                 }\r
1696                 #endregion\r
1697 \r
1698                 #region FillRegion\r
1699                 public void FillRegion (Brush brush, Region region) {\r
1700                         FillShape(brush,region);\r
1701                 }\r
1702 \r
1703                 #endregion\r
1704 \r
1705                 public void Flush () {\r
1706                         Flush (FlushIntention.Flush);\r
1707                 }\r
1708 \r
1709                 \r
1710                 public void Flush (FlushIntention intention) {\r
1711                         if (_image != null)\r
1712                                 _image.NativeObject.CurrentImage.NativeImage.flush();\r
1713                 }\r
1714 \r
1715 #if INTPTR_SUPPORTED\r
1716                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1717                 public void ReleaseHdc (IntPtr hdc)\r
1718                 {\r
1719                         throw new NotImplementedException();\r
1720                 }\r
1721 \r
1722                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1723                 public void ReleaseHdcInternal (IntPtr hdc)\r
1724                 {\r
1725                         throw new NotImplementedException ();\r
1726                 }\r
1727 \r
1728                 [EditorBrowsable (EditorBrowsableState.Advanced)]               \r
1729                 public static Graphics FromHdc (IntPtr hdc)\r
1730                 {\r
1731                         throw new NotImplementedException();\r
1732                 }\r
1733 \r
1734                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1735                 public static Graphics FromHdc (IntPtr hdc, IntPtr hdevice)\r
1736                 {\r
1737                         throw new NotImplementedException ();\r
1738                 }\r
1739 \r
1740                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1741                 public static Graphics FromHdcInternal (IntPtr hdc)\r
1742                 {\r
1743                         throw new NotImplementedException ();\r
1744                 }\r
1745 \r
1746                 [EditorBrowsable (EditorBrowsableState.Advanced)]               \r
1747                 public static Graphics FromHwnd (IntPtr hwnd)\r
1748                 {\r
1749                         throw new NotImplementedException();\r
1750                 }\r
1751 \r
1752                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1753                 public static Graphics FromHwndInternal (IntPtr hwnd)\r
1754                 {\r
1755                         throw new NotImplementedException ();\r
1756                 }\r
1757 \r
1758                 internal static Graphics FromXDrawable (IntPtr drawable, IntPtr display)\r
1759                 {\r
1760                         throw new NotImplementedException();\r
1761                 }\r
1762 \r
1763                 public static IntPtr GetHalftonePalette ()\r
1764                 {\r
1765                         throw new NotImplementedException ();\r
1766                 }\r
1767 \r
1768                 [EditorBrowsable (EditorBrowsableState.Advanced)]\r
1769                 public IntPtr GetHdc ()\r
1770                 {\r
1771                         throw new NotImplementedException();\r
1772                 }\r
1773 #endif\r
1774                 \r
1775                 #region GetNearestColor [TODO]\r
1776                 public Color GetNearestColor (Color color) {\r
1777                         throw new NotImplementedException();\r
1778                 }\r
1779                 #endregion\r
1780 \r
1781                 #region IntersectClip\r
1782                 void IntersectClip (geom.Area area) {\r
1783                         \r
1784                         geom.AffineTransform t = GetFinalTransform();\r
1785                         if (!t.isIdentity()) {\r
1786                                 area = (geom.Area)area.clone();\r
1787                                 area.transform(t);\r
1788                         }\r
1789 \r
1790                         _clip.NativeObject.intersect(area);\r
1791                         RestoreBaseClip();\r
1792                         NativeObject.clip(_clip);\r
1793                 }\r
1794 \r
1795                 public void IntersectClip (Region region) {\r
1796                         if (region == null)\r
1797                                 throw new ArgumentNullException("region");\r
1798 \r
1799                         IntersectClip(region.NativeObject);\r
1800                 }\r
1801                 \r
1802                 public void IntersectClip (RectangleF rect) {\r
1803                         IntersectClip(new geom.Area(rect.NativeObject));\r
1804                 }\r
1805 \r
1806                 public void IntersectClip (Rectangle rect) {                    \r
1807                         IntersectClip(new geom.Area(rect.NativeObject));\r
1808                 }\r
1809                 #endregion\r
1810 \r
1811                 #region IsVisible\r
1812                 public bool IsVisible (Point point) {\r
1813                         return IsVisible(point.X,point.Y);\r
1814                 }\r
1815 \r
1816                 \r
1817                 public bool IsVisible (RectangleF rect) {\r
1818                         return IsVisible ((float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height);\r
1819                 }\r
1820 \r
1821                 public bool IsVisible (PointF point) {\r
1822                         return IsVisible(point.X,point.Y);\r
1823                 }\r
1824                 \r
1825                 public bool IsVisible (Rectangle rect) {\r
1826                         return IsVisible ((float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height);\r
1827                 }\r
1828                 \r
1829                 public bool IsVisible (float x, float y) {\r
1830                         double dx = x;\r
1831                         double dy = y;\r
1832                         geom.AffineTransform t = GetFinalTransform();\r
1833                         if (!t.isIdentity()) {\r
1834                                 double[] p = new double[] {dx, dy};\r
1835                                 t.transform(p, 0, p, 0, 1);\r
1836 \r
1837                                 dx = p[0];\r
1838                                 dy = p[1];\r
1839                         }\r
1840                         if (!_clip.NativeObject.contains(dx, dy))\r
1841                                 return false;\r
1842 \r
1843                         awt.Shape clip = NativeObject.getClip();\r
1844                         if (clip == null)\r
1845                                 return true;\r
1846 \r
1847                         return clip.contains(dx, dy);\r
1848                 }\r
1849                 \r
1850                 public bool IsVisible (int x, int y) {\r
1851                         return IsVisible ((float)x,(float)y);\r
1852                 }\r
1853                 \r
1854                 public bool IsVisible (float x, float y, float width, float height) {\r
1855 \r
1856                         geom.AffineTransform t = GetFinalTransform();\r
1857                         geom.Rectangle2D r = new geom.Rectangle2D.Float(x, y, width, height);\r
1858                         \r
1859                         if (!t.isIdentity())\r
1860                                 r = t.createTransformedShape(r).getBounds2D();\r
1861                 \r
1862                         return NativeObject.hitClip(\r
1863                                         (int)(r.getX()+0.5), (int)(r.getY()+0.5),\r
1864                                         (int)(r.getWidth()+0.5), (int)(r.getHeight()+0.5))\r
1865                                 && _clip.NativeObject.intersects(r);\r
1866                 }\r
1867 \r
1868                 \r
1869                 public bool IsVisible (int x, int y, int width, int height) {\r
1870                         return IsVisible ((float)x,(float)y,(float)width,(float)height);\r
1871                 }\r
1872                 #endregion\r
1873 \r
1874                 #region MeasureCharacterRanges\r
1875                 public Region [] MeasureCharacterRanges (string text, Font font, RectangleF layoutRect, StringFormat stringFormat) {\r
1876                         if (stringFormat == null)\r
1877                                 throw new ArgumentException("stringFormat");\r
1878 \r
1879                         CharacterRange[] ranges = stringFormat.CharRanges;\r
1880                         if (ranges == null || ranges.Length == 0)\r
1881                                 return new Region[0];\r
1882 \r
1883                         GraphicsPath[] pathes = new GraphicsPath[ranges.Length];\r
1884                         for (int i = 0; i < pathes.Length; i++)\r
1885                                 pathes[i] = new GraphicsPath();\r
1886 \r
1887                         TextLineIterator iter = new TextLineIterator(text, font, NativeObject.getFontRenderContext(),\r
1888                                 stringFormat, layoutRect.Width, layoutRect.Height);\r
1889                         \r
1890                         for (LineLayout layout = iter.NextLine(); layout != null; layout = iter.NextLine()) {\r
1891 \r
1892                                 for (int i = 0; i < ranges.Length; i++) {\r
1893                                         int start = ranges[i].First;\r
1894                                         int length = ranges[i].Length;\r
1895                                         start -= iter.CharsConsumed;\r
1896                                         int limit = start + length;\r
1897                                         int layoutStart = iter.CurrentPosition - layout.CharacterCount;\r
1898                                         if (start < iter.CurrentPosition && limit > layoutStart) {\r
1899 \r
1900                                                 float layoutOffset;\r
1901                                                 if (start > layoutStart)\r
1902                                                         layoutOffset = iter.GetAdvanceBetween(layoutStart, start);\r
1903                                                 else {\r
1904                                                         layoutOffset = 0;\r
1905                                                         start = layoutStart;\r
1906                                                 }\r
1907 \r
1908                                                 float width = (limit < iter.CurrentPosition) ?\r
1909                                                         iter.GetAdvanceBetween(start, limit) :\r
1910                                                         layout.Width - layoutOffset;\r
1911 \r
1912                                                 float height = layout.Ascent + layout.Descent;\r
1913 \r
1914                                                 float x = layout.NativeX;\r
1915                                                 float y = layout.NativeY;\r
1916 \r
1917                                                 if (stringFormat.IsVertical) {\r
1918                                                         y += layoutOffset;\r
1919                                                         x -= layout.Descent;\r
1920                                                 }\r
1921                                                 else {\r
1922                                                         x += layoutOffset;\r
1923                                                         y -= layout.Ascent;\r
1924                                                 }\r
1925 \r
1926                                                 if (layout.AccumulatedHeight + height > iter.WrapHeight) {\r
1927                                                         float diff = iter.WrapHeight - layout.AccumulatedHeight;\r
1928                                                         if (stringFormat.IsVertical && stringFormat.IsRightToLeft) {\r
1929                                                                 x += diff;\r
1930                                                                 height -= diff;\r
1931                                                         }\r
1932                                                         else\r
1933                                                                 height = diff;\r
1934                                                 }\r
1935 \r
1936                                                 if (stringFormat.IsVertical)\r
1937                                                         pathes[i].AddRectangle(x + layoutRect.X, y + layoutRect.Y, height, width);\r
1938                                                 else\r
1939                                                         pathes[i].AddRectangle(x + layoutRect.X, y + layoutRect.Y, width, height);\r
1940                                         }\r
1941                                 }\r
1942                         }\r
1943 \r
1944                         geom.AffineTransform lineAlignT = iter.CalcLineAlignmentTransform();\r
1945                         if (lineAlignT != null) {\r
1946                                 for (int i = 0; i < pathes.Length; i++)\r
1947                                         pathes[i].NativeObject.transform(lineAlignT);\r
1948                         }\r
1949 \r
1950                         Region[] regions = new Region[ranges.Length];\r
1951                         for (int i = 0; i < regions.Length; i++)\r
1952                                 regions[i] = new Region(pathes[i]);\r
1953 \r
1954                         return regions;\r
1955                 }\r
1956                 #endregion\r
1957                 \r
1958                 #region MeasureString\r
1959                 public SizeF MeasureString (string text, Font font) {\r
1960                         return MeasureString(text, font, null, float.PositiveInfinity, float.PositiveInfinity, null); \r
1961                 }\r
1962 \r
1963                 \r
1964                 public SizeF MeasureString (string text, Font font, SizeF layoutArea) {\r
1965                         return MeasureString(text, font, layoutArea, null);\r
1966                 }\r
1967 \r
1968                 \r
1969                 public SizeF MeasureString (string text, Font font, int width) {\r
1970                         return MeasureString(text, font, width, null);\r
1971                 }\r
1972 \r
1973 \r
1974                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat format) {\r
1975                         return MeasureString(text, font, format, layoutArea.Width, layoutArea.Height, null);\r
1976                 }\r
1977 \r
1978                 \r
1979                 public SizeF MeasureString (string text, Font font, int width, StringFormat format) {\r
1980                         return MeasureString(text, font, format, width, float.PositiveInfinity, null);\r
1981                 }\r
1982 \r
1983                 \r
1984                 public SizeF MeasureString (string text, Font font, PointF origin, StringFormat format) {\r
1985                         return MeasureString(text, font, format, float.PositiveInfinity, float.PositiveInfinity, null);\r
1986                 }\r
1987 \r
1988                 SizeF MeasureString (string text, Font font, StringFormat format, float width, float height, int[] statistics) {\r
1989 \r
1990                         if (statistics != null) {\r
1991                                 statistics[0] = 0;\r
1992                                 statistics[1] = 0;\r
1993                         }\r
1994 \r
1995                         TextLineIterator iter = new TextLineIterator(text, font, NativeObject.getFontRenderContext(), format, width, height);\r
1996 \r
1997                         float mwidth = 0;\r
1998                         int linesFilled = 0;\r
1999                         for (LineLayout layout = iter.NextLine(); layout != null; layout = iter.NextLine()) {\r
2000 \r
2001                                 linesFilled ++;\r
2002                                 float w = layout.MeasureWidth;\r
2003 \r
2004                                 if (w > mwidth)\r
2005                                         mwidth = w;\r
2006                         }\r
2007 \r
2008                         if (linesFilled == 0)\r
2009                                 return SizeF.Empty;\r
2010 \r
2011                         float mheight = iter.AccumulatedHeight;\r
2012 \r
2013                         if (format != null) {\r
2014                                 if (format.IsVertical) {\r
2015                                         float temp = mheight;\r
2016                                         mheight = mwidth;\r
2017                                         mwidth = temp;\r
2018                                 }\r
2019                         }\r
2020 \r
2021                         if (!(format != null && format.NoClip)) {\r
2022                                 if (mwidth > width)\r
2023                                         mwidth = width;\r
2024                                 if (mheight > height)\r
2025                                         mheight = height;\r
2026                         }\r
2027 \r
2028                         if (statistics != null) {\r
2029                                 statistics[0] = linesFilled;\r
2030                                 statistics[1] = iter.CharsConsumed;\r
2031                         }\r
2032 \r
2033                         return new SizeF(mwidth, mheight);\r
2034                 }\r
2035 \r
2036                 \r
2037                 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat, out int charactersFitted, out int linesFilled) {       \r
2038                         linesFilled = 0;\r
2039                         charactersFitted = 0;\r
2040 \r
2041                         int[] statistics = new int[2];\r
2042                         SizeF sz = MeasureString(text, font, stringFormat, layoutArea.Width, layoutArea.Height, statistics);\r
2043                         linesFilled = statistics[0];\r
2044                         charactersFitted = statistics[1];\r
2045                         return sz;\r
2046                 }\r
2047                 #endregion\r
2048 \r
2049                 #region MultiplyTransform\r
2050                 public void MultiplyTransform (Matrix matrix) {\r
2051                         MultiplyTransform (matrix, MatrixOrder.Prepend);\r
2052                 }\r
2053 \r
2054                 public void MultiplyTransform (Matrix matrix, MatrixOrder order) {\r
2055                         ConcatenateTransform(matrix.NativeObject, order);\r
2056                 }\r
2057                 #endregion\r
2058 \r
2059                 #region Reset (Clip and Transform)\r
2060                 public void ResetClip () {\r
2061                         _clip.MakeInfinite();\r
2062                         RestoreBaseClip();\r
2063                         NativeObject.clip(_clip);\r
2064                 }\r
2065 \r
2066                 public void ResetTransform () {\r
2067                         _transform.Reset();\r
2068                 }\r
2069                 #endregion\r
2070 \r
2071                 #region RotateTransform\r
2072                 public void RotateTransform (float angle) {\r
2073                         RotateTransform (angle, MatrixOrder.Prepend);\r
2074                 }\r
2075 \r
2076                 public void RotateTransform (float angle, MatrixOrder order) {\r
2077                         ConcatenateTransform(\r
2078                                 geom.AffineTransform.getRotateInstance(java.lang.Math.toRadians(angle)),\r
2079                                 order);\r
2080                 }\r
2081                 #endregion\r
2082 \r
2083                 #region ScaleTransform\r
2084                 public void ScaleTransform (float sx, float sy) {\r
2085                         ScaleTransform (sx, sy, MatrixOrder.Prepend);\r
2086                 }\r
2087 \r
2088                 public void ScaleTransform (float sx, float sy, MatrixOrder order) {\r
2089                         ConcatenateTransform(\r
2090                                 geom.AffineTransform.getScaleInstance(sx, sy),\r
2091                                 order);\r
2092                 }\r
2093                 #endregion\r
2094 \r
2095                 #region SetClip [Must be reviewed - more abstraction needed]\r
2096                 public void SetClip (RectangleF rect) {\r
2097                         SetClip (rect, CombineMode.Replace);\r
2098                 }\r
2099 \r
2100                 public void SetClip (GraphicsPath path) {\r
2101                         SetClip (path, CombineMode.Replace);\r
2102                 }\r
2103 \r
2104                 public void SetClip (Rectangle rect) {\r
2105                         SetClip (rect, CombineMode.Replace);\r
2106                 }\r
2107 \r
2108                 public void SetClip (Graphics g) {\r
2109                         SetClip (g, CombineMode.Replace);\r
2110                 }\r
2111 \r
2112                 public void SetClip (Graphics g, CombineMode combineMode) {\r
2113                         if(g == null)\r
2114                                 throw new NullReferenceException();\r
2115                         \r
2116                         CombineClipArea(g._clip.NativeObject, combineMode);\r
2117                 }\r
2118 \r
2119                 public void SetClip (Rectangle rect, CombineMode combineMode) {\r
2120                         SetClip(rect.X,rect.Y,rect.Width,rect.Height,combineMode);                      \r
2121                 }               \r
2122                 public void SetClip (RectangleF rect, CombineMode combineMode) {                        \r
2123                         SetClip(rect.X,rect.Y,rect.Width,rect.Height,combineMode);                      \r
2124                 }\r
2125                 \r
2126                 public void SetClip (Region region, CombineMode combineMode) {\r
2127                         if(region == null)\r
2128                                 throw new ArgumentNullException("region");\r
2129 \r
2130                         CombineClipArea((geom.Area)region.NativeObject.clone(),combineMode);\r
2131                 }\r
2132                 \r
2133                 public void SetClip (GraphicsPath path, CombineMode combineMode) {\r
2134                         if(path == null)\r
2135                                 throw new ArgumentNullException("path");\r
2136 \r
2137                         CombineClipArea(new geom.Area(path.NativeObject), combineMode);\r
2138                 }\r
2139                 #endregion\r
2140 \r
2141                 #region Clipping Staff [INTERNAL]\r
2142                 internal Region ScaledClip {\r
2143                         get {\r
2144                                 return _clip.Clone();\r
2145                         }\r
2146                         set {\r
2147                                 _clip.NativeObject.reset();\r
2148                                 _clip.NativeObject.add(value.NativeObject);\r
2149                         }\r
2150                 }\r
2151                 internal void SetClip(float x,float y,float width,float height,CombineMode combineMode) {                                       \r
2152                         CombineClipArea(new geom.Area(\r
2153                                 new geom.Rectangle2D.Float(x,y,width,height)),combineMode);\r
2154                 }\r
2155 \r
2156                 void CombineClipArea(geom.Area area, CombineMode combineMode) {\r
2157                         geom.AffineTransform t = GetFinalTransform();\r
2158                         if (!t.isIdentity())\r
2159                                 area.transform(t);\r
2160                         if (combineMode == CombineMode.Replace) {\r
2161                                 _clip.NativeObject.reset();\r
2162                                 _clip.NativeObject.add(area);\r
2163                         }\r
2164                         else {\r
2165                                 geom.Area curClip = _clip.NativeObject;\r
2166                                 switch(combineMode) {\r
2167                                         case CombineMode.Complement:\r
2168                                                 curClip.add(area);\r
2169                                                 break;\r
2170                                         case CombineMode.Exclude:\r
2171                                                 curClip.subtract(area);\r
2172                                                 break;\r
2173                                         case CombineMode.Intersect:\r
2174                                                 curClip.intersect(area);\r
2175                                                 break;\r
2176                                         case CombineMode.Union:\r
2177                                                 curClip.add(area);\r
2178                                                 break;\r
2179                                         case CombineMode.Xor:\r
2180                                                 curClip.exclusiveOr(area);\r
2181                                                 break;\r
2182                                         default:\r
2183                                                 throw new ArgumentOutOfRangeException();                                        \r
2184                                 }\r
2185                         }\r
2186 \r
2187                         RestoreBaseClip();\r
2188                         NativeObject.clip(_clip);\r
2189                 }\r
2190 \r
2191                 internal void IntersectScaledClipWithBase(awt.Shape clip) {\r
2192                         NativeObject.clip(clip);\r
2193                 }\r
2194 \r
2195                 void RestoreBaseClip() {\r
2196                         if (_nextGraphicsState == null) {\r
2197                                 NativeObject.setClip(_windowRect);\r
2198                                 return;\r
2199                         }\r
2200 \r
2201                         _nextGraphicsState.RestoreBaseClip(this);\r
2202                 }\r
2203                 \r
2204                 #endregion\r
2205                 \r
2206                 #region TransformPoints\r
2207                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF [] pts) {\r
2208                         //TBD:CoordinateSpace\r
2209                         java.awt.geom.AffineTransform tr = this.Transform.NativeObject;\r
2210                         float[] fpts = new float[2];\r
2211                         for(int i = 0; i< pts.Length; i++) {\r
2212                                 fpts[0] = pts[i].X;\r
2213                                 fpts[1] = pts[i].Y;\r
2214                                 tr.transform(fpts, 0, fpts, 0, 1);\r
2215                                 pts[i].X = fpts[0];\r
2216                                 pts[i].Y = fpts[1];\r
2217                         }\r
2218                 }\r
2219 \r
2220                 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts) {                                               \r
2221                         //TBD:CoordinateSpace\r
2222                         java.awt.geom.AffineTransform tr = this.Transform.NativeObject;\r
2223                         float[] fpts = new float[2];\r
2224                         for(int i = 0; i< pts.Length; i++) {\r
2225                                 fpts[0] = pts[i].X;\r
2226                                 fpts[1] = pts[i].Y;\r
2227                                 tr.transform(fpts, 0, fpts, 0, 1);\r
2228                                 pts[i].X = (int)fpts[0];\r
2229                                 pts[i].Y = (int)fpts[1];\r
2230                         }\r
2231                 }\r
2232                 #endregion\r
2233 \r
2234                 #region TranslateClip\r
2235                 public void TranslateClip (int dx, int dy) {\r
2236                         TranslateClip((float)dx, (float)dy);\r
2237                 }\r
2238 \r
2239                 \r
2240                 public void TranslateClip (float dx, float dy) {\r
2241                         double x = dx;\r
2242                         double y = dy;\r
2243                         geom.AffineTransform f = GetFinalTransform();\r
2244 \r
2245                         if (!f.isIdentity()) {\r
2246                                 double[] p = new double[] {x, y};\r
2247                                 f.deltaTransform(p, 0, p, 0, 1);\r
2248 \r
2249                                 x = p[0];\r
2250                                 y = p[1];\r
2251                         }\r
2252 \r
2253                         // It seems .Net does exactly this...\r
2254                         x = Math.Floor(x+0.96875);\r
2255                         y = Math.Floor(y+0.96875);\r
2256 \r
2257                         geom.AffineTransform t = geom.AffineTransform.getTranslateInstance(x, y);\r
2258 \r
2259                         _clip.NativeObject.transform(t);\r
2260                         RestoreBaseClip();\r
2261                         NativeObject.clip(_clip);\r
2262                 }\r
2263                 #endregion\r
2264 \r
2265                 #region TranslateTransform\r
2266                 public void TranslateTransform (float dx, float dy) {\r
2267                         TranslateTransform (dx, dy, MatrixOrder.Prepend);\r
2268                 }\r
2269 \r
2270                 \r
2271                 public void TranslateTransform (float dx, float dy, MatrixOrder order) {\r
2272                         ConcatenateTransform(\r
2273                                 geom.AffineTransform.getTranslateInstance(dx, dy), \r
2274                                 order);\r
2275                 }\r
2276                 #endregion\r
2277 \r
2278                 #region Properties [Partial TODO]\r
2279                 public Region Clip {\r
2280                         get {\r
2281                                 Region r = _clip.Clone();\r
2282                                 geom.AffineTransform t = GetFinalTransform();\r
2283                                 if (!t.isIdentity())\r
2284                                         r.NativeObject.transform(t.createInverse());\r
2285 \r
2286                                 return r;\r
2287                         }\r
2288                         set {\r
2289                                 SetClip (value, CombineMode.Replace);\r
2290                         }\r
2291                 }\r
2292 \r
2293                 public RectangleF ClipBounds {\r
2294                         get {\r
2295                                 awt.Shape shape = _clip.NativeObject;\r
2296                                 if (shape == null)\r
2297                                         shape = Region.InfiniteRegion.NativeObject;\r
2298 \r
2299                                 geom.RectangularShape r = shape.getBounds2D();\r
2300                                 geom.AffineTransform t = GetFinalTransform();\r
2301                                 if (!t.isIdentity()) {\r
2302                                         geom.AffineTransform it = t.createInverse();\r
2303                                         r = it.createTransformedShape(r).getBounds2D();\r
2304                                 }\r
2305 \r
2306                                 return new RectangleF (r);\r
2307                         }\r
2308                 }\r
2309 \r
2310                 public CompositingMode CompositingMode {\r
2311                         //TBD:check this carefully\r
2312                         get {\r
2313                                 return (NativeObject.getComposite() == awt.AlphaComposite.SrcOver) ?\r
2314                                         CompositingMode.SourceOver : CompositingMode.SourceCopy;\r
2315                         }\r
2316                         set {\r
2317                                 NativeObject.setComposite(\r
2318                                         (value == CompositingMode.SourceOver) ?\r
2319                                         awt.AlphaComposite.SrcOver : awt.AlphaComposite.Src);\r
2320                         }\r
2321 \r
2322                 }\r
2323 \r
2324                 public CompositingQuality CompositingQuality {\r
2325                         get {\r
2326                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2327                                 if(hints.containsKey(awt.RenderingHints.KEY_ALPHA_INTERPOLATION)) {\r
2328                                         object value_ai = hints.get(awt.RenderingHints.KEY_ALPHA_INTERPOLATION);\r
2329 \r
2330                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED)\r
2331                                                 return CompositingQuality.HighSpeed;\r
2332                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY)\r
2333                                                 return CompositingQuality.HighQuality;\r
2334                                         if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT)\r
2335                                                 return CompositingQuality.Default;\r
2336                                 }\r
2337 \r
2338                                 return CompositingQuality.Default;\r
2339                                         \r
2340                         }\r
2341                         set {\r
2342                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2343                                 switch (value) {\r
2344                                         case CompositingQuality.AssumeLinear:\r
2345                                         case CompositingQuality.Default:\r
2346                                         case CompositingQuality.GammaCorrected:\r
2347                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
2348                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);\r
2349                                                 break;\r
2350                                         case CompositingQuality.HighQuality:\r
2351                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
2352                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);\r
2353                                                 break;\r
2354                                         case CompositingQuality.HighSpeed:\r
2355                                                 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,\r
2356                                                         awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);\r
2357                                                 break;\r
2358 //                                      case CompositingQuality.Invalid:\r
2359 //                                              if(hints.containsKey(awt.RenderingHints.KEY_ALPHA_INTERPOLATION))\r
2360 //                                                      hints.remove(awt.RenderingHints.KEY_ALPHA_INTERPOLATION);\r
2361                                 }\r
2362 \r
2363                                 NativeObject.setRenderingHints(hints);\r
2364                         }\r
2365                 }\r
2366 \r
2367                 public float DpiX {\r
2368                         get {                           \r
2369                                 return DefaultScreenResolution;\r
2370                         }\r
2371                 }\r
2372 \r
2373                 public float DpiY {\r
2374                         get {\r
2375                                 //TBD: assume 72 (screen) for now\r
2376                                 return DpiX;\r
2377                         }\r
2378                 }\r
2379 \r
2380                 public InterpolationMode InterpolationMode {\r
2381                         get {                           \r
2382                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2383                                 if(hints.containsKey(awt.RenderingHints.KEY_INTERPOLATION)) {\r
2384                                         object value_i = hints.get(awt.RenderingHints.KEY_INTERPOLATION);\r
2385 \r
2386                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR)\r
2387                                                 return InterpolationMode.Bilinear;\r
2388                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC)\r
2389                                                 return InterpolationMode.Bicubic;\r
2390                                         if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)\r
2391                                                 return InterpolationMode.NearestNeighbor;\r
2392                                 }\r
2393 \r
2394                                 return InterpolationMode.Default;\r
2395                         }\r
2396                         set {\r
2397                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2398 \r
2399                                 switch (value) {\r
2400                                         case InterpolationMode.Bicubic:\r
2401                                         case InterpolationMode.HighQualityBicubic:\r
2402                                         case InterpolationMode.Low:\r
2403                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC);\r
2404                                                 break;\r
2405                                         case InterpolationMode.High:\r
2406                                         case InterpolationMode.Bilinear:\r
2407                                         case InterpolationMode.HighQualityBilinear:\r
2408                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR);\r
2409                                                 break;\r
2410                                         case InterpolationMode.Default:\r
2411                                                 if (hints.containsKey(awt.RenderingHints.KEY_INTERPOLATION))\r
2412                                                         hints.remove(awt.RenderingHints.KEY_INTERPOLATION);\r
2413                                                 break;\r
2414                                         case InterpolationMode.NearestNeighbor:\r
2415                                                 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);\r
2416                                                 break;\r
2417                                         case InterpolationMode.Invalid:\r
2418                                                 throw new ArgumentException();\r
2419                                         default:\r
2420                                                 throw new ArgumentOutOfRangeException();\r
2421                                 }\r
2422 \r
2423                                 NativeObject.setRenderingHints(hints);\r
2424                         }\r
2425                 }\r
2426 \r
2427                 public bool IsClipEmpty {\r
2428                         get {\r
2429                                 return _clip.IsEmpty(this);\r
2430                         }\r
2431                 }\r
2432 \r
2433                 public bool IsVisibleClipEmpty {\r
2434                         get {\r
2435                                 if (_clip.IsEmpty(this))\r
2436                                         return true;\r
2437 \r
2438                                 return VisibleClipBounds.IsEmpty;\r
2439                         }\r
2440                 }\r
2441 \r
2442                 public float PageScale {\r
2443                         get {\r
2444                                 return _pageScale;\r
2445                         }\r
2446                         set {\r
2447                                 _pageScale = value;\r
2448                         }\r
2449                 }\r
2450 \r
2451                 public GraphicsUnit PageUnit {\r
2452                         get {\r
2453                                 return _pageUnit;\r
2454                         }\r
2455                         set {\r
2456                                 _pageUnit = value;\r
2457                         }\r
2458                 }\r
2459 \r
2460                 static internal geom.AffineTransform GetFinalTransform(\r
2461                         geom.AffineTransform transform, GraphicsUnit pageUnit, float pageScale) {\r
2462                         geom.AffineTransform t = null;\r
2463                         if (pageUnit != GraphicsUnit.Display) {\r
2464                                 float scale = pageScale * _unitConversion[ (int)pageUnit ];\r
2465                                 if (Math.Abs(scale-1f) > float.Epsilon)\r
2466                                         t = geom.AffineTransform.getScaleInstance(scale, scale);\r
2467                         }\r
2468 \r
2469                         if (t != null)\r
2470                                 t.concatenate(transform);\r
2471                         else\r
2472                                 t = transform;\r
2473                         \r
2474                         return t;\r
2475                 }\r
2476 \r
2477                 geom.AffineTransform GetFinalTransform() {\r
2478                         return GetFinalTransform(_transform.NativeObject, PageUnit, PageScale);\r
2479                 }\r
2480 \r
2481                 public PixelOffsetMode PixelOffsetMode {\r
2482                         get {\r
2483                                 return _pixelOffsetMode;\r
2484                         }\r
2485                         set {\r
2486                                 _pixelOffsetMode = value;\r
2487                         }\r
2488                 }\r
2489 \r
2490                 public Point RenderingOrigin {\r
2491                         get {\r
2492                                 throw new NotImplementedException();\r
2493                         }\r
2494                         set {\r
2495                                 throw new NotImplementedException();\r
2496                         }\r
2497                 }\r
2498 \r
2499                 public SmoothingMode SmoothingMode {\r
2500                         get {\r
2501                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2502                                 if(hints.containsKey(awt.RenderingHints.KEY_ANTIALIASING)) {\r
2503                                         object value_aa = hints.get(awt.RenderingHints.KEY_ANTIALIASING);\r
2504                                         if (value_aa == awt.RenderingHints.VALUE_ANTIALIAS_ON) {\r
2505                                                 if(hints.containsKey(awt.RenderingHints.KEY_RENDERING)) {\r
2506                                                         object value_render = hints.get(awt.RenderingHints.KEY_RENDERING);\r
2507                                                         if (value_render == awt.RenderingHints.VALUE_RENDER_QUALITY)\r
2508                                                                 return SmoothingMode.HighQuality;\r
2509                                                         if (value_render == awt.RenderingHints.VALUE_RENDER_SPEED)\r
2510                                                                 return SmoothingMode.HighSpeed;\r
2511                                                 }\r
2512 \r
2513                                                 return SmoothingMode.AntiAlias;\r
2514                                         }\r
2515 \r
2516                                         if (value_aa == awt.RenderingHints.VALUE_ANTIALIAS_DEFAULT)\r
2517                                                 return SmoothingMode.Default;\r
2518                                 }\r
2519                                 return SmoothingMode.None;\r
2520 \r
2521                         }\r
2522 \r
2523                         set {\r
2524                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2525 \r
2526                                 switch (value) {\r
2527                                         case SmoothingMode.None:\r
2528                                                 if(hints.containsKey(awt.RenderingHints.KEY_ANTIALIASING))\r
2529                                                         hints.remove(awt.RenderingHints.KEY_ANTIALIASING);\r
2530                                                 if(hints.containsKey(awt.RenderingHints.KEY_RENDERING))\r
2531                                                         hints.remove(awt.RenderingHints.KEY_RENDERING);\r
2532                                                 break;\r
2533                                         case SmoothingMode.AntiAlias:\r
2534                                                 hints.put(awt.RenderingHints.KEY_ANTIALIASING, awt.RenderingHints.VALUE_ANTIALIAS_ON);\r
2535                                                 break;\r
2536                                         case SmoothingMode.HighQuality:\r
2537                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_QUALITY);\r
2538                                                 goto case SmoothingMode.AntiAlias;\r
2539                                         case SmoothingMode.HighSpeed:\r
2540                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_SPEED);\r
2541                                                 goto case SmoothingMode.None;\r
2542                                         case SmoothingMode.Default:\r
2543                                                 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_DEFAULT);\r
2544                                                 goto case SmoothingMode.AntiAlias;\r
2545                                         case SmoothingMode.Invalid:\r
2546                                                 throw new ArgumentException("Invalid parameter used.");\r
2547                                 }\r
2548 \r
2549                                 NativeObject.setRenderingHints(hints);\r
2550                         }\r
2551                 }\r
2552 \r
2553                 /// <summary>\r
2554                 /// Java does not have similar functionality\r
2555                 /// </summary>\r
2556                 public int TextContrast {\r
2557                         get {\r
2558                                 return _textContrast;\r
2559                         }\r
2560 \r
2561                         set {\r
2562                                 _textContrast = value;\r
2563                         }\r
2564                 }\r
2565 \r
2566                 public TextRenderingHint TextRenderingHint {\r
2567                         get {\r
2568                                 return _textRenderingHint;\r
2569 //                              awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2570 //                              if(hints.containsKey(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING)) {\r
2571 //                                      if(hints.get(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING) == \r
2572 //                                              java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON)\r
2573 //                                              return TextRenderingHint.AntiAlias;\r
2574 //                                      if(hints.get(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING) == \r
2575 //                                              java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_OFF)\r
2576 //                                              return TextRenderingHint.SingleBitPerPixel;\r
2577 //                              }\r
2578 //                              //return TextRenderingHint.SystemDefault;\r
2579 //                              return TextRenderingHint.SingleBitPerPixelGridFit;\r
2580                         }\r
2581 \r
2582                         set {\r
2583                                 _textRenderingHint = value;\r
2584                                 awt.RenderingHints hints = NativeObject.getRenderingHints();\r
2585                                 switch (value) {\r
2586                                         case TextRenderingHint.AntiAlias:\r
2587                                         case TextRenderingHint.AntiAliasGridFit:\r
2588                                         case TextRenderingHint.ClearTypeGridFit:\r
2589 //                                      case TextRenderingHint.SystemDefault:\r
2590                                                 hints.put(awt.RenderingHints.KEY_TEXT_ANTIALIASING,\r
2591                                                         awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON);\r
2592                                                 break;\r
2593                                         \r
2594                                         case TextRenderingHint.SingleBitPerPixelGridFit:\r
2595                                                 hints.put(awt.RenderingHints.KEY_TEXT_ANTIALIASING,\r
2596                                                         awt.RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT);\r
2597                                                 break;\r
2598 \r
2599                                         case TextRenderingHint.SingleBitPerPixel:\r
2600                                                 hints.put(awt.RenderingHints.KEY_TEXT_ANTIALIASING,\r
2601                                                         awt.RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);\r
2602                                                 break;\r
2603 \r
2604                                         case TextRenderingHint.SystemDefault:\r
2605                                                 hints.put(awt.RenderingHints.KEY_TEXT_ANTIALIASING,\r
2606                                                         awt.RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT);\r
2607                                                 break;\r
2608                                 }\r
2609                                 \r
2610                                 NativeObject.setRenderingHints(hints);\r
2611                         }\r
2612                 }\r
2613 \r
2614                 public Matrix Transform {\r
2615                         get {\r
2616                                 return _transform.Clone();\r
2617                         }\r
2618                         set {\r
2619                                 if (value == null)\r
2620                                         throw new ArgumentNullException("matrix");\r
2621 \r
2622                                 if (!value.IsInvertible)\r
2623                                         throw new ArgumentException("Invalid parameter used.");\r
2624 \r
2625                                 value.CopyTo(_transform);\r
2626                         }\r
2627                 }\r
2628 \r
2629                 internal Matrix BaseTransform {\r
2630                         get {\r
2631                                 return new Matrix(NativeObject.getTransform());\r
2632                         }\r
2633                         set {\r
2634                                 NativeObject.setTransform(value.NativeObject);\r
2635                         }\r
2636                 }\r
2637 \r
2638                 internal void PrependBaseTransform(geom.AffineTransform t) {\r
2639                         NativeObject.transform(t);\r
2640                 }\r
2641 \r
2642                 internal awt.Shape VisibleShape {\r
2643                         get {\r
2644                                 return _windowRect;\r
2645                         }\r
2646                 }\r
2647 \r
2648                 public RectangleF VisibleClipBounds {\r
2649                         get {\r
2650                                 if (_clip.IsEmpty(this))\r
2651                                         return RectangleF.Empty;\r
2652 \r
2653                                 geom.Rectangle2D r = _clip.NativeObject.getBounds2D();\r
2654                                 awt.Shape clip = NativeObject.getClip();\r
2655                                 geom.Rectangle2D clipBounds = (clip != null) ? clip.getBounds2D() : _windowRect;\r
2656                                 geom.Rectangle2D.intersect(r, clipBounds, r);\r
2657                                 if ((r.getWidth() <= 0) || (r.getHeight() <= 0))\r
2658                                         return RectangleF.Empty;\r
2659 \r
2660                                 geom.AffineTransform t = GetFinalTransform();\r
2661                                 if (!t.isIdentity()) {\r
2662                                         geom.AffineTransform it = t.createInverse();\r
2663                                         r = it.createTransformedShape(r).getBounds2D();\r
2664                                 }\r
2665 \r
2666                                 return new RectangleF (r);\r
2667                         }\r
2668                 }\r
2669 \r
2670                 void ConcatenateTransform(geom.AffineTransform transform, MatrixOrder order) {\r
2671                         geom.AffineTransform at = _transform.NativeObject;\r
2672                         Matrix.Multiply(at, transform, order);\r
2673                 }\r
2674                 #endregion\r
2675         }\r
2676 }\r
2677 \r