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