path.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "wine/test.h"
#include "winuser.h"
#include "winerror.h"

Include dependency graph for path.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)

Functions
static void	test_path_state (void)
static void	test_widenpath (void)
static void	ok_path (HDC hdc, const char *path_name, const path_test_t *expected, int expected_size)
static void	test_arcto (void)
static void	test_anglearc (void)
static void	test_polydraw (void)
static void	test_closefigure (void)
static void WINAPI	linedda_callback (INT x, INT y, LPARAM lparam)
static void	test_linedda (void)
static void	test_rectangle (void)
static void	test_roundrect (void)
static void	test_ellipse (void)
static void	test_all_functions (void)
	START_TEST (path)

Variables
static const path_test_t	arcto_path []
static const path_test_t	anglearc_path []
static const path_test_t	polydraw_path []
static POINT	polydraw_pts []
static BYTE	polydraw_tps []
static const path_test_t	rectangle_path []
static const path_test_t	roundrect_path []
static const path_test_t	ellipse_path []
static const path_test_t	all_funcs_path []

Macro Definition Documentation

expect

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

Definition at line 34 of file path.c.

Function Documentation

linedda_callback()

static void WINAPI linedda_callback ( INT  x, INT  y, LPARAM  lparam  )

static

Definition at line 740 of file path.c.

{
    POINT **pt = (POINT**)lparam;
    ok((*pt)->x == x && (*pt)->y == y, "point mismatch expect(%d,%d) got(%d,%d)\n",
       (*pt)->x, (*pt)->y, x, y);
 
    (*pt)++;
    return;
}

Referenced by test_linedda().

ok_path()

static void ok_path ( HDC  hdc, const char *  path_name, const path_test_t *  expected, int  expected_size  )

static

Definition at line 401 of file path.c.

{
    static const char *type_string[8] = { "Unknown (0)", "PT_CLOSEFIGURE", "PT_LINETO",
                                          "PT_LINETO | PT_CLOSEFIGURE", "PT_BEZIERTO",
                                          "PT_BEZIERTO | PT_CLOSEFIGURE", "PT_MOVETO", "PT_MOVETO | PT_CLOSEFIGURE"};
    POINT *pnt;
    BYTE *types;
    int size, idx;
 
    /* Get the path */
    assert(hdc != 0);
    size = GetPath(hdc, NULL, NULL, 0);
    ok(size > 0, "GetPath returned size %d, last error %d\n", size, GetLastError());
    if (size <= 0) return;
 
    pnt = HeapAlloc(GetProcessHeap(), 0, size*sizeof(POINT));
    assert(pnt != 0);
    types = HeapAlloc(GetProcessHeap(), 0, size*sizeof(BYTE));
    assert(types != 0);
    size = GetPath(hdc, pnt, types, size);
    assert(size > 0);
 
    ros_skip_flaky
    ok( size == expected_size, "%s: Path size %d does not match expected size %d\n",
        path_name, size, expected_size);
 
    for (idx = 0; idx < min( size, expected_size ); idx++)
    {
        /* We allow a few pixels fudge in matching X and Y coordinates to account for imprecision in
         * floating point to integer conversion */
        static const int fudge = 2;
 
        ros_skip_flaky
        ok( types[idx] == expected[idx].type, "%s: Expected #%d: %s (%d,%d) but got %s (%d,%d)\n",
            path_name, idx, type_string[expected[idx].type], expected[idx].x, expected[idx].y,
            type_string[types[idx]], pnt[idx].x, pnt[idx].y);
 
        if (types[idx] == expected[idx].type)
            ros_skip_flaky
            ok( (pnt[idx].x >= expected[idx].x - fudge && pnt[idx].x <= expected[idx].x + fudge) &&
                (pnt[idx].y >= expected[idx].y - fudge && pnt[idx].y <= expected[idx].y + fudge),
                "%s: Expected #%d: %s  position (%d,%d) but got (%d,%d)\n", path_name, idx,
                type_string[expected[idx].type], expected[idx].x, expected[idx].y, pnt[idx].x, pnt[idx].y);
    }
 
    if (winetest_debug > 2)
    {
        printf("static const path_test_t %s[] =\n{\n", path_name);
        for (idx = 0; idx < size; idx++)
            printf("    {%d, %d, %s}, /* %d */\n", pnt[idx].x, pnt[idx].y, type_string[types[idx]], idx);
        printf("};\n" );
    }
 
    HeapFree(GetProcessHeap(), 0, types);
    HeapFree(GetProcessHeap(), 0, pnt);
}

Referenced by test_all_functions(), test_anglearc(), test_arcto(), test_ellipse(), test_polydraw(), test_rectangle(), and test_roundrect().

START_TEST()

START_TEST

(

path

)

Definition at line 1900 of file path.c.

{
    test_path_state();
    test_widenpath();
    test_arcto();
    test_anglearc();
    test_polydraw();
    test_closefigure();
    test_linedda();
    test_rectangle();
    test_roundrect();
    test_ellipse();
    test_all_functions();
}

test_all_functions()

static void test_all_functions ( void  )

static

Definition at line 1862 of file path.c.

