static void test_rect(void)
{
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, sizeof(rect_path)/sizeof(path_test_t), 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, sizeof(rect_path)/sizeof(path_test_t), FALSE);
GdipDeletePath(path);
}
static
void gdip_detach_surface(GF_SURFACE _this)
{
GPGRAPH();
if (_graph->graph) GdipDeleteGraphics(_graph->graph);
_graph->graph = NULL;
if (_graph->clip) GdipDeletePath(_graph->clip);
_graph->clip = NULL;
if (_graph->pBitmap) GdipDisposeImage(_graph->pBitmap);
_graph->pBitmap = NULL;
if (_graph->current) GdipDeletePath(_graph->current);
_graph->current = NULL;
}
static void test_constructor_destructor(void)
{
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);
}
static void test_inset(void)
{
GpCustomLineCap *custom;
GpPath *path;
REAL inset;
GpStatus stat;
stat = GdipCreatePath(FillModeAlternate, &path);
expect(Ok, stat);
stat = GdipAddPathRectangle(path, 5.0, 5.0, 10.0, 10.0);
expect(Ok, stat);
stat = GdipCreateCustomLineCap(NULL, path, LineCapFlat, 0.0, &custom);
expect(Ok, stat);
/* NULL args */
stat = GdipGetCustomLineCapBaseInset(NULL, NULL);
expect(InvalidParameter, stat);
stat = GdipGetCustomLineCapBaseInset(NULL, &inset);
expect(InvalidParameter, stat);
stat = GdipGetCustomLineCapBaseInset(custom, NULL);
expect(InvalidParameter, stat);
/* valid args */
inset = (REAL)0xdeadbeef;
stat = GdipGetCustomLineCapBaseInset(custom, &inset);
expect(Ok, stat);
expectf(0.0, inset);
GdipDeleteCustomLineCap(custom);
GdipDeletePath(path);
}
static M4Err gdip_get_text_size(FontRaster *dr, const unsigned short *string, Float *width, Float *height)
{
GpPath *path_tmp;
GpStringFormat *fmt;
FontPriv *ctx = (FontPriv *)dr->priv;
*width = *height = 0.0;
if (!ctx->font) return M4BadParam;
GdipCreateStringFormat(StringFormatFlagsNoWrap, LANG_NEUTRAL, &fmt);
GdipCreatePath(FillModeAlternate, &path_tmp);
RectF rc;
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
GdipAddPathString(path_tmp, string, -1, ctx->font, ctx->font_style, ctx->font_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
*width = rc.Width;
*height = rc.Height;
adjust_white_space(string, width, ctx->whitespace_width );
GdipDeleteStringFormat(fmt);
GdipDeletePath(path_tmp);
return M4OK;
}
static void test_scale(void)
{
GpCustomLineCap *custom;
GpPath *path;
REAL scale;
GpStatus stat;
stat = GdipCreatePath(FillModeAlternate, &path);
expect(Ok, stat);
stat = GdipAddPathRectangle(path, 5.0, 5.0, 10.0, 10.0);
expect(Ok, stat);
stat = GdipCreateCustomLineCap(NULL, path, LineCapFlat, 0.0, &custom);
expect(Ok, stat);
/* NULL args */
stat = GdipGetCustomLineCapWidthScale(NULL, NULL);
expect(InvalidParameter, stat);
stat = GdipGetCustomLineCapWidthScale(NULL, &scale);
expect(InvalidParameter, stat);
stat = GdipGetCustomLineCapWidthScale(custom, NULL);
expect(InvalidParameter, stat);
/* valid args */
scale = (REAL)0xdeadbeef;
stat = GdipGetCustomLineCapWidthScale(custom, &scale);
expect(Ok, stat);
expectf(1.0, scale);
GdipDeleteCustomLineCap(custom);
GdipDeletePath(path);
}
static void test_empty_rect(void)
{
GpPath *path;
GpStatus status;
BOOL result;
status = GdipCreatePath(FillModeAlternate, &path);
expect(Ok, status);
status = GdipAddPathRectangle(path, 0.0, 0.0, -5.0, 5.0);
expect(Ok, status);
status = GdipIsVisiblePathPoint(path, -2.0, 2.0, NULL, &result);
expect(Ok, status);
expect(FALSE, status);
status = GdipAddPathRectangle(path, 0.0, 0.0, 5.0, -5.0);
expect(Ok, status);
status = GdipAddPathRectangle(path, 0.0, 0.0, 0.0, 5.0);
expect(Ok, status);
status = GdipAddPathRectangle(path, 0.0, 0.0, 5.0, 0.0);
expect(Ok, status);
GdipDeletePath(path);
}
static void test_pathgradientpath(void)
{
GpStatus status;
GpPath *path=NULL;
GpPathGradient *grad=NULL;
status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &grad);
expect(Ok, status);
status = GdipGetPathGradientPath(grad, NULL);
expect(NotImplemented, status);
status = GdipCreatePath(FillModeWinding, &path);
expect(Ok, status);
status = GdipGetPathGradientPath(NULL, path);
expect(NotImplemented, status);
status = GdipGetPathGradientPath(grad, path);
expect(NotImplemented, status);
status = GdipDeletePath(path);
expect(Ok, status);
status = GdipDeleteBrush((GpBrush*)grad);
expect(Ok, status);
}
static void test_addclosedcurve(void)
{
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, sizeof(addclosedcurve_path)/sizeof(path_test_t), FALSE);
GdipDeletePath(path);
}
static void test_ellipse(void)
{
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, sizeof(ellipse_path)/sizeof(path_test_t), FALSE);
GdipDeletePath(path);
}
static void test_line2(void)
{
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(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, sizeof(line2_path)/sizeof(path_test_t), FALSE);
GdipDeletePath(path);
}
static void test_arc(void)
{
GpStatus status;
GpPath* path;
GdipCreatePath(FillModeAlternate, &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, sizeof(arc_path)/sizeof(path_test_t), FALSE);
GdipDeletePath(path);
}
static void test_reverse(void)
{
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, sizeof(reverse_path)/sizeof(path_test_t), FALSE);
GdipDeletePath(path);
}
static void test_getpathdata(void)
{
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);
}
// coverity[+alloc : arg-*0]
GpStatus
GdipCreatePathIter (GpPathIterator **iterator, GpPath *path)
{
GpPath *clone = NULL;
GpPathIterator *iter;
GpStatus status;
if (!iterator)
return InvalidParameter;
iter = (GpPathIterator *) GdipAlloc (sizeof (GpPathIterator));
if (iter == NULL)
return OutOfMemory;
/* supplying a path isn't required */
if (path) {
status = GdipClonePath (path, &clone);
if (status != Ok) {
GdipFree (iter);
if (clone)
GdipDeletePath (clone);
return status;
}
}
iter->path = clone;
iter->markerPosition = 0;
iter->subpathPosition = 0;
iter->pathTypePosition = 0;
*iterator = iter;
return Ok;
}
static void test_addpie(void)
{
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, sizeof(addpie_path)/sizeof(path_test_t), 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, sizeof(addpie_path2)/sizeof(path_test_t), 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, sizeof(addpie_path3)/sizeof(path_test_t), FALSE);
GdipDeletePath(path);
}
static GF_Err gdip_get_text_size(GF_FontReader *dr, const unsigned short *string, Fixed *width, Fixed *height)
{
GpPath *path_tmp;
GpStringFormat *fmt;
FontPriv *ctx = (FontPriv *)dr->udta;
*width = *height = 0;
if (!ctx->font) return GF_BAD_PARAM;
GdipCreateStringFormat(StringFormatFlagsNoWrap, LANG_NEUTRAL, &fmt);
GdipCreatePath(FillModeAlternate, &path_tmp);
RectF rc;
rc.X = rc.Y = 0;
rc.Width = rc.Height = 0;
GdipAddPathString(path_tmp, (const WCHAR *)string, -1, ctx->font, ctx->font_style, ctx->em_size, &rc, fmt);
GdipGetPathWorldBounds(path_tmp, &rc, NULL, NULL);
adjust_white_space(string, &rc.Width, ctx->whitespace_width);
*width = FLT2FIX(rc.Width);
*height = FLT2FIX(rc.Height);
GdipDeleteStringFormat(fmt);
GdipDeletePath(path_tmp);
return GF_OK;
}
static void test_flatten(void)
{
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, sizeof(flattenellipse_path)/sizeof(path_test_t), 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, sizeof(flattenline_path)/sizeof(path_test_t), 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, sizeof(flattenarc_path)/sizeof(path_test_t), 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, sizeof(flattenquater_path)/sizeof(path_test_t), FALSE);
GdipDeleteMatrix(m);
GdipDeletePath(path);
}
GpStatus WINGDIPAPI GdipAddPathRectangle(GpPath *path, REAL x, REAL y,
REAL width, REAL height)
{
GpPath *backup;
GpPointF ptf[2];
GpStatus retstat;
BOOL old_new;
if(!path || width < 0.0 || height < 0.0)
return InvalidParameter;
/* make a backup copy of path data */
if((retstat = GdipClonePath(path, &backup)) != Ok)
return retstat;
/* rectangle should start as new path */
old_new = path->newfigure;
path->newfigure = TRUE;
if((retstat = GdipAddPathLine(path,x,y,x+width,y)) != Ok){
path->newfigure = old_new;
goto fail;
}
ptf[0].X = x+width;
ptf[0].Y = y+height;
ptf[1].X = x;
ptf[1].Y = y+height;
if((retstat = GdipAddPathLine2(path,(GDIPCONST GpPointF*)&ptf,2)) != Ok) goto fail;
path->pathdata.Types[path->pathdata.Count-1] |= PathPointTypeCloseSubpath;
/* free backup */
GdipDeletePath(backup);
return Ok;
fail:
/* reverting */
GdipDeletePath(path);
GdipClonePath(backup, &path);
GdipDeletePath(backup);
return retstat;
}
static
GF_Err gdip_surface_set_clipper(GF_SURFACE _this, GF_IRect *rc)
{
GPGRAPH();
if (_graph->clip) GdipDeletePath(_graph->clip);
_graph->clip = 0L;
if (!rc) return GF_OK;
GdipCreatePath(FillModeAlternate, &_graph->clip);
GdipAddPathRectangleI(_graph->clip, rc->x, rc->y - rc->height, rc->width, rc->height);
return GF_OK;
}
static void test_pathpath(void)
{
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, sizeof(pathpath_path)/sizeof(path_test_t), FALSE);
GdipDeletePath(path1);
GdipDeletePath(path2);
}
/* Transforms GpRegion elements with given matrix */
static GpStatus transform_region_element(region_element* element, GpMatrix *matrix)
{
GpStatus stat;
switch(element->type)
{
case RegionDataEmptyRect:
case RegionDataInfiniteRect:
return Ok;
case RegionDataRect:
{
/* We can't transform a rectangle, so convert it to a path. */
GpRegion *new_region;
GpPath *path;
stat = GdipCreatePath(FillModeAlternate, &path);
if (stat == Ok)
{
stat = GdipAddPathRectangle(path,
element->elementdata.rect.X, element->elementdata.rect.Y,
element->elementdata.rect.Width, element->elementdata.rect.Height);
if (stat == Ok)
stat = GdipCreateRegionPath(path, &new_region);
GdipDeletePath(path);
}
if (stat == Ok)
{
/* Steal the element from the created region. */
memcpy(element, &new_region->node, sizeof(region_element));
heap_free(new_region);
}
else
return stat;
}
/* Fall-through to do the actual conversion. */
case RegionDataPath:
if (!element->elementdata.path->pathdata.Count)
return Ok;
stat = GdipTransformMatrixPoints(matrix,
element->elementdata.path->pathdata.Points,
element->elementdata.path->pathdata.Count);
return stat;
default:
stat = transform_region_element(element->elementdata.combine.left, matrix);
if (stat == Ok)
stat = transform_region_element(element->elementdata.combine.right, matrix);
return stat;
}
}
static
GF_Err gdip_set_vertex_path(GF_STENCIL _this, GF_Path *path)
{
GPSTEN();
GpPath *p;
CHECK_RET(GF_STENCIL_VERTEX_GRADIENT);
p = gdip_create_path(path);
if (_sten->pRadial) GdipDeleteBrush(_sten->pRadial);
GdipCreatePathGradientFromPath(p, &_sten->pRadial);
GdipDeletePath(p);
return GF_OK;
}
static void test_constructor_destructor(void)
{
GpCustomLineCap *custom;
GpPath *path, *path2;
GpStatus stat;
stat = GdipCreatePath(FillModeAlternate, &path);
expect(Ok, stat);
stat = GdipAddPathRectangle(path, 5.0, 5.0, 10.0, 10.0);
expect(Ok, stat);
stat = GdipCreatePath(FillModeAlternate, &path2);
expect(Ok, stat);
stat = GdipAddPathRectangle(path2, 5.0, 5.0, 10.0, 10.0);
expect(Ok, stat);
/* NULL args */
stat = GdipCreateCustomLineCap(NULL, NULL, LineCapFlat, 0.0, NULL);
expect(InvalidParameter, stat);
stat = GdipCreateCustomLineCap(path, NULL, LineCapFlat, 0.0, NULL);
expect(InvalidParameter, stat);
stat = GdipCreateCustomLineCap(NULL, path, LineCapFlat, 0.0, NULL);
expect(InvalidParameter, stat);
stat = GdipCreateCustomLineCap(NULL, NULL, LineCapFlat, 0.0, &custom);
expect(InvalidParameter, stat);
stat = GdipDeleteCustomLineCap(NULL);
expect(InvalidParameter, stat);
/* valid args */
stat = GdipCreateCustomLineCap(NULL, path2, LineCapFlat, 0.0, &custom);
expect(Ok, stat);
stat = GdipDeleteCustomLineCap(custom);
expect(Ok, stat);
/* it's strange but native returns NotImplemented on stroke == NULL */
stat = GdipCreateCustomLineCap(path, NULL, LineCapFlat, 10.0, &custom);
todo_wine expect(NotImplemented, stat);
GdipDeletePath(path2);
GdipDeletePath(path);
}
static void test_isvisible(void)
{
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);
GdipDeletePath(path);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static
GF_Err gdip_surface_set_path(GF_SURFACE _this, GF_Path *path)
{
struct _storepath *_path;
GPGRAPH();
if (!_graph) return GF_BAD_PARAM;
if (_graph->current) GdipDeletePath(_graph->current);
_graph->current = NULL;
if (!path) return GF_OK;
_path = (struct _storepath *)path;
_graph->current = gdip_setup_path(_graph, path);
return GF_OK;
}
static void test_linejoin(void)
{
GpCustomLineCap *custom;
GpPath *path;
GpLineJoin join;
GpStatus stat;
stat = GdipCreatePath(FillModeAlternate, &path);
expect(Ok, stat);
stat = GdipAddPathRectangle(path, 5.0, 5.0, 10.0, 10.0);
expect(Ok, stat);
stat = GdipCreateCustomLineCap(NULL, path, LineCapFlat, 0.0, &custom);
expect(Ok, stat);
/* NULL args */
stat = GdipGetCustomLineCapStrokeJoin(NULL, NULL);
expect(InvalidParameter, stat);
stat = GdipGetCustomLineCapStrokeJoin(custom, NULL);
expect(InvalidParameter, stat);
stat = GdipGetCustomLineCapStrokeJoin(NULL, &join);
expect(InvalidParameter, stat);
stat = GdipSetCustomLineCapStrokeJoin(NULL, LineJoinBevel);
expect(InvalidParameter, stat);
/* LineJoinMiter is default */
stat = GdipGetCustomLineCapStrokeJoin(custom, &join);
expect(Ok, stat);
expect(LineJoinMiter, join);
/* set/get */
stat = GdipSetCustomLineCapStrokeJoin(custom, LineJoinBevel);
expect(Ok, stat);
stat = GdipGetCustomLineCapStrokeJoin(custom, &join);
expect(Ok, stat);
expect(LineJoinBevel, join);
stat = GdipSetCustomLineCapStrokeJoin(custom, LineJoinRound);
expect(Ok, stat);
stat = GdipGetCustomLineCapStrokeJoin(custom, &join);
expect(Ok, stat);
expect(LineJoinRound, join);
stat = GdipSetCustomLineCapStrokeJoin(custom, LineJoinMiterClipped);
expect(Ok, stat);
stat = GdipGetCustomLineCapStrokeJoin(custom, &join);
expect(Ok, stat);
expect(LineJoinMiterClipped, join);
GdipDeleteCustomLineCap(custom);
GdipDeletePath(path);
}
GpStatus
GdipDeletePathIter (GpPathIterator *iterator)
{
if (!iterator)
return InvalidParameter;
if (iterator->path) {
GdipDeletePath (iterator->path);
iterator->path = NULL;
}
GdipFree (iterator);
return Ok;
}
/*
* gdip_region_clear_tree:
* @tree: a GpPathTree to clear
*
* Recursively clear (delete path and free memory) the specified path tree.
*/
void
gdip_region_clear_tree (GpPathTree *tree)
{
if (!tree)
return;
if (tree->path) {
GdipDeletePath (tree->path);
tree->path = NULL;
} else {
gdip_region_clear_tree (tree->branch1);
GdipFree (tree->branch1);
gdip_region_clear_tree (tree->branch2);
GdipFree (tree->branch2);
}
}
static
void gdip_delete_stencil(GF_STENCIL _this)
{
GPSTEN();
if (_sten->pSolid) GdipDeleteBrush(_sten->pSolid);
if (_sten->pTexture) GdipDeleteBrush(_sten->pTexture);
if (_sten->pLinear) GdipDeleteBrush(_sten->pLinear);
if (_sten->pRadial) GdipDeleteBrush(_sten->pRadial);
if (_sten->circle) GdipDeletePath(_sten->circle);
if (_sten->pMat) GdipDeleteMatrix(_sten->pMat);
if (_sten->pLinearMat) GdipDeleteMatrix(_sten->pLinearMat);
if (_sten->pBitmap) GdipDisposeImage(_sten->pBitmap);
if (_sten->conv_buf) gf_free(_sten->conv_buf);
if (_sten->cols) delete [] _sten->cols;
if (_sten->pos) delete [] _sten->pos;
gf_free(_sten);
}
