自学教程：C++ GdipDeletePath函数代码示例

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);}

staticvoid 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 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_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]GpStatusGdipCreatePathIter (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;}

staticGF_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_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);}

staticGF_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;}

GpStatusGdipDeletePathIter (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);	}}

staticvoid 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);}