/hg/gfx-test: Added support for linear and closed Path2D.Float a...

[ptisnovs at icedtea.classpath.org]

changeset a331ece4516a in /hg/gfx-test
details: http://icedtea.classpath.org/hg/gfx-test?cmd=changeset;node=a331ece4516a
author: Pavel Tisnovsky <ptisnovs at redhat.com>
date: Tue Nov 13 11:03:22 2012 +0100

	Added support for linear and closed Path2D.Float and Path2D.Double
	in the framework class src/org/gfxtest/framework/CommonPathsGenerator.java.


diffstat:

 ChangeLog                                           |    5 +
 src/org/gfxtest/framework/CommonPathsGenerator.java |  225 ++++++++++++++++++++
 2 files changed, 230 insertions(+), 0 deletions(-)

diffs (261 lines):

diff -r 24e9281c1f40 -r a331ece4516a ChangeLog
--- a/ChangeLog	Mon Nov 12 10:02:31 2012 +0100
+++ b/ChangeLog	Tue Nov 13 11:03:22 2012 +0100
@@ -1,3 +1,8 @@
+2012-11-13  Pavel Tisnovsky  <ptisnovs at redhat.com>
+
+	* src/org/gfxtest/framework/CommonPathsGenerator.java:
+	Support for linear and closed Path2D.Float and Path2D.Double.
+
 2012-11-12  Pavel Tisnovsky  <ptisnovs at redhat.com>
 
 	* src/org/gfxtest/testsuites/BitBltBasicTests.java:
diff -r 24e9281c1f40 -r a331ece4516a src/org/gfxtest/framework/CommonPathsGenerator.java
--- a/src/org/gfxtest/framework/CommonPathsGenerator.java	Mon Nov 12 10:02:31 2012 +0100
+++ b/src/org/gfxtest/framework/CommonPathsGenerator.java	Tue Nov 13 11:03:22 2012 +0100
@@ -97,6 +97,41 @@
     }
 
     /**
+     * Create new path using Path2D.Double() which contains just one line.
+     * 
+     * @param image
+     *            test image
+     * @return created path
+     */
+    public static Path2D createLinePathDouble(TestImage image)
+    {
+        return createLinePathDouble(image.getWidth(), image.getHeight());
+    }
+
+    /**
+     * Create new path using Path2D.Double() which contains just one line.
+     * 
+     * @param width
+     *            canvas width
+     * @param height
+     *            canvas height
+     * @return created path
+     */
+    public static Path2D createLinePathDouble(int width, int height)
+    {
+        Path2D path = new Path2D.Double();
+        // start point
+        int x1 = LINE_PATH_OFFSET;
+        int y1 = LINE_PATH_OFFSET;
+        // end point
+        int x2 = width - LINE_PATH_OFFSET;
+        int y2 = height - LINE_PATH_OFFSET;
+        path.moveTo(x1, y1);
+        path.lineTo(x2, y2);
+        return path;
+    }
+
+    /**
      * Create new path using Path2D.Float() which contains just one quadratic
      * curve.
      * 
@@ -586,6 +621,156 @@
     }
 
     /**
+     * 
+     * @param image
+     * @return
+     */
+    public static Path2D createClosedPathContainingQuadraticSegmentFloat(TestImage image)
+    {
+        return createClosedPathContainingCubicSegmentFloat(image.getWidth(), image.getHeight());
+    }
+
+    /**
+     * 
+     * @param width
+     * @param height
+     * @return
+     */
+    public static Path2D createClosedPathContainingQuadraticSegmentFloat(int width, int height)
+    {
+        Path2D path = new Path2D.Float();
+        // 1st vertex
+        int x1 = LINE_PATH_OFFSET;
+        int y1 = LINE_PATH_OFFSET;
+        // 2nd vertex
+        int x2 = width - LINE_PATH_OFFSET;
+        int y2 = y1;
+        // 3rd vertex
+        int x3 = x2;
+        int y3 = height - LINE_PATH_OFFSET;
+        // 4rd vertex
+        int x4 = x1;
+        int y4 = y3;
+        path.moveTo(x1, y1);
+        path.lineTo(x2, y2);
+        path.quadTo(x3, y3, x4, y4);
+        path.closePath();
+        return path;
+    }
+
+    /**
+     * 
+     * @param image
+     * @return
+     */
+    public static Path2D createClosedPathContainingCubicSegmentFloat(TestImage image)
+    {
+        return createClosedPathContainingCubicSegmentFloat(image.getWidth(), image.getHeight());
+    }
+
+    /**
+     * 
+     * @param width
+     * @param height
+     * @return
+     */
+    public static Path2D createClosedPathContainingCubicSegmentFloat(int width, int height)
+    {
+        Path2D path = new Path2D.Float();
+        // 1st vertex
+        int x1 = LINE_PATH_OFFSET;
+        int y1 = LINE_PATH_OFFSET;
+        // 2nd vertex
+        int x2 = width - LINE_PATH_OFFSET;
+        int y2 = y1;
+        // 3rd vertex
+        int x3 = x2;
+        int y3 = height - LINE_PATH_OFFSET;
+        // 4rd vertex
+        int x4 = x1;
+        int y4 = y3;
+        path.moveTo(x1, y1);
+        path.curveTo(x2, y2, x3, y3, x4, y4);
+        path.closePath();
+        return path;
+    }
+
+    /**
+     * 
+     * @param image
+     * @return
+     */
+    public static Path2D createClosedPathContainingQuadraticSegmentDouble(TestImage image)
+    {
+        return createClosedPathContainingQuadraticSegmentDouble(image.getWidth(), image.getHeight());
+    }
+
+    /**
+     * 
+     * @param width
+     * @param height
+     * @return
+     */
+    public static Path2D createClosedPathContainingQuadraticSegmentDouble(int width, int height)
+    {
+        Path2D path = new Path2D.Double();
+        // 1st vertex
+        int x1 = LINE_PATH_OFFSET;
+        int y1 = LINE_PATH_OFFSET;
+        // 2nd vertex
+        int x2 = width - LINE_PATH_OFFSET;
+        int y2 = y1;
+        // 3rd vertex
+        int x3 = x2;
+        int y3 = height - LINE_PATH_OFFSET;
+        // 4rd vertex
+        int x4 = x1;
+        int y4 = y3;
+        path.moveTo(x1, y1);
+        path.lineTo(x2, y2);
+        path.quadTo(x3, y3, x4, y4);
+        path.closePath();
+        return path;
+    }
+
+    /**
+     * 
+     * @param image
+     * @return
+     */
+    public static Path2D createClosedPathContainingCubicSegmentDouble(TestImage image)
+    {
+        return createClosedPathContainingCubicSegmentDouble(image.getWidth(), image.getHeight());
+    }
+
+    /**
+     * 
+     * @param width
+     * @param height
+     * @return
+     */
+    public static Path2D createClosedPathContainingCubicSegmentDouble(int width, int height)
+    {
+        Path2D path = new Path2D.Float();
+        // 1st vertex
+        int x1 = LINE_PATH_OFFSET;
+        int y1 = LINE_PATH_OFFSET;
+        // 2nd vertex
+        int x2 = width - LINE_PATH_OFFSET;
+        int y2 = y1;
+        // 3rd vertex
+        int x3 = x2;
+        int y3 = height - LINE_PATH_OFFSET;
+        // 4rd vertex
+        int x4 = x1;
+        int y4 = y3;
+        path.moveTo(x1, y1);
+        path.curveTo(x2, y2, x3, y3, x4, y4);
+        path.closePath();
+        return path;
+    }
+
+    /**
      * Create new path using Path2D.Float() which contains just lines.
      * 
      * @param image
@@ -629,6 +814,46 @@
         return path;
     }
 
+    public static Path2D createCrossedClosedPathContainingQuadraticSegmentFloat(TestImage image)
+    {
+        return createCrossedClosedPathContainingQuadraticSegmentFloat(image.getWidth(), image.getWidth());
+    }
+
+    public static Path2D createCrossedClosedPathContainingQuadraticSegmentFloat(int width, int height)
+    {
+        return null;
+    }
+
+    public static Path2D createCrossedClosedPathContainingQuadraticSegmentDouble(TestImage image)
+    {
+        return createCrossedClosedPathContainingQuadraticSegmentDouble(image.getWidth(), image.getWidth());
+    }
+
+    public static Path2D createCrossedClosedPathContainingQuadraticSegmentDouble(int width, int height)
+    {
+        return null;
+    }
+
+    public static Path2D createCrossedClosedPathContainingCubicSegmentFloat(TestImage image)
+    {
+        return createCrossedClosedPathContainingCubicSegmentFloat(image.getWidth(), image.getWidth());
+    }
+
+    public static Path2D createCrossedClosedPathContainingCubicSegmentFloat(int width, int height)
+    {
+        return null;
+    }
+
+    public static Path2D createCrossedClosedPathContainingCubicSegmentDouble(TestImage image)
+    {
+        return createCrossedClosedPathContainingCubicSegmentDouble(image.getWidth(), image.getWidth());
+    }
+
+    public static Path2D createCrossedClosedPathContainingCubicSegmentDouble(int width, int height)
+    {
+        return null;
+    }
+
     /**
      * Compute X coordinate of first curve end point.
      *