graphicspath.c File Reference

#include "objbase.h"
#include "gdiplus.h"
#include "wine/test.h"
#include <math.h>

Include dependency graph for graphicspath.c:

Go to the source code of this file.

Classes
struct	path_test_t

Macros
#define	expect(expected, got)   ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
#define	expectf(expected, got)   ok(fabs(expected - got) < 2.0, "Expected %.2f, got %.2f\n", expected, got)
#define	POINT_TYPE_MAX_LEN   (75)
#define	ok_path(a, b, c, d)   _ok_path_fudge(a,b,c,d,1.0,__LINE__)
#define	ok_path_fudge(a, b, c, d, e)   _ok_path_fudge(a,b,c,d,e,__LINE__)

Functions
static void	stringify_point_type (PathPointType type, char *name)
static void	_ok_path_fudge (GpPath *path, const path_test_t *expected, INT expected_size, BOOL todo_size, REAL fudge, int line)
static void	test_constructor_destructor (void)
static void	test_getpathdata (void)
static void	test_createpath2 (void)
static void	test_line2 (void)
static void	test_bezier (void)
static void	test_beziers (void)
static void	test_arc (void)
static void	test_worldbounds (void)
static void	test_pathpath (void)
static void	test_ellipse (void)
static void	test_linei (void)
static void	test_polygon (void)
static void	test_rect (void)
static void	test_lastpoint (void)
static void	test_addcurve (void)
static void	test_addclosedcurve (void)
static void	test_reverse (void)
static void	test_addpie (void)
static void	test_flatten (void)
static void	test_widen (void)
static void	test_widen_cap (void)
static void	test_isvisible (void)
static void	test_is_outline_visible_path_point (void)
static void	test_empty_rect (void)
static void	test_rect_line (void)
	START_TEST (graphicspath)

Variables
static path_test_t	line2_path []
static path_test_t	bezier_path []
static path_test_t	arc_path []
static path_test_t	arc_path2 []
static path_test_t	pathpath_path []
static path_test_t	ellipse_path []
static path_test_t	linei_path []
static path_test_t	poly_path []
static path_test_t	rect_path []
static path_test_t	addcurve_path []
static path_test_t	addcurve_path_default_tension []
static path_test_t	addcurve_path2 []
static path_test_t	addcurve_path3 []
static path_test_t	addcurve_path4 []
static path_test_t	addcurve_path5 []
static path_test_t	addclosedcurve_path []
static path_test_t	addclosedcurve_path_default_tension []
static path_test_t	reverse_path []
static path_test_t	addpie_path []
static path_test_t	addpie_path2 []
static path_test_t	addpie_path3 []
static path_test_t	flattenellipse_path []
static path_test_t	flattenline_path []
static path_test_t	flattenarc_path []
static path_test_t	flattenquater_path []
static path_test_t	widenline_path []
static path_test_t	widenline_wide_path []
static path_test_t	widenline_dash_path []
static path_test_t	widenline_thin_dash_path []
static path_test_t	widenline_unit_path []
static path_test_t	widenline_capflat_path []
static path_test_t	widenline_capsquare_path []
static path_test_t	widenline_capround_path []
static path_test_t	widenline_captriangle_path []
static path_test_t	widenline_capsquareanchor_path []
static path_test_t	widenline_caproundanchor_path []
static path_test_t	widenline_capdiamondanchor_path []
static path_test_t	widenline_caparrowanchor_path []
static path_test_t	widenline_capsquareanchor_thin_path []
static path_test_t	widenline_capsquareanchor_dashed_path []
static path_test_t	widenline_capsquareanchor_multifigure_path []
static path_test_t	widenline_customarrow_multifigure_path []
static path_test_t	rect_line_path []

Macro Definition Documentation

expect

#define expect	(		expected,
			got
	)		ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)

Definition at line 26 of file graphicspath.c.

expectf

#define expectf	(		expected,
			got
	)		ok(fabs(expected - got) < 2.0, "Expected %.2f, got %.2f\n", expected, got)

Definition at line 27 of file graphicspath.c.

ok_path

#define ok_path	(		a,
			b,
			c,
			d
	)		_ok_path_fudge(a,b,c,d,1.0,__LINE__)

Definition at line 78 of file graphicspath.c.

ok_path_fudge

#define ok_path_fudge	(		a,
			b,
			c,
			d,
			e
	)		_ok_path_fudge(a,b,c,d,e,__LINE__)

Definition at line 79 of file graphicspath.c.

POINT_TYPE_MAX_LEN

#define POINT_TYPE_MAX_LEN   (75)

Definition at line 28 of file graphicspath.c.

Function Documentation

_ok_path_fudge()

static void _ok_path_fudge ( GpPath *  path, const path_test_t *  expected, INT  expected_size, BOOL  todo_size, REAL  fudge, int  line  )

static

Definition at line 80 of file graphicspath.c.

{
    BYTE * types;
    INT size, idx = 0, eidx = 0, numskip;
    GpPointF * points;
    char ename[POINT_TYPE_MAX_LEN], name[POINT_TYPE_MAX_LEN];
 
    if(GdipGetPointCount(path, &size) != Ok){
        skip("Cannot perform path comparisons due to failure to retrieve path.\n");
        return;
    }
 
    todo_wine_if (todo_size)
        ok_(__FILE__,line)(size == expected_size, "Path size %d does not match expected size %d\n",
            size, expected_size);
 
    points = malloc(size * sizeof(GpPointF));
    types = malloc(size);
 
    if(GdipGetPathPoints(path, points, size) != Ok || GdipGetPathTypes(path, types, size) != Ok){
        skip("Cannot perform path comparisons due to failure to retrieve path.\n");
        goto end;
    }
 
    numskip = expected_size ? expected[eidx].wine_only_entries_preceding : 0;
    while (idx < size && eidx < expected_size){
        /* We allow a few pixels fudge in matching X and Y coordinates to account for imprecision in
         * floating point to integer conversion */
        BOOL match = (types[idx] == expected[eidx].type) &&
            fabs(points[idx].X - expected[eidx].X) <= fudge &&
            fabs(points[idx].Y - expected[eidx].Y) <= fudge;
 
        stringify_point_type(expected[eidx].type, ename);
        stringify_point_type(types[idx], name);
 
        todo_wine_if (expected[eidx].todo || numskip)
            ok_(__FILE__,line)(match, "Expected #%d: %s (%.6f,%.6f) but got %s (%.6f,%.6f)\n", eidx,
               ename, expected[eidx].X, expected[eidx].Y,
               name, points[idx].X, points[idx].Y);
 
        if (match || expected[eidx].todo != 2)
            idx++;
        if (match || !numskip--)
            numskip = expected[++eidx].wine_only_entries_preceding;
    }
 
end:
    free(types);
    free(points);
}

START_TEST()

START_TEST

(

graphicspath

)

Definition at line 2215 of file graphicspath.c.

{
    struct GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
    HMODULE hmsvcrt;
    int (CDECL * _controlfp_s)(unsigned int *cur, unsigned int newval, unsigned int mask);
 
    /* Enable all FP exceptions except _EM_INEXACT, which gdi32 can trigger */
    hmsvcrt = LoadLibraryA("msvcrt");
    _controlfp_s = (void*)GetProcAddress(hmsvcrt, "_controlfp_s");
    if (_controlfp_s) _controlfp_s(0, 0, 0x0008001e);
 
    gdiplusStartupInput.GdiplusVersion              = 1;
    gdiplusStartupInput.DebugEventCallback          = NULL;
    gdiplusStartupInput.SuppressBackgroundThread    = 0;
    gdiplusStartupInput.SuppressExternalCodecs      = 0;
 
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 
    test_constructor_destructor();
    test_getpathdata();
    test_createpath2();
    test_line2();
    test_bezier();
    test_beziers();
    test_arc();
    test_worldbounds();
    test_pathpath();
    test_ellipse();
    test_linei();
    test_rect();
    test_polygon();
    test_lastpoint();
    test_addcurve();
    test_addclosedcurve();
    test_reverse();
    test_addpie();
    test_flatten();
    test_widen();
    test_widen_cap();
    test_isvisible();
    test_is_outline_visible_path_point();
    test_empty_rect();
    test_rect_line();
 
    GdiplusShutdown(gdiplusToken);
}

stringify_point_type()

static void stringify_point_type ( PathPointType  type, char *  name  )

static

Definition at line 30 of file graphicspath.c.

{
    *name = '\0';
 
    switch(type & PathPointTypePathTypeMask){
        case PathPointTypeStart:
            strcat(name, "PathPointTypeStart");
            break;
        case PathPointTypeLine:
            strcat(name, "PathPointTypeLine");
            break;
        case PathPointTypeBezier:
            strcat(name, "PathPointTypeBezier");
            break;
        default:
            strcat(name, "Unknown type");
            return;
    }
 
    type &= ~PathPointTypePathTypeMask;
    if(type & ~((PathPointTypePathMarker | PathPointTypeCloseSubpath))){
        *name = '\0';
        strcat(name, "Unknown type");
        return;
    }
 
    if(type & PathPointTypePathMarker)
        strcat(name, " | PathPointTypePathMarker");
    if(type & PathPointTypeCloseSubpath)
        strcat(name, " | PathPointTypeCloseSubpath");
}

Referenced by _ok_path_fudge().

test_addclosedcurve()

static void test_addclosedcurve ( void  )

static