{
    POINT pts[9] = {{10, 10}, {20, 10}, {10, 20}, {20, 20}, {30, 30}, {40, 20},
                    {20, 30}, {30, 40}, {10, 50}};
    DWORD counts[5] = {4, 5, 0, 1, 2};
    BYTE types[9] = { PT_MOVETO, PT_LINETO, PT_BEZIERTO, PT_BEZIERTO, PT_BEZIERTO, PT_LINETO,
                      PT_LINETO | PT_CLOSEFIGURE, PT_MOVETO, PT_LINETO };
    HDC hdc = GetDC( 0 );
 
    BeginPath( hdc );
    LineTo( hdc, 50, 150 );
    MoveToEx( hdc, 50, 50, NULL );
    LineTo( hdc, 150, 150 );
    LineTo( hdc, 150, 50 );
    LineTo( hdc, 50, 50 );
    AngleArc( hdc, 37, 36, 23, 90, 180 );
    Polyline( hdc, pts, 4 );
    Arc( hdc, 21, 21, 39, 29, 39, 29, 21, 21 );
    PolylineTo( hdc, pts, 4 );
    ArcTo( hdc, 23, 23, 37, 27, 37, 27, 23, 23 );
    PolyPolyline( hdc, pts, counts, 2 );
    Chord( hdc, 42, 43, 57, 66, 39, 29, 21, 21 );
    PolyDraw( hdc, pts, types, 9 );
    Pie( hdc, 52, 54, 65, 68, 39, 29, 21, 21 );
    Polygon( hdc, pts, 9 );
    Ellipse( hdc, 22, 33, 44, 66 );
    Rectangle( hdc, 60, 70, 80, 90 );
    RoundRect( hdc, 100, 100, 200, 200, 35, 45 );
    PolyBezier( hdc, pts, 7 );
    PolyPolygon( hdc, pts, (int *)counts, 2 );
    PolyBezierTo( hdc, pts, 9 );
    LineTo( hdc, 150, 150 );
    /* FIXME: ExtTextOut */
    EndPath( hdc );
    ok_path( hdc, "all_funcs_path", all_funcs_path, sizeof(all_funcs_path)/sizeof(path_test_t) );
    ReleaseDC( 0, hdc );
}

Referenced by START_TEST().

test_anglearc()

static void test_anglearc ( void  )

static

Definition at line 531 of file path.c.

{
    HDC hdc = GetDC(0);
    BeginPath(hdc);
    if (!AngleArc(hdc, 300, 300, 100, 45.0, 135.0) &&
        GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
    {
        /* AngleArc is only available on Win2k and later */
        win_skip("AngleArc is not available\n");
        goto done;
    }
    AngleArc(hdc, 300, 300, 80, 150.0, -180.0);
    CloseFigure(hdc);
    EndPath(hdc);
 
    ok_path(hdc, "anglearc_path", anglearc_path, sizeof(anglearc_path)/sizeof(path_test_t));
done:
    ReleaseDC(0, hdc);
}

Referenced by START_TEST().

test_arcto()

static void test_arcto ( void  )

static

Definition at line 483 of file path.c.

{
    HDC hdc = GetDC(0);
 
    BeginPath(hdc);
    SetArcDirection(hdc, AD_CLOCKWISE);
    if (!ArcTo(hdc, 200, 200, 400, 300, 200, 200, 400, 300) &&
        GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
    {
        /* ArcTo is only available on Win2k and later */
        win_skip("ArcTo is not available\n");
        goto done;
    }
    SetArcDirection(hdc, AD_COUNTERCLOCKWISE);
    ArcTo(hdc, 210, 210, 390, 290, 390, 290, 210, 210);
    CloseFigure(hdc);
    EndPath(hdc);
 
    ok_path(hdc, "arcto_path", arcto_path, sizeof(arcto_path)/sizeof(path_test_t));
done:
    ReleaseDC(0, hdc);
}

Referenced by START_TEST().

test_closefigure()

static void test_closefigure ( void  )

static

Definition at line 694 of file path.c.

                                   {
    int nSize, nSizeWitness;
    POINT pos;
    HDC hdc = GetDC(0);
 
    MoveToEx( hdc, 100, 100, NULL );
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 100 && pos.y == 100, "wrong pos %d,%d\n", pos.x, pos.y );
 
    BeginPath(hdc);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 100 && pos.y == 100, "wrong pos %d,%d\n", pos.x, pos.y );
    MoveToEx(hdc, 95, 95, NULL);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 95 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
    LineTo(hdc, 95,  0);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 95 && pos.y == 0, "wrong pos %d,%d\n", pos.x, pos.y );
    LineTo(hdc,  0, 95);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 0 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
 
    CloseFigure(hdc);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 0 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
    EndPath(hdc);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 0 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
    nSize = GetPath(hdc, NULL, NULL, 0);
 
    AbortPath(hdc);
 
    BeginPath(hdc);
    MoveToEx(hdc, 95, 95, NULL);
    LineTo(hdc, 95,  0);
    LineTo(hdc,  0, 95);
 
    EndPath(hdc);
    nSizeWitness = GetPath(hdc, NULL, NULL, 0);
 
    /* This test shows CloseFigure does not have to add a point at the end of the path */
    ok(nSize == nSizeWitness, "Wrong number of points, no point should be added by CloseFigure\n");
 
    ReleaseDC(0, hdc);
}

Referenced by START_TEST().

test_ellipse()

static void test_ellipse ( void  )

static

Definition at line 1666 of file path.c.

