2 // Test.System.Drawing.Graphics.cs
\r
5 // Konstantin Triger <kostat@mainsoft.com>
\r
9 // Copyright (C) 2005 Mainsoft, Corp (http://www.mainsoft.com)
\r
11 // Permission is hereby granted, free of charge, to any person obtaining
\r
12 // a copy of this software and associated documentation files (the
\r
13 // "Software"), to deal in the Software without restriction, including
\r
14 // without limitation the rights to use, copy, modify, merge, publish,
\r
15 // distribute, sublicense, and/or sell copies of the Software, and to
\r
16 // permit persons to whom the Software is furnished to do so, subject to
\r
17 // the following conditions:
\r
19 // The above copyright notice and this permission notice shall be
\r
20 // included in all copies or substantial portions of the Software.
\r
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
\r
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
\r
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
\r
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
\r
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
\r
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
\r
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\r
32 using System.Collections;
\r
33 using System.Diagnostics;
\r
34 using NUnit.Framework;
\r
35 using System.Drawing;
\r
36 using System.Drawing.Drawing2D;
\r
37 using System.Drawing.Text;
\r
38 using System.Drawing.Imaging;
\r
39 using DrawingTestHelper;
\r
42 namespace Test.Sys.Drawing.GraphicsFixtures {
\r
43 #region GraphicsFixtureProps
\r
46 public class GraphicsFixtureProps {
\r
48 protected DrawingTest t;
\r
49 const int TOLERANCE = 3; //in %
\r
52 public void SetUp() {
\r
53 t = DrawingTest.Create(512, 512);
\r
57 public void TearDown ()
\r
64 public void ClipTest_1() {
\r
65 Region r = new Region();
\r
66 Assert.IsTrue(r.Equals(t.Graphics.Clip, t.Graphics));
\r
70 public void ClipTest_2() {
\r
71 Region r = new Region(new Rectangle(10, 10, 60, 60));
\r
72 t.Graphics.Clip = r;
\r
73 Assert.IsTrue(r.Equals(t.Graphics.Clip, t.Graphics));
\r
75 Pen redPen = new Pen(Color.Red, 3);
\r
76 Pen greenPen = new Pen(Color.Green, 3);
\r
77 // Create points that define curve.
\r
78 Point point1 = new Point( 50, 50);
\r
79 Point point2 = new Point(100, 25);
\r
80 Point point3 = new Point(200, 5);
\r
81 Point point4 = new Point(250, 50);
\r
82 Point point5 = new Point(300, 100);
\r
83 Point point6 = new Point(350, 200);
\r
84 Point point7 = new Point(250, 250);
\r
85 Point[] curvePoints = {
\r
94 // Draw lines between original points to screen.
\r
95 t.Graphics.DrawLines(redPen, curvePoints);
\r
97 Assert.IsTrue(t.PDCompare(TOLERANCE));
\r
101 public void ClipTest_3() {
\r
102 t.Graphics.TranslateTransform(3, 3);
\r
103 t.Graphics.SetClip(new Rectangle(23, 24, 30, 40));
\r
105 RectangleF cb = t.Graphics.VisibleClipBounds;
\r
106 DrawingTest.AssertAlmostEqual(23, cb.X);
\r
107 DrawingTest.AssertAlmostEqual(24, cb.Y);
\r
108 DrawingTest.AssertAlmostEqual(30, cb.Width);
\r
109 DrawingTest.AssertAlmostEqual(40, cb.Height);
\r
111 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
113 t.Graphics.RotateTransform(128);
\r
115 t.Graphics.TranslateTransform(14, 14);
\r
116 t.Graphics.ExcludeClip(new Rectangle(0, 0, 4, 60));
\r
119 t.Graphics.RotateTransform(128);
\r
121 t.Graphics.PageUnit = GraphicsUnit.Pixel;
\r
123 t.Graphics.TranslateClip(5.2f, 3.1f);
\r
125 t.Graphics.ResetTransform();
\r
126 t.Graphics.PageUnit = GraphicsUnit.Pixel;
\r
128 cb = t.Graphics.VisibleClipBounds;
\r
129 DrawingTest.AssertAlmostEqual(28, cb.X);
\r
130 DrawingTest.AssertAlmostEqual(22, cb.Y);
\r
131 DrawingTest.AssertAlmostEqual(30, cb.Width);
\r
132 DrawingTest.AssertAlmostEqual(40, cb.Height);
\r
134 t.Graphics.ScaleTransform(5, 7);
\r
135 t.Graphics.IntersectClip(new Rectangle(7, 4, 20, 20));
\r
137 cb = t.Graphics.VisibleClipBounds;
\r
138 DrawingTest.AssertAlmostEqual(7, cb.X);
\r
139 DrawingTest.AssertAlmostEqual(4f, cb.Y);
\r
140 DrawingTest.AssertAlmostEqual(4.6f, cb.Width);
\r
141 DrawingTest.AssertAlmostEqual(4.85714245f, cb.Height);
\r
145 public void ClipBoundsTest() {
\r
146 Region r = new Region();
\r
147 Assert.IsTrue(t.Graphics.ClipBounds.Equals(r.GetBounds(t.Graphics)));
\r
149 RectangleF rf = new RectangleF(10, 10, 60, 60);
\r
150 r = new Region(rf);
\r
151 t.Graphics.Clip = r;
\r
152 Assert.IsTrue(rf.Equals(t.Graphics.ClipBounds));
\r
156 public void CompositingModeTest() {
\r
157 //TODO: seems to draw equal images
\r
158 Assert.AreEqual(CompositingMode.SourceOver, t.Graphics.CompositingMode);
\r
160 Bitmap b = new Bitmap(100, 100);
\r
161 Graphics g = Graphics.FromImage(b);
\r
163 Color c = Color.FromArgb(100, Color.Red);
\r
165 Brush redBrush = new SolidBrush(c);
\r
166 g.FillEllipse(redBrush, 5, 6, 100, 200);
\r
167 //t.Graphics.FillEllipse(redBrush, 5, 6, 100, 200);
\r
168 t.Graphics.DrawImage(b, 10, 10);
\r
172 t.Graphics.CompositingMode = CompositingMode.SourceCopy;
\r
174 t.Graphics.DrawImage(b, 300, 300);
\r
177 Assert.IsTrue(t.PDCompare(TOLERANCE));
\r
181 public void CompositingQualityTest() {
\r
185 public void DpiXTest() {
\r
186 Assert.IsTrue(t.Graphics.DpiX == 96f);
\r
190 public void DpiYTest() {
\r
191 Assert.IsTrue(t.Graphics.DpiY == 96f);
\r
195 public void InterpolationModeTest() {
\r
196 Assert.AreEqual(InterpolationMode.Bilinear, t.Graphics.InterpolationMode);
\r
200 public void IsClipEmtpyTest() {
\r
201 Assert.IsFalse(t.Graphics.IsClipEmpty);
\r
204 t.Graphics.Clip = null;
\r
205 Assert.Fail("The ArgumentNullException was not thrown");
\r
207 catch(Exception e) {
\r
208 Assert.AreEqual(e.GetType(), typeof(ArgumentNullException));
\r
211 Region r = new Region(new Rectangle(10, 10, 0, 0));
\r
212 t.Graphics.Clip = r;
\r
214 Assert.IsTrue( t.Graphics.IsClipEmpty);
\r
218 public void IsVisibleClipEmtpyTest() {
\r
219 Assert.IsFalse(t.Graphics.IsVisibleClipEmpty, "default t.Graphics.IsVisibleClipEmpty");
\r
221 Region r = new Region(new Rectangle(512, 512, 100, 100));
\r
222 t.Graphics.Clip = r;
\r
223 Assert.IsFalse(t.Graphics.IsClipEmpty);
\r
224 Assert.IsTrue(t.Graphics.IsVisibleClipEmpty);
\r
228 public void PageScaleTest() {
\r
229 Assert.AreEqual(1f, t.Graphics.PageScale);
\r
233 public void PageUnitTest() {
\r
234 Assert.AreEqual(GraphicsUnit.Display, t.Graphics.PageUnit);
\r
238 public void PixelOffsetModeTest() {
\r
239 Assert.AreEqual(PixelOffsetMode.Default, t.Graphics.PixelOffsetMode);
\r
243 [Category("NotWorking")]
\r
244 public void RenderingOriginTest() {
\r
245 Assert.AreEqual(new Point(0,0), t.Graphics.RenderingOrigin);
\r
249 public void SmoothingModeTest() {
\r
250 Assert.AreEqual(SmoothingMode.None, t.Graphics.SmoothingMode);
\r
254 public void TextContrastTest() {
\r
255 Assert.AreEqual(4, t.Graphics.TextContrast);
\r
259 public void TextRenderingHintTest() {
\r
260 Assert.AreEqual(TextRenderingHint.SystemDefault, t.Graphics.TextRenderingHint);
\r
264 public void TransformTest() {
\r
265 Assert.AreEqual(new Matrix(), t.Graphics.Transform);
\r
269 public void VisibleClipBoundsTest() {
\r
270 Assert.AreEqual(new RectangleF(0, 0, 512, 512), t.Graphics.VisibleClipBounds);
\r
278 public class DrawImage {
\r
279 protected DrawingTest t;
\r
280 protected int TOLERANCE = 10; //in %;
\r
281 protected Hashtable st = new Hashtable();
\r
283 Rectangle src = new Rectangle(0, 0, 50, 50);
\r
284 RectangleF srcF = new Rectangle(0, 0, 50, 50);
\r
285 Rectangle dst = new Rectangle(170, 170, 100, 100);
\r
286 RectangleF dstF = new Rectangle(270, 270, 100, 100);
\r
292 public virtual void SetUp() {
\r
293 SetUp("DrawImage");
\r
294 DrawingTest.ShowForms = false;
\r
296 bmp = Bitmap.FromFile("bitmap50.png");
\r
297 bmp2 = Bitmap.FromFile("bitmap25.png");
\r
299 catch(Exception e) {
\r
300 Console.WriteLine(e.Message);
\r
303 public virtual void SetUp(string ownerClass) {
\r
304 t = DrawingTest.Create(512, 512, ownerClass);
\r
305 t.Graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
\r
307 // hashtable of differents tolerance values for specified tests.
\r
310 public void TearDown() {
\r
316 public void DrawImage1() {
\r
317 t.Graphics.DrawImage(bmp, new Point[]{new Point(170,10), new Point(250,0), new Point(100,100)}, src, GraphicsUnit.Pixel );
\r
318 t.Graphics.DrawImage(bmp, new PointF[]{new PointF(70,10), new PointF(150,0), new PointF(10,100)}, srcF, GraphicsUnit.Pixel );
\r
320 Assert.IsTrue(t.Compare());
\r
323 public void DrawImage2() {
\r
324 t.Graphics.DrawImage(bmp, dst, src, GraphicsUnit.Pixel);
\r
325 t.Graphics.DrawImage(bmp, dstF, srcF, GraphicsUnit.Pixel);
\r
327 Assert.IsTrue(t.Compare());
\r
330 public void DrawImage3() {
\r
331 t.Graphics.DrawImage(bmp, 10.0F, 10.0F, srcF, GraphicsUnit.Pixel);
\r
332 t.Graphics.DrawImage(bmp, 70.0F, 150.0F, 250.0F, 150.0F);
\r
334 Assert.IsTrue(t.Compare());
\r
337 public void DrawImage4() {
\r
338 t.Graphics.DrawImage(bmp, dst);
\r
339 t.Graphics.DrawImage(bmp, dstF);
\r
341 Assert.IsTrue(t.Compare());
\r
344 public void DrawImage5() {
\r
345 t.Graphics.SetClip( new Rectangle(70, 0, 20, 200));
\r
346 t.Graphics.DrawImage(bmp, new Point[]{new Point(50,50), new Point(250,30), new Point(100,150)}, src, GraphicsUnit.Pixel );
\r
348 Assert.IsTrue(t.Compare());
\r
351 public void DrawImage6() {
\r
352 t.Graphics.ScaleTransform(2, 2);
\r
353 t.Graphics.SetClip( new Rectangle(70, 0, 20, 200));
\r
354 t.Graphics.DrawImage(bmp, new Point[]{new Point(50,50), new Point(250,30), new Point(100,150)}, src, GraphicsUnit.Pixel );
\r
356 Assert.IsTrue(t.Compare());
\r
359 public void DrawImage7() {
\r
360 t.Graphics.DrawImage(bmp, 170, 70, src, GraphicsUnit.Pixel);
\r
361 t.Graphics.DrawImage(bmp, 70, 350, 350, 150);
\r
363 Assert.IsTrue(t.Compare());
\r
366 public void DrawImage8() {
\r
367 t.Graphics.DrawImage(bmp, new Point[]{new Point(170,10), new Point(250,10), new Point(100,100)} );
\r
368 t.Graphics.DrawImage(bmp, new PointF[]{new PointF(170,100), new PointF(250,100), new PointF(100,190)} );
\r
370 Assert.IsTrue(t.Compare());
\r
373 public void DrawImage9() {
\r
374 t.Graphics.DrawImage(bmp, 0, 0);
\r
375 t.Graphics.DrawImage(bmp, 200, 200);
\r
377 Assert.IsTrue(t.Compare());
\r
380 public void DrawImagePageUnit() {
\r
381 t.Graphics.PageUnit = GraphicsUnit.Document;
\r
382 Point [] p = new Point[]{
\r
383 new Point(100, 100),
\r
384 new Point(200, 100),
\r
388 t.Graphics.DrawImage(bmp2, p, new Rectangle(100, 100, 100, 100), GraphicsUnit.Pixel);
\r
390 Assert.IsTrue(t.Compare());
\r
393 public void DrawImagePageUnit_2() {
\r
394 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
395 t.Graphics.ScaleTransform(0.3f, 0.3f);
\r
396 Point [] p = new Point[]{
\r
397 new Point(100, 100),
\r
398 new Point(200, 100),
\r
402 t.Graphics.DrawImage(bmp2, p, new Rectangle(100, 100, 100, 100), GraphicsUnit.Pixel);
\r
404 Assert.IsTrue(t.Compare());
\r
407 public void DrawImagePageUnit_3() {
\r
408 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
409 t.Graphics.ScaleTransform(0.3f, 0.3f);
\r
410 t.Graphics.DrawImage(bmp2, new Rectangle(100, 100, 100, 100));
\r
412 Assert.IsTrue(t.Compare());
\r
415 public void DrawImagePageUnit_4() {
\r
416 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
417 t.Graphics.ScaleTransform(0.5f, 0.5f);
\r
418 t.Graphics.DrawImage(bmp, 50, 50);
\r
420 Assert.IsTrue(t.Compare());
\r
423 public void DrawImagePageUnitClip() {
\r
424 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
425 t.Graphics.ScaleTransform(0.3f, 0.3f);
\r
426 Point [] p = new Point[]{
\r
427 new Point(100, 100),
\r
428 new Point(200, 100),
\r
432 t.Graphics.SetClip( new Rectangle(120, 120, 50, 100) );
\r
433 t.Graphics.DrawImage(bmp2, p, new Rectangle(100, 100, 100, 100), GraphicsUnit.Pixel);
\r
435 Assert.IsTrue(t.Compare());
\r
439 [Category("NotWorking")] // defect 6145
\r
441 public void DrawImageWithResolution() {
\r
442 t.Graphics.DrawImage(bmp2, 0, 0);
\r
444 Assert.IsTrue(t.Compare());
\r
447 public void DrawImageInContainer1() {
\r
448 t.Graphics.BeginContainer(new Rectangle(10, 10, 50, 50), new Rectangle(70, 70, 100, 100), GraphicsUnit.Pixel);
\r
449 t.Graphics.DrawImage(bmp, 0, 0);
\r
451 Assert.IsTrue(t.Compare());
\r
455 [Category ("NotWorking")] // defect 6145
\r
457 public void DrawImageInContainer2() {
\r
458 t.Graphics.BeginContainer(new Rectangle(10, 10, 50, 50), new Rectangle(70, 70, 100, 100), GraphicsUnit.Pixel);
\r
459 t.Graphics.DrawImage(bmp2, 0, 0);
\r
461 Assert.IsTrue(t.Compare());
\r
464 public void DrawImageInContainer3() {
\r
465 t.Graphics.BeginContainer(new Rectangle(10, 10, 50, 50), new Rectangle(70, 70, 100, 100), GraphicsUnit.Pixel);
\r
466 t.Graphics.SetClip( new Rectangle(0, 0, 15, 15) );
\r
467 t.Graphics.ScaleTransform(0.5f, 0.5f);
\r
468 t.Graphics.DrawImage(bmp2, 0, 0);
\r
470 Assert.IsTrue(t.Compare());
\r
473 public void DrawImageInContainer4() {
\r
474 Point [] p = new Point[]{
\r
475 new Point(100, 100),
\r
476 new Point(200, 100),
\r
480 t.Graphics.SetClip( new Rectangle(70, 70, 70, 70) );
\r
481 GraphicsContainer c = t.Graphics.BeginContainer( new Rectangle(20, 20, 10, 10), new Rectangle(77, 77, 7, 7), GraphicsUnit.Pixel);
\r
482 t.Graphics.DrawImage(bmp2, p, new Rectangle(100, 100, 100, 100), GraphicsUnit.Pixel);
\r
483 t.Graphics.EndContainer( c );
\r
485 Assert.IsTrue(t.Compare());
\r
490 #region GraphicsFixtureFillModes
\r
492 public class GraphicsFixtureFillModes {
\r
493 protected DrawingTest t;
\r
494 protected int TOLERANCE = 3; //in %;
\r
497 public virtual void SetUp() {
\r
498 SetUp("GraphicsFixtureFillModes");
\r
500 public virtual void SetUp(string ownerClass) {
\r
501 t = DrawingTest.Create(512, 512, ownerClass);
\r
504 public void TearDown() {
\r
510 public void FillModeAlternate() {
\r
511 GraphicsPath p = new GraphicsPath();
\r
512 Assert.AreEqual(FillMode.Alternate, p.FillMode);
\r
515 public void FillModeAlternate_1() {
\r
516 Point [] p = new Point[] {
\r
517 new Point(50, 100),
\r
519 new Point(90, 100),
\r
520 new Point(140, 10),
\r
521 new Point(150, 100),
\r
522 new Point(170, 10),
\r
526 GraphicsPath path = new GraphicsPath();
\r
527 path.AddLines( p );
\r
528 path.FillMode = FillMode.Alternate;
\r
529 t.Graphics.FillPath( Brushes.Blue, path );
\r
531 Assert.IsTrue(t.PDCompare());
\r
534 public void FillModeAlternate_2() {
\r
536 Rectangle r1 = new Rectangle(100, 100, 100, 100);
\r
537 Rectangle r2 = new Rectangle(125, 125, 50, 50);
\r
538 GraphicsPath path = new GraphicsPath();
\r
539 path.AddRectangle( r1 );
\r
540 path.AddRectangle( r2 );
\r
541 path.FillMode = FillMode.Alternate;
\r
542 t.Graphics.FillPath( Brushes.Blue, path );
\r
544 Assert.IsTrue(t.PDCompare());
\r
547 public void FillModeAlternate_3() {
\r
548 Point [] p = new Point[] {
\r
549 new Point(50, 100),
\r
550 new Point(150, 50),
\r
551 new Point(250, 100),
\r
553 new Point(250, 50),
\r
557 GraphicsPath path = new GraphicsPath();
\r
558 path.AddLines( p );
\r
559 path.FillMode = FillMode.Alternate;
\r
560 t.Graphics.FillPath( Brushes.Blue, path );
\r
562 Assert.IsTrue(t.PDCompare());
\r
565 public void FillModeWinding_1() {
\r
566 Point [] p = new Point[] {
\r
567 new Point(50, 100),
\r
569 new Point(90, 100),
\r
570 new Point(140, 10),
\r
571 new Point(150, 100),
\r
572 new Point(170, 10),
\r
576 GraphicsPath path = new GraphicsPath();
\r
577 path.AddLines( p );
\r
578 path.FillMode = FillMode.Winding;
\r
579 t.Graphics.FillPath( Brushes.Blue, path );
\r
581 Assert.IsTrue(t.PDCompare());
\r
584 public void FillModeWinding_2() {
\r
586 Rectangle r1 = new Rectangle(100, 100, 100, 100);
\r
587 Rectangle r2 = new Rectangle(125, 125, 50, 50);
\r
588 GraphicsPath path = new GraphicsPath();
\r
589 path.AddRectangle( r1 );
\r
590 path.AddRectangle( r2 );
\r
591 path.FillMode = FillMode.Winding;
\r
592 t.Graphics.FillPath( Brushes.Blue, path );
\r
594 Assert.IsTrue(t.PDCompare());
\r
597 public void FillModeWinding_3() {
\r
598 Point [] p = new Point[] {
\r
599 new Point(50, 100),
\r
600 new Point(150, 50),
\r
601 new Point(250, 100),
\r
603 new Point(250, 50),
\r
607 GraphicsPath path = new GraphicsPath();
\r
608 path.AddLines( p );
\r
609 path.FillMode = FillMode.Winding;
\r
610 t.Graphics.FillPath( Brushes.Blue, path );
\r
612 Assert.IsTrue(t.PDCompare());
\r
619 #region GraphicsFixture
\r
621 /// Summary description for Graphics.
\r
624 public class GraphicsFixture {
\r
625 protected DrawingTest t;
\r
626 protected int TOLERANCE = 3; //in %;
\r
627 protected Hashtable st = new Hashtable();
\r
630 public virtual void SetUp() {
\r
631 SetUp("GraphicsFixture");
\r
633 public virtual void SetUp(string ownerClass) {
\r
634 t = DrawingTest.Create(512, 512, ownerClass);
\r
636 // hashtable of differents tolerance values for specified tests. (for fft comparer)
\r
637 st["DrawArcTest:6"] = TOLERANCE * 2.5f;
\r
638 st["DrawCurveTestF:4"] = TOLERANCE * 2f;
\r
639 st["DrawPolygonPoint:2"] = TOLERANCE * 2f;
\r
640 st["DrawPolygonPointF:2"] = TOLERANCE * 2f;
\r
641 st["DrawStringFloatFormat:2"] = TOLERANCE * 2f; // in .net the font is shmoothed
\r
642 st["DrawStringFloatFormat:4"] = TOLERANCE * 2.5f; // in .net the font is shmoothed
\r
643 st["DrawStringFloatFormat:6"] = TOLERANCE * 2.5f; // in .net the font is shmoothed
\r
644 st["RotateTransformAngleMatrixOrder1:2"] = TOLERANCE * 2f; // Line width problem
\r
645 st["ScaleTransformFloatMatrixOrder:2"] = TOLERANCE * 2f; // Line width problem
\r
646 st["TranslateTransformAngleMatrixOrder:2"] = TOLERANCE * 2f; // Line width problem
\r
647 t.SpecialTolerance = st;
\r
651 public void TearDown ()
\r
658 public virtual void BeginContainerTest() {
\r
659 // Define transformation for container.
\r
660 RectangleF srcRect = new RectangleF(0.0F, 0.0F, 200.0F, 200.0F);
\r
661 RectangleF destRect = new RectangleF(100.0F, 100.0F, 150.0F, 150.0F);
\r
662 // Begin graphics container.
\r
663 GraphicsContainer containerState = t.Graphics.BeginContainer(
\r
665 GraphicsUnit.Pixel);
\r
666 // Fill red rectangle in container.
\r
667 t.Graphics.FillRectangle(new SolidBrush(Color.Red), 0.0F, 0.0F, 200.0F, 200.0F);
\r
669 // End graphics container.
\r
670 t.Graphics.EndContainer(containerState);
\r
671 // Fill untransformed rectangle with green.
\r
672 t.Graphics.FillRectangle(new SolidBrush(Color.Green), 0.0F, 0.0F, 200.0F, 200.0F);
\r
674 Assert.IsTrue(t.PDCompare());
\r
678 public void MeasureString () {
\r
679 Bitmap bmp = new Bitmap (400, 300, PixelFormat.Format32bppArgb);
\r
680 Graphics graphics = Graphics.FromImage (bmp);
\r
681 graphics.PageUnit = GraphicsUnit.Point;
\r
683 string drawString = "Sample Text in points";
\r
684 Font drawFont = new Font ("Arial Black", 70, FontStyle.Regular);
\r
685 SolidBrush drawBrush = new SolidBrush (Color.Blue);
\r
687 float netWidth1 = 836.1719f;
\r
688 float netWidth2 = 1114.896f;
\r
689 float netHeight1 = 98.71094f;
\r
690 float netHeight2 = 131.6146f;
\r
692 SizeF size = graphics.MeasureString (drawString, drawFont, new PointF (0, 0), StringFormat.GenericTypographic);
\r
694 Assert.IsTrue (Math.Abs (size.Width - netWidth1) / netWidth1 < 0.01);
\r
695 Assert.IsTrue (Math.Abs (size.Height - netHeight1) / netHeight1 < 0.01);
\r
697 graphics.PageUnit = GraphicsUnit.Pixel;
\r
698 size = graphics.MeasureString (drawString, drawFont, new PointF (0, 0), StringFormat.GenericTypographic);
\r
700 Assert.IsTrue (Math.Abs (size.Width - netWidth2) / netWidth2 < 0.01);
\r
701 Assert.IsTrue (Math.Abs (size.Height - netHeight2) / netHeight2 < 0.01);
\r
705 public virtual void BeginContainerTest_2() {
\r
706 t.Graphics.DrawRectangle( Pens.Black, new Rectangle(70, 70, 50, 100) );
\r
707 t.Graphics.DrawRectangle( Pens.Black, new Rectangle(50, 100, 150, 50) );
\r
708 t.Graphics.DrawRectangle( Pens.Black, new Rectangle(80, 120, 10, 10) );
\r
710 t.Graphics.SetClip( new Rectangle(70, 70, 50, 100) );
\r
711 t.Graphics.Clear( Color.Blue );
\r
713 GraphicsContainer c1 = t.Graphics.BeginContainer();
\r
714 t.Graphics.SetClip( new Rectangle(50, 100, 150, 50) );
\r
715 t.Graphics.Clear( Color.Green );
\r
717 GraphicsContainer c2 = t.Graphics.BeginContainer();
\r
718 t.Graphics.SetClip( new Rectangle(80, 120, 10, 10) );
\r
719 t.Graphics.Clear( Color.Red );
\r
721 t.Graphics.EndContainer( c2 );
\r
722 t.Graphics.FillRectangle( Brushes.Yellow, new Rectangle(100, 120, 10, 10) );
\r
723 t.Graphics.FillRectangle( Brushes.Yellow, new Rectangle(150, 120, 10, 10) );
\r
725 t.Graphics.EndContainer( c1 );
\r
726 t.Graphics.FillRectangle( Brushes.Yellow, new Rectangle(100, 80, 10, 10) );
\r
727 t.Graphics.FillRectangle( Brushes.Yellow, new Rectangle(150, 80, 10, 10) );
\r
730 Assert.IsTrue(t.PDCompare());
\r
733 public virtual void ClearTest() {
\r
734 // Clear screen with teal background.
\r
736 Assert.IsTrue(t.PDCompare());
\r
737 t.Graphics.Clear(Color.Teal);
\r
739 Assert.IsTrue(t.PDCompare());
\r
743 public virtual void DrawArcTest() {
\r
745 Pen blackPen= new Pen(Color.Black, 1);
\r
746 // Create coordinates of rectangle to bound ellipse.
\r
749 float width = 400.0F;
\r
750 float height = 100.0F;
\r
751 // Create start and sweep angles on ellipse.
\r
752 float startAngle = 370.0F;
\r
753 float sweepAngle = 70.0F;
\r
754 // Draw arc to screen.
\r
755 t.Graphics.DrawArc(blackPen, (int)x, (int)y, (int)width, (int)height, (int)startAngle, (int)sweepAngle);
\r
757 Assert.IsTrue(t.PDCompare());
\r
759 startAngle = 10.0F;
\r
760 sweepAngle = 120.0F;
\r
761 t.Graphics.DrawArc(blackPen, new Rectangle((int)x, (int)y, (int)width, (int)height), startAngle, sweepAngle);
\r
763 Assert.IsTrue(t.PDCompare());
\r
765 startAngle = 10.0F;
\r
766 sweepAngle = 190.0F;
\r
767 t.Graphics.DrawArc(blackPen, x, y, width, height, startAngle, sweepAngle);
\r
769 Assert.IsTrue(t.PDCompare());
\r
771 startAngle = 10.0F;
\r
772 sweepAngle = 300.0F;
\r
773 t.Graphics.DrawArc(blackPen, new RectangleF(x, y, width, height), startAngle, sweepAngle);
\r
775 Assert.IsTrue(t.PDCompare());
\r
777 startAngle = -179.9F;
\r
778 sweepAngle = -359.9F;
\r
779 t.Graphics.DrawArc(blackPen, new RectangleF(x, y, width, height), startAngle, sweepAngle);
\r
781 Assert.IsTrue(t.PDCompare());
\r
783 startAngle = -10.0F;
\r
784 sweepAngle = -300.0F;
\r
785 t.Graphics.DrawArc(blackPen, new RectangleF(x, y, width, height), startAngle, sweepAngle);
\r
787 Assert.IsTrue(t.PDCompare());
\r
791 public virtual void DrawBezierTest() {
\r
793 Pen blackPen = new Pen(Color.Black, 3);
\r
794 // Create coordinates of points for curve.
\r
795 float startX = 100.0F;
\r
796 float startY = 100.0F;
\r
797 float controlX1 = 200.0F;
\r
798 float controlY1 = 10.0F;
\r
799 float controlX2 = 350.0F;
\r
800 float controlY2 = 50.0F;
\r
801 float endX = 500.0F;
\r
802 float endY = 100.0F;
\r
803 // Draw arc to screen.
\r
804 t.Graphics.DrawBezier(blackPen, startX, startY,
\r
805 controlX1, controlY1,
\r
806 controlX2, controlY2,
\r
809 Assert.IsTrue(t.PDCompare());
\r
811 t.Graphics.DrawBezier(blackPen, new PointF( startX, startY),
\r
812 new PointF(controlX1, controlY1),
\r
813 new PointF(controlX2, controlY2),
\r
814 new PointF(endX, endY));
\r
816 Assert.IsTrue(t.PDCompare());
\r
818 t.Graphics.DrawBezier(blackPen, new Point((int)startX, (int)startY),
\r
819 new Point((int)controlX1, (int)controlY1),
\r
820 new Point((int)controlX2, (int)controlY2),
\r
821 new Point((int)endX, (int)endY));
\r
823 Assert.IsTrue(t.PDCompare());
\r
827 public virtual void DrawBeziersTest() {
\r
829 Pen blackPen = new Pen(Color.Black, 3);
\r
830 // Create points for curve.
\r
831 Point start = new Point(100, 100);
\r
832 Point control1 = new Point(200, 10);
\r
833 Point control2 = new Point(350, 50);
\r
834 Point end1 = new Point(500, 100);
\r
835 Point control3 = new Point(600, 150);
\r
836 Point control4 = new Point(650, 250);
\r
837 Point end2 = new Point(500, 300);
\r
838 Point[] bezierPoints = {
\r
839 start, control1, control2, end1,
\r
840 control3, control4, end2
\r
842 // Draw arc to screen.
\r
843 t.Graphics.DrawBeziers(blackPen, bezierPoints);
\r
845 Assert.IsTrue(t.PDCompare());
\r
848 PointF startF = new PointF(100.0F, 100.0F);
\r
849 PointF control1F = new PointF(200.0F, 10.0F);
\r
850 PointF control2F = new PointF(350.0F, 50.0F);
\r
851 PointF end1F = new PointF(500.0F, 100.0F);
\r
852 PointF control3F = new PointF(600.0F, 150.0F);
\r
853 PointF control4F = new PointF(650.0F, 250.0F);
\r
854 PointF end2F = new PointF(500.0F, 300.0F);
\r
855 PointF[] bezierPointsF = {
\r
856 startF, control1F, control2F, end1F,
\r
857 control3F, control4F, end2F
\r
859 // Draw arc to screen.
\r
860 t.Graphics.DrawBeziers(blackPen, bezierPointsF);
\r
862 Assert.IsTrue(t.PDCompare());
\r
866 public virtual void DrawClosedCurveTest() {
\r
868 Pen redPen = new Pen(Color.Red, 3);
\r
869 Pen greenPen = new Pen(Color.Green, 3);
\r
870 // Create points that define curve.
\r
871 PointF point1 = new PointF( 50.0F, 50.0F);
\r
872 PointF point2 = new PointF(100.0F, 25.0F);
\r
873 PointF point3 = new PointF(200.0F, 5.0F);
\r
874 PointF point4 = new PointF(250.0F, 50.0F);
\r
875 PointF point5 = new PointF(300.0F, 100.0F);
\r
876 PointF point6 = new PointF(350.0F, 200.0F);
\r
877 PointF point7 = new PointF(250.0F, 250.0F);
\r
878 PointF[] curvePoints = {
\r
887 // Draw lines between original points to screen.
\r
888 t.Graphics.DrawLines(redPen, curvePoints);
\r
889 // Create tension and fill mode.
\r
890 float tension = 0.7F;
\r
891 FillMode aFillMode = FillMode.Alternate;
\r
892 // Draw closed curve to screen.
\r
893 t.Graphics.DrawClosedCurve(greenPen, curvePoints, tension, aFillMode);
\r
895 Assert.IsTrue(t.PDCompare());
\r
898 aFillMode = FillMode.Winding;
\r
899 // Draw closed curve to screen.
\r
900 t.Graphics.DrawClosedCurve(greenPen, curvePoints, tension, aFillMode);
\r
902 Assert.IsTrue(t.PDCompare());
\r
906 public virtual void DrawCurveTest() {
\r
908 Pen redPen = new Pen(Color.Red, 3);
\r
909 Pen greenPen = new Pen(Color.Green, 3);
\r
910 // Create points that define curve.
\r
911 Point point1 = new Point( 50, 50);
\r
912 Point point2 = new Point(100, 25);
\r
913 Point point3 = new Point(200, 5);
\r
914 Point point4 = new Point(250, 50);
\r
915 Point point5 = new Point(300, 100);
\r
916 Point point6 = new Point(350, 200);
\r
917 Point point7 = new Point(250, 250);
\r
918 Point[] curvePoints = {
\r
927 // Draw lines between original points to screen.
\r
928 t.Graphics.DrawLines(redPen, curvePoints);
\r
929 // Create offset, number of segments, and tension.
\r
931 int numSegments = 4;
\r
932 float tension = 0.7F;
\r
933 // Draw curve to screen.
\r
934 t.Graphics.DrawCurve(greenPen, curvePoints, offset, numSegments, tension);
\r
936 Assert.IsTrue(t.PDCompare());
\r
939 t.Graphics.DrawCurve(greenPen, curvePoints, tension);
\r
941 Assert.IsTrue(t.PDCompare());
\r
944 t.Graphics.DrawCurve(greenPen, curvePoints);
\r
946 Assert.IsTrue(t.PDCompare());
\r
950 public virtual void DrawCurveTestF() {
\r
952 Pen redPen = new Pen(Color.Red, 3);
\r
953 Pen greenPen = new Pen(Color.Green, 3);
\r
954 // Create points that define curve.
\r
955 PointF point1 = new PointF( 50.0F, 50.0F);
\r
956 PointF point2 = new PointF(100.0F, 25.0F);
\r
957 PointF point3 = new PointF(200.0F, 5.0F);
\r
958 PointF point4 = new PointF(250.0F, 50.0F);
\r
959 PointF point5 = new PointF(300.0F, 100.0F);
\r
960 PointF point6 = new PointF(350.0F, 200.0F);
\r
961 PointF point7 = new PointF(250.0F, 250.0F);
\r
962 PointF[] curvePoints = {
\r
971 // Draw lines between original points to screen.
\r
972 t.Graphics.DrawLines(redPen, curvePoints);
\r
973 // Create offset, number of segments, and tension.
\r
975 int numSegments = 4;
\r
976 float tension = 0.7F;
\r
977 // Draw curve to screen.
\r
978 t.Graphics.DrawCurve(greenPen, curvePoints, offset, numSegments, tension);
\r
980 Assert.IsTrue(t.PDCompare());
\r
983 t.Graphics.DrawCurve(greenPen, curvePoints, offset, numSegments);
\r
985 Assert.IsTrue(t.PDCompare());
\r
988 t.Graphics.DrawCurve(greenPen, curvePoints, tension);
\r
990 Assert.IsTrue(t.PDCompare());
\r
993 t.Graphics.DrawCurve(greenPen, curvePoints);
\r
995 Assert.IsTrue(t.PDCompare());
\r
999 public virtual void DrawEllipseTest() {
\r
1001 Pen blackPen = new Pen(Color.Black, 3);
\r
1002 // Create location and size of ellipse.
\r
1007 // Draw ellipse to screen.
\r
1008 t.Graphics.DrawEllipse(blackPen, x, y, width, height);
\r
1010 Assert.IsTrue(t.PDCompare());
\r
1013 t.Graphics.DrawEllipse(blackPen, new Rectangle(x, y, width, height));
\r
1015 Assert.IsTrue(t.PDCompare());
\r
1019 public virtual void DrawEllipseTestF() {
\r
1021 Pen blackPen = new Pen(Color.Black, 3);
\r
1022 // Create location and size of ellipse.
\r
1025 float width = 200.0F;
\r
1026 float height = 100.0F;
\r
1027 // Draw ellipse to screen.
\r
1028 t.Graphics.DrawEllipse(blackPen, x, y, width, height);
\r
1030 Assert.IsTrue(t.PDCompare());
\r
1033 t.Graphics.DrawEllipse(blackPen, new RectangleF(x, y, width, height));
\r
1035 Assert.IsTrue(t.PDCompare());
\r
1038 static string getInFile (string file) {
\r
1041 sRslt = Path.GetFullPath (file);
\r
1043 if (! File.Exists (file))
\r
1044 sRslt = Path.Combine (
\r
1045 Path.Combine ("..", ".."),
\r
1052 [Category("NotWorking")]
\r
1053 public virtual void DrawIconTest() {
\r
1055 Icon newIcon = new Icon(getInFile ("SampIcon.ico"));
\r
1056 // Create coordinates for upper-left corner of icon.
\r
1059 // Draw icon to screen.
\r
1060 t.Graphics.DrawIcon(newIcon, x, y);
\r
1062 Assert.IsTrue(t.PDCompare());
\r
1064 t.Graphics.DrawIcon(newIcon, new Rectangle(200, 300, 125, 345));
\r
1066 Assert.IsTrue(t.PDCompare());
\r
1070 [Category("NotWorking")]
\r
1071 public virtual void DrawIconUnstretchedTest() {
\r
1073 Icon newIcon = new Icon(getInFile ("SampIcon.ico"));
\r
1074 // Create rectangle for icon.
\r
1075 Rectangle rect = new Rectangle( 100, 100, 200, 200);
\r
1076 // Draw icon to screen.
\r
1077 t.Graphics.DrawIconUnstretched(newIcon, rect);
\r
1079 Assert.IsTrue(t.PDCompare());
\r
1081 #if INTPTR_SUPPORTED
\r
1082 // Define DrawImageAbort callback method.
\r
1083 private bool DrawImageCallback(IntPtr callBackData) {
\r
1084 // Test for call that passes callBackData parameter.
\r
1085 if(callBackData==IntPtr.Zero) {
\r
1086 // If no callBackData passed, abort DrawImage method.
\r
1090 // If callBackData passed, continue DrawImage method.
\r
1095 [Test] //TBD: add more overrides
\r
1096 public void DrawImageTest() {
\r
1097 // Create callback method.
\r
1098 Graphics.DrawImageAbort imageCallback
\r
1099 = new Graphics.DrawImageAbort(DrawImageCallback);
\r
1100 IntPtr imageCallbackData = new IntPtr(1);
\r
1102 Image newImage = Image.FromFile("SampIcon.ico");
\r
1103 // Create rectangle for displaying original image.
\r
1104 Rectangle destRect1 = new Rectangle( 100, 25, 450, 150);
\r
1105 // Create coordinates of rectangle for source image.
\r
1108 float width = 150.0F;
\r
1109 float height = 150.0F;
\r
1110 GraphicsUnit units = GraphicsUnit.Pixel;
\r
1111 // Draw original image to screen.
\r
1112 t.Graphics.DrawImage(newImage, destRect1, x, y, width, height, units);
\r
1114 // Create rectangle for adjusted image.
\r
1115 Rectangle destRect2 = new Rectangle(100, 175, 450, 150);
\r
1116 // Create image attributes and set large gamma.
\r
1117 ImageAttributes imageAttr = new ImageAttributes();
\r
1118 imageAttr.SetGamma(4.0F);
\r
1119 // Draw adjusted image to screen.
\r
1121 t.Graphics.DrawImage(
\r
1129 imageCallbackData);
\r
1135 [Category("NotWorking")]
\r
1136 public virtual void DrawImageUnscaledTest() {
\r
1138 Image newImage = Bitmap.FromFile(getInFile ("bitmap_gh.png"));
\r
1139 // Create coordinates for upper-left corner of image.
\r
1142 // Draw image to screen.
\r
1143 t.Graphics.DrawImageUnscaled(newImage, x, y, 100, 125);
\r
1145 Assert.IsTrue(t.PDCompare());
\r
1148 t.Graphics.DrawImageUnscaled(newImage, new Rectangle(x, y, 34, 235));
\r
1150 Assert.IsTrue(t.PDCompare());
\r
1153 t.Graphics.DrawImageUnscaled(newImage, x, y);
\r
1155 Assert.IsTrue(t.PDCompare());
\r
1158 t.Graphics.DrawImageUnscaled(newImage, new Point(x, y));
\r
1160 Assert.IsTrue(t.PDCompare());
\r
1164 public virtual void DrawLineTest() {
\r
1166 Pen blackPen = new Pen(Color.Black, 3);
\r
1167 // Create coordinates of points that define line.
\r
1172 // Draw line to screen.
\r
1173 t.Graphics.DrawLine(blackPen, x1, y1, x2, y2);
\r
1175 Assert.IsTrue(t.PDCompare());
\r
1178 t.Graphics.DrawLine(blackPen, new Point( x1, y1), new Point( x2, y2));
\r
1180 Assert.IsTrue(t.PDCompare());
\r
1184 public virtual void DrawLineTestF() {
\r
1186 Pen blackPen = new Pen(Color.Black, 3);
\r
1187 // Create coordinates of points that define line.
\r
1188 float x1 = 100.0F;
\r
1189 float y1 = 100.0F;
\r
1190 float x2 = 500.0F;
\r
1191 float y2 = 100.0F;
\r
1192 // Draw line to screen.
\r
1193 t.Graphics.DrawLine(blackPen, x1, y1, x2, y2);
\r
1195 Assert.IsTrue(t.PDCompare());
\r
1198 t.Graphics.DrawLine(blackPen, new PointF( x1, y1), new PointF( x2, y2));
\r
1200 Assert.IsTrue(t.PDCompare());
\r
1204 public virtual void DrawLinesTest() {
\r
1206 Pen pen = new Pen(Color.Black, 3);
\r
1207 // Create array of points that define lines to draw.
\r
1208 Point[] points = {
\r
1209 new Point( 10, 10),
\r
1210 new Point( 10, 100),
\r
1211 new Point(200, 50),
\r
1212 new Point(250, 300)
\r
1214 //Draw lines to screen.
\r
1215 t.Graphics.DrawLines(pen, points);
\r
1217 Assert.IsTrue(t.PDCompare());
\r
1221 public virtual void DrawLinesTestF() {
\r
1223 Pen pen = new Pen(Color.Black, 3);
\r
1224 // Create array of points that define lines to draw.
\r
1225 PointF[] points = {
\r
1226 new PointF( 10.0F, 10.0F),
\r
1227 new PointF( 10.0F, 100.0F),
\r
1228 new PointF(200.0F, 50.0F),
\r
1229 new PointF(250.0F, 300.0F)
\r
1231 //Draw lines to screen.
\r
1232 t.Graphics.DrawLines(pen, points);
\r
1234 Assert.IsTrue(t.PDCompare());
\r
1238 public virtual void DrawPathTest() {
\r
1239 // Create graphics path object and add ellipse.
\r
1240 GraphicsPath graphPath = new GraphicsPath();
\r
1241 graphPath.AddEllipse(0, 0, 200, 100);
\r
1243 Pen blackPen = new Pen(Color.Black, 3);
\r
1244 // Draw graphics path to screen.
\r
1245 t.Graphics.DrawPath(blackPen, graphPath);
\r
1247 Assert.IsTrue(t.PDCompare());
\r
1251 public virtual void DrawPieTestF() {
\r
1253 Pen blackPen = new Pen(Color.Black, 3);
\r
1254 // Create location and size of ellipse.
\r
1257 float width = 200.0F;
\r
1258 float height = 100.0F;
\r
1259 // Create start and sweep angles.
\r
1260 float startAngle = 0.0F;
\r
1261 float sweepAngle = 45.0F;
\r
1262 // Draw pie to screen.
\r
1263 t.Graphics.DrawPie(blackPen, x, y, width, height, startAngle, sweepAngle);
\r
1265 Assert.IsTrue(t.PDCompare());
\r
1268 t.Graphics.DrawPie(blackPen, new RectangleF( x, y, width, height), startAngle, sweepAngle);
\r
1270 Assert.IsTrue(t.PDCompare());
\r
1274 public virtual void DrawPieTest() {
\r
1276 Pen blackPen = new Pen(Color.Black, 3);
\r
1277 // Create location and size of ellipse.
\r
1282 // Create start and sweep angles.
\r
1283 int startAngle = 0;
\r
1284 int sweepAngle = 45;
\r
1285 // Draw pie to screen.
\r
1286 t.Graphics.DrawPie(blackPen, x, y, width, height, startAngle, sweepAngle);
\r
1288 Assert.IsTrue(t.PDCompare());
\r
1291 t.Graphics.DrawPie(blackPen, new Rectangle( x, y, width, height), startAngle, sweepAngle);
\r
1293 Assert.IsTrue(t.PDCompare());
\r
1297 public virtual void DrawPolygonPoint() {
\r
1299 Pen blackPen = new Pen(Color.Black, 3);
\r
1300 // Create points that define polygon.
\r
1301 Point point1 = new Point( 50, 50);
\r
1302 Point point2 = new Point(100, 25);
\r
1303 Point point3 = new Point(200, 5);
\r
1304 Point point4 = new Point(250, 50);
\r
1305 Point point5 = new Point(300, 100);
\r
1306 Point point6 = new Point(350, 200);
\r
1307 Point point7 = new Point(250, 250);
\r
1308 Point[] curvePoints = {
\r
1317 // Draw polygon to screen.
\r
1318 t.Graphics.DrawPolygon(blackPen, curvePoints);
\r
1320 Assert.IsTrue(t.PDCompare()); // .NET's lines of polygon is more wide
\r
1324 public virtual void DrawPolygonPointF() {
\r
1326 Pen blackPen = new Pen(Color.Black, 3);
\r
1327 // Create points that define polygon.
\r
1328 PointF point1 = new PointF( 50, 50);
\r
1329 PointF point2 = new PointF(100, 25);
\r
1330 PointF point3 = new PointF(200, 5);
\r
1331 PointF point4 = new PointF(250, 50);
\r
1332 PointF point5 = new PointF(300, 100);
\r
1333 PointF point6 = new PointF(350, 200);
\r
1334 PointF point7 = new PointF(250, 250);
\r
1335 PointF[] curvePoints = {
\r
1344 // Draw polygon to screen.
\r
1345 t.Graphics.DrawPolygon(blackPen, curvePoints);
\r
1347 Assert.IsTrue(t.PDCompare());
\r
1351 public virtual void DrawRectangleFloat() {
\r
1353 Pen blackPen = new Pen(Color.Black, 3);
\r
1354 // Create location and size of rectangle.
\r
1357 float width = 200.0F;
\r
1358 float height = 200.0F;
\r
1359 // Draw rectangle to screen.
\r
1360 t.Graphics.DrawRectangle(blackPen, x, y, width, height);
\r
1362 Assert.IsTrue(t.PDCompare());
\r
1365 t.Graphics.DrawRectangle(blackPen, (int)x, (int)y, (int)width, (int)height);
\r
1367 Assert.IsTrue(t.PDCompare());
\r
1370 t.Graphics.DrawRectangle(blackPen, new Rectangle( (int)x, (int)y, (int)width, (int)height));
\r
1372 Assert.IsTrue(t.PDCompare());
\r
1376 public virtual void DrawRectanglesRectangleF() {
\r
1378 Pen blackPen = new Pen(Color.Black, 3);
\r
1379 // Create array of rectangles.
\r
1380 RectangleF[] rects = {
\r
1381 new RectangleF( 20.0F, 20.0F, 100.0F, 200.0F),
\r
1382 new RectangleF(100.0F, 200.0F, 250.0F, 50.0F),
\r
1383 new RectangleF(300.0F, 20.0F, 50.0F, 100.0F)
\r
1385 // Draw rectangles to screen.
\r
1386 t.Graphics.DrawRectangles(blackPen, rects);
\r
1388 Assert.IsTrue(t.PDCompare());
\r
1392 public virtual void DrawRectanglesRectangle() {
\r
1394 Pen blackPen = new Pen(Color.Black, 3);
\r
1395 // Create array of rectangles.
\r
1396 Rectangle[] rects = {
\r
1397 new Rectangle( 20, 20, 100, 200),
\r
1398 new Rectangle(100, 200, 250, 50),
\r
1399 new Rectangle(300, 20, 50, 100)
\r
1401 // Draw rectangles to screen.
\r
1402 t.Graphics.DrawRectangles(blackPen, rects);
\r
1404 Assert.IsTrue(t.PDCompare());
\r
1407 [Test] //TBD: add more combinations
\r
1408 [Category("NotWorking")]
\r
1409 public virtual void DrawStringFloatFormat() {
\r
1410 // Create string to draw.
\r
1411 String drawString = "Sample Text";
\r
1412 // Create font and brush.
\r
1413 Font drawFont = new Font("Arial", 34, FontStyle.Italic);
\r
1414 SolidBrush drawBrush = new SolidBrush(Color.Black);
\r
1415 // Create point for upper-left corner of drawing.
\r
1418 // Set format of string.
\r
1419 StringFormat drawFormat = new StringFormat();
\r
1420 drawFormat.FormatFlags = StringFormatFlags.DirectionVertical;
\r
1421 // Draw string to screen.
\r
1422 t.Graphics.DrawString(drawString, drawFont, drawBrush, x, y, drawFormat);
\r
1424 Assert.IsTrue(t.PDCompare()); // in .net the font is shmoothed
\r
1427 drawFormat.FormatFlags = StringFormatFlags.NoClip;
\r
1428 // Draw string to screen.
\r
1429 t.Graphics.DrawString(drawString, drawFont, drawBrush, x, y, drawFormat);
\r
1431 Assert.IsTrue(t.PDCompare());
\r
1434 drawFormat.FormatFlags = StringFormatFlags.FitBlackBox;
\r
1435 // Draw string to screen.
\r
1436 t.Graphics.DrawString(drawString, drawFont, drawBrush, x, y, drawFormat);
\r
1438 Assert.IsTrue(t.PDCompare());
\r
1442 public virtual void EndContainerState() {
\r
1443 // Begin graphics container.
\r
1444 GraphicsContainer containerState = t.Graphics.BeginContainer();
\r
1445 // Translate world transformation.
\r
1446 t.Graphics.TranslateTransform(100.0F, 100.0F);
\r
1447 // Fill translated rectangle in container with red.
\r
1448 t.Graphics.FillRectangle(new SolidBrush(Color.Red), 0, 0, 200, 200);
\r
1450 // End graphics container.
\r
1451 t.Graphics.EndContainer(containerState);
\r
1452 // Fill untransformed rectangle with green.
\r
1453 t.Graphics.FillRectangle(new SolidBrush(Color.Green), 0, 0, 200, 200);
\r
1455 Assert.IsTrue(t.PDCompare());
\r
1459 public virtual void EnumerateMetafile() {
\r
1463 public virtual void ExcludeClipRegion() {
\r
1464 // Create rectangle for exclusion.
\r
1465 Rectangle excludeRect = new Rectangle(100, 100, 200, 200);
\r
1466 // Set clipping region to exclude rectangle.
\r
1467 t.Graphics.ExcludeClip(excludeRect);
\r
1468 // Fill large rectangle to show clipping region.
\r
1469 t.Graphics.FillRectangle(new SolidBrush(Color.Blue), 0, 0, 300, 300);
\r
1471 Assert.IsTrue(t.PDCompare());
\r
1475 public virtual void FillClosedCurvePointFillModeTension() {
\r
1476 // Create solid brush.
\r
1477 SolidBrush redBrush = new SolidBrush(Color.Red);
\r
1478 // Create array of points for curve.
\r
1479 Point point1 = new Point(100, 100);
\r
1480 Point point2 = new Point(200, 50);
\r
1481 Point point3 = new Point(250, 200);
\r
1482 Point point4 = new Point( 50, 150);
\r
1483 Point[] points = {point1, point2, point3, point4};
\r
1485 FillMode newFillMode = FillMode.Winding;
\r
1487 float tension = 0.68F;
\r
1488 // Fill curve on screen.
\r
1489 t.Graphics.FillClosedCurve(redBrush, points);
\r
1491 Assert.IsTrue(t.PDCompare());
\r
1494 t.Graphics.FillClosedCurve(redBrush, points, newFillMode);
\r
1496 Assert.IsTrue(t.PDCompare());
\r
1499 newFillMode = FillMode.Alternate;
\r
1500 t.Graphics.FillClosedCurve(redBrush, points, newFillMode, tension);
\r
1502 Assert.IsTrue(t.PDCompare());
\r
1506 public virtual void FillClosedCurvePointFFillModeTension() {
\r
1507 // Create solid brush.
\r
1508 SolidBrush redBrush = new SolidBrush(Color.Red);
\r
1509 // Create array of points for curve.
\r
1510 PointF point1 = new PointF(100.0F, 100.0F);
\r
1511 PointF point2 = new PointF(200.0F, 50.0F);
\r
1512 PointF point3 = new PointF(250.0F, 200.0F);
\r
1513 PointF point4 = new PointF( 50.0F, 150.0F);
\r
1514 PointF[] points = {point1, point2, point3, point4};
\r
1516 FillMode newFillMode = FillMode.Winding;
\r
1518 float tension = 0.68F;
\r
1519 // Fill curve on screen.
\r
1520 t.Graphics.FillClosedCurve(redBrush, points);
\r
1522 Assert.IsTrue(t.PDCompare());
\r
1525 t.Graphics.FillClosedCurve(redBrush, points, newFillMode);
\r
1527 Assert.IsTrue(t.PDCompare());
\r
1530 newFillMode = FillMode.Alternate;
\r
1531 t.Graphics.FillClosedCurve(redBrush, points, newFillMode, tension);
\r
1533 Assert.IsTrue(t.PDCompare());
\r
1537 public virtual void FillEllipse() {
\r
1538 // Create solid brush.
\r
1539 SolidBrush redBrush = new SolidBrush(Color.Red);
\r
1540 // Create location and size of ellipse.
\r
1545 // Fill ellipse on screen.
\r
1546 t.Graphics.FillEllipse(redBrush, x, y, width, height);
\r
1548 Assert.IsTrue(t.PDCompare());
\r
1551 t.Graphics.FillEllipse(redBrush, new Rectangle( x, y, width, height));
\r
1553 Assert.IsTrue(t.PDCompare());
\r
1557 public virtual void FillEllipseFloat() {
\r
1558 // Create solid brush.
\r
1559 SolidBrush redBrush = new SolidBrush(Color.Red);
\r
1560 // Create location and size of ellipse.
\r
1563 float width = 200.0F;
\r
1564 float height = 100.0F;
\r
1565 // Fill ellipse on screen.
\r
1566 t.Graphics.FillEllipse(redBrush, x, y, width, height);
\r
1568 Assert.IsTrue(t.PDCompare());
\r
1571 t.Graphics.FillEllipse(redBrush, new RectangleF( x, y, width, height));
\r
1573 Assert.IsTrue(t.PDCompare());
\r
1577 public virtual void FillPathEllipse() {
\r
1578 // Create solid brush.
\r
1579 SolidBrush redBrush = new SolidBrush(Color.Red);
\r
1580 // Create graphics path object and add ellipse.
\r
1581 GraphicsPath graphPath = new GraphicsPath();
\r
1582 graphPath.AddEllipse(0, 0, 200, 100);
\r
1583 // Fill graphics path to screen.
\r
1584 t.Graphics.FillPath(redBrush, graphPath);
\r
1586 Assert.IsTrue(t.PDCompare());
\r
1590 public virtual void FillPieFloat() {
\r
1591 // Create solid brush.
\r
1592 SolidBrush redBrush = new SolidBrush(Color.Red);
\r
1593 // Create location and size of ellipse.
\r
1598 // Create start and sweep angles.
\r
1599 float startAngle = 0.0F;
\r
1600 float sweepAngle = 45.0F;
\r
1601 // Fill pie to screen.
\r
1602 t.Graphics.FillPie(redBrush, new Rectangle(x, y, width, height), startAngle, sweepAngle);
\r
1604 Assert.IsTrue(t.PDCompare());
\r
1607 t.Graphics.FillPie(redBrush, x, y, width, height, (int)startAngle, (int)sweepAngle);
\r
1609 Assert.IsTrue(t.PDCompare());
\r
1612 t.Graphics.FillPie(redBrush, (float)x, (float)y, (float)width, (float)height, startAngle, sweepAngle);
\r
1614 Assert.IsTrue(t.PDCompare());
\r
1618 public virtual void FillPolygonPointFillMode() {
\r
1619 // Create solid brush.
\r
1620 SolidBrush blueBrush = new SolidBrush(Color.Blue);
\r
1621 // Create points that define polygon.
\r
1622 Point point1 = new Point( 50, 50);
\r
1623 Point point2 = new Point(100, 25);
\r
1624 Point point3 = new Point(200, 5);
\r
1625 Point point4 = new Point(250, 50);
\r
1626 Point point5 = new Point(300, 100);
\r
1627 Point point6 = new Point(350, 200);
\r
1628 Point point7 = new Point(250, 250);
\r
1629 Point[] curvePoints = {
\r
1639 // Fill polygon to screen.
\r
1640 t.Graphics.FillPolygon(blueBrush, curvePoints, FillMode.Winding);
\r
1642 Assert.IsTrue(t.PDCompare());
\r
1645 t.Graphics.FillPolygon(blueBrush, curvePoints, FillMode.Alternate);
\r
1647 Assert.IsTrue(t.PDCompare());
\r
1650 t.Graphics.FillPolygon(blueBrush, curvePoints);
\r
1652 Assert.IsTrue(t.PDCompare());
\r
1656 public virtual void FillPolygonPointFFillMode() {
\r
1657 // Create solid brush.
\r
1658 SolidBrush blueBrush = new SolidBrush(Color.Blue);
\r
1659 // Create points that define polygon.
\r
1660 PointF point1 = new PointF( 50.0F, 50.0F);
\r
1661 PointF point2 = new PointF(100.0F, 25.0F);
\r
1662 PointF point3 = new PointF(200.0F, 5.0F);
\r
1663 PointF point4 = new PointF(250.0F, 50.0F);
\r
1664 PointF point5 = new PointF(300.0F, 100.0F);
\r
1665 PointF point6 = new PointF(350.0F, 200.0F);
\r
1666 PointF point7 = new PointF(250.0F, 250.0F);
\r
1667 PointF[] curvePoints = {
\r
1677 // Fill polygon to screen.
\r
1678 t.Graphics.FillPolygon(blueBrush, curvePoints, FillMode.Winding);
\r
1680 Assert.IsTrue(t.PDCompare());
\r
1683 t.Graphics.FillPolygon(blueBrush, curvePoints, FillMode.Alternate);
\r
1685 Assert.IsTrue(t.PDCompare());
\r
1688 t.Graphics.FillPolygon(blueBrush, curvePoints);
\r
1690 Assert.IsTrue(t.PDCompare());
\r
1694 public virtual void FillRectangle() {
\r
1695 // Create solid brush.
\r
1696 SolidBrush blueBrush = new SolidBrush(Color.Blue);
\r
1697 // Create location and size of rectangle.
\r
1702 // Fill rectangle to screen.
\r
1703 t.Graphics.FillRectangle(blueBrush, x, y, width, height);
\r
1705 Assert.IsTrue(t.PDCompare());
\r
1708 t.Graphics.FillRectangle(blueBrush, new Rectangle( x, y, width, height));
\r
1710 Assert.IsTrue(t.PDCompare());
\r
1714 public virtual void FillRectangleFloat() {
\r
1715 // Create solid brush.
\r
1716 SolidBrush blueBrush = new SolidBrush(Color.Blue);
\r
1717 // Create location and size of rectangle.
\r
1720 float width = 300.0F;
\r
1721 float height = 200.0F;
\r
1722 // Fill rectangle to screen.
\r
1723 t.Graphics.FillRectangle(blueBrush, x, y, width, height);
\r
1725 Assert.IsTrue(t.PDCompare());
\r
1728 t.Graphics.FillRectangle(blueBrush, new RectangleF( x, y, width, height));
\r
1730 Assert.IsTrue(t.PDCompare());
\r
1734 public virtual void FillRectanglesRectangle() {
\r
1735 // Create solid brush.
\r
1736 SolidBrush blueBrush = new SolidBrush(Color.Blue);
\r
1737 // Create array of rectangles.
\r
1738 Rectangle[] rects = {
\r
1739 new Rectangle( 0, 0, 100, 200),
\r
1740 new Rectangle(100, 200, 250, 50),
\r
1741 new Rectangle(300, 0, 50, 100)
\r
1743 // Fill rectangles to screen.
\r
1744 t.Graphics.FillRectangles(blueBrush, rects);
\r
1746 Assert.IsTrue(t.PDCompare());
\r
1750 public virtual void FillRectanglesRectangleF() {
\r
1751 // Create solid brush.
\r
1752 SolidBrush blueBrush = new SolidBrush(Color.Blue);
\r
1753 // Create array of rectangles.
\r
1754 RectangleF[] rects = {
\r
1755 new RectangleF( 0.0F, 0.0F, 100.0F, 200.0F),
\r
1756 new RectangleF(100.0F, 200.0F, 250.0F, 50.0F),
\r
1757 new RectangleF(300.0F, 0.0F, 50.0F, 100.0F)
\r
1759 // Fill rectangles to screen.
\r
1760 t.Graphics.FillRectangles(blueBrush, rects);
\r
1762 Assert.IsTrue(t.PDCompare());
\r
1766 public virtual void FillRegionRectangle() {
\r
1767 // Create solid brush.
\r
1768 SolidBrush blueBrush = new SolidBrush(Color.Blue);
\r
1769 // Create rectangle for region.
\r
1770 Rectangle fillRect = new Rectangle(100, 150, 200, 250);
\r
1771 // Create region for fill.
\r
1772 Region fillRegion = new Region(fillRect);
\r
1773 // Fill region to screen.
\r
1774 t.Graphics.FillRegion(blueBrush, fillRegion);
\r
1776 Assert.IsTrue(t.PDCompare());
\r
1780 public virtual void FlushTest() {
\r
1781 t.Graphics.Flush();
\r
1782 t.Graphics.Flush(FlushIntention.Flush);
\r
1786 public virtual void IntersectClipRegion() {
\r
1787 // Set clipping region.
\r
1788 Rectangle clipRect = new Rectangle(0, 0, 200, 300);
\r
1789 Region clipRegion = new Region(clipRect);
\r
1790 t.Graphics.SetClip(clipRegion, CombineMode.Replace);
\r
1791 // Update clipping region to intersection of
\r
1792 // existing region with specified rectangle.
\r
1793 Rectangle intersectRect = new Rectangle(100, 100, 200, 300);
\r
1794 Region intersectRegion = new Region(intersectRect);
\r
1795 t.Graphics.IntersectClip(intersectRegion);
\r
1796 // Fill rectangle to demonstrate effective clipping region.
\r
1797 t.Graphics.FillRectangle(new SolidBrush(Color.Blue), 0, 0, 500, 600);
\r
1799 // Reset clipping region to infinite.
\r
1800 t.Graphics.ResetClip();
\r
1801 // Draw clipRect and intersectRect to screen.
\r
1802 t.Graphics.DrawRectangle(new Pen(Color.Black), clipRect);
\r
1804 t.Graphics.DrawRectangle(new Pen(Color.Red), intersectRect);
\r
1806 Assert.IsTrue(t.PDCompare());
\r
1810 public virtual void IsVisible4Float() {
\r
1811 // Set clip region.
\r
1812 Region clipRegion = new Region(new Rectangle(50, 50, 100, 100));
\r
1813 t.Graphics.SetClip(clipRegion, CombineMode.Replace);
\r
1814 // Set up coordinates of rectangles.
\r
1815 float x1 = 100.0F;
\r
1816 float y1 = 100.0F;
\r
1817 float width1 = 20.0F;
\r
1818 float height1 = 20.0F;
\r
1819 float x2 = 200.0F;
\r
1820 float y2 = 200.0F;
\r
1821 float width2 = 20.0F;
\r
1822 float height2 = 20.0F;
\r
1823 // If rectangle is visible, fill it.
\r
1824 if (t.Graphics.IsVisible(x1, y1, width1, height1)) {
\r
1825 t.Graphics.FillRectangle(new SolidBrush(Color.Red), x1, y1, width1, height1);
\r
1828 if (t.Graphics.IsVisible(x2, y2, width2, height2)) {
\r
1829 t.Graphics.FillRectangle(new SolidBrush(Color.Blue), x2, y2, width2, height2);
\r
1833 Assert.IsTrue(t.PDCompare());
\r
1837 [Category("NotWorking")]
\r
1838 public virtual void MeasureCharacterRangesRegions() {
\r
1840 string measureString = "First and Second ranges";
\r
1841 Font stringFont = new Font("Times New Roman", 16.0F);
\r
1842 // Set character ranges to "First" and "Second".
\r
1843 CharacterRange[] characterRanges = {
\r
1844 new CharacterRange(0, 5),
\r
1845 new CharacterRange(10, 6)
\r
1847 // Create rectangle for layout.
\r
1850 float width = 35.0F;
\r
1851 float height = 200.0F;
\r
1852 RectangleF layoutRect = new RectangleF(x, y, width, height);
\r
1853 // Set string format.
\r
1854 StringFormat stringFormat = new StringFormat();
\r
1855 stringFormat.FormatFlags = StringFormatFlags.DirectionVertical;
\r
1856 stringFormat.SetMeasurableCharacterRanges(characterRanges);
\r
1857 // Draw string to screen.
\r
1858 t.Graphics.DrawString(
\r
1864 // Measure two ranges in string.
\r
1865 Region[] stringRegions = new Region[2];
\r
1866 stringRegions = t.Graphics.MeasureCharacterRanges(
\r
1871 // Draw rectangle for first measured range.
\r
1872 RectangleF measureRect1 = stringRegions[0].GetBounds(t.Graphics);
\r
1873 t.Graphics.DrawRectangle(
\r
1874 new Pen(Color.Red, 1),
\r
1875 Rectangle.Round(measureRect1));
\r
1877 // Draw rectangle for second measured range.
\r
1878 RectangleF measureRect2 = stringRegions[1].GetBounds(t.Graphics);
\r
1879 t.Graphics.DrawRectangle(
\r
1880 new Pen(Color.Blue, 1),
\r
1881 Rectangle.Round(measureRect2));
\r
1883 Assert.IsTrue(t.PDCompare());
\r
1886 [Test] //TBD: add more overloads
\r
1887 [Category("NotWorking")]
\r
1888 public virtual void MeasureStringSizeFFormatInts() {
\r
1890 string measureString = "Measure String";
\r
1891 Font stringFont = new Font("Arial", 16);
\r
1892 // Set maximum layout size.
\r
1893 SizeF layoutSize = new SizeF(100.0F, 200.0F);
\r
1894 // Set string format.
\r
1895 StringFormat newStringFormat = new StringFormat();
\r
1896 newStringFormat.FormatFlags = StringFormatFlags.DirectionVertical;
\r
1897 // Measure string.
\r
1898 int charactersFitted;
\r
1900 SizeF stringSize = new SizeF();
\r
1901 stringSize = t.Graphics.MeasureString(
\r
1906 out charactersFitted,
\r
1908 // Draw rectangle representing size of string.
\r
1909 t.Graphics.DrawRectangle(
\r
1910 new Pen(Color.Red, 1),
\r
1911 0.0F, 0.0F, stringSize.Width, stringSize.Height);
\r
1913 // Draw string to screen.
\r
1914 t.Graphics.DrawString(
\r
1921 // Draw output parameters to screen.
\r
1922 string outString = "chars " + charactersFitted + ", lines " + linesFilled;
\r
1923 t.Graphics.DrawString(
\r
1927 new PointF(100, 0));
\r
1929 Assert.IsTrue(t.PDCompare());
\r
1933 public virtual void MultiplyTransform() {
\r
1934 // Create transform matrix.
\r
1935 Matrix transformMatrix = new Matrix();
\r
1936 // Translate matrix, prepending translation vector.
\r
1937 transformMatrix.Translate(200.0F, 100.0F);
\r
1938 // Rotate transformation matrix of graphics object,
\r
1939 // prepending rotation matrix.
\r
1940 t.Graphics.RotateTransform(30.0F);
\r
1941 // Multiply (append to) transformation matrix of
\r
1942 // graphics object to translate graphics transformation.
\r
1943 t.Graphics.MultiplyTransform(transformMatrix);
\r
1944 // Draw rotated, translated ellipse.
\r
1945 t.Graphics.DrawEllipse(new Pen(Color.Blue, 3), -80, -40, 160, 80);
\r
1947 Assert.IsTrue(t.PDCompare());
\r
1951 public virtual void MultiplyTransformMatrixOrder() {
\r
1952 // Create transform matrix.
\r
1953 Matrix transformMatrix = new Matrix();
\r
1954 // Translate matrix, prepending translation vector.
\r
1955 transformMatrix.Translate(200.0F, 100.0F);
\r
1956 // Rotate transformation matrix of graphics object,
\r
1957 // prepending rotation matrix.
\r
1958 t.Graphics.RotateTransform(30.0F);
\r
1959 // Multiply (append to) transformation matrix of
\r
1960 // graphics object to translate graphics transformation.
\r
1961 t.Graphics.MultiplyTransform(transformMatrix, MatrixOrder.Append);
\r
1962 // Draw rotated, translated ellipse.
\r
1963 t.Graphics.DrawEllipse(new Pen(Color.Blue, 3), -80, -40, 160, 80);
\r
1965 Assert.IsTrue(t.PDCompare());
\r
1969 public virtual void MultiplyTransformMatrixOrder1() {
\r
1970 // Create transform matrix.
\r
1971 Matrix transformMatrix = new Matrix();
\r
1972 // Translate matrix, prepending translation vector.
\r
1973 transformMatrix.Translate(200.0F, 100.0F);
\r
1974 // Rotate transformation matrix of graphics object,
\r
1975 // prepending rotation matrix.
\r
1976 t.Graphics.RotateTransform(30.0F);
\r
1977 // Multiply (append to) transformation matrix of
\r
1978 // graphics object to translate graphics transformation.
\r
1979 t.Graphics.MultiplyTransform(transformMatrix, MatrixOrder.Prepend);
\r
1980 // Draw rotated, translated ellipse.
\r
1981 t.Graphics.DrawEllipse(new Pen(Color.Blue, 3), -80, -40, 160, 80);
\r
1983 Assert.IsTrue(t.PDCompare());
\r
1987 public virtual void ResetClipIntersectClipRectangleF() {
\r
1988 // Set clipping region.
\r
1989 Rectangle clipRect = new Rectangle(0, 0, 200, 200);
\r
1990 t.Graphics.SetClip(clipRect);
\r
1991 // Update clipping region to intersection of existing region with new rectangle.
\r
1992 RectangleF intersectRectF = new RectangleF(100.0F, 100.0F, 200.0F, 200.0F);
\r
1993 t.Graphics.IntersectClip(intersectRectF);
\r
1994 // Fill rectangle to demonstrate effective clipping region.
\r
1995 t.Graphics.FillRectangle(new SolidBrush(Color.Blue), 0, 0, 500, 500);
\r
1996 // Reset clipping region to infinite.
\r
1997 t.Graphics.ResetClip();
\r
1998 // Draw clipRect and intersectRect to screen.
\r
1999 t.Graphics.DrawRectangle(new Pen(Color.Black), clipRect);
\r
2000 t.Graphics.DrawRectangle(new Pen(Color.Red), Rectangle.Round(intersectRectF));
\r
2002 Assert.IsTrue(t.PDCompare());
\r
2006 public virtual void SaveRestoreTranslate() {
\r
2007 // Translate transformation matrix.
\r
2008 t.Graphics.TranslateTransform(100, 0);
\r
2009 // Save translated graphics state.
\r
2010 GraphicsState transState = t.Graphics.Save();
\r
2011 // Reset transformation matrix to identity and fill rectangle.
\r
2012 t.Graphics.ResetTransform();
\r
2013 t.Graphics.FillRectangle(new SolidBrush(Color.Red), 0, 0, 100, 100);
\r
2015 // Restore graphics state to translated state and fill second rectangle.
\r
2016 t.Graphics.Restore(transState);
\r
2017 t.Graphics.FillRectangle(new SolidBrush(Color.Blue), 0, 0, 100, 100);
\r
2019 Assert.IsTrue(t.PDCompare());
\r
2023 public virtual void RotateTransformAngleMatrixOrder() {
\r
2024 // Set world transform of graphics object to translate.
\r
2025 t.Graphics.TranslateTransform(100.0F, 0.0F);
\r
2026 // Then to rotate, appending rotation matrix.
\r
2027 t.Graphics.RotateTransform(30.0F, MatrixOrder.Append);
\r
2028 // Draw translated, rotated ellipse to screen.
\r
2029 t.Graphics.DrawEllipse(new Pen(Color.Blue, 3), 0, 0, 200, 80);
\r
2031 Assert.IsTrue(t.PDCompare());
\r
2035 public virtual void RotateTransformAngleMatrixOrder1() {
\r
2036 // Set world transform of graphics object to translate.
\r
2037 t.Graphics.TranslateTransform(100.0F, 0.0F);
\r
2038 // Then to rotate, appending rotation matrix.
\r
2039 t.Graphics.RotateTransform(30.0F, MatrixOrder.Prepend);
\r
2040 // Draw translated, rotated ellipse to screen.
\r
2041 t.Graphics.DrawEllipse(new Pen(Color.Blue, 3), 0, 0, 200, 80);
\r
2043 Assert.IsTrue(t.PDCompare()); // Line width problem
\r
2047 public virtual void ScaleTransformFloatMatrixOrder() {
\r
2048 // Set world transform of graphics object to rotate.
\r
2049 t.Graphics.RotateTransform(30.0F);
\r
2050 // Then to scale, appending to world transform.
\r
2051 t.Graphics.ScaleTransform(3.0F, 1.0F, MatrixOrder.Append);
\r
2052 // Draw rotated, scaled rectangle to screen.
\r
2053 t.Graphics.DrawRectangle(new Pen(Color.Blue, 3), 50, 0, 100, 40);
\r
2055 Assert.IsTrue(t.PDCompare()); // Line width problem
\r
2059 public virtual void ScaleTransformFloatMatrixOrder1() {
\r
2060 // Set world transform of graphics object to rotate.
\r
2061 t.Graphics.RotateTransform(30.0F);
\r
2062 // Then to scale, appending to world transform.
\r
2063 t.Graphics.ScaleTransform(3.0F, 1.0F, MatrixOrder.Prepend);
\r
2064 // Draw rotated, scaled rectangle to screen.
\r
2065 t.Graphics.DrawRectangle(new Pen(Color.Blue, 3), 50, 0, 100, 40);
\r
2067 Assert.IsTrue(t.PDCompare());
\r
2070 [Test] //TBD: add more combination
\r
2071 public virtual void SetClipRegionCombine() {
\r
2072 // Create region for clipping.
\r
2073 Region clipRegion = new Region(new Rectangle(0, 0, 200, 100));
\r
2074 // Set clipping region of graphics to region.
\r
2075 t.Graphics.SetClip(clipRegion, CombineMode.Replace);
\r
2076 // Fill rectangle to demonstrate clip region.
\r
2077 t.Graphics.FillRectangle(new SolidBrush(Color.Black), 0, 0, 500, 300);
\r
2079 Assert.IsTrue(t.PDCompare());
\r
2083 public virtual void TransformPointsPointF() {
\r
2084 // Create array of two points.
\r
2085 PointF[] points = {new PointF(0.0F, 0.0F),
\r
2086 new PointF(100.0F, 50.0F)};
\r
2087 // Draw line connecting two untransformed points.
\r
2088 t.Graphics.DrawLine(new Pen(Color.Blue, 3),
\r
2091 // Set world transformation of Graphics object to translate.
\r
2092 t.Graphics.TranslateTransform(40.0F, 30.0F);
\r
2093 // Transform points in array from world to page coordinates.
\r
2094 t.Graphics.TransformPoints(CoordinateSpace.Page,
\r
2095 CoordinateSpace.World,
\r
2097 // Reset world transformation.
\r
2098 t.Graphics.ResetTransform();
\r
2099 // Draw line that connects transformed points.
\r
2100 t.Graphics.DrawLine(new Pen(Color.Red, 3),
\r
2104 Assert.IsTrue(t.PDCompare());
\r
2108 public virtual void TranslateClipFloat() {
\r
2109 // Create rectangle for clipping region.
\r
2110 RectangleF clipRect = new RectangleF(0.0F, 0.0F, 100.0F, 100.0F);
\r
2111 // Set clipping region of graphics to rectangle.
\r
2112 t.Graphics.SetClip(clipRect);
\r
2113 // Translate clipping region.
\r
2116 t.Graphics.TranslateClip(dx, dy);
\r
2117 // Fill rectangle to demonstrate translated clip region.
\r
2118 t.Graphics.FillRectangle(new SolidBrush(Color.Black), 0, 0, 500, 300);
\r
2120 Assert.IsTrue(t.PDCompare());
\r
2124 public virtual void TranslateTransformAngleMatrixOrder() {
\r
2125 // Set world transform of graphics object to rotate.
\r
2126 t.Graphics.RotateTransform(30.0F);
\r
2127 // Then to translate, appending to world transform.
\r
2128 t.Graphics.TranslateTransform(100.0F, 0.0F, MatrixOrder.Append);
\r
2129 // Draw rotated, translated ellipse to screen.
\r
2130 t.Graphics.DrawEllipse(new Pen(Color.Blue, 3), 0, 0, 200, 80);
\r
2132 Assert.IsTrue(t.PDCompare()); // Line width problem
\r
2136 public virtual void TranslateTransformAngleMatrixOrder1() {
\r
2137 // Set world transform of graphics object to rotate.
\r
2138 t.Graphics.RotateTransform(30.0F);
\r
2139 // Then to translate, appending to world transform.
\r
2140 t.Graphics.TranslateTransform(100.0F, 0.0F, MatrixOrder.Prepend);
\r
2141 // Draw rotated, translated ellipse to screen.
\r
2142 t.Graphics.DrawEllipse(new Pen(Color.Blue, 3), 0, 0, 200, 80);
\r
2144 Assert.IsTrue(t.PDCompare());
\r
2148 public virtual void TransfromPageScaleUnits() {
\r
2149 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
2150 t.Graphics.PageScale = 1.0F;
\r
2151 t.Graphics.DrawLine(Pens.Red, 10, 70, 70, 10);
\r
2153 t.Graphics.PageUnit = GraphicsUnit.Document;
\r
2154 t.Graphics.PageScale = 10.0F;
\r
2155 t.Graphics.DrawLine(Pens.Blue, 10, 70, 70, 10);
\r
2157 t.Graphics.PageUnit = GraphicsUnit.Inch;
\r
2158 t.Graphics.PageScale = 0.055F;
\r
2159 t.Graphics.DrawLine(Pens.Green, 10, 70, 70, 10);
\r
2161 Matrix mx=new Matrix(0.5f,0,0,0.5f,0,0);
\r
2162 t.Graphics.Transform = mx;
\r
2164 t.Graphics.PageUnit = GraphicsUnit.Inch;
\r
2165 t.Graphics.DrawLine(Pens.Black, 10, 70, 70, 10);
\r
2167 t.Graphics.PageUnit = GraphicsUnit.Point;
\r
2168 t.Graphics.PageScale = 2.7F;
\r
2169 t.Graphics.DrawLine(Pens.Yellow, 10, 70, 70, 10);
\r
2172 Assert.IsTrue(t.PDCompare());
\r
2176 public virtual void TransfromPageScaleUnits_2() {
\r
2177 t.Graphics.RotateTransform(45);
\r
2178 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
2179 t.Graphics.PageScale = 1.0F;
\r
2180 t.Graphics.DrawLine(Pens.Red, 10, 70, 70, 10);
\r
2182 t.Graphics.TranslateTransform(100, 0);
\r
2183 t.Graphics.PageUnit = GraphicsUnit.Pixel;
\r
2184 t.Graphics.PageScale = 2.0F;
\r
2185 t.Graphics.DrawLine(Pens.Blue, 10, 70, 70, 10);
\r
2187 t.Graphics.ResetTransform();
\r
2188 t.Graphics.DrawLine(Pens.Green, 10, 70, 70, 10);
\r
2191 Assert.IsTrue(t.PDCompare());
\r
2194 public virtual void TransfromPageScaleUnits_3() {
\r
2195 t.Graphics.TranslateTransform(20, 20);
\r
2196 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
2197 t.Graphics.PageScale = 1.0F;
\r
2198 t.Graphics.DrawLine(Pens.Red, 10, 70, 70, 10);
\r
2200 t.Graphics.TranslateTransform(10, 10);
\r
2201 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
2202 t.Graphics.PageScale = 1.0F;
\r
2203 t.Graphics.DrawLine(Pens.Red, 10, 70, 70, 10);
\r
2205 t.Graphics.RotateTransform(15);
\r
2207 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
2208 t.Graphics.PageScale = 0.5F;
\r
2209 t.Graphics.DrawLine(Pens.Red, 10, 70, 70, 10);
\r
2211 t.Graphics.PageUnit = GraphicsUnit.Pixel;
\r
2212 t.Graphics.PageScale = 0.5F;
\r
2213 t.Graphics.DrawLine(Pens.Red, 10, 70, 70, 10);
\r
2215 t.Graphics.PageUnit = GraphicsUnit.Pixel;
\r
2216 t.Graphics.TranslateTransform(0, 0);
\r
2217 t.Graphics.PageScale = 1.5F;
\r
2218 t.Graphics.DrawLine(Pens.Red, 10, 70, 70, 10);
\r
2221 Assert.IsTrue(t.PDCompare());
\r
2228 #region GraphicsFixturePropClip
\r
2231 public class GraphicsFixturePropClip : GraphicsFixture {
\r
2232 public override void SetUp() {
\r
2233 base.SetUp ("GraphicsFixturePropClip");
\r
2234 t.Graphics.Clip = new Region(new Rectangle(10, 10, 100, 100));
\r
2236 st["DrawArcTest:6"] = TOLERANCE * 5.0f;
\r
2237 st["DrawArcTest:8"] = TOLERANCE * 3.7f;
\r
2238 st["DrawLinesTest:2"] = TOLERANCE * 3.0f;
\r
2239 st["DrawLinesTestF:2"] = TOLERANCE * 3.0f;
\r
2240 st["DrawPieTestF:2"] = TOLERANCE * 2.0f;
\r
2241 st["DrawPieTestF:4"] = TOLERANCE * 2.0f;
\r
2242 st["DrawPieTest:2"] = TOLERANCE * 2.0f;
\r
2243 st["DrawPieTest:4"] = TOLERANCE * 2.0f;
\r
2244 st["FillClosedCurvePointFillModeTension:2"] = TOLERANCE * 1.5f;
\r
2245 st["FillClosedCurvePointFFillModeTension:2"] = TOLERANCE * 1.5f;
\r
2246 st["FillClosedCurvePointFillModeTension:4"] = TOLERANCE * 1.5f;
\r
2247 st["FillClosedCurvePointFFillModeTension:4"] = TOLERANCE * 1.5f;
\r
2248 st["FillClosedCurvePointFillModeTension:5"] = TOLERANCE * 1.5f;
\r
2249 st["FillClosedCurvePointFFillModeTension:6"] = TOLERANCE * 1.5f;
\r
2250 st["ScaleTransformFloatMatrixOrder1:2"] = TOLERANCE * 3.5f;
\r
2254 [Category("NotWorking")]
\r
2255 public override void DrawIconTest() {
\r
2256 base.DrawIconTest ();
\r
2260 [Category("NotWorking")]
\r
2261 public override void DrawIconUnstretchedTest() {
\r
2262 base.DrawIconUnstretchedTest ();
\r
2266 public override void DrawImageUnscaledTest() {
\r
2267 base.DrawImageUnscaledTest ();
\r
2271 public override void DrawStringFloatFormat() {
\r
2272 base.DrawStringFloatFormat ();
\r
2276 [Category("NotWorking")]
\r
2277 public override void MeasureCharacterRangesRegions() {
\r
2278 base.MeasureCharacterRangesRegions ();
\r
2282 [Category("NotWorking")]
\r
2283 public override void MeasureStringSizeFFormatInts() {
\r
2284 base.MeasureStringSizeFFormatInts ();
\r
2290 #region GraphicsFixturePropCompositingMode
\r
2293 public class GraphicsFixturePropCompositingMode1 : GraphicsFixture {
\r
2294 public override void SetUp() {
\r
2295 base.SetUp ("GraphicsFixturePropCompositingMode1");
\r
2296 t.Graphics.CompositingMode = CompositingMode.SourceCopy;
\r
2300 [Category("NotWorking")]
\r
2301 public override void DrawIconTest() {
\r
2302 base.DrawIconTest ();
\r
2306 [Category("NotWorking")]
\r
2307 public override void DrawIconUnstretchedTest() {
\r
2308 base.DrawIconUnstretchedTest ();
\r
2312 [Category("NotWorking")]
\r
2313 public override void DrawImageUnscaledTest() {
\r
2314 base.DrawImageUnscaledTest ();
\r
2318 [Category("NotWorking")]
\r
2319 public override void DrawStringFloatFormat() {
\r
2320 base.DrawStringFloatFormat ();
\r
2324 [Category("NotWorking")]
\r
2325 public override void MeasureCharacterRangesRegions() {
\r
2326 base.MeasureCharacterRangesRegions ();
\r
2330 [Category("NotWorking")]
\r
2331 public override void MeasureStringSizeFFormatInts() {
\r
2332 base.MeasureStringSizeFFormatInts ();
\r
2337 public class GraphicsFixturePropCompositingMode2 : GraphicsFixture {
\r
2338 public override void SetUp() {
\r
2339 base.SetUp ("GraphicsFixturePropCompositingMode2");
\r
2340 t.Graphics.CompositingMode = CompositingMode.SourceOver;
\r
2344 [Category("NotWorking")]
\r
2345 public override void DrawIconTest() {
\r
2346 base.DrawIconTest ();
\r
2350 [Category("NotWorking")]
\r
2351 public override void DrawIconUnstretchedTest() {
\r
2352 base.DrawIconUnstretchedTest ();
\r
2356 [Category("NotWorking")]
\r
2357 public override void DrawImageUnscaledTest() {
\r
2358 base.DrawImageUnscaledTest ();
\r
2362 [Category("NotWorking")]
\r
2363 public override void DrawStringFloatFormat() {
\r
2364 base.DrawStringFloatFormat ();
\r
2368 [Category("NotWorking")]
\r
2369 public override void MeasureCharacterRangesRegions() {
\r
2370 base.MeasureCharacterRangesRegions ();
\r
2374 [Category("NotWorking")]
\r
2375 public override void MeasureStringSizeFFormatInts() {
\r
2376 base.MeasureStringSizeFFormatInts ();
\r
2382 #region GraphicsFixturePropInterpolationMode
\r
2385 public class GraphicsFixturePropInterpolationMode1 : GraphicsFixture {
\r
2386 public override void SetUp() {
\r
2387 base.SetUp ("GraphicsFixturePropInterpolationMode1");
\r
2388 t.Graphics.InterpolationMode = InterpolationMode.Bilinear;
\r
2392 [Category("NotWorking")]
\r
2393 public override void DrawIconTest() {
\r
2394 base.DrawIconTest ();
\r
2398 [Category("NotWorking")]
\r
2399 public override void DrawIconUnstretchedTest() {
\r
2400 base.DrawIconUnstretchedTest ();
\r
2404 [Category("NotWorking")]
\r
2405 public override void DrawImageUnscaledTest() {
\r
2406 base.DrawImageUnscaledTest ();
\r
2410 [Category("NotWorking")]
\r
2411 public override void DrawStringFloatFormat() {
\r
2412 base.DrawStringFloatFormat ();
\r
2416 [Category("NotWorking")]
\r
2417 public override void MeasureCharacterRangesRegions() {
\r
2418 base.MeasureCharacterRangesRegions ();
\r
2422 [Category("NotWorking")]
\r
2423 public override void MeasureStringSizeFFormatInts() {
\r
2424 base.MeasureStringSizeFFormatInts ();
\r
2429 public class GraphicsFixturePropInterpolationMode2 : GraphicsFixture {
\r
2430 public override void SetUp() {
\r
2431 base.SetUp ("GraphicsFixturePropInterpolationMode2");
\r
2432 t.Graphics.InterpolationMode = InterpolationMode.Bicubic;
\r
2436 [Category("NotWorking")]
\r
2437 public override void DrawIconTest() {
\r
2438 base.DrawIconTest ();
\r
2442 [Category("NotWorking")]
\r
2443 public override void DrawIconUnstretchedTest() {
\r
2444 base.DrawIconUnstretchedTest ();
\r
2448 [Category("NotWorking")]
\r
2449 public override void DrawImageUnscaledTest() {
\r
2450 base.DrawImageUnscaledTest ();
\r
2454 [Category("NotWorking")]
\r
2455 public override void DrawStringFloatFormat() {
\r
2456 base.DrawStringFloatFormat ();
\r
2460 [Category("NotWorking")]
\r
2461 public override void MeasureCharacterRangesRegions() {
\r
2462 base.MeasureCharacterRangesRegions ();
\r
2466 [Category("NotWorking")]
\r
2467 public override void MeasureStringSizeFFormatInts() {
\r
2468 base.MeasureStringSizeFFormatInts ();
\r
2474 #region GraphicsFixturePropPageScale
\r
2477 public class GraphicsFixturePropPageScale : GraphicsFixture {
\r
2478 public override void SetUp() {
\r
2479 base.SetUp ("GraphicsFixturePropPageScale");
\r
2481 t.Graphics.PageScale = 4.34f;
\r
2482 t.Graphics.PageUnit = GraphicsUnit.Pixel;
\r
2484 st["IntersectClipRegion:4"] = TOLERANCE * 1.5f;
\r
2485 st["ResetClipIntersectClipRectangleF:2"] = TOLERANCE * 1.5f;
\r
2489 [Category("NotWorking")]
\r
2490 public override void DrawIconTest() {
\r
2491 base.DrawIconTest ();
\r
2495 [Category("NotWorking")]
\r
2496 public override void DrawIconUnstretchedTest() {
\r
2497 base.DrawIconUnstretchedTest ();
\r
2501 [Category("NotWorking")]
\r
2502 public override void DrawImageUnscaledTest() {
\r
2503 base.DrawImageUnscaledTest ();
\r
2507 public override void DrawStringFloatFormat() {
\r
2508 base.DrawStringFloatFormat ();
\r
2512 [Category("NotWorking")]
\r
2513 public override void MeasureCharacterRangesRegions() {
\r
2514 base.MeasureCharacterRangesRegions ();
\r
2518 [Category("NotWorking")]
\r
2519 public override void MeasureStringSizeFFormatInts() {
\r
2520 base.MeasureStringSizeFFormatInts ();
\r
2526 #region GraphicsFixturePropPageUnit
\r
2529 public class GraphicsFixturePropPageUnit1 : GraphicsFixture {
\r
2530 public override void SetUp() {
\r
2531 base.SetUp ("GraphicsFixturePropPageUnit1");
\r
2532 t.Graphics.PageUnit = GraphicsUnit.Display;
\r
2536 [Category("NotWorking")]
\r
2537 public override void DrawIconTest() {
\r
2538 base.DrawIconTest ();
\r
2542 [Category("NotWorking")]
\r
2543 public override void DrawIconUnstretchedTest() {
\r
2544 base.DrawIconUnstretchedTest ();
\r
2548 [Category("NotWorking")]
\r
2549 public override void DrawImageUnscaledTest() {
\r
2550 base.DrawImageUnscaledTest ();
\r
2554 [Category("NotWorking")]
\r
2555 public override void DrawStringFloatFormat() {
\r
2556 base.DrawStringFloatFormat ();
\r
2560 [Category("NotWorking")]
\r
2561 public override void MeasureCharacterRangesRegions() {
\r
2562 base.MeasureCharacterRangesRegions ();
\r
2566 [Category("NotWorking")]
\r
2567 public override void MeasureStringSizeFFormatInts() {
\r
2568 base.MeasureStringSizeFFormatInts ();
\r
2573 public class GraphicsFixturePropPageUnit2 : GraphicsFixture {
\r
2574 public override void SetUp() {
\r
2575 base.SetUp ("GraphicsFixturePropPageUnit2");
\r
2576 t.Graphics.PageUnit = GraphicsUnit.Document;
\r
2578 // FIXME: scaling down loss some pixels.
\r
2579 st["DrawBezierTest:2"] = TOLERANCE * 2.5f;
\r
2580 st["DrawBezierTest:4"] = TOLERANCE * 2.5f;
\r
2581 st["DrawBezierTest:6"] = TOLERANCE * 2.5f;
\r
2582 st["DrawBeziersTest:2"] = TOLERANCE * 2.0f;
\r
2583 st["DrawBeziersTest:4"] = TOLERANCE * 2.0f;
\r
2584 st["DrawClosedCurveTest:2"] = TOLERANCE * 3.0f;
\r
2585 st["DrawClosedCurveTest:4"] = TOLERANCE * 3.7f;
\r
2586 st["DrawCurveTest:2"] = TOLERANCE * 2.5f;
\r
2587 st["DrawCurveTest:4"] = TOLERANCE * 2.0f;
\r
2588 st["DrawCurveTest:6"] = TOLERANCE * 4.0f;
\r
2589 st["DrawCurveTestF:2"] = TOLERANCE * 2.5f;
\r
2590 st["DrawCurveTestF:4"] = TOLERANCE * 6.0f;
\r
2591 st["DrawCurveTestF:6"] = TOLERANCE * 6.0f;
\r
2592 st["DrawCurveTestF:8"] = TOLERANCE * 6.0f;
\r
2593 st["DrawEllipseTest:2"] = TOLERANCE * 2.0f;
\r
2594 st["DrawEllipseTest:4"] = TOLERANCE * 2.0f;
\r
2595 st["DrawEllipseTestF:2"] = TOLERANCE * 2.0f;
\r
2596 st["DrawEllipseTestF:4"] = TOLERANCE * 2.0f;
\r
2597 st["DrawLinesTest:2"] = TOLERANCE * 2.0f;
\r
2598 st["DrawLinesTestF:2"] = TOLERANCE * 2.0f;
\r
2599 st["DrawPathTest:2"] = TOLERANCE * 2.0f;
\r
2600 st["DrawPolygonPoint:2"] = TOLERANCE * 7.0f;
\r
2601 st["DrawPolygonPointF:2"] = TOLERANCE * 7.0f;
\r
2602 st["FillPieFloat:2"] = TOLERANCE * 1.5f;
\r
2603 st["FillPieFloat:4"] = TOLERANCE * 1.5f;
\r
2604 st["FillPieFloat:6"] = TOLERANCE * 1.5f;
\r
2605 st["IntersectClipRegion:4"] = TOLERANCE * 3.0f;
\r
2606 st["MultiplyTransform:2"] = TOLERANCE * 2.5f;
\r
2607 st["MultiplyTransformMatrixOrder1:2"] = TOLERANCE * 2.5f;
\r
2608 st["TranslateTransformAngleMatrixOrder1:2"] = TOLERANCE * 4.0f;
\r
2609 st["ScaleTransformFloatMatrixOrder:2"] = TOLERANCE * 4.0f;
\r
2610 st["ScaleTransformFloatMatrixOrder1:2"] = TOLERANCE * 5.5f;
\r
2611 st["RotateTransformAngleMatrixOrder:2"] = TOLERANCE * 3.5f;
\r
2615 [Category("NotWorking")]
\r
2616 public override void BeginContainerTest() {
\r
2617 base.BeginContainerTest ();
\r
2621 [Category("NotWorking")]
\r
2622 public override void DrawIconTest() {
\r
2623 base.DrawIconTest ();
\r
2627 [Category("NotWorking")]
\r
2628 public override void DrawIconUnstretchedTest() {
\r
2629 base.DrawIconUnstretchedTest ();
\r
2633 [Category("NotWorking")]
\r
2634 public override void DrawImageUnscaledTest() {
\r
2635 base.DrawImageUnscaledTest ();
\r
2639 [Category("NotWorking")]
\r
2640 public override void DrawStringFloatFormat() {
\r
2641 base.DrawStringFloatFormat ();
\r
2645 [Category("NotWorking")]
\r
2646 public override void EndContainerState() {
\r
2647 base.EndContainerState ();
\r
2651 [Category("NotWorking")]
\r
2652 public override void MeasureCharacterRangesRegions() {
\r
2653 base.MeasureCharacterRangesRegions ();
\r
2657 [Category("NotWorking")]
\r
2658 public override void MeasureStringSizeFFormatInts() {
\r
2659 base.MeasureStringSizeFFormatInts ();
\r
2664 public class GraphicsFixturePropPageUnit3 : GraphicsFixture {
\r
2665 public override void SetUp() {
\r
2666 base.SetUp ("GraphicsFixturePropPageUnit3");
\r
2667 t.Graphics.PageUnit = GraphicsUnit.Inch;
\r
2671 [Category("NotWorking")]
\r
2672 public override void DrawIconTest() {
\r
2673 base.DrawIconTest ();
\r
2677 [Category("NotWorking")]
\r
2678 public override void DrawIconUnstretchedTest() {
\r
2679 base.DrawIconUnstretchedTest ();
\r
2683 public override void DrawImageUnscaledTest() {
\r
2684 base.DrawImageUnscaledTest ();
\r
2688 public override void DrawStringFloatFormat() {
\r
2689 base.DrawStringFloatFormat ();
\r
2693 [Category("NotWorking")]
\r
2694 public override void IsVisible4Float() {
\r
2695 base.IsVisible4Float ();
\r
2699 public override void MeasureCharacterRangesRegions() {
\r
2700 base.MeasureCharacterRangesRegions ();
\r
2704 [Category("NotWorking")]
\r
2705 public override void MeasureStringSizeFFormatInts() {
\r
2706 base.MeasureStringSizeFFormatInts ();
\r
2711 public class GraphicsFixturePropPageUnit4 : GraphicsFixture {
\r
2712 public override void SetUp() {
\r
2713 base.SetUp ("GraphicsFixturePropPageUnit4");
\r
2714 t.Graphics.PageUnit = GraphicsUnit.Millimeter;
\r
2716 st["DrawArcTest:8"] = TOLERANCE * 1.5f;
\r
2717 st["DrawRectangleFloat:2"] = TOLERANCE * 1.5f; // line width problem
\r
2718 st["DrawRectangleFloat:4"] = TOLERANCE * 1.5f;
\r
2719 st["DrawRectangleFloat:6"] = TOLERANCE * 1.5f;
\r
2720 st["DrawRectanglesRectangle:2"] = TOLERANCE * 1.5f;
\r
2721 st["DrawRectanglesRectangleF:2"] = TOLERANCE * 1.5f;
\r
2725 [Category("NotWorking")]
\r
2726 public override void DrawClosedCurveTest() {
\r
2727 base.DrawClosedCurveTest ();
\r
2731 [Category("NotWorking")]
\r
2732 public override void DrawIconTest() {
\r
2733 base.DrawIconTest ();
\r
2737 [Category("NotWorking")]
\r
2738 public override void DrawIconUnstretchedTest() {
\r
2739 base.DrawIconUnstretchedTest ();
\r
2743 [Category("NotWorking")]
\r
2744 public override void DrawImageUnscaledTest() {
\r
2745 base.DrawImageUnscaledTest ();
\r
2749 public override void DrawStringFloatFormat() {
\r
2750 base.DrawStringFloatFormat ();
\r
2754 [Category("NotWorking")]
\r
2755 public override void MeasureCharacterRangesRegions() {
\r
2756 base.MeasureCharacterRangesRegions ();
\r
2760 [Category("NotWorking")]
\r
2761 public override void MeasureStringSizeFFormatInts() {
\r
2762 base.MeasureStringSizeFFormatInts ();
\r
2767 public class GraphicsFixturePropPageUnit5 : GraphicsFixture {
\r
2768 public override void SetUp() {
\r
2769 base.SetUp ("GraphicsFixturePropPageUnit5");
\r
2771 t.Graphics.PageUnit = GraphicsUnit.Pixel;
\r
2775 [Category("NotWorking")]
\r
2776 public override void DrawIconTest() {
\r
2777 base.DrawIconTest ();
\r
2781 [Category("NotWorking")]
\r
2782 public override void DrawIconUnstretchedTest() {
\r
2783 base.DrawIconUnstretchedTest ();
\r
2787 [Category("NotWorking")]
\r
2788 public override void DrawImageUnscaledTest() {
\r
2789 base.DrawImageUnscaledTest ();
\r
2793 [Category("NotWorking")]
\r
2794 public override void DrawStringFloatFormat() {
\r
2795 base.DrawStringFloatFormat ();
\r
2799 [Category("NotWorking")]
\r
2800 public override void MeasureCharacterRangesRegions() {
\r
2801 base.MeasureCharacterRangesRegions ();
\r
2805 [Category("NotWorking")]
\r
2806 public override void MeasureStringSizeFFormatInts() {
\r
2807 base.MeasureStringSizeFFormatInts ();
\r
2812 public class GraphicsFixturePropPageUnit6 : GraphicsFixture {
\r
2813 public override void SetUp() {
\r
2814 base.SetUp ("GraphicsFixturePropPageUnit6");
\r
2815 t.Graphics.PageUnit = GraphicsUnit.Point;
\r
2817 st["DrawArcTest:2"] = TOLERANCE * 2.5f;
\r
2818 st["DrawArcTest:4"] = TOLERANCE * 8.0f; // big difference in width of line
\r
2819 st["DrawArcTest:6"] = TOLERANCE * 8.0f; // big difference in width of line
\r
2820 st["DrawArcTest:8"] = TOLERANCE * 6.0f; // big difference in width of line
\r
2821 st["IsVisible4Float:2"] = TOLERANCE * 1.5f;
\r
2822 st["TransformPointsPointF:2"] = TOLERANCE * 2.0f;
\r
2826 [Category("NotWorking")]
\r
2827 public override void DrawClosedCurveTest() {
\r
2828 base.DrawClosedCurveTest ();
\r
2832 [Category("NotWorking")]
\r
2833 public override void DrawCurveTest() {
\r
2834 base.DrawCurveTest ();
\r
2838 [Category("NotWorking")]
\r
2839 public override void DrawCurveTestF() {
\r
2840 base.DrawCurveTestF ();
\r
2844 [Category("NotWorking")]
\r
2845 public override void DrawEllipseTest() {
\r
2846 base.DrawEllipseTest ();
\r
2850 [Category("NotWorking")]
\r
2851 public override void DrawEllipseTestF() {
\r
2852 base.DrawEllipseTestF ();
\r
2856 [Category("NotWorking")]
\r
2857 public override void DrawIconTest() {
\r
2858 base.DrawIconTest ();
\r
2862 [Category("NotWorking")]
\r
2863 public override void DrawIconUnstretchedTest() {
\r
2864 base.DrawIconUnstretchedTest ();
\r
2868 [Category("NotWorking")]
\r
2869 public override void DrawImageUnscaledTest() {
\r
2870 base.DrawImageUnscaledTest ();
\r
2874 [Category("NotWorking")]
\r
2875 public override void DrawPathTest() {
\r
2876 base.DrawPathTest ();
\r
2880 [Category("NotWorking")]
\r
2881 public override void DrawStringFloatFormat() {
\r
2882 base.DrawStringFloatFormat ();
\r
2886 [Category("NotWorking")]
\r
2887 public override void EndContainerState() {
\r
2888 base.EndContainerState ();
\r
2892 [Category("NotWorking")]
\r
2893 public override void MeasureCharacterRangesRegions() {
\r
2894 base.MeasureCharacterRangesRegions ();
\r
2898 [Category("NotWorking")]
\r
2899 public override void MeasureStringSizeFFormatInts() {
\r
2900 base.MeasureStringSizeFFormatInts ();
\r
2904 [Category("NotWorking")]
\r
2905 public override void MultiplyTransform() {
\r
2906 base.MultiplyTransform ();
\r
2910 [Category("NotWorking")]
\r
2911 public override void MultiplyTransformMatrixOrder1() {
\r
2912 base.MultiplyTransformMatrixOrder1 ();
\r
2916 [Category("NotWorking")]
\r
2917 public override void RotateTransformAngleMatrixOrder1() {
\r
2918 base.RotateTransformAngleMatrixOrder1 ();
\r
2922 [Category("NotWorking")]
\r
2923 public override void TranslateTransformAngleMatrixOrder() {
\r
2924 base.TranslateTransformAngleMatrixOrder ();
\r
2929 // public class GraphicsFixturePropPageUnit7 : GraphicsFixture {
\r
2930 // public override void SetUp() {
\r
2933 // t.Graphics.PageUnit = GraphicsUnit.World;
\r
2939 #region GraphicsFixturePropPixelOffsetMode
\r
2942 public class GraphicsFixturePropPixelOffsetMode : GraphicsFixture {
\r
2943 public override void SetUp() {
\r
2944 base.SetUp ("GraphicsFixturePropPixelOffsetMode");
\r
2945 t.Graphics.PixelOffsetMode = PixelOffsetMode.Half;
\r
2947 st["TransformPointsPointF:2"] = TOLERANCE * 3.0f;
\r
2951 [Category("NotWorking")]
\r
2952 public override void DrawIconTest() {
\r
2953 base.DrawIconTest ();
\r
2957 [Category("NotWorking")]
\r
2958 public override void DrawIconUnstretchedTest() {
\r
2959 base.DrawIconUnstretchedTest ();
\r
2963 [Category("NotWorking")]
\r
2964 public override void DrawImageUnscaledTest() {
\r
2965 base.DrawImageUnscaledTest ();
\r
2969 [Category("NotWorking")]
\r
2970 public override void DrawStringFloatFormat() {
\r
2971 base.DrawStringFloatFormat ();
\r
2975 [Category("NotWorking")]
\r
2976 public override void MeasureCharacterRangesRegions() {
\r
2977 base.MeasureCharacterRangesRegions ();
\r
2981 [Category("NotWorking")]
\r
2982 public override void MeasureStringSizeFFormatInts() {
\r
2983 base.MeasureStringSizeFFormatInts ();
\r
2988 public class GraphicsFixturePropPixelOffsetMode1 : GraphicsFixture {
\r
2989 public override void SetUp() {
\r
2990 base.SetUp ("GraphicsFixturePropPixelOffsetMode1");
\r
2991 t.Graphics.PixelOffsetMode = PixelOffsetMode.HighSpeed;
\r
2995 [Category("NotWorking")]
\r
2996 public override void DrawIconTest() {
\r
2997 base.DrawIconTest ();
\r
3001 [Category("NotWorking")]
\r
3002 public override void DrawIconUnstretchedTest() {
\r
3003 base.DrawIconUnstretchedTest ();
\r
3007 [Category("NotWorking")]
\r
3008 public override void DrawImageUnscaledTest() {
\r
3009 base.DrawImageUnscaledTest ();
\r
3013 [Category("NotWorking")]
\r
3014 public override void DrawStringFloatFormat() {
\r
3015 base.DrawStringFloatFormat ();
\r
3019 [Category("NotWorking")]
\r
3020 public override void MeasureCharacterRangesRegions() {
\r
3021 base.MeasureCharacterRangesRegions ();
\r
3025 [Category("NotWorking")]
\r
3026 public override void MeasureStringSizeFFormatInts() {
\r
3027 base.MeasureStringSizeFFormatInts ();
\r
3032 public class GraphicsFixturePropPixelOffsetMode2 : GraphicsFixture {
\r
3033 public override void SetUp() {
\r
3034 base.SetUp ("GraphicsFixturePropPixelOffsetMode2");
\r
3035 t.Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
\r
3037 st["TransformPointsPointF:2"] = TOLERANCE * 3.0f;
\r
3041 [Category("NotWorking")]
\r
3042 public override void DrawIconTest() {
\r
3043 base.DrawIconTest ();
\r
3047 [Category("NotWorking")]
\r
3048 public override void DrawIconUnstretchedTest() {
\r
3049 base.DrawIconUnstretchedTest ();
\r
3053 [Category("NotWorking")]
\r
3054 public override void DrawImageUnscaledTest() {
\r
3055 base.DrawImageUnscaledTest ();
\r
3059 [Category("NotWorking")]
\r
3060 public override void DrawStringFloatFormat() {
\r
3061 base.DrawStringFloatFormat ();
\r
3065 [Category("NotWorking")]
\r
3066 public override void MeasureCharacterRangesRegions() {
\r
3067 base.MeasureCharacterRangesRegions ();
\r
3071 [Category("NotWorking")]
\r
3072 public override void MeasureStringSizeFFormatInts() {
\r
3073 base.MeasureStringSizeFFormatInts ();
\r
3079 #region GraphicsFixturePropRenderingOrigin
\r
3082 [Category("NotWorking")]
\r
3083 public class GraphicsFixturePropRenderingOrigin : GraphicsFixture {
\r
3084 public override void SetUp() {
\r
3085 base.SetUp ("GraphicsFixturePropRenderingOrigin");
\r
3086 t.Graphics.RenderingOrigin = new Point(12, 23);
\r
3090 [Category("NotWorking")]
\r
3091 public override void BeginContainerTest() {
\r
3092 base.BeginContainerTest ();
\r
3096 [Category("NotWorking")]
\r
3097 public override void BeginContainerTest_2() {
\r
3098 base.BeginContainerTest_2 ();
\r
3102 [Category("NotWorking")]
\r
3103 public override void ClearTest() {
\r
3104 base.ClearTest ();
\r
3108 [Category("NotWorking")]
\r
3109 public override void DrawArcTest() {
\r
3110 base.DrawArcTest ();
\r
3114 [Category("NotWorking")]
\r
3115 public override void DrawBezierTest() {
\r
3116 base.DrawBezierTest ();
\r
3120 [Category("NotWorking")]
\r
3121 public override void DrawBeziersTest() {
\r
3122 base.DrawBeziersTest ();
\r
3126 [Category("NotWorking")]
\r
3127 public override void DrawClosedCurveTest() {
\r
3128 base.DrawClosedCurveTest ();
\r
3132 [Category("NotWorking")]
\r
3133 public override void DrawCurveTest() {
\r
3134 base.DrawCurveTest ();
\r
3138 [Category("NotWorking")]
\r
3139 public override void DrawCurveTestF() {
\r
3140 base.DrawCurveTestF ();
\r
3144 [Category("NotWorking")]
\r
3145 public override void DrawEllipseTest() {
\r
3146 base.DrawEllipseTest ();
\r
3150 [Category("NotWorking")]
\r
3151 public override void DrawEllipseTestF() {
\r
3152 base.DrawEllipseTestF ();
\r
3156 [Category("NotWorking")]
\r
3157 public override void DrawIconTest() {
\r
3158 base.DrawIconTest ();
\r
3162 [Category("NotWorking")]
\r
3163 public override void DrawIconUnstretchedTest() {
\r
3164 base.DrawIconUnstretchedTest ();
\r
3168 [Category("NotWorking")]
\r
3169 public override void DrawImageUnscaledTest() {
\r
3170 base.DrawImageUnscaledTest ();
\r
3174 [Category("NotWorking")]
\r
3175 public override void DrawLineTest() {
\r
3176 base.DrawLineTest ();
\r
3180 [Category("NotWorking")]
\r
3181 public override void DrawLineTestF() {
\r
3182 base.DrawLineTestF ();
\r
3186 [Category("NotWorking")]
\r
3187 public override void DrawLinesTest() {
\r
3188 base.DrawLinesTest ();
\r
3192 [Category("NotWorking")]
\r
3193 public override void DrawLinesTestF() {
\r
3194 base.DrawLinesTestF ();
\r
3198 [Category("NotWorking")]
\r
3199 public override void DrawPathTest() {
\r
3200 base.DrawPathTest ();
\r
3204 [Category("NotWorking")]
\r
3205 public override void DrawPieTestF() {
\r
3206 base.DrawPieTestF ();
\r
3210 [Category("NotWorking")]
\r
3211 public override void DrawPieTest() {
\r
3212 base.DrawPieTest ();
\r
3216 [Category("NotWorking")]
\r
3217 public override void DrawPolygonPoint() {
\r
3218 base.DrawPolygonPoint ();
\r
3222 [Category("NotWorking")]
\r
3223 public override void DrawPolygonPointF() {
\r
3224 base.DrawPolygonPointF ();
\r
3228 [Category("NotWorking")]
\r
3229 public override void DrawRectangleFloat() {
\r
3230 base.DrawRectangleFloat ();
\r
3234 [Category("NotWorking")]
\r
3235 public override void DrawRectanglesRectangleF() {
\r
3236 base.DrawRectanglesRectangleF ();
\r
3240 [Category("NotWorking")]
\r
3241 public override void DrawRectanglesRectangle() {
\r
3242 base.DrawRectanglesRectangle ();
\r
3246 [Category("NotWorking")]
\r
3247 public override void DrawStringFloatFormat() {
\r
3248 base.DrawStringFloatFormat ();
\r
3252 [Category("NotWorking")]
\r
3253 public override void EndContainerState() {
\r
3254 base.EndContainerState ();
\r
3258 [Category("NotWorking")]
\r
3259 public override void EnumerateMetafile() {
\r
3260 base.EnumerateMetafile ();
\r
3264 [Category("NotWorking")]
\r
3265 public override void ExcludeClipRegion() {
\r
3266 base.ExcludeClipRegion ();
\r
3270 [Category("NotWorking")]
\r
3271 public override void FillClosedCurvePointFillModeTension() {
\r
3272 base.FillClosedCurvePointFillModeTension ();
\r
3276 [Category("NotWorking")]
\r
3277 public override void FillClosedCurvePointFFillModeTension() {
\r
3278 base.FillClosedCurvePointFFillModeTension ();
\r
3282 [Category("NotWorking")]
\r
3283 public override void FillEllipse() {
\r
3284 base.FillEllipse ();
\r
3288 [Category("NotWorking")]
\r
3289 public override void FillEllipseFloat() {
\r
3290 base.FillEllipseFloat ();
\r
3294 [Category("NotWorking")]
\r
3295 public override void FillPathEllipse() {
\r
3296 base.FillPathEllipse ();
\r
3300 [Category("NotWorking")]
\r
3301 public override void FillPieFloat() {
\r
3302 base.FillPieFloat ();
\r
3306 [Category("NotWorking")]
\r
3307 public override void FillPolygonPointFillMode() {
\r
3308 base.FillPolygonPointFillMode ();
\r
3312 [Category("NotWorking")]
\r
3313 public override void FillPolygonPointFFillMode() {
\r
3314 base.FillPolygonPointFFillMode ();
\r
3318 [Category("NotWorking")]
\r
3319 public override void FillRectangle() {
\r
3320 base.FillRectangle ();
\r
3324 [Category("NotWorking")]
\r
3325 public override void FillRectangleFloat() {
\r
3326 base.FillRectangleFloat ();
\r
3330 [Category("NotWorking")]
\r
3331 public override void FillRectanglesRectangle() {
\r
3332 base.FillRectanglesRectangle ();
\r
3336 [Category("NotWorking")]
\r
3337 public override void FillRectanglesRectangleF() {
\r
3338 base.FillRectanglesRectangleF ();
\r
3342 [Category("NotWorking")]
\r
3343 public override void FillRegionRectangle() {
\r
3344 base.FillRegionRectangle ();
\r
3348 [Category("NotWorking")]
\r
3349 public override void FlushTest() {
\r
3350 base.FlushTest ();
\r
3354 [Category("NotWorking")]
\r
3355 public override void IsVisible4Float() {
\r
3356 base.IsVisible4Float ();
\r
3360 [Category("NotWorking")]
\r
3361 public override void MeasureCharacterRangesRegions() {
\r
3362 base.MeasureCharacterRangesRegions ();
\r
3366 [Category("NotWorking")]
\r
3367 public override void MeasureStringSizeFFormatInts() {
\r
3368 base.MeasureStringSizeFFormatInts ();
\r
3372 [Category("NotWorking")]
\r
3373 public override void MultiplyTransform() {
\r
3374 base.MultiplyTransform ();
\r
3378 [Category("NotWorking")]
\r
3379 public override void MultiplyTransformMatrixOrder() {
\r
3380 base.MultiplyTransformMatrixOrder ();
\r
3384 [Category("NotWorking")]
\r
3385 public override void MultiplyTransformMatrixOrder1() {
\r
3386 base.MultiplyTransformMatrixOrder1 ();
\r
3390 [Category("NotWorking")]
\r
3391 public override void ResetClipIntersectClipRectangleF() {
\r
3392 base.ResetClipIntersectClipRectangleF ();
\r
3396 [Category("NotWorking")]
\r
3397 public override void SaveRestoreTranslate() {
\r
3398 base.SaveRestoreTranslate ();
\r
3402 [Category("NotWorking")]
\r
3403 public override void RotateTransformAngleMatrixOrder() {
\r
3404 base.RotateTransformAngleMatrixOrder ();
\r
3408 [Category("NotWorking")]
\r
3409 public override void RotateTransformAngleMatrixOrder1() {
\r
3410 base.RotateTransformAngleMatrixOrder1 ();
\r
3414 [Category("NotWorking")]
\r
3415 public override void ScaleTransformFloatMatrixOrder() {
\r
3416 base.ScaleTransformFloatMatrixOrder ();
\r
3420 [Category("NotWorking")]
\r
3421 public override void ScaleTransformFloatMatrixOrder1() {
\r
3422 base.ScaleTransformFloatMatrixOrder1 ();
\r
3426 [Category("NotWorking")]
\r
3427 public override void SetClipRegionCombine() {
\r
3428 base.SetClipRegionCombine ();
\r
3432 [Category("NotWorking")]
\r
3433 public override void TransformPointsPointF() {
\r
3434 base.TransformPointsPointF ();
\r
3438 [Category("NotWorking")]
\r
3439 public override void TranslateClipFloat() {
\r
3440 base.TranslateClipFloat ();
\r
3444 [Category("NotWorking")]
\r
3445 public override void TranslateTransformAngleMatrixOrder() {
\r
3446 base.TranslateTransformAngleMatrixOrder ();
\r
3450 [Category("NotWorking")]
\r
3451 public override void TranslateTransformAngleMatrixOrder1() {
\r
3452 base.TranslateTransformAngleMatrixOrder1 ();
\r
3456 [Category("NotWorking")]
\r
3457 public override void TransfromPageScaleUnits() {
\r
3458 base.TransfromPageScaleUnits ();
\r
3462 [Category("NotWorking")]
\r
3463 public override void TransfromPageScaleUnits_2() {
\r
3464 base.TransfromPageScaleUnits_2 ();
\r
3468 [Category("NotWorking")]
\r
3469 public override void TransfromPageScaleUnits_3() {
\r
3470 base.TransfromPageScaleUnits_3 ();
\r
3477 /// TBD: add more variants
\r
3479 #region GraphicsFixturePropSmoothingMode
\r
3482 public class GraphicsFixturePropSmoothingMode : GraphicsFixture {
\r
3483 public override void SetUp() {
\r
3484 base.SetUp ("GraphicsFixturePropSmoothingMode");
\r
3485 t.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
\r
3487 st["DrawArcTest:4"] = TOLERANCE * 3.0f;
\r
3488 st["DrawLineTest:2"] = TOLERANCE * 3.0f;
\r
3489 st["DrawLineTest:4"] = TOLERANCE * 3.0f; // difference in line width even in horizontal lines
\r
3490 st["DrawLineTestF:2"] = TOLERANCE * 3.0f;
\r
3491 st["DrawLineTestF:4"] = TOLERANCE * 3.0f;
\r
3492 st["DrawPieTest:2"] = TOLERANCE * 1.5f;
\r
3493 st["DrawPieTestF:2"] = TOLERANCE * 1.5f;
\r
3494 st["DrawPieTest:4"] = TOLERANCE * 1.5f;
\r
3495 st["DrawPieTestF:4"] = TOLERANCE * 1.5f;
\r
3496 st["DrawRectangleFloat:2"] = TOLERANCE * 3.0f; // big difference in line width
\r
3497 st["DrawRectangleFloat:4"] = TOLERANCE * 3.0f; // big difference in line width
\r
3498 st["DrawRectangleFloat:6"] = TOLERANCE * 3.0f;
\r
3499 st["DrawRectanglesRectangle:2"] = TOLERANCE * 3.0f;
\r
3500 st["DrawRectanglesRectangleF:2"] = TOLERANCE * 3.0f;
\r
3504 [Category("NotWorking")]
\r
3505 public override void DrawIconTest() {
\r
3506 base.DrawIconTest ();
\r
3510 [Category("NotWorking")]
\r
3511 public override void DrawIconUnstretchedTest() {
\r
3512 base.DrawIconUnstretchedTest ();
\r
3516 [Category("NotWorking")]
\r
3517 public override void DrawImageUnscaledTest() {
\r
3518 base.DrawImageUnscaledTest ();
\r
3522 [Category("NotWorking")]
\r
3523 public override void DrawStringFloatFormat() {
\r
3524 base.DrawStringFloatFormat ();
\r
3528 [Category("NotWorking")]
\r
3529 public override void MeasureCharacterRangesRegions() {
\r
3530 base.MeasureCharacterRangesRegions ();
\r
3534 [Category("NotWorking")]
\r
3535 public override void MeasureStringSizeFFormatInts() {
\r
3536 base.MeasureStringSizeFFormatInts ();
\r
3541 public class GraphicsFixturePropSmoothingMode1 : GraphicsFixture {
\r
3542 public override void SetUp() {
\r
3543 base.SetUp ("GraphicsFixturePropSmoothingMode1");
\r
3544 t.Graphics.SmoothingMode = SmoothingMode.HighSpeed;
\r
3548 [Category("NotWorking")]
\r
3549 public override void DrawIconTest() {
\r
3550 base.DrawIconTest ();
\r
3554 [Category("NotWorking")]
\r
3555 public override void DrawIconUnstretchedTest() {
\r
3556 base.DrawIconUnstretchedTest ();
\r
3560 [Category("NotWorking")]
\r
3561 public override void DrawImageUnscaledTest() {
\r
3562 base.DrawImageUnscaledTest ();
\r
3566 [Category("NotWorking")]
\r
3567 public override void DrawStringFloatFormat() {
\r
3568 base.DrawStringFloatFormat ();
\r
3572 [Category("NotWorking")]
\r
3573 public override void MeasureCharacterRangesRegions() {
\r
3574 base.MeasureCharacterRangesRegions ();
\r
3578 [Category("NotWorking")]
\r
3579 public override void MeasureStringSizeFFormatInts() {
\r
3580 base.MeasureStringSizeFFormatInts ();
\r
3586 #region GraphicsFixturePropTextContrast
\r
3589 public class GraphicsFixturePropTextContrast : GraphicsFixture {
\r
3590 public override void SetUp() {
\r
3591 base.SetUp ("GraphicsFixturePropTextContrast");
\r
3592 t.Graphics.TextContrast = 9;
\r
3596 [Category("NotWorking")]
\r
3597 public override void DrawIconTest() {
\r
3598 base.DrawIconTest ();
\r
3602 [Category("NotWorking")]
\r
3603 public override void DrawIconUnstretchedTest() {
\r
3604 base.DrawIconUnstretchedTest ();
\r
3608 [Category("NotWorking")]
\r
3609 public override void DrawImageUnscaledTest() {
\r
3610 base.DrawImageUnscaledTest ();
\r
3614 [Category("NotWorking")]
\r
3615 public override void DrawStringFloatFormat() {
\r
3616 base.DrawStringFloatFormat ();
\r
3620 [Category("NotWorking")]
\r
3621 public override void MeasureCharacterRangesRegions() {
\r
3622 base.MeasureCharacterRangesRegions ();
\r
3626 [Category("NotWorking")]
\r
3627 public override void MeasureStringSizeFFormatInts() {
\r
3628 base.MeasureStringSizeFFormatInts ();
\r
3634 #region GraphicsFixtureGraphicsState
\r
3637 public class GraphicsFixtureGraphicsState {
\r
3638 protected DrawingTest t;
\r
3639 protected int TOLERANCE = 3; //in %;
\r
3642 public virtual void SetUp() {
\r
3643 t = DrawingTest.Create(512, 512, "GraphicsFixtureGraphicsState");
\r
3647 public void TearDown ()
\r
3654 public void BeginEndContainer() {
\r
3655 t.Graphics.FillRectangle( Brushes.Blue, 0, 0, 100, 100 );
\r
3657 GraphicsContainer c1 = t.Graphics.BeginContainer(
\r
3658 new Rectangle(100, 100, 100, 100),
\r
3659 new Rectangle(0, 0, 100, 100),
\r
3660 GraphicsUnit.Pixel);
\r
3662 t.Graphics.FillRectangle( Brushes.Green, 0, 0, 100, 100 );
\r
3664 GraphicsContainer c2 = t.Graphics.BeginContainer(
\r
3665 new Rectangle(100, 100, 100, 100),
\r
3666 new Rectangle(0, 0, 100, 100),
\r
3667 GraphicsUnit.Pixel);
\r
3669 t.Graphics.FillRectangle( Brushes.Red, 0, 0, 100, 100 );
\r
3671 GraphicsState s1 = t.Graphics.Save();
\r
3672 t.Graphics.PageUnit = GraphicsUnit.Pixel;
\r
3674 t.Graphics.PageScale = 0.7f;
\r
3675 t.Graphics.FillRectangle( Brushes.SeaGreen, 0, 0, 100, 100 );
\r
3677 t.Graphics.EndContainer(c2);
\r
3678 t.Graphics.PageScale = 0.7f;
\r
3679 t.Graphics.FillRectangle( Brushes.SeaGreen, 0, 0, 100, 100 );
\r
3681 t.Graphics.EndContainer(c1);
\r
3682 t.Graphics.PageScale = 0.7f;
\r
3683 t.Graphics.FillRectangle( Brushes.SeaGreen, 0, 0, 100, 100 );
\r
3686 Assert.IsTrue(t.PDCompare());
\r
3690 public void SaveRestoreGraphicsProps() {
\r
3691 t.Graphics.CompositingQuality = CompositingQuality.GammaCorrected;
\r
3692 t.Graphics.CompositingMode = CompositingMode.SourceCopy;
\r
3693 t.Graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
\r
3694 t.Graphics.PageScale = 7;
\r
3695 t.Graphics.PageUnit = GraphicsUnit.Inch;
\r
3696 t.Graphics.PixelOffsetMode = PixelOffsetMode.Half;
\r
3697 t.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
\r
3698 t.Graphics.Transform = new Matrix(1, 2, 3, 4, 5, 6);
\r
3699 t.Graphics.TextContrast = 10;
\r
3700 t.Graphics.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
\r
3702 GraphicsContainer c1 = t.Graphics.BeginContainer();
\r
3704 Assert.AreEqual(CompositingQuality.Default, t.Graphics.CompositingQuality);
\r
3705 Assert.AreEqual(CompositingMode.SourceOver, t.Graphics.CompositingMode);
\r
3706 Assert.AreEqual(InterpolationMode.Bilinear, t.Graphics.InterpolationMode);
\r
3707 Assert.AreEqual(1.0F, t.Graphics.PageScale);
\r
3708 Assert.AreEqual(GraphicsUnit.Display, t.Graphics.PageUnit);
\r
3709 Assert.AreEqual(PixelOffsetMode.Default, t.Graphics.PixelOffsetMode);
\r
3710 Assert.AreEqual(SmoothingMode.None, t.Graphics.SmoothingMode);
\r
3711 Assert.AreEqual(true, t.Graphics.Transform.IsIdentity);
\r
3712 Assert.AreEqual(4.0f, t.Graphics.TextContrast);
\r
3713 Assert.AreEqual(TextRenderingHint.SystemDefault, t.Graphics.TextRenderingHint);
\r
3715 t.Graphics.EndContainer(c1);
\r
3718 public void SaveRestoreGraphicsProps_2() {
\r
3719 GraphicsState s = t.Graphics.Save();
\r
3721 t.Graphics.CompositingQuality = CompositingQuality.GammaCorrected;
\r
3722 t.Graphics.CompositingMode = CompositingMode.SourceCopy;
\r
3723 t.Graphics.InterpolationMode = InterpolationMode.NearestNeighbor;
\r
3724 t.Graphics.PageScale = 7;
\r
3725 t.Graphics.PageUnit = GraphicsUnit.Inch;
\r
3726 t.Graphics.PixelOffsetMode = PixelOffsetMode.Half;
\r
3727 t.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
\r
3728 t.Graphics.Transform = new Matrix(1, 2, 3, 4, 5, 6);
\r
3729 t.Graphics.TextContrast = 10;
\r
3730 t.Graphics.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
\r
3732 t.Graphics.Restore(s);
\r
3734 Assert.AreEqual(CompositingQuality.Default, t.Graphics.CompositingQuality);
\r
3735 Assert.AreEqual(CompositingMode.SourceOver, t.Graphics.CompositingMode);
\r
3736 Assert.AreEqual(InterpolationMode.Bilinear, t.Graphics.InterpolationMode);
\r
3737 Assert.AreEqual(1.0F, t.Graphics.PageScale);
\r
3738 Assert.AreEqual(GraphicsUnit.Display, t.Graphics.PageUnit);
\r
3739 Assert.AreEqual(PixelOffsetMode.Default, t.Graphics.PixelOffsetMode);
\r
3740 Assert.AreEqual(SmoothingMode.None, t.Graphics.SmoothingMode);
\r
3741 Assert.AreEqual(true, t.Graphics.Transform.IsIdentity);
\r
3742 Assert.AreEqual(4.0f, t.Graphics.TextContrast);
\r
3743 Assert.AreEqual(TextRenderingHint.SystemDefault, t.Graphics.TextRenderingHint);
\r
3747 public void SaveRestoreGraphicsProps_3() {
\r
3748 t.Graphics.PageScale = 2;
\r
3749 GraphicsContainer c1 = t.Graphics.BeginContainer();
\r
3751 t.Graphics.PageScale = 3;
\r
3752 GraphicsContainer c2 = t.Graphics.BeginContainer();
\r
3754 t.Graphics.PageScale = 4;
\r
3755 GraphicsContainer c3 = t.Graphics.BeginContainer();
\r
3757 t.Graphics.EndContainer(c2);
\r
3758 Assert.AreEqual(3, t.Graphics.PageScale);
\r
3760 t.Graphics.PageScale = 5;
\r
3761 GraphicsState c5 = t.Graphics.Save();
\r
3763 t.Graphics.EndContainer(c3);
\r
3764 Assert.AreEqual(5, t.Graphics.PageScale);
\r
3766 t.Graphics.Restore(c5);
\r
3767 Assert.AreEqual(5, t.Graphics.PageScale);
\r
3769 t.Graphics.EndContainer(c1);
\r
3770 Assert.AreEqual(2, t.Graphics.PageScale);
\r
3773 public void SaveRestoreGraphicsProps_4() {
\r
3774 t.Graphics.PageScale = 2;
\r
3775 GraphicsContainer c1 = t.Graphics.BeginContainer();
\r
3777 t.Graphics.PageScale = 3;
\r
3778 GraphicsState c2 = t.Graphics.Save();
\r
3780 t.Graphics.EndContainer(c1);
\r
3781 Assert.AreEqual(2, t.Graphics.PageScale);
\r
3783 t.Graphics.Restore(c2);
\r
3784 Assert.AreEqual(2, t.Graphics.PageScale);
\r
3789 #region GraphicsFixturePropTextRenderingHint
\r
3792 public class GraphicsFixturePropTextRenderingHint : GraphicsFixture {
\r
3793 public override void SetUp() {
\r
3794 base.SetUp ("GraphicsFixturePropTextRenderingHint");
\r
3795 t.Graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
\r
3799 [Category("NotWorking")]
\r
3800 public override void DrawIconTest() {
\r
3801 base.DrawIconTest ();
\r
3805 [Category("NotWorking")]
\r
3806 public override void DrawIconUnstretchedTest() {
\r
3807 base.DrawIconUnstretchedTest ();
\r
3811 [Category("NotWorking")]
\r
3812 public override void DrawImageUnscaledTest() {
\r
3813 base.DrawImageUnscaledTest ();
\r
3817 [Category("NotWorking")]
\r
3818 public override void DrawStringFloatFormat() {
\r
3819 base.DrawStringFloatFormat ();
\r
3823 [Category("NotWorking")]
\r
3824 public override void MeasureCharacterRangesRegions() {
\r
3825 base.MeasureCharacterRangesRegions ();
\r
3829 [Category("NotWorking")]
\r
3830 public override void MeasureStringSizeFFormatInts() {
\r
3831 base.MeasureStringSizeFFormatInts ();
\r
3836 public class GraphicsFixturePropTextRenderingHint1 : GraphicsFixture {
\r
3837 public override void SetUp() {
\r
3838 base.SetUp ("GraphicsFixturePropTextRenderingHint1");
\r
3839 t.Graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
\r
3843 [Category("NotWorking")]
\r
3844 public override void DrawIconTest() {
\r
3845 base.DrawIconTest ();
\r
3849 [Category("NotWorking")]
\r
3850 public override void DrawIconUnstretchedTest() {
\r
3851 base.DrawIconUnstretchedTest ();
\r
3855 [Category("NotWorking")]
\r
3856 public override void DrawImageUnscaledTest() {
\r
3857 base.DrawImageUnscaledTest ();
\r
3861 [Category("NotWorking")]
\r
3862 public override void DrawStringFloatFormat() {
\r
3863 base.DrawStringFloatFormat ();
\r
3867 [Category("NotWorking")]
\r
3868 public override void MeasureCharacterRangesRegions() {
\r
3869 base.MeasureCharacterRangesRegions ();
\r
3873 [Category("NotWorking")]
\r
3874 public override void MeasureStringSizeFFormatInts() {
\r
3875 base.MeasureStringSizeFFormatInts ();
\r
3880 public class GraphicsFixturePropTextRenderingHint2 : GraphicsFixture {
\r
3881 public override void SetUp() {
\r
3882 base.SetUp ("GraphicsFixturePropTextRenderingHint2");
\r
3883 t.Graphics.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
\r
3887 [Category("NotWorking")]
\r
3888 public override void DrawIconTest() {
\r
3889 base.DrawIconTest ();
\r
3893 [Category("NotWorking")]
\r
3894 public override void DrawIconUnstretchedTest() {
\r
3895 base.DrawIconUnstretchedTest ();
\r
3899 [Category("NotWorking")]
\r
3900 public override void DrawImageUnscaledTest() {
\r
3901 base.DrawImageUnscaledTest ();
\r
3905 [Category("NotWorking")]
\r
3906 public override void DrawStringFloatFormat() {
\r
3907 base.DrawStringFloatFormat ();
\r
3911 [Category("NotWorking")]
\r
3912 public override void MeasureCharacterRangesRegions() {
\r
3913 base.MeasureCharacterRangesRegions ();
\r
3917 [Category("NotWorking")]
\r
3918 public override void MeasureStringSizeFFormatInts() {
\r
3919 base.MeasureStringSizeFFormatInts ();
\r
3924 public class GraphicsFixturePropTextRenderingHint3 : GraphicsFixture {
\r
3925 public override void SetUp() {
\r
3926 base.SetUp ("GraphicsFixturePropTextRenderingHint3");
\r
3927 t.Graphics.TextRenderingHint = TextRenderingHint.SingleBitPerPixel;
\r
3931 [Category("NotWorking")]
\r
3932 public override void DrawIconTest() {
\r
3933 base.DrawIconTest ();
\r
3937 [Category("NotWorking")]
\r
3938 public override void DrawIconUnstretchedTest() {
\r
3939 base.DrawIconUnstretchedTest ();
\r
3943 [Category("NotWorking")]
\r
3944 public override void DrawImageUnscaledTest() {
\r
3945 base.DrawImageUnscaledTest ();
\r
3949 [Category("NotWorking")]
\r
3950 public override void DrawStringFloatFormat() {
\r
3951 base.DrawStringFloatFormat ();
\r
3955 [Category("NotWorking")]
\r
3956 public override void MeasureCharacterRangesRegions() {
\r
3957 base.MeasureCharacterRangesRegions ();
\r
3961 [Category("NotWorking")]
\r
3962 public override void MeasureStringSizeFFormatInts() {
\r
3963 base.MeasureStringSizeFFormatInts ();
\r
3968 public class GraphicsFixturePropTextRenderingHint4 : GraphicsFixture {
\r
3969 public override void SetUp() {
\r
3970 base.SetUp ("GraphicsFixturePropTextRenderingHint4");
\r
3971 t.Graphics.TextRenderingHint = TextRenderingHint.SingleBitPerPixelGridFit;
\r
3975 [Category("NotWorking")]
\r
3976 public override void DrawIconTest() {
\r
3977 base.DrawIconTest ();
\r
3981 [Category("NotWorking")]
\r
3982 public override void DrawIconUnstretchedTest() {
\r
3983 base.DrawIconUnstretchedTest ();
\r
3987 [Category("NotWorking")]
\r
3988 public override void DrawImageUnscaledTest() {
\r
3989 base.DrawImageUnscaledTest ();
\r
3993 [Category("NotWorking")]
\r
3994 public override void DrawStringFloatFormat() {
\r
3995 base.DrawStringFloatFormat ();
\r
3999 [Category("NotWorking")]
\r
4000 public override void MeasureCharacterRangesRegions() {
\r
4001 base.MeasureCharacterRangesRegions ();
\r
4005 [Category("NotWorking")]
\r
4006 public override void MeasureStringSizeFFormatInts() {
\r
4007 base.MeasureStringSizeFFormatInts ();
\r
4012 public class GraphicsFixturePropTextRenderingHint5 : GraphicsFixture {
\r
4013 public override void SetUp() {
\r
4014 base.SetUp ("GraphicsFixturePropTextRenderingHint5");
\r
4015 t.Graphics.TextRenderingHint = TextRenderingHint.SystemDefault;
\r
4019 [Category("NotWorking")]
\r
4020 public override void DrawIconTest() {
\r
4021 base.DrawIconTest ();
\r
4025 [Category("NotWorking")]
\r
4026 public override void DrawIconUnstretchedTest() {
\r
4027 base.DrawIconUnstretchedTest ();
\r
4031 [Category("NotWorking")]
\r
4032 public override void DrawImageUnscaledTest() {
\r
4033 base.DrawImageUnscaledTest ();
\r
4037 [Category("NotWorking")]
\r
4038 public override void DrawStringFloatFormat() {
\r
4039 base.DrawStringFloatFormat ();
\r
4043 [Category("NotWorking")]
\r
4044 public override void MeasureCharacterRangesRegions() {
\r
4045 base.MeasureCharacterRangesRegions ();
\r
4049 [Category("NotWorking")]
\r
4050 public override void MeasureStringSizeFFormatInts() {
\r
4051 base.MeasureStringSizeFFormatInts ();
\r
4057 #region GraphicsFixturePropTransform
\r
4060 public class GraphicsFixturePropTransform : GraphicsFixture {
\r
4061 public override void SetUp() {
\r
4062 base.SetUp ("GraphicsFixturePropTransform");
\r
4063 t.Graphics.Transform = new Matrix(0, 1, 2, 0, 0, 0);
\r
4065 st["DrawArcTest:2"] = TOLERANCE * 11.0f; // FIXME: Transfrom is ok, but very big difference in width
\r
4066 st["DrawArcTest:4"] = TOLERANCE * 12.0f; // FIXME: Transfrom is ok, but very big difference in width
\r
4067 st["DrawArcTest:6"] = TOLERANCE * 12.0f; // FIXME: Transfrom is ok, but very big difference in width
\r
4068 st["DrawArcTest:8"] = TOLERANCE * 10.0f; // FIXME: Transfrom is ok, but very big difference in width
\r
4069 st["DrawClosedCurveTest:4"] = TOLERANCE * 2.0f;
\r
4070 st["RotateTransformAngleMatrixOrder:2"] = TOLERANCE * 1.5f;
\r
4071 st["TransformPointsPointF:2"] = TOLERANCE * 3.5f;
\r
4075 [Category("NotWorking")]
\r
4076 public override void DrawIconTest() {
\r
4077 base.DrawIconTest ();
\r
4081 [Category("NotWorking")]
\r
4082 public override void DrawIconUnstretchedTest() {
\r
4083 base.DrawIconUnstretchedTest ();
\r
4087 [Category("NotWorking")]
\r
4088 public override void DrawImageUnscaledTest() {
\r
4089 base.DrawImageUnscaledTest ();
\r
4093 [Category("NotWorking")]
\r
4094 public override void DrawStringFloatFormat() {
\r
4095 base.DrawStringFloatFormat ();
\r
4099 [Category("NotWorking")]
\r
4100 public override void MeasureCharacterRangesRegions() {
\r
4101 base.MeasureCharacterRangesRegions ();
\r
4105 [Category("NotWorking")]
\r
4106 public override void MeasureStringSizeFFormatInts() {
\r
4107 base.MeasureStringSizeFFormatInts ();
\r
projects / mono.git / blob