2 using System.Drawing.Drawing2D;
\r
3 using System.Drawing.Imaging;
\r
4 using System.Drawing.Text;
\r
5 using System.ComponentModel;
\r
6 using System.Runtime.InteropServices;
\r
8 using awt = java.awt;
\r
9 using geom = java.awt.geom;
\r
11 namespace System.Drawing {
\r
13 public sealed class Graphics : MarshalByRefObject, IDisposable {
\r
16 readonly awt.Graphics2D _nativeObject;
\r
17 PixelOffsetMode _pixelOffsetMode = PixelOffsetMode.Default;
\r
18 int _textContrast = 4;
\r
19 readonly Image _image;
\r
22 GraphicsUnit _pageUnit = GraphicsUnit.Display;
\r
23 float _pageScale = 1.0f;
\r
25 static readonly float [] _unitConversion = {
\r
29 DefaultScreenResolution / 72.0f, // Point
\r
30 DefaultScreenResolution, // Inch
\r
31 DefaultScreenResolution / 300.0f,// Document
\r
32 DefaultScreenResolution / 25.4f // Millimeter
\r
35 static internal readonly bool IsHeadless;
\r
41 public delegate bool EnumerateMetafileProc (EmfPlusRecordType recordType,
\r
45 PlayRecordCallback callbackData);
\r
46 [ComVisible (false)]
\r
47 public delegate bool DrawImageAbort (IntPtr callbackData);
\r
50 #region Constr. and Destr.
\r
51 private Graphics (Image image) {
\r
52 _nativeObject = (awt.Graphics2D)image.NativeObject.getGraphics();
\r
54 _transform = new Matrix ();
\r
55 _nativeObject.setTransform( _transform.NativeObject );
\r
57 NativeObject.setRenderingHint(awt.RenderingHints.KEY_COLOR_RENDERING, awt.RenderingHints.VALUE_COLOR_RENDER_QUALITY);
\r
62 #region Internal Accessors
\r
65 bool isHeadless = awt.GraphicsEnvironment.isHeadless();
\r
68 awt.Toolkit.getDefaultToolkit();
\r
75 IsHeadless = isHeadless;
\r
78 static internal int DefaultScreenResolution {
\r
80 return IsHeadless ? 96 :
\r
81 awt.Toolkit.getDefaultToolkit().getScreenResolution();
\r
85 internal java.awt.Graphics2D NativeObject {
\r
87 return _nativeObject;
\r
92 #region FromImage (static accessor)
\r
93 public static Graphics FromImage (Image image) {
\r
94 return new Graphics(image);
\r
98 #region Workers [INTERNAL]
\r
99 void InternalSetBrush(Brush b) {
\r
100 java.awt.Graphics2D g = NativeObject;
\r
102 SolidBrush sb = b as SolidBrush;
\r
104 g.setColor(sb.Color.NativeObject);
\r
106 else if(b is LinearGradientBrush) {
\r
107 #if DEBUG_GRADIENT_BRUSH
\r
108 if(((LinearGradientBrush)b).dPoints != null)
\r
110 PointF []pts = ((LinearGradientBrush)b).dPoints;
\r
111 java.awt.Shape s = g.getClip();
\r
112 g.setClip(0,0,99999,99999);
\r
113 g.setPaint(new java.awt.Color(255,0,0));
\r
114 g.drawLine((int)pts[0].X,(int)pts[0].Y,(int)pts[1].X,(int)pts[1].Y);
\r
115 g.setPaint(new java.awt.Color(0,255,0));
\r
116 g.drawLine((int)pts[1].X,(int)pts[1].Y,(int)pts[2].X,(int)pts[2].Y);
\r
117 g.setPaint(new java.awt.Color(255,0,0));
\r
118 g.drawLine((int)pts[2].X,(int)pts[2].Y,(int)pts[3].X,(int)pts[3].Y);
\r
119 g.setPaint(new java.awt.Color(0,255,0));
\r
120 g.drawLine((int)pts[3].X,(int)pts[3].Y,(int)pts[0].X,(int)pts[0].Y);
\r
128 void DrawShape(Pen pen, awt.Shape shape) {
\r
130 throw new ArgumentNullException("pen");
\r
132 shape = ((awt.Stroke)pen).createStrokedShape(shape);
\r
133 FillShape(pen.Brush, shape);
\r
136 void FillShape(awt.Paint paint, awt.Shape shape) {
\r
138 throw new ArgumentNullException("brush");
\r
140 awt.Paint old = NativeObject.getPaint();
\r
141 NativeObject.setPaint(paint);
\r
143 NativeObject.fill(shape);
\r
146 NativeObject.setPaint(old);
\r
150 internal SizeF MeasureDraw (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format, bool fDraw) {
\r
151 SizeF retVal = new SizeF(0,0);
\r
152 awt.Graphics2D g = NativeObject;
\r
154 java.awt.Font fnt = font.NativeObject;
\r
155 if(s != null && s.Length != 0 && fnt != null) {
\r
156 float size = fnt.getSize();
\r
157 float wid = layoutRectangle.Width;
\r
158 float hei = layoutRectangle.Height;
\r
159 float x = layoutRectangle.X;
\r
160 float y = layoutRectangle.Y;
\r
161 java.text.AttributedString astr = new java.text.AttributedString(s);
\r
162 astr.addAttribute(java.awt.font.TextAttribute.FONT, fnt);
\r
163 java.text.AttributedCharacterIterator prg = astr.getIterator();
\r
164 java.awt.font.TextLayout textlayout = new java.awt.font.TextLayout(prg, g.getFontRenderContext());
\r
165 int prgStart = prg.getBeginIndex();
\r
166 int prgEnd = prg.getEndIndex();
\r
167 java.awt.font.LineBreakMeasurer lineMeasurer = new java.awt.font.LineBreakMeasurer(
\r
168 prg, new java.awt.font.FontRenderContext(null, false, false));
\r
169 lineMeasurer.setPosition(prgStart);
\r
170 float formatWidth = wid;
\r
172 //some vertical layout magic - should be reviewed
\r
173 // if(format != null)
\r
175 // StringFormatFlags formatflag = format.FormatFlags;
\r
176 // if(formatflag != StringFormatFlags.DirectionVertical)
\r
178 // if(size > (float)8 && wid > (float)13)
\r
179 // formatWidth = wid - (float)12;
\r
180 // if(formatflag == StringFormatFlags.DirectionRightToLeft && size == (float)6)
\r
181 // formatWidth = wid - (float)10;
\r
185 //now calculate number of lines and full layout height
\r
186 //this is required for LineAlignment calculations....
\r
189 float layPrevHeight=0;
\r
191 float drawPosY = y;
\r
192 //bool fSkipLastLine = false;
\r
193 java.awt.font.TextLayout layout;
\r
194 java.awt.geom.Rectangle2D bnds = new java.awt.geom.Rectangle2D.Float();
\r
195 while(lineMeasurer.getPosition() < prgEnd) {
\r
196 layout = lineMeasurer.nextLayout(formatWidth);
\r
198 bnds = bnds.createUnion(layout.getBounds());
\r
199 layPrevHeight = layHeight;
\r
200 layHeight += layout.getDescent() + layout.getLeading() + layout.getAscent();
\r
202 if((format != null) &&
\r
203 ((format.FormatFlags & StringFormatFlags.MeasureTrailingSpaces) != 0))
\r
204 advance = layout.getAdvance();
\r
206 advance = layout.getVisibleAdvance();
\r
207 if(layWidth < advance)
\r
208 layWidth = advance;
\r
209 if((format != null) && ((format.FormatFlags & StringFormatFlags.NoWrap) != 0))
\r
212 //Overhanging parts of glyphs, and unwrapped text reaching outside
\r
213 //the formatting rectangle are allowed to show. By default all text
\r
214 //and glyph parts reaching outside the formatting rectangle are clipped.
\r
215 if((lines == 1) &&
\r
216 (format != null) &&
\r
217 ((format.FormatFlags & StringFormatFlags.NoClip) != 0)) {
\r
218 formatWidth = layWidth;
\r
221 //Only entire lines are laid out in the formatting rectangle. By default layout
\r
222 //continues until the end of the text, or until no more lines are visible as a
\r
223 //result of clipping, whichever comes first. Note that the default settings allow
\r
224 //the last line to be partially obscured by a formatting rectangle that is not a
\r
225 //whole multiple of the line height. To ensure that only whole lines are seen, specify
\r
226 //this value and be careful to provide a formatting rectangle at least as tall as the
\r
227 //height of one line.
\r
228 if(format != null && ((format.FormatFlags & StringFormatFlags.LineLimit) != 0) &&
\r
229 layHeight > hei && layPrevHeight < hei) {
\r
230 layHeight = layPrevHeight;
\r
234 retVal.Height = layHeight;
\r
235 retVal.Width = layWidth+size/2.5f;
\r
239 InternalSetBrush(brush);
\r
243 //for draw we should probably update origins
\r
246 if(format != null) {
\r
247 StringAlignment align = format.LineAlignment;
\r
248 if(align == StringAlignment.Center) {
\r
249 drawPosY = y + (float)hei/2 - layHeight/2;
\r
251 else if(align == StringAlignment.Far) {
\r
252 drawPosY = (float)y + (float)hei - layHeight;
\r
254 //in both cases if string is not fit - switch to near
\r
259 //Horisontal... on the fly
\r
260 lineMeasurer.setPosition(prgStart);
\r
261 float drawPosX = x;
\r
262 for(int line = 0;line < lines /*lineMeasurer.getPosition() < prgEnd*/;line++, drawPosY += layout.getDescent() + layout.getLeading()) {
\r
263 layout = lineMeasurer.nextLayout(formatWidth);
\r
264 drawPosX = x + size / (float)5;//???
\r
265 drawPosY += layout.getAscent();
\r
266 if(format != null) {
\r
268 if((format.FormatFlags & StringFormatFlags.MeasureTrailingSpaces) != 0)
\r
269 advance = layout.getAdvance();
\r
271 advance = layout.getVisibleAdvance();
\r
273 if(format.Alignment == StringAlignment.Center) {
\r
274 drawPosX = (float)((double)x + ((double)formatWidth)/2 - advance/2);
\r
276 else if(format.Alignment == StringAlignment.Far) {
\r
277 drawPosX = (float)(drawPosX + formatWidth) - advance;
\r
279 if((format.FormatFlags & StringFormatFlags.DirectionVertical ) != 0) {
\r
280 java.awt.geom.AffineTransform at1 = java.awt.geom.AffineTransform.getTranslateInstance(
\r
281 drawPosX + size / (float)5, (drawPosY - layout.getAscent()) + size / (float)5);
\r
283 at1.rotate(Math.PI/2);
\r
284 awt.Shape sha = textlayout.getOutline(at1);
\r
285 //g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
\r
289 if((format.FormatFlags & StringFormatFlags.DirectionRightToLeft) != 0) {
\r
290 drawPosX = ((drawPosX + formatWidth) - advance) + (float)9;
\r
291 layout.draw(g, drawPosX, drawPosY);
\r
294 //Draw current line
\r
295 layout.draw(g, drawPosX, drawPosY);
\r
304 public void Dispose() {
\r
305 NativeObject.dispose();
\r
310 public void Clear (Color color) {
\r
311 geom.AffineTransform old = NativeObject.getTransform();
\r
312 NativeObject.setTransform(new geom.AffineTransform());
\r
314 FillShape(color.NativeObject, new awt.Rectangle(0,0,_image.Width,_image.Height));
\r
317 NativeObject.setTransform(old);
\r
323 public void DrawArc (Pen pen, Rectangle rect, float startAngle, float sweepAngle) {
\r
334 public void DrawArc (Pen pen, RectangleF rect, float startAngle, float sweepAngle) {
\r
344 public void DrawArc (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle) {
\r
351 (float)sweepAngle);
\r
354 public void DrawArc (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle) {
\r
355 GraphicsPath path = new GraphicsPath();
\r
356 path.AddArc(x, y, width, height, startAngle, sweepAngle);
\r
357 DrawPath(pen, path);
\r
361 #region DrawBezier(s)
\r
362 public void DrawBezier (Pen pen, PointF pt1, PointF pt2, PointF pt3, PointF pt4) {
\r
363 DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
\r
366 public void DrawBezier (Pen pen, Point pt1, Point pt2, Point pt3, Point pt4) {
\r
367 DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
\r
370 public void DrawBezier (Pen pen, float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) {
\r
371 geom.GeneralPath path = new geom.GeneralPath();
\r
372 path.moveTo(x1,y1);
\r
373 path.curveTo(x2,y2,x3,y3,x4,y4);
\r
374 DrawShape(pen, path);
\r
377 public void DrawBeziers (Pen pen, Point [] points) {
\r
378 GraphicsPath path = new GraphicsPath();
\r
379 path.AddBeziers(points);
\r
380 DrawPath(pen, path);
\r
383 public void DrawBeziers (Pen pen, PointF [] points) {
\r
384 GraphicsPath path = new GraphicsPath();
\r
385 path.AddBeziers(points);
\r
386 DrawPath(pen, path);
\r
390 #region DrawClosedCurve
\r
391 public void DrawClosedCurve (Pen pen, PointF [] points) {
\r
392 DrawClosedCurve(pen, points, 0.5f, FillMode.Alternate);
\r
395 public void DrawClosedCurve (Pen pen, Point [] points) {
\r
396 DrawClosedCurve(pen, points, 0.5f, FillMode.Alternate);
\r
399 public void DrawClosedCurve (Pen pen, Point [] points, float tension, FillMode fillmode) {
\r
400 GraphicsPath path = new GraphicsPath(fillmode);
\r
401 path.AddClosedCurve(points, tension);
\r
402 DrawPath(pen, path);
\r
405 public void DrawClosedCurve (Pen pen, PointF [] points, float tension, FillMode fillmode) {
\r
406 GraphicsPath path = new GraphicsPath(fillmode);
\r
407 path.AddClosedCurve(points, tension);
\r
408 DrawPath(pen, path);
\r
413 public void DrawCurve (Pen pen, Point [] points) {
\r
414 DrawCurve(pen, points, 0.5f);
\r
417 public void DrawCurve (Pen pen, PointF [] points) {
\r
418 DrawCurve(pen, points, 0.5f);
\r
421 public void DrawCurve (Pen pen, PointF [] points, float tension) {
\r
422 DrawCurve(pen, points, 0, points.Length-1, tension);
\r
425 public void DrawCurve (Pen pen, Point [] points, float tension) {
\r
426 DrawCurve(pen, points, 0, points.Length-1, tension);
\r
430 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments) {
\r
431 DrawCurve(pen, points, offset, numberOfSegments, 0.5f);
\r
434 public void DrawCurve (Pen pen, Point [] points, int offset, int numberOfSegments, float tension) {
\r
435 GraphicsPath path = new GraphicsPath();
\r
436 path.AddCurve(points, offset, numberOfSegments, tension);
\r
437 DrawPath(pen, path);
\r
441 public void DrawCurve (Pen pen, PointF [] points, int offset, int numberOfSegments, float tension) {
\r
442 GraphicsPath path = new GraphicsPath();
\r
443 path.AddCurve(points, offset, numberOfSegments, tension);
\r
444 DrawPath(pen, path);
\r
448 #region DrawEllipse
\r
449 public void DrawEllipse (Pen pen, Rectangle rect) {
\r
450 DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);
\r
453 public void DrawEllipse (Pen pen, RectangleF rect) {
\r
454 DrawEllipse (pen, rect.X, rect.Y, rect.Width, rect.Height);
\r
457 public void DrawEllipse (Pen pen, int x, int y, int width, int height) {
\r
458 DrawEllipse(pen,(float)x,(float)y,(float)width,(float)height);
\r
461 public void DrawEllipse (Pen pen, float x, float y, float width, float height) {
\r
462 DrawShape(pen, new geom.Ellipse2D.Float(x,y,width,height));
\r
467 public void DrawIcon (Icon icon, Rectangle targetRect) {
\r
468 Bitmap b = icon.ToBitmap ();
\r
469 this.DrawImage (b, targetRect);
\r
472 public void DrawIcon (Icon icon, int x, int y) {
\r
473 Bitmap b = icon.ToBitmap ();
\r
474 this.DrawImage (b, x, y);
\r
477 public void DrawIconUnstretched (Icon icon, Rectangle targetRect) {
\r
478 Bitmap b = icon.ToBitmap ();
\r
479 this.DrawImageUnscaled (b, targetRect);
\r
485 public void DrawImage (Image image, Point point)
\r
487 DrawImage(image, (int)point.X, (int)point.Y);
\r
490 public void DrawImage (Image image, PointF point)
\r
492 DrawImage(image, (int)point.X, (int)point.Y);
\r
496 public void DrawImage (Image image, Point [] destPoints) {
\r
497 Matrix m = new Matrix(new Rectangle(0, 0, image.Width, image.Height), destPoints);
\r
498 DrawImage(image, m);
\r
501 public void DrawImage (Image image, PointF [] destPoints)
\r
503 Matrix m = new Matrix(new RectangleF(0, 0, image.Width, image.Height), destPoints);
\r
504 DrawImage(image, m);
\r
508 public void DrawImage (Image image, Rectangle rect)
\r
510 DrawImage(image, rect.X, rect.Y, rect.Width, rect.Height);
\r
513 public void DrawImage (Image image, RectangleF rect)
\r
515 DrawImage(image, (int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height);
\r
519 public void DrawImage (Image image, int x, int y)
\r
521 float current_scale = PageScale;
\r
522 if (current_scale != 1)
\r
527 NativeObject.drawImage(image.NativeObject, x, y, null);
\r
531 if (current_scale != 1)
\r
532 PageScale = current_scale;
\r
536 public void DrawImage (Image image, float x, float y)
\r
538 DrawImage(image, (int)x, (int)y);
\r
542 public void DrawImage (Image image, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit) {
\r
543 if (srcUnit != GraphicsUnit.Pixel)
\r
544 throw new NotImplementedException();
\r
545 // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx
\r
547 float current_scale = PageScale;
\r
548 if (current_scale != 1)
\r
553 NativeObject.drawImage(image.NativeObject,
\r
556 destRect.X + destRect.Width,
\r
557 destRect.Y + destRect.Height,
\r
560 srcRect.X + srcRect.Width,
\r
561 srcRect.Y + srcRect.Height,
\r
566 if (current_scale != 1)
\r
567 PageScale = current_scale;
\r
571 public void DrawImage (Image image, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit) {
\r
574 new Rectangle((int)destRect.X, (int)destRect.Y, (int)destRect.Width, (int)destRect.Height),
\r
575 new Rectangle((int)srcRect.X, (int)srcRect.Y, (int)srcRect.Width, (int)srcRect.Height),
\r
580 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit) {
\r
581 DrawImage(image, destPoints, srcRect, srcUnit, null);
\r
584 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit) {
\r
585 DrawImage(image, destPoints, srcRect, srcUnit, null);
\r
589 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr) {
\r
590 //TBD: ImageAttributes
\r
591 if (srcUnit != GraphicsUnit.Pixel)
\r
592 throw new NotImplementedException();
\r
593 // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx
\r
595 Matrix mx = new Matrix(srcRect, destPoints);
\r
597 Region region = new Region(srcRect);
\r
598 region.Transform (mx);
\r
600 geom.Area current_clip = (geom.Area)GetNativeClip().clone();
\r
601 IntersectClip(region);
\r
604 DrawImage(image, mx);
\r
608 SetNativeClip(current_clip);
\r
612 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr) {
\r
613 //TBD: ImageAttributes
\r
614 if (srcUnit != GraphicsUnit.Pixel)
\r
615 throw new NotImplementedException();
\r
616 // Like in .NET http://dotnet247.com/247reference/msgs/45/227979.aspx
\r
618 Matrix mx = new Matrix(srcRect, destPoints);
\r
620 Region region = new Region(srcRect);
\r
621 region.Transform (mx);
\r
623 geom.Area current_clip = (geom.Area)GetNativeClip().clone();
\r
624 IntersectClip(region);
\r
627 DrawImage(image, mx);
\r
631 SetNativeClip(current_clip);
\r
636 public void DrawImage (Image image, int x, int y, int width, int height) {
\r
637 float current_scale = PageScale;
\r
638 if (current_scale != 1)
\r
643 NativeObject.drawImage(image.NativeObject, x, y, width, height, null);
\r
647 if (current_scale != 1)
\r
648 PageScale = current_scale;
\r
652 public void DrawImage (Image image, float x, float y, float width, float height) {
\r
653 DrawImage(image, (int)x, (int)y, (int)width, (int)height);
\r
657 public void DrawImage (Image image, int x, int y, Rectangle srcRect, GraphicsUnit srcUnit) {
\r
658 DrawImage(image, new Rectangle(x, y, srcRect.Width, srcRect.Height), srcRect, srcUnit);
\r
661 public void DrawImage (Image image, float x, float y, RectangleF srcRect, GraphicsUnit srcUnit) {
\r
662 DrawImage(image, new RectangleF(x, y, srcRect.Width, srcRect.Height), srcRect, srcUnit);
\r
666 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit) {
\r
667 DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);
\r
670 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit) {
\r
671 DrawImage(image, destRect, srcX, srcY, srcWidth, srcHeight, srcUnit, null);
\r
675 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr) {
\r
680 new Rectangle(srcX, srcY, srcWidth, srcHeight),
\r
684 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttrs) {
\r
689 new Rectangle((int)srcX, (int)srcY, (int)srcWidth, (int)srcHeight),
\r
694 internal void DrawImage (Image image, Matrix m) {
\r
695 float current_scale = PageScale;
\r
696 if (current_scale != 1)
\r
701 NativeObject.drawImage(image.NativeObject, m.NativeObject, null);
\r
705 if (current_scale != 1)
\r
706 PageScale = current_scale;
\r
712 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
\r
714 throw new NotImplementedException();
\r
718 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
\r
721 throw new NotImplementedException();
\r
725 public void DrawImage (Image image, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)
\r
727 throw new NotImplementedException();
\r
731 #if INTPTR_SUPPORT
\r
732 public void DrawImage (Image image, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, int callbackData)
\r
734 throw new NotImplementedException();
\r
738 #if INTPTR_SUPPORT
\r
739 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
\r
741 //TBD:units,attributes, callback
\r
742 java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;
\r
743 g.drawImage(image.NativeObject,destRect.X,destRect.Y,destRect.Width,destRect.Height,srcX,srcY,srcWidth,srcHeight,null);
\r
746 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback)
\r
748 //TBD:units,attributes, callback
\r
749 java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;
\r
750 g.drawImage(image.NativeObject,
\r
753 (int)destRect.Width,
\r
754 (int)destRect.Height,
\r
758 (int)srcHeight,null);
\r
761 public void DrawImage (Image image, Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)
\r
763 //TBD:units,attributes, callback
\r
764 java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;
\r
765 g.drawImage(image.NativeObject,
\r
768 (int)destRect.Width,
\r
769 (int)destRect.Height,
\r
773 (int)srcHeight,null);
\r
776 public void DrawImage (Image image, Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, GraphicsUnit srcUnit, ImageAttributes imageAttr, DrawImageAbort callback, IntPtr callbackData)
\r
778 //TBD:units,attributes, callback
\r
779 java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;
\r
780 g.drawImage(image.NativeObject,
\r
792 public void DrawImageUnscaled (Image image, Point point)
\r
794 DrawImageUnscaled (image, point.X, point.Y);
\r
797 public void DrawImageUnscaled (Image image, Rectangle rect) {
\r
798 DrawImageUnscaled (image, rect.X, rect.Y, rect.Width, rect.Height);
\r
801 public void DrawImageUnscaled (Image image, int x, int y) {
\r
802 DrawImage (image, x, y, image.Width, image.Height);
\r
805 public void DrawImageUnscaled (Image image, int x, int y, int width, int height) {
\r
806 Image tmpImg = new Bitmap (width, height);
\r
807 Graphics g = FromImage (tmpImg);
\r
808 g.DrawImage (image, 0, 0, image.Width, image.Height);
\r
809 this.DrawImage (tmpImg, x, y, width, height);
\r
816 public void DrawLine (Pen pen, PointF pt1, PointF pt2) {
\r
817 DrawLine(pen,pt1.X,pt1.Y,pt2.X,pt2.Y);
\r
820 public void DrawLine (Pen pen, Point pt1, Point pt2) {
\r
821 DrawLine(pen,(float)pt1.X,(float)pt1.Y,(float)pt2.X,(float)pt2.Y);
\r
824 public void DrawLine (Pen pen, int x1, int y1, int x2, int y2) {
\r
825 DrawLine(pen,(float)x1,(float)y1,(float)x2,(float)y2);
\r
828 public void DrawLine (Pen pen, float x1, float y1, float x2, float y2) {
\r
829 DrawShape(pen, new geom.Line2D.Float(x1,y1,x2,y2));
\r
832 public void DrawLines (Pen pen, PointF [] points) {
\r
833 GraphicsPath path = new GraphicsPath();
\r
834 path.AddLines(points);
\r
835 DrawShape(pen, path);
\r
838 public void DrawLines (Pen pen, Point [] points) {
\r
839 GraphicsPath path = new GraphicsPath();
\r
840 path.AddLines(points);
\r
841 DrawShape(pen, path);
\r
846 public void DrawPath (Pen pen, GraphicsPath path) {
\r
847 DrawShape(pen, path);
\r
852 public void DrawPie (Pen pen, Rectangle rect, float startAngle, float sweepAngle) {
\r
853 DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
\r
856 public void DrawPie (Pen pen, RectangleF rect, float startAngle, float sweepAngle) {
\r
857 DrawPie (pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
\r
860 public void DrawPie (Pen pen, float x, float y, float width, float height, float startAngle, float sweepAngle) {
\r
861 GraphicsPath path = new GraphicsPath();
\r
862 path.AddPie(x, y, width, height, startAngle, sweepAngle);
\r
863 DrawPath(pen, path);
\r
866 public void DrawPie (Pen pen, int x, int y, int width, int height, int startAngle, int sweepAngle) {
\r
867 DrawPie(pen,(float)x,(float)y,(float)width,(float)height,(float)startAngle,(float)sweepAngle);
\r
871 #region DrawPolygon
\r
872 public void DrawPolygon (Pen pen, Point [] points) {
\r
873 GraphicsPath path = new GraphicsPath();
\r
874 path.AddPolygon(points);
\r
875 DrawPath(pen, path);
\r
878 public void DrawPolygon (Pen pen, PointF [] points) {
\r
879 GraphicsPath path = new GraphicsPath();
\r
880 path.AddPolygon(points);
\r
881 DrawPath(pen, path);
\r
885 #region DrawRectangle(s)
\r
886 internal void DrawRectangle (Pen pen, RectangleF rect) {
\r
887 DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);
\r
890 public void DrawRectangle (Pen pen, Rectangle rect) {
\r
891 DrawRectangle (pen, rect.Left, rect.Top, rect.Width, rect.Height);
\r
894 public void DrawRectangle (Pen pen, float x, float y, float width, float height) {
\r
895 DrawShape(pen, new geom.Rectangle2D.Float(x,y,width,height));
\r
898 public void DrawRectangle (Pen pen, int x, int y, int width, int height) {
\r
899 DrawRectangle (pen,(float) x,(float) y,(float) width,(float) height);
\r
902 public void DrawRectangles (Pen pen, RectangleF [] rects) {
\r
903 foreach(RectangleF r in rects)
\r
904 DrawRectangle (pen, r.Left, r.Top, r.Width, r.Height);
\r
907 public void DrawRectangles (Pen pen, Rectangle [] rects) {
\r
908 foreach(Rectangle r in rects)
\r
909 DrawRectangle (pen, r.Left, r.Top, r.Width, r.Height);
\r
914 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle) {
\r
915 MeasureDraw(s,font,brush,layoutRectangle,null,true);
\r
918 public void DrawString (string s, Font font, Brush brush, PointF point) {
\r
919 MeasureDraw(s,font,brush,new RectangleF(point.X,point.Y,99999f,99999f),null,true);
\r
922 public void DrawString (string s, Font font, Brush brush, PointF point, StringFormat format) {
\r
923 MeasureDraw(s,font,brush,new RectangleF(point.X,point.Y,99999f,99999f),format,true);
\r
926 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format) {
\r
927 MeasureDraw(s,font,brush,layoutRectangle,format,true);
\r
931 public void DrawString (string s, Font font, Brush brush, RectangleF layoutRectangle, StringFormat format)
\r
933 java.awt.Graphics2D g = (java.awt.Graphics2D)nativeObject;
\r
935 java.awt.Paint oldpaint = g.getPaint();
\r
936 g.setPaint(brush.NativeObject);
\r
937 java.awt.Font oldfont = g.getFont();
\r
938 g.setFont(font.NativeObject);
\r
939 java.awt.Shape oldb = g.getClip();
\r
940 g.setClip(new java.awt.geom.Rectangle2D.Float(layoutRectangle.X,layoutRectangle.Y,layoutRectangle.Width,layoutRectangle.Height));
\r
942 g.drawString(s,layoutRectangle.X,layoutRectangle.Y+layoutRectangle.Height);
\r
944 g.setPaint(oldpaint);
\r
946 g.setFont(oldfont);
\r
949 public void DrawString (string s, Font font, Brush brush, float x, float y) {
\r
950 MeasureDraw(s,font,brush,new RectangleF(x,y,99999f,99999f),null,true);
\r
953 public void DrawString (string s, Font font, Brush brush, float x, float y, StringFormat format) {
\r
954 MeasureDraw(s,font,brush,new RectangleF(x,y,99999f,99999f),format,true);
\r
958 #region Container [TODO]
\r
959 public void EndContainer (GraphicsContainer container) {
\r
960 throw new NotImplementedException ();
\r
963 public GraphicsContainer BeginContainer () {
\r
964 throw new NotImplementedException ();
\r
967 public GraphicsContainer BeginContainer (Rectangle dstrect, Rectangle srcrect, GraphicsUnit unit) {
\r
968 throw new NotImplementedException ();
\r
972 public GraphicsContainer BeginContainer (RectangleF dstrect, RectangleF srcrect, GraphicsUnit unit) {
\r
973 throw new NotImplementedException ();
\r
978 #region Metafiles Staff [TODO NotSupp]
\r
979 public void AddMetafileComment (byte [] data) {
\r
980 throw new NotImplementedException ();
\r
984 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback)
\r
986 throw new NotImplementedException ();
\r
989 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback)
\r
991 throw new NotImplementedException ();
\r
994 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback)
\r
996 throw new NotImplementedException ();
\r
999 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback)
\r
1001 throw new NotImplementedException ();
\r
1004 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback)
\r
1006 throw new NotImplementedException ();
\r
1009 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback)
\r
1011 throw new NotImplementedException ();
\r
1014 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1016 throw new NotImplementedException ();
\r
1019 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1021 throw new NotImplementedException ();
\r
1024 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1026 throw new NotImplementedException ();
\r
1029 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1031 throw new NotImplementedException ();
\r
1034 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1036 throw new NotImplementedException ();
\r
1039 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1041 throw new NotImplementedException ();
\r
1044 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
\r
1046 throw new NotImplementedException ();
\r
1049 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
\r
1051 throw new NotImplementedException ();
\r
1054 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
\r
1056 throw new NotImplementedException ();
\r
1059 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
\r
1061 throw new NotImplementedException ();
\r
1064 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
\r
1066 throw new NotImplementedException ();
\r
1069 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback)
\r
1071 throw new NotImplementedException ();
\r
1074 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1076 throw new NotImplementedException ();
\r
1079 public void EnumerateMetafile (Metafile metafile, Point destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1081 throw new NotImplementedException ();
\r
1084 public void EnumerateMetafile (Metafile metafile, PointF destPoint, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1086 throw new NotImplementedException ();
\r
1089 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1091 throw new NotImplementedException ();
\r
1094 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1096 throw new NotImplementedException ();
\r
1099 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1101 throw new NotImplementedException ();
\r
1104 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1106 throw new NotImplementedException ();
\r
1109 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1111 throw new NotImplementedException ();
\r
1114 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1116 throw new NotImplementedException ();
\r
1119 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1121 throw new NotImplementedException ();
\r
1124 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1126 throw new NotImplementedException ();
\r
1129 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit srcUnit, EnumerateMetafileProc callback, IntPtr callbackData)
\r
1131 throw new NotImplementedException ();
\r
1134 public void EnumerateMetafile (Metafile metafile, Point [] destPoints, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1136 throw new NotImplementedException ();
\r
1139 public void EnumerateMetafile (Metafile metafile, Rectangle destRect, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1141 throw new NotImplementedException ();
\r
1144 public void EnumerateMetafile (Metafile metafile, Point destPoint, Rectangle srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1146 throw new NotImplementedException ();
\r
1149 public void EnumerateMetafile (Metafile metafile, RectangleF destRect, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1151 throw new NotImplementedException ();
\r
1154 public void EnumerateMetafile (Metafile metafile, PointF [] destPoints, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1156 throw new NotImplementedException ();
\r
1159 public void EnumerateMetafile (Metafile metafile, PointF destPoint, RectangleF srcRect, GraphicsUnit unit, EnumerateMetafileProc callback, IntPtr callbackData, ImageAttributes imageAttr)
\r
1161 throw new NotImplementedException ();
\r
1166 #region ExcludeClip
\r
1167 public void ExcludeClip (Rectangle rect) {
\r
1168 geom.Area clip = GetNativeClip();
\r
1169 clip.subtract(new geom.Area(rect.NativeObject));
\r
1170 SetNativeClip(clip);
\r
1173 public void ExcludeClip (Region region) {
\r
1174 geom.Area clip = GetNativeClip();
\r
1175 clip.subtract(region.NativeObject);
\r
1176 SetNativeClip(clip);
\r
1180 #region FillClosedCurve
\r
1181 public void FillClosedCurve (Brush brush, PointF [] points) {
\r
1182 FillClosedCurve (brush, points, FillMode.Alternate);
\r
1186 public void FillClosedCurve (Brush brush, Point [] points) {
\r
1187 FillClosedCurve (brush, points, FillMode.Alternate);
\r
1191 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode) {
\r
1192 FillClosedCurve (brush, points, fillmode, 0.5f);
\r
1195 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode) {
\r
1196 FillClosedCurve (brush, points, fillmode, 0.5f);
\r
1199 public void FillClosedCurve (Brush brush, PointF [] points, FillMode fillmode, float tension) {
\r
1200 GraphicsPath path = new GraphicsPath(fillmode);
\r
1201 path.AddClosedCurve(points, tension);
\r
1202 FillPath(brush, path);
\r
1205 public void FillClosedCurve (Brush brush, Point [] points, FillMode fillmode, float tension) {
\r
1206 GraphicsPath path = new GraphicsPath(fillmode);
\r
1207 path.AddClosedCurve(points, tension);
\r
1208 FillPath(brush, path);
\r
1212 #region FillEllipse
\r
1213 public void FillEllipse (Brush brush, Rectangle rect) {
\r
1214 FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);
\r
1217 public void FillEllipse (Brush brush, RectangleF rect) {
\r
1218 FillEllipse (brush, rect.X, rect.Y, rect.Width, rect.Height);
\r
1221 public void FillEllipse (Brush brush, float x, float y, float width, float height) {
\r
1222 FillShape(brush,new java.awt.geom.Ellipse2D.Float(x,y,width,height));
\r
1225 public void FillEllipse (Brush brush, int x, int y, int width, int height) {
\r
1226 FillEllipse (brush,(float)x,(float)y,(float)width,(float)height);
\r
1231 public void FillPath (Brush brush, GraphicsPath path) {
\r
1232 FillShape(brush,path);
\r
1237 public void FillPie (Brush brush, Rectangle rect, float startAngle, float sweepAngle) {
\r
1238 FillPie(brush,(float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height,(float)startAngle,(float)sweepAngle);
\r
1241 public void FillPie (Brush brush, int x, int y, int width, int height, int startAngle, int sweepAngle) {
\r
1242 FillPie(brush,(float)x,(float)y,(float)width,(float)height,(float)startAngle,(float)sweepAngle);
\r
1245 public void FillPie (Brush brush, float x, float y, float width, float height, float startAngle, float sweepAngle) {
\r
1246 GraphicsPath path = new GraphicsPath();
\r
1247 path.AddPie(x, y, width, height, startAngle, sweepAngle);
\r
1248 FillPath(brush, path);
\r
1252 #region FillPolygon
\r
1253 public void FillPolygon (Brush brush, PointF [] points) {
\r
1254 FillPolygon(brush, points, FillMode.Alternate);
\r
1257 public void FillPolygon (Brush brush, Point [] points) {
\r
1258 FillPolygon(brush, points, FillMode.Alternate);
\r
1261 public void FillPolygon (Brush brush, Point [] points, FillMode fillMode) {
\r
1262 GraphicsPath path = new GraphicsPath(fillMode);
\r
1263 path.AddPolygon(points);
\r
1264 FillPath(brush,path);
\r
1267 public void FillPolygon (Brush brush, PointF [] points, FillMode fillMode) {
\r
1268 GraphicsPath path = new GraphicsPath(fillMode);
\r
1269 path.AddPolygon(points);
\r
1270 FillPath(brush,path);
\r
1274 #region FillRectangle
\r
1275 public void FillRectangle (Brush brush, RectangleF rect) {
\r
1276 FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);
\r
1279 public void FillRectangle (Brush brush, Rectangle rect) {
\r
1280 FillRectangle (brush, rect.Left, rect.Top, rect.Width, rect.Height);
\r
1283 public void FillRectangle (Brush brush, int x, int y, int width, int height) {
\r
1284 FillRectangle(brush,(float)x,(float)y,(float)width,(float)height);
\r
1287 public void FillRectangle (Brush brush, float x, float y, float width, float height) {
\r
1288 FillShape(brush,new java.awt.geom.Rectangle2D.Float(x,y,width,height));
\r
1291 public void FillRectangles (Brush brush, Rectangle [] rects) {
\r
1292 GraphicsPath path = new GraphicsPath();
\r
1293 path.AddRectangles(rects);
\r
1294 FillPath(brush,path);
\r
1297 public void FillRectangles (Brush brush, RectangleF [] rects) {
\r
1298 GraphicsPath path = new GraphicsPath();
\r
1299 path.AddRectangles(rects);
\r
1300 FillPath(brush,path);
\r
1304 #region FillRegion
\r
1305 public void FillRegion (Brush brush, Region region) {
\r
1306 FillShape(brush,region);
\r
1311 public void Flush () {
\r
1312 Flush (FlushIntention.Flush);
\r
1316 public void Flush (FlushIntention intention) {
\r
1317 if (_image != null)
\r
1318 _image.NativeObject.flush();
\r
1321 #if INTPTR_SUPPORTED
\r
1322 [EditorBrowsable (EditorBrowsableState.Advanced)]
\r
1323 public void ReleaseHdc (IntPtr hdc)
\r
1325 throw new NotImplementedException();
\r
1328 [EditorBrowsable (EditorBrowsableState.Advanced)]
\r
1329 public void ReleaseHdcInternal (IntPtr hdc)
\r
1331 throw new NotImplementedException ();
\r
1334 [EditorBrowsable (EditorBrowsableState.Advanced)]
\r
1335 public static Graphics FromHdc (IntPtr hdc)
\r
1337 throw new NotImplementedException();
\r
1340 [EditorBrowsable (EditorBrowsableState.Advanced)]
\r
1341 public static Graphics FromHdc (IntPtr hdc, IntPtr hdevice)
\r
1343 throw new NotImplementedException ();
\r
1346 [EditorBrowsable (EditorBrowsableState.Advanced)]
\r
1347 public static Graphics FromHdcInternal (IntPtr hdc)
\r
1349 throw new NotImplementedException ();
\r
1352 [EditorBrowsable (EditorBrowsableState.Advanced)]
\r
1353 public static Graphics FromHwnd (IntPtr hwnd)
\r
1355 throw new NotImplementedException();
\r
1358 [EditorBrowsable (EditorBrowsableState.Advanced)]
\r
1359 public static Graphics FromHwndInternal (IntPtr hwnd)
\r
1361 throw new NotImplementedException ();
\r
1364 internal static Graphics FromXDrawable (IntPtr drawable, IntPtr display)
\r
1366 throw new NotImplementedException();
\r
1369 public static IntPtr GetHalftonePalette ()
\r
1371 throw new NotImplementedException ();
\r
1374 [EditorBrowsable (EditorBrowsableState.Advanced)]
\r
1375 public IntPtr GetHdc ()
\r
1377 throw new NotImplementedException();
\r
1381 #region GetNearestColor [TODO]
\r
1382 public Color GetNearestColor (Color color) {
\r
1383 throw new NotImplementedException();
\r
1387 #region IntersectClip
\r
1388 void IntersectClip (geom.Area area) {
\r
1389 geom.Area clip = GetNativeClip();
\r
1390 clip.intersect(area);
\r
1391 SetNativeClip(clip);
\r
1394 public void IntersectClip (Region region) {
\r
1395 if (region == null)
\r
1396 throw new ArgumentNullException("region");
\r
1398 IntersectClip(region.NativeObject);
\r
1401 public void IntersectClip (RectangleF rect) {
\r
1402 IntersectClip(new geom.Area(rect.NativeObject));
\r
1405 public void IntersectClip (Rectangle rect) {
\r
1406 IntersectClip(new geom.Area(rect.NativeObject));
\r
1411 public bool IsVisible (Point point) {
\r
1412 return IsVisible(point.X,point.Y);
\r
1416 public bool IsVisible (RectangleF rect) {
\r
1417 return IsVisible ((float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height);
\r
1420 public bool IsVisible (PointF point) {
\r
1421 return IsVisible(point.X,point.Y);
\r
1424 public bool IsVisible (Rectangle rect) {
\r
1425 return IsVisible ((float)rect.X,(float)rect.Y,(float)rect.Width,(float)rect.Height);
\r
1428 public bool IsVisible (float x, float y) {
\r
1429 java.awt.Graphics2D g = NativeObject;
\r
1430 java.awt.Shape s = g.getClip();
\r
1434 return s.contains(x,y);
\r
1437 public bool IsVisible (int x, int y) {
\r
1438 return IsVisible ((float)x,(float)y);
\r
1441 public bool IsVisible (float x, float y, float width, float height) {
\r
1442 java.awt.Graphics2D g = NativeObject;
\r
1443 java.awt.Shape s = g.getClip();
\r
1447 return s.contains(x,y,width,height);
\r
1451 public bool IsVisible (int x, int y, int width, int height) {
\r
1452 return IsVisible ((float)x,(float)y,(float)width,(float)height);
\r
1456 #region MeasureCharacterRanges [TODO]
\r
1457 public Region [] MeasureCharacterRanges (string text, Font font, RectangleF layoutRect, StringFormat stringFormat) {
\r
1458 throw new NotImplementedException();
\r
1462 #region MeasureString [1 method still TODO]
\r
1463 public SizeF MeasureString (string text, Font font) {
\r
1464 return MeasureDraw(text,font,null,new RectangleF(0,0,99999f,99999f),null,false);
\r
1468 public SizeF MeasureString (string text, Font font, SizeF layoutArea) {
\r
1469 return MeasureDraw(text,font,null,new RectangleF(0,0,layoutArea.Width,layoutArea.Height),null,false);
\r
1473 public SizeF MeasureString (string text, Font font, int width) {
\r
1474 return MeasureDraw(text,font,null,new RectangleF(0,0,(float)width,99999f),null,false);
\r
1478 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat format) {
\r
1479 return MeasureDraw(text,font,null,new RectangleF(0,0,layoutArea.Width,layoutArea.Height),format,false);
\r
1483 public SizeF MeasureString (string text, Font font, int width, StringFormat format) {
\r
1484 return MeasureDraw(text,font,null,new RectangleF(0,0,(float)width,99999f),format,false);
\r
1488 public SizeF MeasureString (string text, Font font, PointF origin, StringFormat format) {
\r
1489 //TBD: MeasureDraw still not dealing with clipping region of dc
\r
1490 return MeasureDraw(text,font,null,new RectangleF(origin.X,origin.Y,99999f,99999f),format,false);
\r
1494 public SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat, out int charactersFitted, out int linesFilled) {
\r
1496 throw new NotImplementedException();
\r
1500 #region MultiplyTransform
\r
1501 public void MultiplyTransform (Matrix matrix) {
\r
1502 MultiplyTransform (matrix, MatrixOrder.Prepend);
\r
1505 public void MultiplyTransform (Matrix matrix, MatrixOrder order) {
\r
1506 ConcatenateTransform(matrix.NativeObject, order);
\r
1510 #region Reset (Clip and Transform)
\r
1511 public void ResetClip () {
\r
1512 java.awt.Graphics2D g = NativeObject;
\r
1517 public void ResetTransform () {
\r
1518 _transform = new Matrix(1,0,0,1,0,0);
\r
1519 UpdateInternalTransform();
\r
1523 public GraphicsState Save () {
\r
1524 throw new NotImplementedException();
\r
1527 public void Restore (GraphicsState gstate) {
\r
1528 throw new NotImplementedException();
\r
1531 #region RotateTransform
\r
1532 public void RotateTransform (float angle) {
\r
1533 RotateTransform (angle, MatrixOrder.Prepend);
\r
1536 public void RotateTransform (float angle, MatrixOrder order) {
\r
1537 ConcatenateTransform(
\r
1538 geom.AffineTransform.getRotateInstance(java.lang.Math.toRadians(angle)),
\r
1543 #region ScaleTransform
\r
1544 public void ScaleTransform (float sx, float sy) {
\r
1545 ScaleTransform (sx, sy, MatrixOrder.Prepend);
\r
1548 public void ScaleTransform (float sx, float sy, MatrixOrder order) {
\r
1549 ConcatenateTransform(
\r
1550 geom.AffineTransform.getScaleInstance(sx, sy),
\r
1555 #region SetClip [Must be reviewed - more abstraction needed]
\r
1556 public void SetClip (RectangleF rect) {
\r
1557 SetClip (rect, CombineMode.Replace);
\r
1560 public void SetClip (GraphicsPath path) {
\r
1561 SetClip (path, CombineMode.Replace);
\r
1564 public void SetClip (Rectangle rect) {
\r
1565 SetClip (rect, CombineMode.Replace);
\r
1568 public void SetClip (Graphics g) {
\r
1569 SetClip (g, CombineMode.Replace);
\r
1572 public void SetClip (Graphics g, CombineMode combineMode) {
\r
1574 throw new NullReferenceException();
\r
1577 CombineClipArea(g.GetNativeClip(),
\r
1581 public void SetClip (Rectangle rect, CombineMode combineMode) {
\r
1582 SetClip(rect.X,rect.Y,rect.Width,rect.Height,combineMode);
\r
1584 public void SetClip (RectangleF rect, CombineMode combineMode) {
\r
1585 SetClip(rect.X,rect.Y,rect.Width,rect.Height,combineMode);
\r
1588 public void SetClip (Region region, CombineMode combineMode) {
\r
1589 if(region == null)
\r
1590 throw new ArgumentNullException("region");
\r
1592 if(region == Region.InfiniteRegion) {
\r
1593 SetNativeClip(null);
\r
1597 SetNativeClip(CombineClipArea(region.NativeObject,combineMode));
\r
1600 public void SetClip (GraphicsPath path, CombineMode combineMode) {
\r
1602 throw new ArgumentNullException("path");
\r
1604 SetNativeClip(CombineClipArea(new java.awt.geom.Area(path.NativeObject),combineMode));
\r
1608 #region Clipping Staff [INTERNAL]
\r
1609 internal void SetClip(float x,float y,float width,float height,CombineMode combineMode) {
\r
1610 SetNativeClip(CombineClipArea(new geom.Area(
\r
1611 new geom.Rectangle2D.Float(x,y,width,height)),combineMode));
\r
1614 geom.Area CombineClipArea(java.awt.geom.Area area, CombineMode combineMode) {
\r
1615 if (combineMode == CombineMode.Replace)
\r
1618 geom.Area curClip = GetNativeClip();
\r
1619 switch(combineMode) {
\r
1620 case CombineMode.Complement:
\r
1621 curClip.add(area);
\r
1623 case CombineMode.Exclude:
\r
1624 curClip.subtract(area);
\r
1626 case CombineMode.Intersect:
\r
1627 curClip.intersect(area);
\r
1629 case CombineMode.Union:
\r
1630 curClip.add(area);
\r
1632 case CombineMode.Xor:
\r
1633 curClip.exclusiveOr(area);
\r
1636 throw new ArgumentOutOfRangeException();
\r
1642 void SetNativeClip(awt.Shape s) {
\r
1643 NativeObject.setClip(s);
\r
1646 geom.Area GetNativeClip() {
\r
1647 awt.Shape clip = NativeObject.getClip();
\r
1648 return clip != null ? new geom.Area(clip) : (geom.Area)Region.InfiniteRegion.NativeObject.clone();
\r
1652 #region TransformPoints
\r
1653 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF [] pts) {
\r
1654 //TBD:CoordinateSpace
\r
1655 java.awt.geom.AffineTransform tr = this.Transform.NativeObject;
\r
1656 float[] fpts = new float[2];
\r
1657 for(int i = 0; i< pts.Length; i++) {
\r
1658 fpts[0] = pts[i].X;
\r
1659 fpts[1] = pts[i].Y;
\r
1660 tr.transform(fpts, 0, fpts, 0, 1);
\r
1661 pts[i].X = fpts[0];
\r
1662 pts[i].Y = fpts[1];
\r
1666 public void TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts) {
\r
1667 //TBD:CoordinateSpace
\r
1668 java.awt.geom.AffineTransform tr = this.Transform.NativeObject;
\r
1669 float[] fpts = new float[2];
\r
1670 for(int i = 0; i< pts.Length; i++) {
\r
1671 fpts[0] = pts[i].X;
\r
1672 fpts[1] = pts[i].Y;
\r
1673 tr.transform(fpts, 0, fpts, 0, 1);
\r
1674 pts[i].X = (int)fpts[0];
\r
1675 pts[i].Y = (int)fpts[1];
\r
1680 #region TranslateClip
\r
1681 public void TranslateClip (int dx, int dy) {
\r
1682 TranslateClip((float)dx, (float)dy);
\r
1686 public void TranslateClip (float dx, float dy) {
\r
1687 geom.Area clip = GetNativeClip();
\r
1688 clip.transform(geom.AffineTransform.getTranslateInstance(dx, dy));
\r
1689 SetNativeClip(clip);
\r
1693 #region TranslateTransform
\r
1694 public void TranslateTransform (float dx, float dy) {
\r
1695 TranslateTransform (dx, dy, MatrixOrder.Prepend);
\r
1699 public void TranslateTransform (float dx, float dy, MatrixOrder order) {
\r
1700 ConcatenateTransform(
\r
1701 geom.AffineTransform.getTranslateInstance(dx, dy),
\r
1706 #region Properties [Partial TODO]
\r
1707 public Region Clip {
\r
1709 java.awt.Graphics2D g = NativeObject;
\r
1710 java.awt.Shape s = g.getClip();
\r
1712 return new Region(new java.awt.geom.Area(s));
\r
1715 return Region.InfiniteRegion.Clone();
\r
1719 SetClip (value, CombineMode.Replace);
\r
1723 public RectangleF ClipBounds {
\r
1725 java.awt.Graphics2D g = NativeObject;
\r
1726 java.awt.Rectangle r = g.getClipBounds();
\r
1727 RectangleF rect = new RectangleF ((float)r.getX(),(float)r.getY(),(float)r.getWidth(),(float)r.getHeight());
\r
1732 public CompositingMode CompositingMode {
\r
1733 //TBD:check this carefully
\r
1735 return (NativeObject.getComposite() == awt.AlphaComposite.SrcOver) ?
\r
1736 CompositingMode.SourceOver : CompositingMode.SourceCopy;
\r
1739 NativeObject.setComposite(
\r
1740 (value == CompositingMode.SourceOver) ?
\r
1741 awt.AlphaComposite.SrcOver : awt.AlphaComposite.Src);
\r
1746 public CompositingQuality CompositingQuality {
\r
1748 awt.RenderingHints hints = NativeObject.getRenderingHints();
\r
1749 if(hints.containsKey(awt.RenderingHints.KEY_ALPHA_INTERPOLATION)) {
\r
1750 object value_ai = hints.get(awt.RenderingHints.KEY_ALPHA_INTERPOLATION);
\r
1752 if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED)
\r
1753 return CompositingQuality.HighSpeed;
\r
1754 if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY)
\r
1755 return CompositingQuality.HighQuality;
\r
1756 if (value_ai == awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT)
\r
1757 return CompositingQuality.Default;
\r
1760 return CompositingQuality.Default;
\r
1764 awt.RenderingHints hints = NativeObject.getRenderingHints();
\r
1766 case CompositingQuality.AssumeLinear:
\r
1767 case CompositingQuality.Default:
\r
1768 case CompositingQuality.GammaCorrected:
\r
1769 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,
\r
1770 awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);
\r
1772 case CompositingQuality.HighQuality:
\r
1773 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,
\r
1774 awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
\r
1776 case CompositingQuality.HighSpeed:
\r
1777 hints.put(awt.RenderingHints.KEY_ALPHA_INTERPOLATION,
\r
1778 awt.RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
\r
1780 // case CompositingQuality.Invalid:
\r
1781 // if(hints.containsKey(awt.RenderingHints.KEY_ALPHA_INTERPOLATION))
\r
1782 // hints.remove(awt.RenderingHints.KEY_ALPHA_INTERPOLATION);
\r
1785 NativeObject.setRenderingHints(hints);
\r
1789 public float DpiX {
\r
1791 return DefaultScreenResolution;
\r
1795 public float DpiY {
\r
1797 //TBD: assume 72 (screen) for now
\r
1802 public InterpolationMode InterpolationMode {
\r
1804 awt.RenderingHints hints = NativeObject.getRenderingHints();
\r
1805 if(hints.containsKey(awt.RenderingHints.KEY_INTERPOLATION)) {
\r
1806 object value_i = hints.get(awt.RenderingHints.KEY_INTERPOLATION);
\r
1808 if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR)
\r
1809 return InterpolationMode.Bilinear;
\r
1810 if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC)
\r
1811 return InterpolationMode.Bicubic;
\r
1812 if (value_i == awt.RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)
\r
1813 return InterpolationMode.NearestNeighbor;
\r
1816 return InterpolationMode.Default;
\r
1819 awt.RenderingHints hints = NativeObject.getRenderingHints();
\r
1822 case InterpolationMode.Bicubic:
\r
1823 case InterpolationMode.HighQualityBicubic:
\r
1824 case InterpolationMode.Low:
\r
1825 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_BICUBIC);
\r
1827 case InterpolationMode.High:
\r
1828 case InterpolationMode.Bilinear:
\r
1829 case InterpolationMode.HighQualityBilinear:
\r
1830 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_BILINEAR);
\r
1832 case InterpolationMode.Default:
\r
1833 if (hints.containsKey(awt.RenderingHints.KEY_INTERPOLATION))
\r
1834 hints.remove(awt.RenderingHints.KEY_INTERPOLATION);
\r
1836 case InterpolationMode.NearestNeighbor:
\r
1837 hints.put(awt.RenderingHints.KEY_INTERPOLATION, awt.RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
\r
1839 case InterpolationMode.Invalid:
\r
1840 throw new ArgumentException();
\r
1842 throw new ArgumentOutOfRangeException();
\r
1845 NativeObject.setRenderingHints(hints);
\r
1849 public bool IsClipEmpty {
\r
1851 java.awt.Graphics2D g = NativeObject;
\r
1852 awt.Shape clip = g.getClip();
\r
1855 return new geom.Area(clip).isEmpty();
\r
1859 public bool IsVisibleClipEmpty {
\r
1861 awt.Shape clip = NativeObject.getClip();
\r
1864 return !clip.intersects(0, 0, _image.Width, _image.Height);
\r
1868 public float PageScale {
\r
1870 return _pageScale;
\r
1873 _pageScale = value;
\r
1874 UpdateInternalTransform();
\r
1878 public GraphicsUnit PageUnit {
\r
1883 _pageUnit = value;
\r
1884 UpdateInternalTransform();
\r
1888 internal void UpdateInternalTransform()
\r
1890 float new_scale = _pageScale * _unitConversion[ (int)PageUnit ];
\r
1891 Matrix mx = _transform.Clone();
\r
1893 mx.Scale( new_scale, new_scale, MatrixOrder.Prepend );
\r
1895 mx.OffsetX * new_scale - mx.OffsetX,
\r
1896 mx.OffsetY * new_scale - mx.OffsetY, MatrixOrder.Append);
\r
1898 java.awt.Graphics2D g = NativeObject;
\r
1899 g.setTransform( mx.NativeObject );
\r
1902 public PixelOffsetMode PixelOffsetMode {
\r
1904 return _pixelOffsetMode;
\r
1907 _pixelOffsetMode = value;
\r
1911 public Point RenderingOrigin {
\r
1913 throw new NotImplementedException();
\r
1916 throw new NotImplementedException();
\r
1920 public SmoothingMode SmoothingMode {
\r
1922 awt.RenderingHints hints = NativeObject.getRenderingHints();
\r
1923 if(hints.containsKey(awt.RenderingHints.KEY_ANTIALIASING)) {
\r
1924 object value_aa = hints.get(awt.RenderingHints.KEY_ANTIALIASING);
\r
1925 if (value_aa == awt.RenderingHints.VALUE_ANTIALIAS_ON) {
\r
1926 if(hints.containsKey(awt.RenderingHints.KEY_RENDERING)) {
\r
1927 object value_render = hints.get(awt.RenderingHints.KEY_RENDERING);
\r
1928 if (value_render == awt.RenderingHints.VALUE_RENDER_QUALITY)
\r
1929 return SmoothingMode.HighQuality;
\r
1930 if (value_render == awt.RenderingHints.VALUE_RENDER_SPEED)
\r
1931 return SmoothingMode.HighSpeed;
\r
1934 return SmoothingMode.AntiAlias;
\r
1937 if (value_aa == awt.RenderingHints.VALUE_ANTIALIAS_DEFAULT)
\r
1938 return SmoothingMode.Default;
\r
1940 return SmoothingMode.None;
\r
1945 awt.RenderingHints hints = NativeObject.getRenderingHints();
\r
1948 case SmoothingMode.None:
\r
1949 if(hints.containsKey(awt.RenderingHints.KEY_ANTIALIASING))
\r
1950 hints.remove(awt.RenderingHints.KEY_ANTIALIASING);
\r
1951 if(hints.containsKey(awt.RenderingHints.KEY_RENDERING))
\r
1952 hints.remove(awt.RenderingHints.KEY_RENDERING);
\r
1954 case SmoothingMode.AntiAlias:
\r
1955 hints.put(awt.RenderingHints.KEY_ANTIALIASING, awt.RenderingHints.VALUE_ANTIALIAS_ON);
\r
1957 case SmoothingMode.HighQuality:
\r
1958 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_QUALITY);
\r
1959 goto case SmoothingMode.AntiAlias;
\r
1960 case SmoothingMode.HighSpeed:
\r
1961 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_SPEED);
\r
1962 goto case SmoothingMode.None;
\r
1963 case SmoothingMode.Default:
\r
1964 hints.put(awt.RenderingHints.KEY_RENDERING, awt.RenderingHints.VALUE_RENDER_DEFAULT);
\r
1965 goto case SmoothingMode.AntiAlias;
\r
1966 case SmoothingMode.Invalid:
\r
1967 throw new ArgumentException("Invalid parameter used.");
\r
1970 NativeObject.setRenderingHints(hints);
\r
1975 /// Java does not have similar functionality
\r
1977 public int TextContrast {
\r
1979 return _textContrast;
\r
1983 _textContrast = value;
\r
1987 public TextRenderingHint TextRenderingHint {
\r
1989 awt.RenderingHints hints = NativeObject.getRenderingHints();
\r
1990 if(hints.containsKey(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING)) {
\r
1991 if(hints.get(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING) ==
\r
1992 java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON)
\r
1993 return TextRenderingHint.AntiAlias;
\r
1994 if(hints.get(java.awt.RenderingHints.KEY_TEXT_ANTIALIASING) ==
\r
1995 java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_OFF)
\r
1996 return TextRenderingHint.SingleBitPerPixel;
\r
1998 return TextRenderingHint.SystemDefault;
\r
2003 awt.RenderingHints hints = NativeObject.getRenderingHints();
\r
2005 case TextRenderingHint.AntiAlias:
\r
2006 case TextRenderingHint.AntiAliasGridFit:
\r
2007 case TextRenderingHint.ClearTypeGridFit:
\r
2008 case TextRenderingHint.SingleBitPerPixel:
\r
2009 case TextRenderingHint.SingleBitPerPixelGridFit:
\r
2010 case TextRenderingHint.SystemDefault:
\r
2016 public Matrix Transform {
\r
2018 return _transform;
\r
2021 _transform = value.Clone();
\r
2022 UpdateInternalTransform();
\r
2026 public RectangleF VisibleClipBounds {
\r
2028 RectangleF bounds = ClipBounds;
\r
2029 bounds.Intersect(new RectangleF(0, 0, _image.Width, _image.Height));
\r
2034 void ConcatenateTransform(geom.AffineTransform transform, MatrixOrder order) {
\r
2035 geom.AffineTransform at = _transform.NativeObject;
\r
2036 Matrix.Multiply(at, transform, order);
\r
2038 UpdateInternalTransform();
\r