{
    HDC hdc = GetDC( 0 );
 
    BeginPath( hdc );
    Ellipse( hdc, 20, 20, 40, 40 );
    Ellipse( hdc, 30, 50, 55, 35 );
    Ellipse( hdc, 60, 60, 35, 45 );
    Ellipse( hdc, 70, 70, 50, 70 );
    Ellipse( hdc, 75, 75, 75, 85 );
    Ellipse( hdc, 80, 80, 81, 81 );
    SetArcDirection( hdc, AD_CLOCKWISE );
    Ellipse( hdc, 20, 20, 40, 40 );
    Ellipse( hdc, 30, 50, 55, 35 );
    Ellipse( hdc, 60, 60, 35, 45 );
    Ellipse( hdc, 70, 70, 50, 70 );
    Ellipse( hdc, 75, 75, 75, 85 );
    Ellipse( hdc, 80, 80, 81, 81 );
    SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
    SetMapMode( hdc, MM_ANISOTROPIC );
    SetViewportExtEx( hdc, -2, 2, NULL );
    Ellipse( hdc, 20, 20, 40, 40 );
    Ellipse( hdc, 30, 50, 55, 35 );
    SetViewportExtEx( hdc, 3, -3, NULL );
    Ellipse( hdc, 20, 20, 40, 40 );
    Ellipse( hdc, 30, 50, 55, 35 );
    SetWindowExtEx( hdc, -20, 20, NULL );
    Ellipse( hdc, 20, 20, 40, 40 );
    Ellipse( hdc, 24, 22, 21, 20 );
    SetMapMode( hdc, MM_TEXT );
    SetGraphicsMode( hdc, GM_ADVANCED );
    Ellipse( hdc, 20, 20, 40, 40 );
    Ellipse( hdc, 30, 50, 55, 35 );
    Ellipse( hdc, 60, 60, 35, 45 );
    Ellipse( hdc, 70, 70, 50, 70 );
    Ellipse( hdc, 75, 75, 75, 85 );
    Ellipse( hdc, 80, 80, 81, 81 );
    SetArcDirection( hdc, AD_CLOCKWISE );
    Ellipse( hdc, 20, 20, 40, 40 );
    Ellipse( hdc, 30, 50, 55, 35 );
    Ellipse( hdc, 60, 60, 35, 45 );
    Ellipse( hdc, 70, 70, 50, 70 );
    Ellipse( hdc, 75, 75, 75, 85 );
    Ellipse( hdc, 80, 80, 81, 81 );
    SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
    EndPath( hdc );
    SetMapMode( hdc, MM_TEXT );
    ok_path( hdc, "ellipse_path", ellipse_path, sizeof(ellipse_path)/sizeof(path_test_t) );
}

Referenced by START_TEST().

test_linedda()

static void test_linedda ( void  )

static

Definition at line 750 of file path.c.

{
    const POINT *pt;
    static const POINT array_10_20_20_40[] = {{10,20},{10,21},{11,22},{11,23},
                                              {12,24},{12,25},{13,26},{13,27},
                                              {14,28},{14,29},{15,30},{15,31},
                                              {16,32},{16,33},{17,34},{17,35},
                                              {18,36},{18,37},{19,38},{19,39},
                                              {-1,-1}};
    static const POINT array_10_20_20_43[] = {{10,20},{10,21},{11,22},{11,23},
                                              {12,24},{12,25},{13,26},{13,27},
                                              {13,28},{14,29},{14,30},{15,31},
                                              {15,32},{16,33},{16,34},{17,35},
                                              {17,36},{17,37},{18,38},{18,39},
                                              {19,40},{19,41},{20,42},{-1,-1}};
 
    static const POINT array_10_20_10_20[] = {{-1,-1}};
    static const POINT array_10_20_11_27[] = {{10,20},{10,21},{10,22},{10,23},
                                              {11,24},{11,25},{11,26},{-1,-1}};
 
    static const POINT array_20_43_10_20[] = {{20,43},{20,42},{19,41},{19,40},
                                              {18,39},{18,38},{17,37},{17,36},
                                              {17,35},{16,34},{16,33},{15,32},
                                              {15,31},{14,30},{14,29},{13,28},
                                              {13,27},{13,26},{12,25},{12,24},
                                              {11,23},{11,22},{10,21},{-1,-1}};
 
    static const POINT array_20_20_10_43[] = {{20,20},{20,21},{19,22},{19,23},
                                              {18,24},{18,25},{17,26},{17,27},
                                              {17,28},{16,29},{16,30},{15,31},
                                              {15,32},{14,33},{14,34},{13,35},
                                              {13,36},{13,37},{12,38},{12,39},
                                              {11,40},{11,41},{10,42},{-1,-1}};
 
    static const POINT array_20_20_43_10[] = {{20,20},{21,20},{22,19},{23,19},
                                              {24,18},{25,18},{26,17},{27,17},
                                              {28,17},{29,16},{30,16},{31,15},
                                              {32,15},{33,14},{34,14},{35,13},
                                              {36,13},{37,13},{38,12},{39,12},
                                              {40,11},{41,11},{42,10},{-1,-1}};
 
 
    pt = array_10_20_20_40;
    LineDDA(10, 20, 20, 40, linedda_callback, (LPARAM)&pt);
    ok(pt->x == -1 && pt->y == -1, "didn't find terminator\n");
 
    pt = array_10_20_20_43;
    LineDDA(10, 20, 20, 43, linedda_callback, (LPARAM)&pt);
    ok(pt->x == -1 && pt->y == -1, "didn't find terminator\n");
 
    pt = array_10_20_10_20;
    LineDDA(10, 20, 10, 20, linedda_callback, (LPARAM)&pt);
    ok(pt->x == -1 && pt->y == -1, "didn't find terminator\n");
 
    pt = array_10_20_11_27;
    LineDDA(10, 20, 11, 27, linedda_callback, (LPARAM)&pt);
    ok(pt->x == -1 && pt->y == -1, "didn't find terminator\n");
 
    pt = array_20_43_10_20;
    LineDDA(20, 43, 10, 20, linedda_callback, (LPARAM)&pt);
    ok(pt->x == -1 && pt->y == -1, "didn't find terminator\n");
 
    pt = array_20_20_10_43;
    LineDDA(20, 20, 10, 43, linedda_callback, (LPARAM)&pt);
    ok(pt->x == -1 && pt->y == -1, "didn't find terminator\n");
 
    pt = array_20_20_43_10;
    LineDDA(20, 20, 43, 10, linedda_callback, (LPARAM)&pt);
    ok(pt->x == -1 && pt->y == -1, "didn't find terminator\n");
}