Definition at line 1094 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpPointF points[4];
 
    points[0].X = 0.0;
    points[0].Y = 0.0;
    points[1].X = 10.0;
    points[1].Y = 10.0;
    points[2].X = 10.0;
    points[2].Y = 20.0;
    points[3].X = 30.0;
    points[3].Y = 10.0;
 
    GdipCreatePath(FillModeAlternate, &path);
 
    /* NULL args */
    status = GdipAddPathClosedCurve2(NULL, NULL, 0, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathClosedCurve2(path, NULL, 0, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathClosedCurve2(path, points, -1, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathClosedCurve2(path, points, 1, 1.0);
    expect(InvalidParameter, status);
 
    /* add to empty path */
    status = GdipAddPathClosedCurve2(path, points, 4, 1.0);
    expect(Ok, status);
    ok_path(path, addclosedcurve_path, ARRAY_SIZE(addclosedcurve_path), FALSE);
    GdipDeletePath(path);
 
     /* add to empty path with default tension */
    GdipCreatePath(FillModeAlternate, &path);
    status = GdipAddPathClosedCurve(path, points, 4);
    expect(Ok, status);
    ok_path(path, addclosedcurve_path_default_tension, ARRAY_SIZE(addclosedcurve_path_default_tension), FALSE);
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_addcurve()

static void test_addcurve ( void  )

static

Definition at line 970 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpPointF points[4];
 
    points[0].X = 0.0;
    points[0].Y = 0.0;
    points[1].X = 10.0;
    points[1].Y = 10.0;
    points[2].X = 10.0;
    points[2].Y = 20.0;
    points[3].X = 30.0;
    points[3].Y = 10.0;
 
    GdipCreatePath(FillModeAlternate, &path);
 
    /* NULL args */
    status = GdipAddPathCurve2(NULL, NULL, 0, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve2(path, NULL, 0, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve2(path, points, -1, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve2(path, points, 1, 1.0);
    expect(InvalidParameter, status);
 
    /* add to empty path */
    status = GdipAddPathCurve2(path, points, 4, 1.0);
    expect(Ok, status);
    ok_path(path, addcurve_path, ARRAY_SIZE(addcurve_path), FALSE);
    GdipDeletePath(path);
 
    /* add to empty path with default tension */
    GdipCreatePath(FillModeAlternate, &path);
    status = GdipAddPathCurve(path, points, 4);
    expect(Ok, status);
    ok_path(path, addcurve_path_default_tension, ARRAY_SIZE(addcurve_path_default_tension), FALSE);
    GdipDeletePath(path);
 
    /* add to notempty path and opened figure */
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathLine(path, 100.0, 120.0, 123.0, 10.0);
    status = GdipAddPathCurve2(path, points, 4, 1.0);
    expect(Ok, status);
    ok_path(path, addcurve_path2, ARRAY_SIZE(addcurve_path2), FALSE);
 
    /* NULL args */
    GdipResetPath(path);
    status = GdipAddPathCurve3(NULL, NULL, 0, 0, 0, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve3(path, NULL, 0, 0, 0, 0.0);
    expect(InvalidParameter, status);
    /* wrong count, offset.. */
    status = GdipAddPathCurve3(path, points, 0, 0, 0, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve3(path, points, 4, 0, 0, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve3(path, points, 4, 0, 4, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve3(path, points, 4, 1, 3, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve3(path, points, 4, 1, 0, 0.0);
    expect(InvalidParameter, status);
    status = GdipAddPathCurve3(path, points, 4, 3, 1, 0.0);
    expect(InvalidParameter, status);
 
    /* use all points */
    status = GdipAddPathCurve3(path, points, 4, 0, 3, 1.0);
    expect(Ok, status);
    ok_path(path, addcurve_path, ARRAY_SIZE(addcurve_path), FALSE);
    GdipResetPath(path);
 
    /* Skip first point */
    status = GdipAddPathCurve3(path, points, 4, 1, 2, 1.0);
    expect(Ok, status);
    ok_path(path, addcurve_path3, ARRAY_SIZE(addcurve_path3), FALSE);
    GdipResetPath(path);
 
    /* Skip two last points */
    status = GdipAddPathCurve3(path, points, 4, 0, 1, 1.0);
    expect(Ok, status);
    ok_path(path, addcurve_path4, ARRAY_SIZE(addcurve_path4), FALSE);
    GdipResetPath(path);
 
    /* Skip first and last points */
    status = GdipAddPathCurve3(path, points, 4, 1, 1, 1.0);
    expect(Ok, status);
    ok_path(path, addcurve_path5, ARRAY_SIZE(addcurve_path5), FALSE);
    GdipResetPath(path);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_addpie()

static void test_addpie ( void  )

static

Definition at line 1191 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
 
    GdipCreatePath(FillModeAlternate, &path);
 
    /* NULL argument */
    status = GdipAddPathPie(NULL, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
    expect(InvalidParameter, status);
 
    status = GdipAddPathPie(path, 0.0, 0.0, 100.0, 50.0, 10.0, 50.0);
    expect(Ok, status);
    ok_path(path, addpie_path, ARRAY_SIZE(addpie_path), FALSE);
    status = GdipResetPath(path);
    expect(Ok, status);
 
    /* zero width base ellipse */
    status = GdipAddPathPie(path, 0.0, 0.0, 0.0, 60.0, -90.0, 24.0);
    expect(InvalidParameter, status);
    ok_path(path, addpie_path2, ARRAY_SIZE(addpie_path2), FALSE);
    status = GdipResetPath(path);
    expect(Ok, status);
 
    /* zero height base ellipse */
    status = GdipAddPathPie(path, 0.0, 0.0, 60.0, 0.0 , -90.0, 24.0);
    expect(InvalidParameter, status);
    ok_path(path, addpie_path3, ARRAY_SIZE(addpie_path3), FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_arc()

static void test_arc ( void  )

static

Definition at line 448 of file graphicspath.c.

{
    GpStatus status;
    GpPath* path;
 
    GdipCreatePath(FillModeAlternate, &path);
 
    status = GdipAddPathArc(path, 100.0, 100.0, 1.0, 0.0, 0.0, 90.0);
    expect(InvalidParameter, status);
 
    status = GdipAddPathArc(path, 100.0, 100.0, 0.0, 1.0, 0.0, 90.0);
    expect(InvalidParameter, status);
 
    status = GdipAddPathArc(path, 100.0, 100.0, -40, 1.0, 0.0, 90.0);
    expect(InvalidParameter, status);
 
    status = GdipAddPathArc(path, 100.0, 100.0, 1.0, -50.0, 0.0, 90.0);
    expect(InvalidParameter, status);
 
    GdipResetPath(path);
    /* Exactly 90 degrees */
    status = GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 90.0);
    expect(Ok, status);
    /* Over 90 degrees */
    status = GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
    expect(Ok, status);
    /* Negative start angle */
    status = GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, -80.0, 100.0);
    expect(Ok, status);
    /* Negative sweep angle */
    status = GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 80.0, -100.0);
    expect(Ok, status);
    /* More than a full revolution */
    status = GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 50.0, -400.0);
    expect(Ok, status);
    /* 0 sweep angle */
    status = GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 50.0, 0.0);
    expect(Ok, status);
 
    ok_path(path, arc_path, ARRAY_SIZE(arc_path), FALSE);
 
    GdipResetPath(path);
    GdipAddPathLine(path, 1.0, 0.0, 1.0, 0.5);
    status = GdipAddPathArc(path, 0.0, 0.0, 1.0, 1.0, 0.0, 90.0);
    expect(Ok, status);
 
    ok_path_fudge(path, arc_path2, ARRAY_SIZE(arc_path2), FALSE, 0.000005);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_bezier()

static void test_bezier ( void  )

static

Definition at line 359 of file graphicspath.c.

{
    GpStatus status;
    GpPath* path;
 
    GdipCreatePath(FillModeAlternate, &path);
 
    status = GdipAddPathBezier(path, 10.0, 10.0, 20.0, 10.0, 20.0, 20.0, 30.0, 20.0);
    expect(Ok, status);
    status = GdipAddPathBezier(path, 30.0, 20.0, 40.0, 20.0, 40.0, 30.0, 50.0, 30.0);
    expect(Ok, status);
    status = GdipAddPathBezier(path, 50.0, 10.0, 60.0, 10.0, 60.0, 20.0, 70.0, 20.0);
    expect(Ok, status);
 
    ok_path(path, bezier_path, ARRAY_SIZE(bezier_path), FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_beziers()

static void test_beziers ( void  )

static

Definition at line 378 of file graphicspath.c.

{
    GpStatus status;
    GpPath* path;
    PointF bezier_points1[] = {{10.0,10.0}, {20.0,10.0}, {20.0,20.0}, {30.0,20.0}};
    PointF bezier_points2[] = {{30.0,20.0}, {40.0,20.0}, {40.0,30.0}, {50.0,30.0}};
    PointF bezier_points3[] = {{50.0,10.0}, {60.0,10.0}, {60.0,20.0}, {70.0,20.0}};
 
    GdipCreatePath(FillModeAlternate, &path);
 
    status = GdipAddPathBeziers(path, bezier_points1, 4);
    expect(Ok, status);
    status = GdipAddPathBeziers(path, bezier_points2, 4);
    expect(Ok, status);
    status = GdipAddPathBeziers(path, bezier_points3, 4);
    expect(Ok, status);
 
    ok_path(path, bezier_path, ARRAY_SIZE(bezier_path), FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_constructor_destructor()

static void test_constructor_destructor ( void  )

static

Definition at line 132 of file graphicspath.c.

{
    GpStatus status;
    GpPath* path = NULL;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    expect(Ok, status);
    ok(path != NULL, "Expected path to be initialized\n");
 
    status = GdipDeletePath(NULL);
    expect(InvalidParameter, status);
 
    status = GdipDeletePath(path);
    expect(Ok, status);
}

Referenced by START_TEST().

test_createpath2()

static void test_createpath2 ( void  )

static

Definition at line 179 of file graphicspath.c.

{
    GpStatus status;
    GpPath* path = NULL;
    GpPathData data;
    INT i, count, expect_count;
 
    PointF test_line_points[] = {{1.0,1.0}, {2.0,1.0}, {2.0,2.0}};
    BYTE test_line_types[] = {PathPointTypeStart, PathPointTypeLine, PathPointTypeStart};
 
    PointF test_bez_points[] = {{1.0,1.0}, {2.0,1.0}, {3.0,1.0}, {4.0,1.0},
            {5.0,1.0}, {6.0,1.0}, {7.0,1.0}};
    BYTE test_bez_types[] = {PathPointTypeStart, PathPointTypeBezier,
            PathPointTypeBezier, PathPointTypeBezier, PathPointTypeBezier,
            PathPointTypeBezier, PathPointTypeBezier};
 
    status = GdipCreatePath2(test_line_points, test_line_types, 2, FillModeAlternate, &path);
    expect(Ok, status);
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(2, count);
    GdipDeletePath(path);
 
    status = GdipCreatePath2(test_line_points, test_line_types, 1, FillModeAlternate, &path);
    expect(Ok, status);
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(1, count);
    GdipDeletePath(path);
 
    path = (void *)0xdeadbeef;
    status = GdipCreatePath2(test_line_points, test_line_types, 0, FillModeAlternate, &path);
    expect(OutOfMemory, status);
    ok(!path, "Expected NULL, got %p\n", path);
    if(path && path != (void *)0xdeadbeef)
        GdipDeletePath(path);
 
    path = (void *)0xdeadbeef;
    status = GdipCreatePath2(test_line_points, test_line_types, -1, FillModeAlternate, &path);
    expect(OutOfMemory, status);
    ok(!path, "Expected NULL, got %p\n", path);
    if(path && path != (void *)0xdeadbeef)
        GdipDeletePath(path);
 
    path = (void *)0xdeadbeef;
    status = GdipCreatePath2(NULL, test_line_types, 2, FillModeAlternate, &path);
    expect(InvalidParameter, status);
    ok(path == (void *)0xdeadbeef, "Expected %p, got %p\n", (void *)0xdeadbeef, path);
    if(path && path != (void *)0xdeadbeef)
        GdipDeletePath(path);
 
    path = (void *)0xdeadbeef;
    status = GdipCreatePath2(test_line_points, NULL, 2, FillModeAlternate, &path);
    expect(InvalidParameter, status);
    ok(path == (void *)0xdeadbeef, "Expected %p, got %p\n", (void *)0xdeadbeef, path);
    if(path && path != (void *)0xdeadbeef)
        GdipDeletePath(path);
 
    status = GdipCreatePath2(test_line_points, test_line_types, 2, FillModeAlternate, NULL);
    expect(InvalidParameter, status);
 
    /* Multi-point paths should not end with Start */
    status = GdipCreatePath2(test_line_points, test_line_types, 3, FillModeAlternate, &path);
    expect(Ok, status);
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(0, count);
    GdipDeletePath(path);
 
    /* Zero-length line points do not get altered */
    test_line_points[1].X = test_line_points[0].X;
    test_line_points[1].Y = test_line_points[0].Y;
    status = GdipCreatePath2(test_line_points, test_line_types, 2, FillModeAlternate, &path);
    expect(Ok, status);
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(2, count);
    GdipDeletePath(path);
 
    /* The type of the first point is always converted to PathPointTypeStart */
    test_line_types[0] = PathPointTypeLine;
    status = GdipCreatePath2(test_line_points, test_line_types, 1, FillModeAlternate, &path);
    expect(Ok, status);
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(1, count);
    data.Count  = count;
    data.Types  = GdipAlloc(sizeof(BYTE) * count);
    data.Points = GdipAlloc(sizeof(PointF) * count);
    status = GdipGetPathData(path, &data);
    expect(Ok, status);
    expect((data.Points[0].X == 1.0) && (data.Points[0].Y == 1.0), TRUE);
    expect(data.Types[0], PathPointTypeStart);
    GdipFree(data.Points);
    GdipFree(data.Types);
    GdipDeletePath(path);
 
    /* Bezier points must come in groups of three */
    for(i = 2; i <= 7; i++) {
        expect_count = (i % 3 == 1) ? i : 0;
        status = GdipCreatePath2(test_bez_points, test_bez_types, i, FillModeAlternate, &path);
        expect(Ok, status);
        status = GdipGetPointCount(path, &count);
        expect(Ok, status);
        expect(expect_count, count);
        GdipDeletePath(path);
    }
}

Referenced by START_TEST().

test_ellipse()

static void test_ellipse ( void  )

static

Definition at line 724 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpPointF points[2];
 
    points[0].X = 7.0;
    points[0].Y = 11.0;
    points[1].X = 13.0;
    points[1].Y = 17.0;
 
    GdipCreatePath(FillModeAlternate, &path);
    status = GdipAddPathEllipse(path, 10.0, 100.0, 20.0, 50.5);
    expect(Ok, status);
    GdipAddPathLine2(path, points, 2);
    status = GdipAddPathEllipse(path, 10.0, 200.0, -5.0, -10.0);
    expect(Ok, status);
    GdipClosePathFigure(path);
    status = GdipAddPathEllipse(path, 10.0, 300.0, 0.0, 1.0);
    expect(Ok, status);
 
    ok_path(path, ellipse_path, ARRAY_SIZE(ellipse_path), FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_empty_rect()

static void test_empty_rect ( void  )

static

Definition at line 2136 of file graphicspath.c.

{
    GpPath *path;
    GpStatus status;
    INT count;
    BOOL result;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    expect(Ok, status);
 
    status = GdipAddPathRectangle(path, 0.0, 0.0, -5.0, 5.0);
    expect(Ok, status);
 
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(0, count);
 
    status = GdipIsVisiblePathPoint(path, -2.0, 2.0, NULL, &result);
    expect(Ok, status);
    expect(FALSE, result);
 
    status = GdipAddPathRectangle(path, 0.0, 0.0, 5.0, -5.0);
    expect(Ok, status);
 
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(0, count);
 
    status = GdipAddPathRectangle(path, 0.0, 0.0, 0.0, 5.0);
    expect(Ok, status);
 
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(0, count);
 
    status = GdipAddPathRectangle(path, 0.0, 0.0, 5.0, 0.0);
    expect(Ok, status);
 
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(0, count);
 
    status = GdipAddPathRectangle(path, 0.0, 0.0, 5.0, 0.1);
    expect(Ok, status);
 
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(4, count);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_flatten()

static void test_flatten ( void  )

static

Definition at line 1278 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpMatrix *m;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    expect(Ok, status);
    status = GdipCreateMatrix(&m);
    expect(Ok, status);
 
    /* NULL arguments */
    status = GdipFlattenPath(NULL, NULL, 0.0);
    expect(InvalidParameter, status);
    status = GdipFlattenPath(NULL, m, 0.0);
    expect(InvalidParameter, status);
 
    /* flatten empty path */
    status = GdipFlattenPath(path, NULL, 1.0);
    expect(Ok, status);
 
    status = GdipTransformPath(path, 0);
    expect(Ok, status);
 
    status = GdipAddPathEllipse(path, 0.0, 0.0, 100.0, 50.0);
    expect(Ok, status);
 
    status = GdipFlattenPath(path, NULL, 1.0);
    expect(Ok, status);
    ok_path(path, flattenellipse_path, ARRAY_SIZE(flattenellipse_path), TRUE);
 
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 10.0, 50.0, 100.0);
    expect(Ok, status);
    status = GdipFlattenPath(path, NULL, 1.0);
    expect(Ok, status);
    ok_path(path, flattenline_path, ARRAY_SIZE(flattenline_path), FALSE);
 
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathArc(path, 0.0, 0.0, 100.0, 50.0, 0.0, 90.0);
    expect(Ok, status);
    status = GdipFlattenPath(path, NULL, 1.0);
    expect(Ok, status);
    ok_path(path, flattenarc_path, ARRAY_SIZE(flattenarc_path), TRUE);
 
    /* easy case - quater of a full circle */
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathArc(path, 0.0, 0.0, 100.0, 100.0, 0.0, 90.0);
    expect(Ok, status);
    status = GdipFlattenPath(path, NULL, 1.0);
    expect(Ok, status);
    ok_path(path, flattenquater_path, ARRAY_SIZE(flattenquater_path), FALSE);
 
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipStartPathFigure(path);
    expect(Ok, status);
 
    /* path seen in the wild that caused a stack overflow */
    /* same path but redo with the manual points that caused a crash */
    status = GdipAddPathBezier(path, 154.950806, 33.391144, 221.586075, 15.536285, 291.747314, 15.536285, 358.382568, 33.391144);
    expect(Ok, status);
    status = GdipAddPathBezier(path, 256.666809, 412.999512, 256.666718, 412.999481, 256.666656, 412.999481, 256.666565, 412.999512);
    expect(Ok, status);
    status = GdipClosePathFigure(path);
    expect(Ok, status);
    status = GdipFlattenPath(path, NULL, 1.0);
    expect(Ok, status);
 
    GdipDeleteMatrix(m);
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_getpathdata()

static void test_getpathdata ( void  )

static

Definition at line 148 of file graphicspath.c.

{
    GpPath *path;
    GpPathData data;
    GpStatus status;
    INT count;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 5.0, 100.0, 50.0);
    expect(Ok, status);
 
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    expect(2, count);
 
    data.Count  = count;
    data.Types  = GdipAlloc(sizeof(BYTE) * count);
    data.Points = GdipAlloc(sizeof(PointF) * count);
 
    status = GdipGetPathData(path, &data);
    expect(Ok, status);
    expect((data.Points[0].X == 5.0) && (data.Points[0].Y == 5.0) &&
           (data.Points[1].X == 100.0) && (data.Points[1].Y == 50.0), TRUE);
    expect((data.Types[0] == PathPointTypeStart) && (data.Types[1] == PathPointTypeLine), TRUE);
 
    GdipFree(data.Points);
    GdipFree(data.Types);
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_is_outline_visible_path_point()

static void test_is_outline_visible_path_point ( void  )

static

Definition at line 1995 of file graphicspath.c.

{
    BOOL result;
    GpBitmap *bitmap;
    GpGraphics *graphics = NULL;
    GpPath *path;
    GpPen *pen = NULL;
    GpStatus status;
    static const int width = 20, height = 20;
 
    /* Graphics associated with an Image object.*/
    status = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppRGB, NULL, &bitmap);
    expect(Ok, status);
    status = GdipGetImageGraphicsContext((GpImage *)bitmap, &graphics);
    expect(Ok, status);
    ok(graphics != NULL, "Expected the graphics context to be initialized.\n");
 
    status = GdipCreatePath(FillModeAlternate, &path);
    expect(Ok, status);
 
    status = GdipAddPathRectangle(path, 2.0, 0.0, 13.0, 15.0);
    expect(Ok, status);
 
    status = GdipCreatePen1((ARGB)0xffff00ff, 3.0f, UnitPixel, &pen);
    expect(Ok, status);
    ok(pen != NULL, "Expected pen to be initialized\n");
 
    /* With NULL pen */
    result = 9;
    status = GdipIsOutlineVisiblePathPoint(path, 0.0, 1.0, NULL, graphics, &result);
    expect(InvalidParameter, status);
    expect(9, result);
 
    /* Without transformation */
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 0.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 1.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 10.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 16.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 17.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
 
    /* Translating */
    status = GdipTranslateWorldTransform(graphics, 50.0, 50.0, MatrixOrderPrepend);
    expect(Ok, status);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 10.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 15.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 16.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
 
    /* Scaling */
    status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderPrepend);
    expect(Ok, status);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 0.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 1.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 2.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 3.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 14.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 15.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 16.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
 
    /* Page Unit */
    GdipResetWorldTransform(graphics);
    status = GdipSetPageUnit(graphics, UnitMillimeter);
    expect(Ok, status);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 0.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 1.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 2.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 3.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 14.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    result = FALSE;
    status = GdipIsOutlineVisiblePathPoint(path, 15.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = TRUE;
    status = GdipIsOutlineVisiblePathPoint(path, 16.0, 1.0, pen, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
 
    GdipResetWorldTransform(graphics);
    GdipDeletePath(path);
    GdipDeleteGraphics(graphics);
}

Referenced by START_TEST().

test_isvisible()

static void test_isvisible ( void  )

static

Definition at line 1931 of file graphicspath.c.

{
    GpPath *path;
    GpGraphics *graphics = NULL;
    HDC hdc = GetDC(0);
    BOOL result;
    GpStatus status;
 
    status = GdipCreateFromHDC(hdc, &graphics);
    expect(Ok, status);
    status = GdipCreatePath(FillModeAlternate, &path);
    expect(Ok, status);
 
    /* NULL */
    status = GdipIsVisiblePathPoint(NULL, 0.0, 0.0, NULL, NULL);
    expect(InvalidParameter, status);
    status = GdipIsVisiblePathPoint(path, 0.0, 0.0, NULL, NULL);
    expect(InvalidParameter, status);
    status = GdipIsVisiblePathPoint(path, 0.0, 0.0, NULL, NULL);
    expect(InvalidParameter, status);
    status = GdipIsVisiblePathPoint(path, 0.0, 0.0, graphics, NULL);
    expect(InvalidParameter, status);
 
    /* empty path */
    result = TRUE;
    status = GdipIsVisiblePathPoint(path, 0.0, 0.0, NULL, &result);
    expect(Ok, status);
    expect(FALSE, result);
    /* rect */
    status = GdipAddPathRectangle(path, 0.0, 0.0, 10.0, 10.0);
    expect(Ok, status);
    result = FALSE;
    status = GdipIsVisiblePathPoint(path, 0.0, 0.0, NULL, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = TRUE;
    status = GdipIsVisiblePathPoint(path, 11.0, 11.0, NULL, &result);
    expect(Ok, status);
    expect(FALSE, result);
    /* not affected by clipping */
    status = GdipSetClipRect(graphics, 5.0, 5.0, 5.0, 5.0, CombineModeReplace);
    expect(Ok, status);
    result = FALSE;
    status = GdipIsVisiblePathPoint(path, 0.0, 0.0, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    /* not affected by world transform */
    status = GdipScaleWorldTransform(graphics, 2.0, 2.0, MatrixOrderPrepend);
    expect(Ok, status);
    result = FALSE;
    status = GdipIsVisiblePathPoint(path, 9.0, 9.0, graphics, &result);
    expect(Ok, status);
    expect(TRUE, result);
    result = TRUE;
    status = GdipIsVisiblePathPoint(path, 11.0, 11.0, graphics, &result);
    expect(Ok, status);
    expect(FALSE, result);
    GdipResetWorldTransform(graphics);
 
    GdipDeletePath(path);
    GdipDeleteGraphics(graphics);
    ReleaseDC(0, hdc);
}

Referenced by run_tests(), and START_TEST().

test_lastpoint()

static void test_lastpoint ( void  )

static

Definition at line 885 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpPointF ptf;
 
    GdipCreatePath(FillModeAlternate, &path);
    status = GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
    expect(Ok, status);
 
    /* invalid args */
    status = GdipGetPathLastPoint(NULL, &ptf);
    expect(InvalidParameter, status);
    status = GdipGetPathLastPoint(path, NULL);
    expect(InvalidParameter, status);
    status = GdipGetPathLastPoint(NULL, NULL);
    expect(InvalidParameter, status);
 
    status = GdipGetPathLastPoint(path, &ptf);
    expect(Ok, status);
    expect(TRUE, (ptf.X == 5.0) && (ptf.Y == 55.0));
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_line2()

static void test_line2 ( void  )

static

Definition at line 300 of file graphicspath.c.

{
    GpStatus status;
    GpPath* path;
    int i;
    GpPointF line2_points[9];
 
    for(i = 0; i < 9; i ++){
        line2_points[i].X = i * 5.0 * (REAL)(i % 2);
        line2_points[i].Y = 50.0 - i * 5.0;
    }
 
    GdipCreatePath(FillModeAlternate, &path);
 
    status = GdipAddPathLine2(NULL, line2_points, 2);
    expect(InvalidParameter, status);
    status = GdipAddPathLine2(path, NULL, 2);
    expect(InvalidParameter, status);
    status = GdipAddPathLine2(path, line2_points, 0);
    expect(InvalidParameter, status);
    status = GdipAddPathLine2(path, line2_points, -1);
    expect(InvalidParameter, status);
 
    status = GdipAddPathLine2(path, line2_points, 3);
    expect(Ok, status);
    status = GdipAddPathLine2(path, &(line2_points[3]), 3);
    expect(Ok, status);
    status = GdipClosePathFigure(path);
    expect(Ok, status);
    status = GdipAddPathLine2(path, &(line2_points[6]), 3);
    expect(Ok, status);
 
    ok_path(path, line2_path, ARRAY_SIZE(line2_path), FALSE);
 
    GdipResetPath(path);
    status = GdipAddPathLine2(path, line2_points, 3);
    expect(Ok, status);
    status = GdipAddPathLine2(path, &(line2_points[2]), 3);
    expect(Ok, status);
 
    ok_path(path, line2_path, 5, FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_linei()

static void test_linei ( void  )

static

Definition at line 767 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
 
    GdipCreatePath(FillModeAlternate, &path);
    status = GdipAddPathLineI(path, 5.0, 5.0, 6.0, 8.0);
    expect(Ok, status);
    GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, -80.0, 100.0);
    status = GdipAddPathLineI(path, 15.0, 15.0, 26.0, 28.0);
    expect(Ok, status);
    GdipClosePathFigure(path);
    status = GdipAddPathLineI(path, 35.0, 35.0, 36.0, 38.0);
    expect(Ok, status);
    status = GdipAddPathLineI(path, 36, 38, 39, 40);
    expect(Ok, status);
 
    ok_path(path, linei_path, ARRAY_SIZE(linei_path), FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_pathpath()

static void test_pathpath ( void  )

static

Definition at line 658 of file graphicspath.c.

{
    GpStatus status;
    GpPath* path1, *path2;
 
    GdipCreatePath(FillModeAlternate, &path2);
    GdipAddPathArc(path2, 100.0, 100.0, 500.0, 700.0, 95.0, 100.0);
 
    GdipCreatePath(FillModeAlternate, &path1);
    GdipAddPathArc(path1, 100.0, 100.0, 500.0, 700.0, 0.0, 90.0);
    status = GdipAddPathPath(path1, path2, FALSE);
    expect(Ok, status);
    GdipAddPathArc(path1, 100.0, 100.0, 500.0, 700.0, -80.0, 100.0);
    status = GdipAddPathPath(path1, path2, TRUE);
    expect(Ok, status);
 
    ok_path(path1, pathpath_path, ARRAY_SIZE(pathpath_path), FALSE);
 
    GdipDeletePath(path1);
    GdipDeletePath(path2);
}

Referenced by START_TEST().

test_polygon()

static void test_polygon ( void  )

static

Definition at line 799 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpPointF points[5];
 
    points[0].X = 0.0;
    points[0].Y = 0.0;
    points[1].X = 10.0;
    points[1].Y = 10.0;
    points[2].X = 10.0;
    points[2].Y = 20.0;
    points[3].X = 30.0;
    points[3].Y = 10.0;
    points[4].X = 20.0;
    points[4].Y = 0.0;
 
    GdipCreatePath(FillModeAlternate, &path);
 
    /* NULL args */
    status = GdipAddPathPolygon(NULL, points, 5);
    expect(InvalidParameter, status);
    status = GdipAddPathPolygon(path, NULL, 5);
    expect(InvalidParameter, status);
    /* Polygon should have 3 points at least */
    status = GdipAddPathPolygon(path, points, 2);
    expect(InvalidParameter, status);
 
    /* to test how it prolongs not empty path */
    status = GdipAddPathLine(path, 5.0, 5.0, 6.0, 8.0);
    expect(Ok, status);
    status = GdipAddPathPolygon(path, points, 5);
    expect(Ok, status);
    /* check resulting path */
    ok_path(path, poly_path, ARRAY_SIZE(poly_path), FALSE);
 
    GdipDeletePath(path);
}

Referenced by D3DXCreatePolygonTest(), and START_TEST().

test_rect()

static void test_rect ( void  )

static

Definition at line 850 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpRectF rects[2];
 
    GdipCreatePath(FillModeAlternate, &path);
    status = GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
    expect(Ok, status);
    status = GdipAddPathRectangle(path, 100.0, 50.0, 120.0, 30.0);
    expect(Ok, status);
 
    ok_path(path, rect_path, ARRAY_SIZE(rect_path), FALSE);
 
    GdipDeletePath(path);
 
    GdipCreatePath(FillModeAlternate, &path);
 
    rects[0].X      = 5.0;
    rects[0].Y      = 5.0;
    rects[0].Width  = 100.0;
    rects[0].Height = 50.0;
    rects[1].X      = 100.0;
    rects[1].Y      = 50.0;
    rects[1].Width  = 120.0;
    rects[1].Height = 30.0;
 
    status = GdipAddPathRectangles(path, (GDIPCONST GpRectF*)&rects, 2);
    expect(Ok, status);
 
    ok_path(path, rect_path, ARRAY_SIZE(rect_path), FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST(), and test_gethrgn().

test_rect_line()

static void test_rect_line ( void  )

static

Definition at line 2197 of file graphicspath.c.

{
    GpStatus status;
    GpPath* path;
 
    GdipCreatePath(FillModeAlternate, &path);
 
    status = GdipAddPathRectangleI(path, 1, 4, 16, 64);
    expect(Ok, status);
 
    status = GdipAddPathLineI(path, 1, 8, 17, 8);
    expect(Ok, status);
 
    ok_path(path, rect_line_path, ARRAY_SIZE(rect_line_path), FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_reverse()

static void test_reverse ( void  )

static

Definition at line 1145 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpPointF pts[7];
    INT i;
 
    for(i = 0; i < 7; i++){
        pts[i].X = i * 5.0 * (REAL)(i % 2);
        pts[i].Y = 50.0 - i * 5.0;
    }
 
    GdipCreatePath(FillModeAlternate, &path);
 
    /* NULL argument */
    status = GdipReversePath(NULL);
    expect(InvalidParameter, status);
 
    /* empty path */
    status = GdipReversePath(path);
    expect(Ok, status);
 
    GdipAddPathLine2(path, pts, 4);
    GdipClosePathFigure(path);
    GdipAddPathLine2(path, &(pts[4]), 3);
 
    status = GdipReversePath(path);
    expect(Ok, status);
    ok_path(path, reverse_path, ARRAY_SIZE(reverse_path), FALSE);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_widen()

static void test_widen ( void  )

static

Definition at line 1397 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpPen *pen;
    GpMatrix *m;
    INT count=-1;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    expect(Ok, status);
    status = GdipCreatePen1(0xffffffff, 10.0, UnitPixel, &pen);
    expect(Ok, status);
    status = GdipCreateMatrix(&m);
    expect(Ok, status);
 
    /* NULL arguments */
    status = GdipAddPathLine(path, 5.0, 10.0, 50.0, 10.0);
    expect(Ok, status);
    status = GdipWidenPath(NULL, NULL, NULL, 0.0);
    expect(InvalidParameter, status);
    status = GdipWidenPath(path, pen, m, 0.0);
    expect(Ok, status);
    status = GdipWidenPath(path, pen, NULL, 1.0);
    expect(Ok, status);
    status = GdipWidenPath(path, NULL, m, 1.0);
    expect(InvalidParameter, status);
    status = GdipWidenPath(NULL, pen, m, 1.0);
    expect(InvalidParameter, status);
 
    /* widen empty path */
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(OutOfMemory, status);
 
    /* horizontal line */
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 10.0, 50.0, 10.0);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path(path, widenline_path, ARRAY_SIZE(widenline_path), FALSE);
 
    /* horizontal 2x stretch */
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 2.5, 10.0, 25.0, 10.0);
    expect(Ok, status);
 
    status = GdipScaleMatrix(m, 2.0, 1.0, MatrixOrderAppend);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path(path, widenline_path, ARRAY_SIZE(widenline_path), FALSE);
 
    /* vertical 2x stretch */
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 5.0, 50.0, 5.0);
    expect(Ok, status);
 
    status = GdipScaleMatrix(m, 0.5, 2.0, MatrixOrderAppend);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path(path, widenline_path, ARRAY_SIZE(widenline_path), FALSE);
 
    status = GdipScaleMatrix(m, 1.0, 0.5, MatrixOrderAppend);
    expect(Ok, status);
 
    /* dashed line */
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 5.0, 50.0, 5.0);
    expect(Ok, status);
 
    status = GdipSetPenDashStyle(pen, DashStyleDash);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path(path, widenline_dash_path, ARRAY_SIZE(widenline_dash_path), FALSE);
 
    status = GdipSetPenDashStyle(pen, DashStyleSolid);
    expect(Ok, status);
 
    /* dashed line less than 1 pixel wide */
    GdipDeletePen(pen);
    GdipCreatePen1(0xffffffff, 0.5, UnitPixel, &pen);
    GdipSetPenDashStyle(pen, DashStyleDash);
 
    GdipResetPath(path);
    GdipAddPathLine(path, 5.0, 5.0, 9.5, 5.0);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path_fudge(path, widenline_thin_dash_path, ARRAY_SIZE(widenline_thin_dash_path), FALSE, 0.000005);
 
    /* pen width in UnitWorld */
    GdipDeletePen(pen);
    status = GdipCreatePen1(0xffffffff, 10.0, UnitWorld, &pen);
    expect(Ok, status);
 
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 10.0, 50.0, 10.0);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path(path, widenline_path, ARRAY_SIZE(widenline_path), FALSE);
 
    /* horizontal 2x stretch */
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 2.5, 10.0, 25.0, 10.0);
    expect(Ok, status);
 
    status = GdipScaleMatrix(m, 2.0, 1.0, MatrixOrderAppend);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path(path, widenline_path, ARRAY_SIZE(widenline_path), FALSE);
 
    /* vertical 2x stretch */
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 5.0, 50.0, 5.0);
    expect(Ok, status);
 
    status = GdipScaleMatrix(m, 0.5, 2.0, MatrixOrderAppend);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path(path, widenline_wide_path, ARRAY_SIZE(widenline_wide_path), FALSE);
 
    status = GdipScaleMatrix(m, 1.0, 0.5, MatrixOrderAppend);
    expect(Ok, status);
 
    /* pen width in UnitInch */
    GdipDeletePen(pen);
    status = GdipCreatePen1(0xffffffff, 10.0, UnitWorld, &pen);
    expect(Ok, status);
 
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 10.0, 50.0, 10.0);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
    ok_path(path, widenline_path, ARRAY_SIZE(widenline_path), FALSE);
 
    /* pen width = 0 pixels - native fails to widen but can draw with this pen */
    GdipDeletePen(pen);
    status = GdipCreatePen1(0xffffffff, 0.0, UnitPixel, &pen);
    expect(Ok, status);
 
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 10.0, 50.0, 10.0);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
 
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    ok(count == 0 || broken(count == 4), "expected 0, got %i\n", count);
 
    /* pen width = 0 pixels, UnitWorld - result is a path 1 unit wide */
    GdipDeletePen(pen);
    status = GdipCreatePen1(0xffffffff, 0.0, UnitWorld, &pen);
    expect(Ok, status);
 
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 10.0, 50.0, 10.0);
    expect(Ok, status);
 
    status = GdipWidenPath(path, pen, m, 1.0);
    expect(Ok, status);
 
    status = GdipGetPointCount(path, &count);
    expect(Ok, status);
    ok_path_fudge(path, widenline_unit_path, ARRAY_SIZE(widenline_unit_path), FALSE, 0.000005);
 
    GdipDeleteMatrix(m);
    GdipDeletePen(pen);
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_widen_cap()

static void test_widen_cap ( void  )

static

Definition at line 1797 of file graphicspath.c.

{
    struct
    {
        LineCap type;
        REAL line_width;
        const path_test_t *expected;
        INT expected_size;
        BOOL dashed;
    }
    caps[] =
    {
        { LineCapFlat, 10.0, widenline_capflat_path,
                ARRAY_SIZE(widenline_capflat_path) },
        { LineCapSquare, 10.0, widenline_capsquare_path,
                ARRAY_SIZE(widenline_capsquare_path) },
        { LineCapRound, 10.0, widenline_capround_path,
                ARRAY_SIZE(widenline_capround_path) },
        { LineCapTriangle, 10.0, widenline_captriangle_path,
                ARRAY_SIZE(widenline_captriangle_path) },
        { LineCapNoAnchor, 10.0, widenline_capflat_path,
                ARRAY_SIZE(widenline_capflat_path) },
        { LineCapSquareAnchor, 10.0, widenline_capsquareanchor_path,
                ARRAY_SIZE(widenline_capsquareanchor_path) },
        { LineCapRoundAnchor, 10.0, widenline_caproundanchor_path,
                ARRAY_SIZE(widenline_caproundanchor_path) },
        { LineCapDiamondAnchor, 10.0, widenline_capdiamondanchor_path,
                ARRAY_SIZE(widenline_capdiamondanchor_path) },
        { LineCapArrowAnchor, 10.0, widenline_caparrowanchor_path,
                ARRAY_SIZE(widenline_caparrowanchor_path) },
        { LineCapSquareAnchor, 0.0, widenline_capsquareanchor_thin_path,
                ARRAY_SIZE(widenline_capsquareanchor_thin_path) },
        { LineCapSquareAnchor, 10.0, widenline_capsquareanchor_dashed_path,
                ARRAY_SIZE(widenline_capsquareanchor_dashed_path), TRUE },
    };
 
    GpAdjustableArrowCap *arrowcap;
    GpStatus status;
    GpPath *path;
    GpPen *pen;
 
    int i;
 
    status = GdipCreatePath(FillModeAlternate, &path);
    expect(Ok, status);
 
    for (i = 0; i < ARRAY_SIZE(caps); i++)
    {
        status = GdipCreatePen1(0xffffffff, caps[i].line_width, UnitPixel, &pen);
        expect(Ok, status);
        if (caps[i].dashed)
        {
            status = GdipSetPenDashStyle(pen, DashStyleDash);
            expect(Ok, status);
        }
 
        status = GdipResetPath(path);
        expect(Ok, status);
        status = GdipAddPathLine(path, 5.0, 10.0, 50.0, 10.0);
        expect(Ok, status);
        status = GdipSetPenStartCap(pen, caps[i].type);
        expect(Ok, status);
        status = GdipSetPenEndCap(pen, caps[i].type);
        expect(Ok, status);
 
        status = GdipWidenPath(path, pen, NULL, FlatnessDefault);
        expect(Ok, status);
 
        if (i == 9)
        {
            INT size;
            status = GdipGetPointCount(path, &size);
            expect(Ok, status);
            ok(size == caps[i].expected_size || broken(size == 12), "unexpected path size %i\n", size);
 
            if (size == 12)
            {
                GdipDeletePen(pen);
                continue;
            }
        }
 
        ok_path_fudge(path, caps[i].expected, caps[i].expected_size, FALSE, 0.000005);
 
        GdipDeletePen(pen);
    }
 
    status = GdipCreatePen1(0xffffffff, 10.0, UnitPixel, &pen);
    expect(Ok, status);
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 10.0, 25.0, 10.0);
    expect(Ok, status);
    status = GdipStartPathFigure(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 30.0, 10.0, 50.0, 10.0);
    expect(Ok, status);
    status = GdipSetPenStartCap(pen, LineCapSquareAnchor);
    expect(Ok, status);
    status = GdipSetPenEndCap(pen, LineCapSquareAnchor);
    expect(Ok, status);
    status = GdipWidenPath(path, pen, NULL, FlatnessDefault);
    expect(Ok, status);
    ok_path_fudge(path, widenline_capsquareanchor_multifigure_path,
        ARRAY_SIZE(widenline_capsquareanchor_multifigure_path), FALSE, 0.000005);
 
    status = GdipResetPath(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 5.0, 10.0, 25.0, 10.0);
    expect(Ok, status);
    status = GdipStartPathFigure(path);
    expect(Ok, status);
    status = GdipAddPathLine(path, 30.0, 10.0, 30.0, 30.0);
    expect(Ok, status);
    status = GdipCreateAdjustableArrowCap(4.0, 4.0, TRUE, &arrowcap);
    ok(status == Ok, "Failed to create adjustable cap, %d\n", status);
    status = GdipSetAdjustableArrowCapMiddleInset(arrowcap, 1.0);
    ok(status == Ok, "Failed to set middle inset inadjustable cap, %d\n", status);
    status = GdipSetPenCustomStartCap(pen, (GpCustomLineCap*)arrowcap);
    ok(status == Ok, "Failed to create custom end cap, %d\n", status);
    status = GdipSetPenCustomEndCap(pen, (GpCustomLineCap*)arrowcap);
    ok(status == Ok, "Failed to create custom end cap, %d\n", status);
    status = GdipSetPenWidth(pen, 1.0);
    expect(Ok, status);
    status = GdipWidenPath(path, pen, NULL, FlatnessDefault);
    expect(Ok, status);
    ok_path_fudge(path, widenline_customarrow_multifigure_path,
        ARRAY_SIZE(widenline_customarrow_multifigure_path), FALSE, 0.000005);
 
    GdipDeletePen(pen);
 
    GdipDeletePath(path);
}

Referenced by START_TEST().

test_worldbounds()

static void test_worldbounds ( void  )

static

Definition at line 499 of file graphicspath.c.

{
    GpStatus status;
    GpPath *path;
    GpPen *pen;
    GpMatrix *matrix;
    GpRectF bounds;
    GpPointF line2_points[10];
    int i;
 
    for(i = 0; i < 10; i ++){
        line2_points[i].X = 200.0 + i * 50.0 * (i % 2);
        line2_points[i].Y = 200.0 + i * 50.0 * !(i % 2);
    }
    GdipCreatePen1((ARGB)0xdeadbeef, 20.0, UnitWorld, &pen);
    GdipSetPenEndCap(pen, LineCapSquareAnchor);
    GdipCreateMatrix2(1.5, 0.0, 1.0, 1.2, 10.4, 10.2, &matrix);
 
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
    GdipAddPathLine2(path, &(line2_points[0]), 10);
    status = GdipGetPathWorldBounds(path, &bounds, NULL, NULL);
    expect(Ok, status);
    GdipDeletePath(path);
 
    expectf(200.0, bounds.X);
    expectf(200.0, bounds.Y);
    expectf(450.0, bounds.Width);
    expectf(600.0, bounds.Height);
 
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
    GdipAddPathLine2(path, &(line2_points[0]), 10);
    status = GdipGetPathWorldBounds(path, &bounds, matrix, NULL);
    expect(Ok, status);
    GdipDeletePath(path);
 
    expectf(510.4, bounds.X);
    expectf(250.2, bounds.Y);
    expectf(1275.0, bounds.Width);
    expectf(720.0, bounds.Height);
 
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
    GdipAddPathLine2(path, &(line2_points[0]), 10);
    status = GdipGetPathWorldBounds(path, &bounds, NULL, pen);
    expect(Ok, status);
    GdipDeletePath(path);
 
    expectf(100.0, bounds.X);
    expectf(100.0, bounds.Y);
    expectf(650.0, bounds.Width);
    expectf(800.0, bounds.Height);
 
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathLine2(path, &(line2_points[0]), 2);
    status = GdipGetPathWorldBounds(path, &bounds, NULL, pen);
    expect(Ok, status);
    GdipDeletePath(path);
 
    expectf(156.0, bounds.X);
    expectf(156.0, bounds.Y);
    expectf(138.0, bounds.Width);
    expectf(88.0, bounds.Height);
 
    line2_points[2].X = 2 * line2_points[1].X - line2_points[0].X;
    line2_points[2].Y = 2 * line2_points[1].Y - line2_points[0].Y;
 
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathLine2(path, &(line2_points[0]), 3);
    status = GdipGetPathWorldBounds(path, &bounds, NULL, pen);
    expect(Ok, status);
    GdipDeletePath(path);
 
    expectf(100.0, bounds.X);
    expectf(100.0, bounds.Y);
    expectf(300.0, bounds.Width);
    expectf(200.0, bounds.Height);
 
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 45.0, 20.0);
    status = GdipGetPathWorldBounds(path, &bounds, NULL, pen);
    expect(Ok, status);
    GdipDeletePath(path);
 
    expectf(386.7, bounds.X);
    expectf(553.4, bounds.Y);
    expectf(266.8, bounds.Width);
    expectf(289.6, bounds.Height);
 
    GdipCreatePath(FillModeAlternate, &path);
    status = GdipGetPathWorldBounds(path, &bounds, matrix, pen);
    expect(Ok, status);
    GdipDeletePath(path);
 
    expectf(0.0, bounds.X);
    expectf(0.0, bounds.Y);
    expectf(0.0, bounds.Width);
    expectf(0.0, bounds.Height);
 
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathLine2(path, &(line2_points[0]), 2);
    status = GdipGetPathWorldBounds(path, &bounds, matrix, pen);
    expect(Ok, status);
    GdipDeletePath(path);
 
    todo_wine{
        expectf(427.9, bounds.X);
        expectf(167.7, bounds.Y);
        expectf(239.9, bounds.Width);
        expectf(164.9, bounds.Height);
    }
 
    GdipDeleteMatrix(matrix);
    GdipCreateMatrix2(0.9, -0.5, -0.5, -1.2, 10.4, 10.2, &matrix);
    GdipCreatePath(FillModeAlternate, &path);
    GdipAddPathArc(path, 100.0, 100.0, 500.0, 700.0, 0.0, 100.0);
    GdipAddPathLine2(path, &(line2_points[0]), 10);
    status = GdipGetPathWorldBounds(path, &bounds, matrix, NULL);
    expect(Ok, status);
    GdipDeletePath(path);
    GdipDeleteMatrix(matrix);
 
    expectf(-209.6, bounds.X);
    expectf(-1274.8, bounds.Y);
    expectf(705.0, bounds.Width);
    expectf(945.0, bounds.Height);
 
    GdipDeletePen(pen);
}

Referenced by START_TEST().

Variable Documentation

addclosedcurve_path

path_test_t addclosedcurve_path[]

static

Initial value:

= {
    {0.0, 0.0,   PathPointTypeStart,  0, 0}, 
    {-6.7, 0.0,  PathPointTypeBezier, 0, 0}, 
    {6.7, 3.3,   PathPointTypeBezier, 0, 0}, 
    {10.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {13.3, 16.7, PathPointTypeBezier, 0, 0}, 
    {3.3,  20.0, PathPointTypeBezier, 0, 0}, 
    {10.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {16.7, 20.0, PathPointTypeBezier, 0, 0}, 
    {33.3, 16.7, PathPointTypeBezier, 0, 0}, 
    {30.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {26.7, 3.3,  PathPointTypeBezier, 0, 0}, 
    {6.7,  0.0,  PathPointTypeBezier, 0, 0}, 
    {0.0,  0.0,  PathPointTypeBezier | PathPointTypeCloseSubpath, 0, 0}  
    }

Definition at line 1064 of file graphicspath.c.

Referenced by test_addclosedcurve().

addclosedcurve_path_default_tension

path_test_t addclosedcurve_path_default_tension[]

static

Initial value:

= {
    {0.0, 0.0,   PathPointTypeStart,  0, 0}, 
    {-3.33, 0.0, PathPointTypeBezier, 0, 0}, 
    {8.33, 6.66, PathPointTypeBezier, 0, 0}, 
    {10.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {11.6, 13.3, PathPointTypeBezier, 0, 0}, 
    {6.66, 20.0, PathPointTypeBezier, 0, 0}, 
    {10.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {13.3, 20.0, PathPointTypeBezier, 0, 0}, 
    {31.6, 13.3, PathPointTypeBezier, 0, 0}, 
    {30.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {28.3, 6.66, PathPointTypeBezier, 0, 0}, 
    {3.33, 0.0,  PathPointTypeBezier, 0, 0}, 
    {0.0,  0.0,  PathPointTypeBezier | PathPointTypeCloseSubpath, 0, 0}  
    }

Definition at line 1079 of file graphicspath.c.

Referenced by test_addclosedcurve().

addcurve_path

path_test_t addcurve_path[]

static

Initial value:

= {
    {0.0, 0.0,   PathPointTypeStart,  0, 0}, 
    {3.3, 3.3,   PathPointTypeBezier, 0, 0}, 
    {6.7, 3.3,   PathPointTypeBezier, 0, 0}, 
    {10.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {13.3, 16.7, PathPointTypeBezier, 0, 0}, 
    {3.3,  20.0, PathPointTypeBezier, 0, 0}, 
    {10.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {16.7, 20.0, PathPointTypeBezier, 0, 0}, 
    {23.3, 13.3, PathPointTypeBezier, 0, 0}, 
    {30.0, 10.0, PathPointTypeBezier, 0, 0}  
    }

Definition at line 910 of file graphicspath.c.

Referenced by test_addcurve().

addcurve_path2

path_test_t addcurve_path2[]

static

Initial value:

= {
    {100.0,120.0,PathPointTypeStart,  0, 0}, 
    {123.0,10.0, PathPointTypeLine,   0, 0}, 
    {0.0, 0.0,   PathPointTypeLine,   0, 0}, 
    {3.3, 3.3,   PathPointTypeBezier, 0, 0}, 
    {6.7, 3.3,   PathPointTypeBezier, 0, 0}, 
    {10.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {13.3, 16.7, PathPointTypeBezier, 0, 0}, 
    {3.3,  20.0, PathPointTypeBezier, 0, 0}, 
    {10.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {16.7, 20.0, PathPointTypeBezier, 0, 0}, 
    {23.3, 13.3, PathPointTypeBezier, 0, 0}, 
    {30.0, 10.0, PathPointTypeBezier, 0, 0}  
    }

Definition at line 934 of file graphicspath.c.

Referenced by test_addcurve().

addcurve_path3

path_test_t addcurve_path3[]

static

Initial value:

= {
    {10.0, 10.0, PathPointTypeStart,  0, 0}, 
    {13.3, 16.7, PathPointTypeBezier, 0, 0}, 
    {3.3,  20.0, PathPointTypeBezier, 0, 0}, 
    {10.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {16.7, 20.0, PathPointTypeBezier, 0, 0}, 
    {23.3, 13.3, PathPointTypeBezier, 0, 0}, 
    {30.0, 10.0, PathPointTypeBezier, 0, 0}  
    }

Definition at line 948 of file graphicspath.c.

Referenced by test_addcurve().

addcurve_path4

path_test_t addcurve_path4[]

static

Initial value:

= {
    {0.0,  0.0,  PathPointTypeStart,  0, 0}, 
    {3.33, 3.33, PathPointTypeBezier, 0, 0}, 
    {6.66, 3.33, PathPointTypeBezier, 0, 0}, 
    {10.0, 10.0, PathPointTypeBezier, 0, 0}, 
    }

Definition at line 957 of file graphicspath.c.

Referenced by test_addcurve().

addcurve_path5

path_test_t addcurve_path5[]

static

Initial value:

= {
    {10.0, 10.0, PathPointTypeStart,  0, 0}, 
    {13.3, 16.6, PathPointTypeBezier, 0, 0}, 
    {3.33, 20.0, PathPointTypeBezier, 0, 0}, 
    {10.0, 20.0, PathPointTypeBezier, 0, 0}  
    }

Definition at line 963 of file graphicspath.c.

Referenced by test_addcurve().

addcurve_path_default_tension

path_test_t addcurve_path_default_tension[]

static

Initial value:

= {
    {0.0, 0.0,   PathPointTypeStart,  0, 0}, 
    {1.66, 1.66, PathPointTypeBezier, 0, 0}, 
    {8.33, 6.66, PathPointTypeBezier, 0, 0}, 
    {10.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {11.6, 13.3, PathPointTypeBezier, 0, 0}, 
    {6.66, 20.0, PathPointTypeBezier, 0, 0}, 
    {10.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {13.3, 20.0, PathPointTypeBezier, 0, 0}, 
    {26.6, 11.6, PathPointTypeBezier, 0, 0}, 
    {30.0, 10.0, PathPointTypeBezier, 0, 0}  
    }

Definition at line 922 of file graphicspath.c.

Referenced by test_addcurve().

addpie_path

path_test_t addpie_path[]

static

Initial value:

= {
    {50.0, 25.0, PathPointTypeStart, 0, 0}, 
    {97.2, 33.3, PathPointTypeLine,  0, 0}, 
    {91.8, 40.9, PathPointTypeBezier,0, 0}, 
    {79.4, 46.8, PathPointTypeBezier,0, 0}, 
    {63.9, 49.0, PathPointTypeBezier | PathPointTypeCloseSubpath,  0, 0} 
    }

Definition at line 1178 of file graphicspath.c.

Referenced by test_addpie().

addpie_path2

path_test_t addpie_path2[]

static

Initial value:

= {
    {0.0, 30.0, PathPointTypeStart | PathPointTypeCloseSubpath, 0, 0} 
    }

Definition at line 1185 of file graphicspath.c.

Referenced by test_addpie().

addpie_path3

path_test_t addpie_path3[]

static

Initial value:

= {
    {30.0, 0.0, PathPointTypeStart | PathPointTypeCloseSubpath, 0, 0} 
    }

Definition at line 1188 of file graphicspath.c.

Referenced by test_addpie().

arc_path

path_test_t arc_path[]

static

Definition at line 400 of file graphicspath.c.

Referenced by test_arc().

arc_path2

path_test_t arc_path2[]

static

Initial value:

= {
    {1.0, 0.0, PathPointTypeStart, 0, 0}, 
    {1.0, 0.5, PathPointTypeLine, 0, 0}, 
    {1.0, 0.776142, PathPointTypeBezier, 0, 0}, 
    {0.776142, 1.0, PathPointTypeBezier, 0, 0}, 
    {0.5, 1.0, PathPointTypeBezier, 0, 0} 
    }

Definition at line 440 of file graphicspath.c.

Referenced by test_arc().

bezier_path

path_test_t bezier_path[]

static

Initial value:

= {
    {10.0, 10.0, PathPointTypeStart, 0, 0}, 
    {20.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {20.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {30.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {40.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {40.0, 30.0, PathPointTypeBezier, 0, 0}, 
    {50.0, 30.0, PathPointTypeBezier, 0, 0}, 
    {50.0, 10.0, PathPointTypeLine, 0, 0}, 
    {60.0, 10.0, PathPointTypeBezier, 0, 0}, 
    {60.0, 20.0, PathPointTypeBezier, 0, 0}, 
    {70.0, 20.0, PathPointTypeBezier, 0, 0} 
    }

Definition at line 345 of file graphicspath.c.

Referenced by test_bezier(), and test_beziers().

ellipse_path

path_test_t ellipse_path[]

static

Definition at line 680 of file graphicspath.c.

Referenced by test_ellipse().

flattenarc_path

path_test_t flattenarc_path[]

static

Initial value:

= {
    {100.0, 25.0,PathPointTypeStart, 0, 0}, 
    {99.0, 30.0, PathPointTypeLine,  0, 0}, 
    {96.0, 34.8, PathPointTypeLine,  0, 0}, 
    {91.5, 39.0, PathPointTypeLine,  0, 0}, 
    {85.5, 42.8, PathPointTypeLine,  0, 0}, 
    {69.5, 48.0, PathPointTypeLine,  0, 1}, 
    {50.0, 50.0, PathPointTypeLine,  0, 1}  
    }

Definition at line 1256 of file graphicspath.c.

Referenced by test_flatten().

flattenellipse_path

path_test_t flattenellipse_path[]

static

Initial value:

= {
    {100.0, 25.0,PathPointTypeStart, 0, 0}, 
    {99.0, 30.0, PathPointTypeLine,  0, 0}, 
    {96.0, 34.8, PathPointTypeLine,  0, 0}, 
    {91.5, 39.0, PathPointTypeLine,  0, 0}, 
    {85.5, 42.8, PathPointTypeLine,  0, 0}, 
    {69.5, 48.0, PathPointTypeLine,  0, 1}, 
    {50.0, 50.0, PathPointTypeLine,  0, 1}, 
    {30.5, 48.0, PathPointTypeLine,  0, 1}, 
    {14.8, 42.8, PathPointTypeLine,  0, 1}, 
    {8.5,  39.0, PathPointTypeLine,  0, 1}, 
    {4.0,  34.8, PathPointTypeLine,  0, 1}, 
    {1.0,  30.0, PathPointTypeLine,  0, 1}, 
    {0.0,  25.0, PathPointTypeLine,  0, 1}, 
    {1.0,  20.0, PathPointTypeLine,  0, 1}, 
    {4.0,  15.3, PathPointTypeLine,  0, 1}, 
    {8.5,  11.0, PathPointTypeLine,  0, 1}, 
    {14.8, 7.3,  PathPointTypeLine,  0, 1}, 
    {30.5, 2.0,  PathPointTypeLine,  0, 1}, 
    {50.0, 0.0,  PathPointTypeLine,  0, 1}, 
    {69.5, 2.0,  PathPointTypeLine,  0, 1}, 
    {85.5, 7.3,  PathPointTypeLine,  0, 1}, 
    {91.5, 11.0, PathPointTypeLine,  0, 1}, 
    {96.0, 15.3, PathPointTypeLine,  0, 1}, 
    {99.0, 20.0, PathPointTypeLine,  0, 1}, 
    {100.0,25.0, PathPointTypeLine | PathPointTypeCloseSubpath,  0, 1}  
    }

Definition at line 1223 of file graphicspath.c.

Referenced by test_flatten().

flattenline_path

path_test_t flattenline_path[]

static

Initial value:

= {
    {5.0, 10.0,PathPointTypeStart, 0, 0}, 
    {50.0, 100.0, PathPointTypeLine,  0, 0} 
    }

Definition at line 1251 of file graphicspath.c.

Referenced by test_flatten().

flattenquater_path

path_test_t flattenquater_path[]

static

Initial value:

= {
    {100.0, 50.0,PathPointTypeStart, 0, 0}, 
    {99.0, 60.0, PathPointTypeLine,  0, 0}, 
    {96.0, 69.5, PathPointTypeLine,  0, 0}, 
    {91.5, 78.0, PathPointTypeLine,  0, 0}, 
    {85.5, 85.5, PathPointTypeLine,  0, 0}, 
    {78.0, 91.5, PathPointTypeLine,  0, 0}, 
    {69.5, 96.0, PathPointTypeLine,  0, 0}, 
    {60.0, 99.0, PathPointTypeLine,  0, 0}, 
    {50.0, 100.0,PathPointTypeLine,  0, 0}  
    }

Definition at line 1266 of file graphicspath.c.

Referenced by test_flatten().

line2_path

path_test_t line2_path[]

static

Initial value:

= {
    {0.0, 50.0, PathPointTypeStart, 0, 0}, 
    {5.0, 45.0, PathPointTypeLine, 0, 0}, 
    {0.0, 40.0, PathPointTypeLine, 0, 0}, 
    {15.0, 35.0, PathPointTypeLine, 0, 0}, 
    {0.0, 30.0, PathPointTypeLine, 0, 0}, 
    {25.0, 25.0, PathPointTypeLine | PathPointTypeCloseSubpath, 0, 0}, 
    {0.0, 20.0, PathPointTypeStart, 0, 0}, 
    {35.0, 15.0, PathPointTypeLine, 0, 0}, 
    {0.0, 10.0, PathPointTypeLine, 0, 0} 
    }

Definition at line 288 of file graphicspath.c.

Referenced by test_line2().

linei_path

path_test_t linei_path[]

static

Initial value:

= {
    {5.00, 5.00, PathPointTypeStart, 0, 0}, 
    {6.00, 8.00, PathPointTypeLine, 0, 0}, 
    {409.92, 110.20, PathPointTypeLine, 0, 0}, 
    {543.96, 156.53, PathPointTypeBezier, 0, 0}, 
    {625.80, 346.22, PathPointTypeBezier, 0, 0}, 
    {592.71, 533.88, PathPointTypeBezier, 0, 0}, 
    {592.47, 535.28, PathPointTypeBezier, 0, 0}, 
    {592.22, 536.67, PathPointTypeBezier, 0, 0}, 
    {591.96, 538.06, PathPointTypeBezier, 0, 0}, 
    {15.00, 15.00, PathPointTypeLine, 0, 0}, 
    {26.00, 28.00, PathPointTypeLine | PathPointTypeCloseSubpath, 0, 0}, 
    {35.00, 35.00, PathPointTypeStart, 0, 0}, 
    {36.00, 38.00, PathPointTypeLine, 0, 0}, 
    {39.00, 40.00, PathPointTypeLine, 0, 0} 
    }

Definition at line 750 of file graphicspath.c.

Referenced by test_linei().

pathpath_path

path_test_t pathpath_path[]

static

Initial value:

= {
    {600.00, 450.00, PathPointTypeStart, 0, 0}, 
    {600.00, 643.30, PathPointTypeBezier, 0, 0}, 
    {488.07, 800.00, PathPointTypeBezier, 0, 0}, 
    {350.00, 800.00, PathPointTypeBezier, 0, 0}, 
    {319.61, 797.40, PathPointTypeStart, 0, 0}, 
    {182.56, 773.90, PathPointTypeBezier, 0, 0}, 
    {85.07, 599.31, PathPointTypeBezier, 0, 0}, 
    {101.85, 407.45, PathPointTypeBezier, 0, 0}, 
    {102.54, 399.66, PathPointTypeBezier, 0, 0}, 
    {103.40, 391.91, PathPointTypeBezier, 0, 0}, 
    {104.46, 384.21, PathPointTypeBezier, 0, 0}, 
    {409.92, 110.20, PathPointTypeLine, 0, 0}, 
    {543.96, 156.53, PathPointTypeBezier, 0, 0}, 
    {625.80, 346.22, PathPointTypeBezier, 0, 0}, 
    {592.71, 533.88, PathPointTypeBezier, 0, 0}, 
    {592.47, 535.28, PathPointTypeBezier, 0, 0}, 
    {592.22, 536.67, PathPointTypeBezier, 0, 0}, 
    {591.96, 538.06, PathPointTypeBezier, 0, 0}, 
    {319.61, 797.40, PathPointTypeLine, 0, 0}, 
    {182.56, 773.90, PathPointTypeBezier, 0, 0}, 
    {85.07, 599.31, PathPointTypeBezier, 0, 0}, 
    {101.85, 407.45, PathPointTypeBezier, 0, 0}, 
    {102.54, 399.66, PathPointTypeBezier, 0, 0}, 
    {103.40, 391.91, PathPointTypeBezier, 0, 0}, 
    {104.46, 384.21, PathPointTypeBezier, 0, 0} 
    }

Definition at line 630 of file graphicspath.c.

Referenced by test_pathpath().

poly_path

path_test_t poly_path[]

static

Initial value:

= {
    {5.00, 5.00, PathPointTypeStart, 0, 0},   
    {6.00, 8.00, PathPointTypeLine, 0, 0},    
    {0.00,  0.00,  PathPointTypeStart, 0, 0}, 
    {10.00, 10.00, PathPointTypeLine, 0, 0},  
    {10.00, 20.00, PathPointTypeLine, 0, 0},  
    {30.00, 10.00, PathPointTypeLine, 0, 0},  
    {20.00, 0.00, PathPointTypeLine | PathPointTypeCloseSubpath, 0, 0}, 
    }

Definition at line 789 of file graphicspath.c.

Referenced by test_polygon().

rect_line_path

path_test_t rect_line_path[]

static

Initial value:

= {
    {1.0, 4.0, PathPointTypeStart, 0, 0}, 
    {17.0, 4.0, PathPointTypeLine, 0, 0}, 
    {17.0, 68.0, PathPointTypeLine, 0, 0}, 
    {1.0, 68.0, PathPointTypeLine | PathPointTypeCloseSubpath, 0, 0}, 
    {1.0, 8.0, PathPointTypeStart, 0, 0}, 
    {17.0, 8.0, PathPointTypeLine, 0, 0} 
    }

Definition at line 2188 of file graphicspath.c.

Referenced by test_rect_line().

rect_path

path_test_t rect_path[]

static

Initial value:

= {
    {5.0, 5.0,       PathPointTypeStart, 0, 0}, 
    {105.0, 5.0,     PathPointTypeLine,  0, 0}, 
    {105.0, 55.0,    PathPointTypeLine,  0, 0}, 
    {5.0, 55.0,      PathPointTypeLine | PathPointTypeCloseSubpath, 0, 0}, 
 
    {100.0, 50.0,    PathPointTypeStart, 0, 0}, 
    {220.0, 50.0,    PathPointTypeLine,  0, 0}, 
    {220.0, 80.0,    PathPointTypeLine,  0, 0}, 
    {100.0, 80.0,    PathPointTypeLine | PathPointTypeCloseSubpath, 0, 0}  
    }

Definition at line 838 of file graphicspath.c.

Referenced by test_rect().

reverse_path

path_test_t reverse_path[]

static

Initial value:

= {
    {0.0,  20.0, PathPointTypeStart, 0, 0}, 
    {25.0, 25.0, PathPointTypeLine,  0, 0}, 
    {0.0,  30.0, PathPointTypeLine,  0, 0}, 
    {15.0, 35.0, PathPointTypeStart, 0, 0}, 
    {0.0,  40.0, PathPointTypeLine,  0, 0}, 
    {5.0,  45.0, PathPointTypeLine,  0, 0}, 
    {0.0,  50.0, PathPointTypeLine | PathPointTypeCloseSubpath, 0, 0}  
    }

Definition at line 1135 of file graphicspath.c.

Referenced by test_reverse().

widenline_caparrowanchor_path

path_test_t widenline_caparrowanchor_path[]

static

Initial value:

= {
    {15.0, 5.0,       PathPointTypeStart, 0, 1}, 
    {40.0, 5.0,       PathPointTypeLine,  0, 1}, 
    {40.0, 15.0,      PathPointTypeLine,  0, 1}, 
    {15.0, 15.0,      PathPointTypeLine|PathPointTypeCloseSubpath, 0, 1}, 
    {5.0, 10.0,       PathPointTypeStart, 0, 0}, 
    {22.320507, 0.0,  PathPointTypeLine,  0, 0}, 
    {22.320507, 20.0, PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {50.0, 10.0,      PathPointTypeStart, 0, 0}, 
    {32.679489, 20.0, PathPointTypeLine,  0, 0}, 
    {32.679489, 0.0,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    }

Definition at line 1700 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_capdiamondanchor_path

path_test_t widenline_capdiamondanchor_path[]

static

Initial value:

= {
    {5.0, 5.0,   PathPointTypeStart, 0, 0}, 
    {50.0, 5.0,  PathPointTypeLine,  0, 0}, 
    {50.0, 15.0, PathPointTypeLine,  0, 0}, 
    {5.0, 15.0,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {-5.0, 10.0, PathPointTypeStart, 0, 0}, 
    {5.0, 0.0,   PathPointTypeLine,  0, 0}, 
    {15.0, 10.0, PathPointTypeLine,  0, 0}, 
    {5.0, 20.0,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {60.0, 10.0, PathPointTypeStart, 0, 0}, 
    {50.0, 20.0, PathPointTypeLine,  0, 0}, 
    {40.0, 10.0, PathPointTypeLine,  0, 0}, 
    {50.0, 0.0,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    }

Definition at line 1685 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_capflat_path

path_test_t widenline_capflat_path[]

static

Initial value:

= {
    {5.0, 5.0,   PathPointTypeStart, 0, 0}, 
    {50.0, 5.0,  PathPointTypeLine,  0, 0}, 
    {50.0, 15.0, PathPointTypeLine,  0, 0}, 
    {5.0, 15.0,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0} 
    }

Definition at line 1595 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_capround_path

path_test_t widenline_capround_path[]

static

Initial value:

= {
    {5.0, 5.0,        PathPointTypeStart,  0, 0}, 
    {50.0, 5.0,       PathPointTypeLine,   0, 0}, 
    {52.761421, 5.0,  PathPointTypeBezier, 0, 0}, 
    {55.0, 7.238576,  PathPointTypeBezier, 0, 0}, 
    {55.0, 10.0,      PathPointTypeBezier, 0, 0}, 
    {55.0, 12.761423, PathPointTypeBezier, 0, 0}, 
    {52.761421, 15.0, PathPointTypeBezier, 0, 0}, 
    {50.0, 15.0,      PathPointTypeBezier, 0, 0}, 
    {5.0, 15.0,       PathPointTypeLine,   0, 0}, 
    {2.238576, 15.0,  PathPointTypeBezier, 0, 0}, 
    {0.0, 12.761423,  PathPointTypeBezier, 0, 0}, 
    {0.0, 10.0,       PathPointTypeBezier, 0, 0}, 
    {0.0, 7.238576,   PathPointTypeBezier, 0, 0}, 
    {2.238576, 5.0,   PathPointTypeBezier, 0, 0}, 
    {5.0, 5.0,        PathPointTypeBezier|PathPointTypeCloseSubpath, 0, 0}, 
    }

Definition at line 1609 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_caproundanchor_path

path_test_t widenline_caproundanchor_path[]

static

Definition at line 1652 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_capsquare_path

path_test_t widenline_capsquare_path[]

static

Initial value:

= {
    {0.0, 5.0,   PathPointTypeStart, 0, 0}, 
    {55.0, 5.0,  PathPointTypeLine,  0, 0}, 
    {55.0, 15.0, PathPointTypeLine,  0, 0}, 
    {0.0, 15.0,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0} 
    }

Definition at line 1602 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_capsquareanchor_dashed_path

path_test_t widenline_capsquareanchor_dashed_path[]

static

Initial value:

= {
    {5.0, 5.0,             PathPointTypeStart, 0, 0}, 
    {35.0, 5.0,            PathPointTypeLine,  0, 0}, 
    {35.0, 15.0,           PathPointTypeLine,  0, 0}, 
    {5.0, 15.0,            PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {45.0, 5.0,            PathPointTypeStart, 0, 0}, 
    {50.0, 5.0,            PathPointTypeLine,  0, 0}, 
    {50.0, 15.0,           PathPointTypeLine,  0, 0}, 
    {45.0, 15.0,           PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {12.071068, 2.928932,  PathPointTypeStart, 0, 0}, 
    {12.071068, 17.071066, PathPointTypeLine,  0, 0}, 
    {-2.071068, 17.071066, PathPointTypeLine,  0, 0}, 
    {-2.071068, 2.928932,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {42.928928, 17.071068, PathPointTypeStart, 0, 0}, 
    {42.928928, 2.928932,  PathPointTypeLine,  0, 0}, 
    {57.071068, 2.928932,  PathPointTypeLine,  0, 0}, 
    {57.071068, 17.071068, PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    }

Definition at line 1724 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_capsquareanchor_multifigure_path

path_test_t widenline_capsquareanchor_multifigure_path[]

static

Initial value:

= {
    {5.0, 5.0,             PathPointTypeStart, 0, 0}, 
    {25.0, 5.0,            PathPointTypeLine,  0, 0}, 
    {25.0, 15.0,           PathPointTypeLine,  0, 0}, 
    {5.0, 15.0,            PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {30.0, 5.0,            PathPointTypeStart, 0, 0}, 
    {50.0, 5.0,            PathPointTypeLine,  0, 0}, 
    {50.0, 15.0,           PathPointTypeLine,  0, 0}, 
    {30.0, 15.0,           PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {12.071068, 2.928932,  PathPointTypeStart, 0, 0}, 
    {12.071068, 17.071066, PathPointTypeLine,  0, 0}, 
    {-2.071068, 17.071066, PathPointTypeLine,  0, 0}, 
    {-2.071068, 2.928932,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {17.928930, 17.071068, PathPointTypeStart, 0, 0}, 
    {17.928930, 2.928932,  PathPointTypeLine,  0, 0}, 
    {32.071068, 2.928932,  PathPointTypeLine,  0, 0}, 
    {32.071068, 17.071068, PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {37.071068, 2.928932,  PathPointTypeStart, 0, 0}, 
    {37.071068, 17.071066, PathPointTypeLine,  0, 0}, 
    {22.928930, 17.071066, PathPointTypeLine,  0, 0}, 
    {22.928930, 2.928932,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {42.928928, 17.071068, PathPointTypeStart, 0, 0}, 
    {42.928928, 2.928932,  PathPointTypeLine,  0, 0}, 
    {57.071068, 2.928932,  PathPointTypeLine,  0, 0}, 
    {57.071068, 17.071068, PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    }

Definition at line 1743 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_capsquareanchor_path

path_test_t widenline_capsquareanchor_path[]

static

Initial value:

= {
    {5.0, 5.0,             PathPointTypeStart, 0, 0}, 
    {50.0, 5.0,            PathPointTypeLine,  0, 0}, 
    {50.0, 15.0,           PathPointTypeLine,  0, 0}, 
    {5.0, 15.0,            PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {12.071068, 2.928932,  PathPointTypeStart, 0, 0}, 
    {12.071068, 17.071066, PathPointTypeLine,  0, 0}, 
    {-2.071068, 17.071066, PathPointTypeLine,  0, 0}, 
    {-2.071068, 2.928932,  PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {42.928928, 17.071068, PathPointTypeStart, 0, 0}, 
    {42.928928, 2.928932,  PathPointTypeLine,  0, 0}, 
    {57.071068, 2.928932,  PathPointTypeLine,  0, 0}, 
    {57.071068, 17.071068, PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    }

Definition at line 1637 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_capsquareanchor_thin_path

path_test_t widenline_capsquareanchor_thin_path[]

static

Initial value:

= {
    {6.414213, 8.585786,   PathPointTypeStart, 0, 0}, 
    {6.414213, 11.414213,  PathPointTypeLine,  0, 0}, 
    {3.585786, 11.414213,  PathPointTypeLine,  0, 0}, 
    {3.585786, 8.585786,   PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    {48.585785, 11.414213, PathPointTypeStart, 0, 0}, 
    {48.585785, 8.585786,  PathPointTypeLine,  0, 0}, 
    {51.414211, 8.585786,  PathPointTypeLine,  0, 0}, 
    {51.414211, 11.414213, PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0}, 
    }

Definition at line 1713 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_captriangle_path

path_test_t widenline_captriangle_path[]

static

Initial value:

= {
    {5.0, 5.0,   PathPointTypeStart, 0, 0}, 
    {50.0, 5.0,  PathPointTypeLine,  0, 0}, 
    {55.0, 10.0, PathPointTypeLine,  0, 0}, 
    {50.0, 15.0, PathPointTypeLine,  0, 0}, 
    {5.0, 15.0,  PathPointTypeLine,  0, 0}, 
    {0.0, 10.0,  PathPointTypeLine,  0, 0}, 
    {5.0, 5.0,   PathPointTypeLine|PathPointTypeCloseSubpath, 0, 0} 
    }

Definition at line 1627 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_customarrow_multifigure_path

path_test_t widenline_customarrow_multifigure_path[]

static

Initial value:

= {
    {6.0, 9.5,          PathPointTypeStart}, 
    {24.0, 9.5,         PathPointTypeLine}, 
    {24.0, 10.5,        PathPointTypeLine}, 
    {6.0, 10.5,         PathPointTypeLine|PathPointTypeCloseSubpath}, 
    {30.5, 11.0,        PathPointTypeStart}, 
    {30.5, 29.0,        PathPointTypeLine}, 
    {29.5, 29.0,        PathPointTypeLine}, 
    {29.5, 11.0,        PathPointTypeLine|PathPointTypeCloseSubpath}, 
    {13.0, 14.0,        PathPointTypeStart}, 
    {5.0, 10.0,         PathPointTypeLine}, 
    {13.0, 6.0,         PathPointTypeLine}, 
    {11.0, 10.0,        PathPointTypeLine|PathPointTypeCloseSubpath}, 
    {17.0, 6.0,         PathPointTypeStart}, 
    {25.0, 10.0,        PathPointTypeLine}, 
    {17.0, 14.0,        PathPointTypeLine}, 
    {19.0, 10.0,        PathPointTypeLine|PathPointTypeCloseSubpath}, 
    {26.0, 18.0,        PathPointTypeStart}, 
    {30.0, 10.0,        PathPointTypeLine}, 
    {34.0, 18.0,        PathPointTypeLine}, 
    {30.0, 16.0,        PathPointTypeLine|PathPointTypeCloseSubpath}, 
    {34.0, 22.0,        PathPointTypeStart}, 
    {30.0, 30.0,        PathPointTypeLine}, 
    {26.0, 22.0,        PathPointTypeLine}, 
    {30.0, 24.0,        PathPointTypeLine|PathPointTypeCloseSubpath}, 
    }

Definition at line 1770 of file graphicspath.c.

Referenced by test_widen_cap().

widenline_dash_path

path_test_t widenline_dash_path[]

static

Initial value:

= {
    {5.0, 0.0,   PathPointTypeStart, 0, 0}, 
    {35.0, 0.0,  PathPointTypeLine,  0, 0}, 
    {35.0, 10.0, PathPointTypeLine,  0, 0}, 
    {5.0, 10.0,  PathPointTypeLine|PathPointTypeCloseSubpath,  0, 0}, 
    {45.0, 0.0,   PathPointTypeStart, 0, 0}, 
    {50.0, 0.0,  PathPointTypeLine,  0, 0}, 
    {50.0, 10.0, PathPointTypeLine,  0, 0}, 
    {45.0, 10.0,  PathPointTypeLine|PathPointTypeCloseSubpath,  0, 0}, 
    }

Definition at line 1368 of file graphicspath.c.

Referenced by test_widen().

widenline_path

path_test_t widenline_path[]

static

Initial value:

= {
    {5.0, 5.0,   PathPointTypeStart, 0, 0}, 
    {50.0, 5.0,  PathPointTypeLine,  0, 0}, 
    {50.0, 15.0, PathPointTypeLine,  0, 0}, 
    {5.0, 15.0,  PathPointTypeLine|PathPointTypeCloseSubpath,  0, 0} 
    }

Definition at line 1354 of file graphicspath.c.

Referenced by test_widen().

widenline_thin_dash_path

path_test_t widenline_thin_dash_path[]

static

Initial value:

= {
    {5.0, 4.75, PathPointTypeStart, 0, 0}, 
    {8.0, 4.75, PathPointTypeLine,  0, 0}, 
    {8.0, 5.25, PathPointTypeLine,  0, 0}, 
    {5.0, 5.25, PathPointTypeLine|PathPointTypeCloseSubpath,  0, 0}, 
    {9.0, 4.75, PathPointTypeStart, 0, 0}, 
    {9.5, 4.75, PathPointTypeLine,  0, 0}, 
    {9.5, 5.25, PathPointTypeLine,  0, 0}, 
    {9.0, 5.25, PathPointTypeLine|PathPointTypeCloseSubpath,  0, 0}, 
    }

Definition at line 1379 of file graphicspath.c.

Referenced by test_widen().

widenline_unit_path

path_test_t widenline_unit_path[]

static

Initial value:

= {
    {5.0, 9.5,   PathPointTypeStart, 0, 0}, 
    {50.0, 9.5,  PathPointTypeLine,  0, 0}, 
    {50.0, 10.5, PathPointTypeLine,  0, 0}, 
    {5.0, 10.5,  PathPointTypeLine|PathPointTypeCloseSubpath,  0, 0} 
    }

Definition at line 1390 of file graphicspath.c.

Referenced by test_widen().

widenline_wide_path

path_test_t widenline_wide_path[]

static

Initial value:

= {
    {5.0, 0.0,   PathPointTypeStart, 0, 0}, 
    {50.0, 0.0,  PathPointTypeLine,  0, 0}, 
    {50.0, 20.0, PathPointTypeLine,  0, 0}, 
    {5.0, 20.0,  PathPointTypeLine|PathPointTypeCloseSubpath,  0, 0} 
    }

Definition at line 1361 of file graphicspath.c.

Referenced by test_widen().