Referenced by START_TEST().

test_path_state()

static void test_path_state ( void  )

static

Definition at line 36 of file path.c.

{
    BYTE buffer[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
    BITMAPINFO *bi = (BITMAPINFO *)buffer;
    HDC hdc;
    HRGN rgn;
    HBITMAP orig, dib;
    void *bits;
    BOOL ret;
 
    hdc = CreateCompatibleDC( 0 );
    memset( buffer, 0, sizeof(buffer) );
    bi->bmiHeader.biSize = sizeof(bi->bmiHeader);
    bi->bmiHeader.biHeight = 256;
    bi->bmiHeader.biWidth = 256;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biPlanes = 1;
    bi->bmiHeader.biCompression = BI_RGB;
    dib = CreateDIBSection( 0, bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0 );
    orig = SelectObject( hdc, dib );
 
    BeginPath( hdc );
    LineTo( hdc, 100, 100 );
    ret = WidenPath( hdc );
    ok( !ret, "WidenPath succeeded\n" );
 
    /* selecting another bitmap doesn't affect the path */
    SelectObject( hdc, orig );
    ret = WidenPath( hdc );
    ok( !ret, "WidenPath succeeded\n" );
 
    SelectObject( hdc, dib );
    ret = WidenPath( hdc );
    ok( !ret, "WidenPath succeeded\n" );
 
    ret = EndPath( hdc );
    ok( ret, "EndPath failed error %u\n", GetLastError() );
    ret = WidenPath( hdc );
    ok( ret, "WidenPath failed error %u\n", GetLastError() );
 
    SelectObject( hdc, orig );
    ret = WidenPath( hdc );
    ok( ret, "WidenPath failed error %u\n", GetLastError() );
 
    BeginPath( hdc );
    LineTo( hdc, 100, 100 );
    ret = WidenPath( hdc );
    ok( !ret, "WidenPath succeeded\n" );
    SaveDC( hdc );
    SelectObject( hdc, dib );
    ret = EndPath( hdc );
    ok( ret, "EndPath failed error %u\n", GetLastError() );
    ret = WidenPath( hdc );
    ok( ret, "WidenPath failed error %u\n", GetLastError() );
 
    /* path should be open again after RestoreDC */
    RestoreDC( hdc, -1  );
    ret = WidenPath( hdc );
    ok( !ret, "WidenPath succeeded\n" );
    ret = EndPath( hdc );
    ok( ret, "EndPath failed error %u\n", GetLastError() );
 
    SaveDC( hdc );
    BeginPath( hdc );
    RestoreDC( hdc, -1  );
    ret = WidenPath( hdc );
    ok( ret, "WidenPath failed error %u\n", GetLastError() );
 
    /* test all functions with no path at all */
    AbortPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = WidenPath( hdc );
    ok( !ret, "WidenPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = FlattenPath( hdc );
    ok( !ret, "FlattenPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = StrokePath( hdc );
    ok( !ret, "StrokePath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = FillPath( hdc );
    ok( !ret, "FillPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = StrokeAndFillPath( hdc );
    ok( !ret, "StrokeAndFillPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = SelectClipPath( hdc, RGN_OR );
    ok( !ret, "SelectClipPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    rgn = PathToRegion( hdc );
    ok( !rgn, "PathToRegion succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = EndPath( hdc );
    ok( !ret, "SelectClipPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    SetLastError( 0xdeadbeef );
    ret = CloseFigure( hdc );
    ok( !ret, "CloseFigure succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    /* test all functions with an open path */
    AbortPath( hdc );
    BeginPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = WidenPath( hdc );
    ok( !ret, "WidenPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    AbortPath( hdc );
    BeginPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = FlattenPath( hdc );
    ok( !ret, "FlattenPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    AbortPath( hdc );
    BeginPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = StrokePath( hdc );
    ok( !ret, "StrokePath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    AbortPath( hdc );
    BeginPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = FillPath( hdc );
    ok( !ret, "FillPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    AbortPath( hdc );
    BeginPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = StrokeAndFillPath( hdc );
    ok( !ret, "StrokeAndFillPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    AbortPath( hdc );
    BeginPath( hdc );
    Rectangle( hdc, 1, 1, 10, 10 );  /* region needs some contents */
    SetLastError( 0xdeadbeef );
    ret = SelectClipPath( hdc, RGN_OR );
    ok( !ret, "SelectClipPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    AbortPath( hdc );
    BeginPath( hdc );
    Rectangle( hdc, 1, 1, 10, 10 );  /* region needs some contents */
    SetLastError( 0xdeadbeef );
    rgn = PathToRegion( hdc );
    ok( !rgn, "PathToRegion succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    AbortPath( hdc );
    BeginPath( hdc );
    ret = CloseFigure( hdc );
    ok( ret, "CloseFigure failed\n" );
 
    /* test all functions with a closed path */
    AbortPath( hdc );
    BeginPath( hdc );
    EndPath( hdc );
    ret = WidenPath( hdc );
    ok( ret, "WidenPath failed\n" );
    ok( GetPath( hdc, NULL, NULL, 0 ) != -1, "path deleted\n" );
 
    AbortPath( hdc );
    BeginPath( hdc );
    EndPath( hdc );
    ret = FlattenPath( hdc );
    ok( ret, "FlattenPath failed\n" );
    ok( GetPath( hdc, NULL, NULL, 0 ) != -1, "path deleted\n" );
 
    AbortPath( hdc );
    BeginPath( hdc );
    EndPath( hdc );
    ret = StrokePath( hdc );
    ok( ret, "StrokePath failed\n" );
    ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
 
    BeginPath( hdc );
    EndPath( hdc );
    ret = FillPath( hdc );
    ok( ret, "FillPath failed\n" );
    ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
 
    BeginPath( hdc );
    EndPath( hdc );
    ret = StrokeAndFillPath( hdc );
    ok( ret, "StrokeAndFillPath failed\n" );
    ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
 
    BeginPath( hdc );
    Rectangle( hdc, 1, 1, 10, 10 );  /* region needs some contents */
    EndPath( hdc );
    ret = SelectClipPath( hdc, RGN_OR );
    ok( ret, "SelectClipPath failed\n" );
    ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
 
    BeginPath( hdc );
    EndPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = SelectClipPath( hdc, RGN_OR );
    ok( !ret, "SelectClipPath succeeded on empty path\n" );
    ok( GetLastError() == 0xdeadbeef, "wrong error %u\n", GetLastError() );
    ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
 
    BeginPath( hdc );
    Rectangle( hdc, 1, 1, 10, 10 );  /* region needs some contents */
    EndPath( hdc );
    rgn = PathToRegion( hdc );
    ok( rgn != 0, "PathToRegion failed\n" );
    DeleteObject( rgn );
    ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
 
    BeginPath( hdc );
    EndPath( hdc );
    SetLastError( 0xdeadbeef );
    rgn = PathToRegion( hdc );
    ok( !rgn, "PathToRegion succeeded on empty path\n" );
    ok( GetLastError() == 0xdeadbeef, "wrong error %u\n", GetLastError() );
    DeleteObject( rgn );
    ok( GetPath( hdc, NULL, NULL, 0 ) == -1, "path not deleted\n" );
 
    BeginPath( hdc );
    EndPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = CloseFigure( hdc );
    ok( !ret, "CloseFigure succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    AbortPath( hdc );
    BeginPath( hdc );
    EndPath( hdc );
    SetLastError( 0xdeadbeef );
    ret = EndPath( hdc );
    ok( !ret, "EndPath succeeded\n" );
    ok( GetLastError() == ERROR_CAN_NOT_COMPLETE || broken(GetLastError() == 0xdeadbeef),
        "wrong error %u\n", GetLastError() );
 
    DeleteDC( hdc );
    DeleteObject( dib );
}

Referenced by START_TEST().

test_polydraw()

static void test_polydraw ( void  )

static

Definition at line 608 of file path.c.

{
    BOOL retb;
    POINT pos;
    HDC hdc = GetDC(0);
 
    MoveToEx( hdc, -20, -20, NULL );
 
    BeginPath(hdc);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == -20 && pos.y == -20, "wrong pos %d,%d\n", pos.x, pos.y );
 
    /* closefigure with no previous moveto */
    if (!(retb = PolyDraw(hdc, polydraw_pts, polydraw_tps, 2)) &&
        GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
    {
        /* PolyDraw is only available on Win2k and later */
        win_skip("PolyDraw is not available\n");
        goto done;
    }
    expect(TRUE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 10 && pos.y == 15, "wrong pos %d,%d\n", pos.x, pos.y );
    LineTo(hdc, -10, -10);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == -10 && pos.y == -10, "wrong pos %d,%d\n", pos.x, pos.y );
 
    MoveToEx(hdc, 100, 100, NULL);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 100 && pos.y == 100, "wrong pos %d,%d\n", pos.x, pos.y );
    LineTo(hdc, 95, 95);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 95 && pos.y == 95, "wrong pos %d,%d\n", pos.x, pos.y );
    /* closefigure with previous moveto */
    retb = PolyDraw(hdc, polydraw_pts, polydraw_tps, 2);
    expect(TRUE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 10 && pos.y == 15, "wrong pos %d,%d\n", pos.x, pos.y );
    /* bad bezier points */
    retb = PolyDraw(hdc, &(polydraw_pts[2]), &(polydraw_tps[2]), 4);
    expect(FALSE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 10 && pos.y == 15, "wrong pos %d,%d\n", pos.x, pos.y );
    retb = PolyDraw(hdc, &(polydraw_pts[6]), &(polydraw_tps[6]), 4);
    expect(FALSE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 10 && pos.y == 15, "wrong pos %d,%d\n", pos.x, pos.y );
    /* good bezier points */
    retb = PolyDraw(hdc, &(polydraw_pts[8]), &(polydraw_tps[8]), 4);
    expect(TRUE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 35 && pos.y == 40, "wrong pos %d,%d\n", pos.x, pos.y );
    /* does lineto or bezierto take precedence? */
    retb = PolyDraw(hdc, &(polydraw_pts[12]), &(polydraw_tps[12]), 4);
    expect(FALSE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 35 && pos.y == 40, "wrong pos %d,%d\n", pos.x, pos.y );
    /* bad point type, has already moved cursor position */
    retb = PolyDraw(hdc, &(polydraw_pts[15]), &(polydraw_tps[15]), 4);
    expect(FALSE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 35 && pos.y == 40, "wrong pos %d,%d\n", pos.x, pos.y );
    /* bad point type, cursor position is moved, but back to its original spot */
    retb = PolyDraw(hdc, &(polydraw_pts[17]), &(polydraw_tps[17]), 4);
    expect(FALSE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 35 && pos.y == 40, "wrong pos %d,%d\n", pos.x, pos.y );
    /* does lineto or moveto take precedence? */
    retb = PolyDraw(hdc, &(polydraw_pts[20]), &(polydraw_tps[20]), 3);
    expect(TRUE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 65 && pos.y == 65, "wrong pos %d,%d\n", pos.x, pos.y );
    /* consecutive movetos */
    retb = PolyDraw(hdc, &(polydraw_pts[23]), &(polydraw_tps[23]), 4);
    expect(TRUE, retb);
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 80 && pos.y == 80, "wrong pos %d,%d\n", pos.x, pos.y );
 
    EndPath(hdc);
    ok_path(hdc, "polydraw_path", polydraw_path, sizeof(polydraw_path)/sizeof(path_test_t));
    GetCurrentPositionEx( hdc, &pos );
    ok( pos.x == 80 && pos.y == 80, "wrong pos %d,%d\n", pos.x, pos.y );
done:
    ReleaseDC(0, hdc);
}

Referenced by START_TEST().

test_rectangle()

static void test_rectangle ( void  )

static

Definition at line 925 of file path.c.

{
    HDC hdc = GetDC( 0 );
 
    BeginPath( hdc );
    Rectangle( hdc, 20, 20, 40, 40 );
    Rectangle( hdc, 30, 50, 55, 35 );
    Rectangle( hdc, 60, 60, 35, 45 );
    Rectangle( hdc, 70, 70, 50, 70 );
    Rectangle( hdc, 75, 75, 75, 85 );
    Rectangle( hdc, 80, 80, 81, 81 );
    SetArcDirection( hdc, AD_CLOCKWISE );
    Rectangle( hdc, 20, 20, 40, 40 );
    Rectangle( hdc, 30, 50, 55, 35 );
    Rectangle( hdc, 60, 60, 35, 45 );
    Rectangle( hdc, 70, 70, 50, 70 );
    Rectangle( hdc, 75, 75, 75, 85 );
    Rectangle( hdc, 80, 80, 81, 81 );
    SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
    SetMapMode( hdc, MM_ANISOTROPIC );
    SetViewportExtEx( hdc, -2, 2, NULL );
    Rectangle( hdc, 20, 20, 40, 40 );
    Rectangle( hdc, 30, 50, 55, 35 );
    SetViewportExtEx( hdc, 3, -3, NULL );
    Rectangle( hdc, 20, 20, 40, 40 );
    Rectangle( hdc, 30, 50, 55, 35 );
    SetWindowExtEx( hdc, -20, 20, NULL );
    Rectangle( hdc, 20, 20, 40, 40 );
    Rectangle( hdc, 24, 22, 21, 20 );
    SetMapMode( hdc, MM_TEXT );
    SetGraphicsMode( hdc, GM_ADVANCED );
    Rectangle( hdc, 20, 20, 40, 40 );
    Rectangle( hdc, 30, 50, 55, 35 );
    Rectangle( hdc, 60, 60, 35, 45 );
    Rectangle( hdc, 70, 70, 50, 70 );
    Rectangle( hdc, 75, 75, 75, 85 );
    Rectangle( hdc, 80, 80, 81, 81 );
    SetArcDirection( hdc, AD_CLOCKWISE );
    Rectangle( hdc, 20, 20, 40, 40 );
    Rectangle( hdc, 30, 50, 55, 35 );
    Rectangle( hdc, 60, 60, 35, 45 );
    Rectangle( hdc, 70, 70, 50, 70 );
    Rectangle( hdc, 75, 75, 75, 85 );
    Rectangle( hdc, 80, 80, 81, 81 );
    SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
    EndPath( hdc );
    SetMapMode( hdc, MM_TEXT );
    ok_path( hdc, "rectangle_path", rectangle_path, sizeof(rectangle_path)/sizeof(path_test_t) );
    ReleaseDC( 0, hdc );
}

Referenced by START_TEST().

test_roundrect()

static void test_roundrect ( void  )

static

Definition at line 1292 of file path.c.

{
    HDC hdc = GetDC( 0 );
 
    BeginPath( hdc );
    RoundRect( hdc, 20, 20, 40, 40, 10, 10 );
    RoundRect( hdc, 30, 50, 55, 35, -30, -30 );
    RoundRect( hdc, 60, 60, 35, 45, 5, 2 );
    RoundRect( hdc, 70, 70, 50, 70, 3, 5 );
    RoundRect( hdc, 75, 75, 75, 85, 6, 4 );
    RoundRect( hdc, 80, 80, 81, 81, 8, 9 );
    RoundRect( hdc, 90, 90, 95, 85, 0, 7 );
    SetArcDirection( hdc, AD_CLOCKWISE );
    RoundRect( hdc, 20, 20, 40, 40, 10, 10 );
    RoundRect( hdc, 30, 50, 55, 35, -30, -30 );
    SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
    SetMapMode( hdc, MM_ANISOTROPIC );
    SetViewportExtEx( hdc, -2, 2, NULL );
    RoundRect( hdc, 20, 20, 40, 40, 15, 12 );
    RoundRect( hdc, 30, 50, 55, 35, 7, 9 );
    SetViewportExtEx( hdc, 3, -3, NULL );
    RoundRect( hdc, 20, 20, 40, 40, 15, 12 );
    RoundRect( hdc, 30, 50, 55, 35, 3, 4 );
    SetWindowExtEx( hdc, -20, 20, NULL );
    RoundRect( hdc, 20, 20, 40, 40, 2, 1 );
    RoundRect( hdc, 24, 22, 21, 20, 4, 4 );
    SetMapMode( hdc, MM_TEXT );
    SetGraphicsMode( hdc, GM_ADVANCED );
    RoundRect( hdc, 20, 20, 40, 40, 10, 10 );
    RoundRect( hdc, 30, 50, 55, 35, -30, -30 );
    RoundRect( hdc, 60, 60, 35, 45, 5, 2 );
    RoundRect( hdc, 70, 70, 50, 70, 3, 5 );
    RoundRect( hdc, 75, 75, 75, 85, 6, 4 );
    RoundRect( hdc, 80, 80, 81, 81, 8, 9 );
    RoundRect( hdc, 90, 90, 95, 85, 0, 7 );
    SetArcDirection( hdc, AD_CLOCKWISE );
    RoundRect( hdc, 20, 20, 40, 40, 10, 10 );
    RoundRect( hdc, 30, 50, 55, 35, -30, -30 );
    SetArcDirection( hdc, AD_COUNTERCLOCKWISE );
    EndPath( hdc );
    SetMapMode( hdc, MM_TEXT );
    ok_path( hdc, "roundrect_path", roundrect_path, sizeof(roundrect_path)/sizeof(path_test_t) );
    ReleaseDC( 0, hdc );
}

Referenced by START_TEST().

test_widenpath()

static void test_widenpath ( void  )

static

Definition at line 311 of file path.c.

{
    HDC hdc = GetDC(0);
    HPEN greenPen, narrowPen;
    POINT pnt[6];
    INT nSize;
    BOOL ret;
 
    /* Create a pen to be used in WidenPath */
    greenPen = CreatePen(PS_SOLID, 10, RGB(0,0,0));
    SelectObject(hdc, greenPen);
 
    /* Prepare a path */
    pnt[0].x = 100;
    pnt[0].y = 0;
    pnt[1].x = 200;
    pnt[1].y = 0;
    pnt[2].x = 300;
    pnt[2].y = 100;
    pnt[3].x = 300;
    pnt[3].y = 200;
    pnt[4].x = 200;
    pnt[4].y = 300;
    pnt[5].x = 100;
    pnt[5].y = 300;
 
    /* Set a polyline path */
    BeginPath(hdc);
    Polyline(hdc, pnt, 6);
    EndPath(hdc);
 
    /* Widen the polyline path */
    ok(WidenPath(hdc), "WidenPath fails while widening a poyline path.\n");
 
    /* Test if WidenPath seems to have done his job */
    nSize = GetPath(hdc, NULL, NULL, 0);
    ok(nSize != -1, "GetPath fails after calling WidenPath.\n");
    ok(nSize > 6, "Path number of points is too low. Should be more than 6 but is %d\n", nSize);
 
    AbortPath(hdc);
 
    /* Test WidenPath with an open path (last error only set on Win2k and later) */
    SetLastError(0xdeadbeef);
    BeginPath(hdc);
    ret = WidenPath(hdc);
    ok(ret == FALSE && (GetLastError() == ERROR_CAN_NOT_COMPLETE || GetLastError() == 0xdeadbeef),
       "WidenPath fails while widening an open path. Return value is %d, should be %d. Error is %u\n", ret, FALSE, GetLastError());
 
    AbortPath(hdc);
 
    /* Test when the pen width is equal to 1. The path should change too */
    narrowPen = CreatePen(PS_SOLID, 1, RGB(0,0,0));
    SelectObject(hdc, narrowPen);
    BeginPath(hdc);
    Polyline(hdc, pnt, 6);
    EndPath(hdc);
    ret = WidenPath(hdc);
    ok(ret == TRUE, "WidenPath failed: %d\n", GetLastError());
    nSize = GetPath(hdc, NULL, NULL, 0);
    ok(nSize > 6, "WidenPath should compute a widened path with a 1px wide pen. Path length is %d, should be more than 6\n", nSize);
 
    ReleaseDC(0, hdc);
    return;
}

Referenced by START_TEST().

Variable Documentation

all_funcs_path

const path_test_t all_funcs_path[]

static

Definition at line 1716 of file path.c.

Referenced by test_all_functions().

anglearc_path

const path_test_t anglearc_path[]

static

Initial value:

=
{
    {0, 0, PT_MOVETO}, 
    {371, 229, PT_LINETO}, 
    {352, 211, PT_BEZIERTO}, 
    {327, 200, PT_BEZIERTO}, 
    {300, 200, PT_BEZIERTO}, 
    {245, 200, PT_BEZIERTO}, 
    {200, 245, PT_BEZIERTO}, 
    {200, 300, PT_BEZIERTO}, 
    {200, 300, PT_BEZIERTO}, 
    {200, 300, PT_BEZIERTO}, 
    {200, 300, PT_BEZIERTO}, 
    {231, 260, PT_LINETO}, 
    {245, 235, PT_BEZIERTO}, 
    {271, 220, PT_BEZIERTO}, 
    {300, 220, PT_BEZIERTO}, 
    {344, 220, PT_BEZIERTO}, 
    {380, 256, PT_BEZIERTO}, 
    {380, 300, PT_BEZIERTO}, 
    {380, 314, PT_BEZIERTO}, 
    {376, 328, PT_BEZIERTO}, 
    {369, 340, PT_BEZIERTO | PT_CLOSEFIGURE}, 
}

Definition at line 506 of file path.c.

Referenced by test_anglearc().

arcto_path

const path_test_t arcto_path[]

static

Initial value:

=
{
    {0, 0, PT_MOVETO}, 
    {229, 215, PT_LINETO}, 
    {248, 205, PT_BEZIERTO}, 
    {273, 200, PT_BEZIERTO}, 
    {300, 200, PT_BEZIERTO}, 
    {355, 200, PT_BEZIERTO}, 
    {399, 222, PT_BEZIERTO}, 
    {399, 250, PT_BEZIERTO}, 
    {399, 263, PT_BEZIERTO}, 
    {389, 275, PT_BEZIERTO}, 
    {370, 285, PT_BEZIERTO}, 
    {363, 277, PT_LINETO}, 
    {380, 270, PT_BEZIERTO}, 
    {389, 260, PT_BEZIERTO}, 
    {389, 250, PT_BEZIERTO}, 
    {389, 228, PT_BEZIERTO}, 
    {349, 210, PT_BEZIERTO}, 
    {300, 210, PT_BEZIERTO}, 
    {276, 210, PT_BEZIERTO}, 
    {253, 214, PT_BEZIERTO}, 
    {236, 222, PT_BEZIERTO | PT_CLOSEFIGURE}, 
}

Definition at line 458 of file path.c.

Referenced by test_arcto().

ellipse_path

const path_test_t ellipse_path[]

static

Definition at line 1337 of file path.c.

Referenced by test_ellipse().

polydraw_path

const path_test_t polydraw_path[]

static

Definition at line 551 of file path.c.

Referenced by test_polydraw().

polydraw_pts

POINT polydraw_pts[]

static

Initial value:

= {
    {10, 10}, {10, 15},
    {15, 15}, {15, 20}, {20, 20}, {20, 25},
    {25, 25}, {25, 30},
    {30, 30}, {30, 35}, {35, 35}, {35, 40},
    {40, 40}, {40, 45}, {45, 45},
    {45, 50}, {50, 50},
    {50, 55}, {45, 50}, {55, 60},
    {60, 60}, {60, 65}, {65, 65},
    {70, 70}, {75, 70}, {75, 75}, {80, 80}}

Definition at line 586 of file path.c.

Referenced by test_polydraw().

polydraw_tps

BYTE polydraw_tps[]

static

Initial value:

=
    {PT_LINETO, PT_CLOSEFIGURE | PT_LINETO, 
     PT_LINETO, PT_BEZIERTO, PT_LINETO, PT_LINETO, 
     PT_MOVETO, PT_LINETO, 
     PT_BEZIERTO, PT_BEZIERTO, PT_BEZIERTO, PT_LINETO, 
     PT_MOVETO, PT_LINETO, PT_CLOSEFIGURE, 
     PT_LINETO, PT_MOVETO | PT_CLOSEFIGURE, 
     PT_LINETO, PT_LINETO, PT_MOVETO | PT_CLOSEFIGURE, 
     PT_LINETO, PT_MOVETO | PT_LINETO, PT_LINETO,  
     PT_MOVETO, PT_MOVETO, PT_MOVETO, PT_LINETO | PT_CLOSEFIGURE}

Definition at line 597 of file path.c.

Referenced by test_polydraw().

rectangle_path

const path_test_t rectangle_path[]

static

Definition at line 821 of file path.c.

Referenced by test_rectangle().

roundrect_path

const path_test_t roundrect_path[]

static

Definition at line 976 of file path.c.

Referenced by test_roundrect().