GpStatus WINGDIPAPI GdipAddPathArc(GpPath *path, REAL x1, REAL y1, REAL x2,
REAL y2, REAL startAngle, REAL sweepAngle)
{
INT count, old_count, i;
if(!path)
return InvalidParameter;
count = arc2polybezier(NULL, x1, y1, x2, y2, startAngle, sweepAngle);
if(count == 0)
return Ok;
if(!lengthen_path(path, count))
return OutOfMemory;
old_count = path->pathdata.Count;
arc2polybezier(&path->pathdata.Points[old_count], x1, y1, x2, y2,
startAngle, sweepAngle);
for(i = 0; i < count; i++){
path->pathdata.Types[old_count + i] = PathPointTypeBezier;
}
path->pathdata.Types[old_count] =
(path->newfigure ? PathPointTypeStart : PathPointTypeLine);
path->newfigure = FALSE;
path->pathdata.Count += count;
return Ok;
}
GpStatus WINGDIPAPI GdipAddPathLine(GpPath *path, REAL x1, REAL y1, REAL x2, REAL y2)
{
INT old_count;
if(!path)
return InvalidParameter;
if(!lengthen_path(path, 2))
return OutOfMemory;
old_count = path->pathdata.Count;
path->pathdata.Points[old_count].X = x1;
path->pathdata.Points[old_count].Y = y1;
path->pathdata.Points[old_count + 1].X = x2;
path->pathdata.Points[old_count + 1].Y = y2;
path->pathdata.Types[old_count] =
(path->newfigure ? PathPointTypeStart : PathPointTypeLine);
path->pathdata.Types[old_count + 1] = PathPointTypeLine;
path->newfigure = FALSE;
path->pathdata.Count += 2;
return Ok;
}
GpStatus WINGDIPAPI GdipAddPathPath(GpPath *path, GDIPCONST GpPath* addingPath,
BOOL connect)
{
INT old_count, count;
if(!path || !addingPath)
return InvalidParameter;
old_count = path->pathdata.Count;
count = addingPath->pathdata.Count;
if(!lengthen_path(path, count))
return OutOfMemory;
memcpy(&path->pathdata.Points[old_count], addingPath->pathdata.Points,
count * sizeof(GpPointF));
memcpy(&path->pathdata.Types[old_count], addingPath->pathdata.Types, count);
if(path->newfigure || !connect)
path->pathdata.Types[old_count] = PathPointTypeStart;
else
path->pathdata.Types[old_count] = PathPointTypeLine;
path->newfigure = FALSE;
path->pathdata.Count += count;
return Ok;
}
GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points,
INT count)
{
INT i, old_count;
if(!path || !points)
return InvalidParameter;
if(!lengthen_path(path, count))
return OutOfMemory;
old_count = path->pathdata.Count;
for(i = 0; i < count; i++){
path->pathdata.Points[old_count + i].X = points[i].X;
path->pathdata.Points[old_count + i].Y = points[i].Y;
path->pathdata.Types[old_count + i] = PathPointTypeLine;
}
if(path->newfigure){
path->pathdata.Types[old_count] = PathPointTypeStart;
path->newfigure = FALSE;
}
path->pathdata.Count += count;
return Ok;
}
GpStatus WINGDIPAPI GdipAddPathEllipse(GpPath *path, REAL x, REAL y, REAL width,
REAL height)
{
INT old_count, numpts;
if(!path)
return InvalidParameter;
if(!lengthen_path(path, MAX_ARC_PTS))
return OutOfMemory;
old_count = path->pathdata.Count;
if((numpts = arc2polybezier(&path->pathdata.Points[old_count], x, y, width,
height, 0.0, 360.0)) != MAX_ARC_PTS){
ERR("expected %d points but got %d\n", MAX_ARC_PTS, numpts);
return GenericError;
}
memset(&path->pathdata.Types[old_count + 1], PathPointTypeBezier,
MAX_ARC_PTS - 1);
/* An ellipse is an intrinsic figure (always is its own subpath). */
path->pathdata.Types[old_count] = PathPointTypeStart;
path->pathdata.Types[old_count + MAX_ARC_PTS - 1] |= PathPointTypeCloseSubpath;
path->newfigure = TRUE;
path->pathdata.Count += MAX_ARC_PTS;
return Ok;
}
GpStatus WINGDIPAPI GdipAddPathBezier(GpPath *path, REAL x1, REAL y1, REAL x2,
REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
{
INT old_count;
if(!path)
return InvalidParameter;
if(!lengthen_path(path, 4))
return OutOfMemory;
old_count = path->pathdata.Count;
path->pathdata.Points[old_count].X = x1;
path->pathdata.Points[old_count].Y = y1;
path->pathdata.Points[old_count + 1].X = x2;
path->pathdata.Points[old_count + 1].Y = y2;
path->pathdata.Points[old_count + 2].X = x3;
path->pathdata.Points[old_count + 2].Y = y3;
path->pathdata.Points[old_count + 3].X = x4;
path->pathdata.Points[old_count + 3].Y = y4;
path->pathdata.Types[old_count] =
(path->newfigure ? PathPointTypeStart : PathPointTypeLine);
path->pathdata.Types[old_count + 1] = PathPointTypeBezier;
path->pathdata.Types[old_count + 2] = PathPointTypeBezier;
path->pathdata.Types[old_count + 3] = PathPointTypeBezier;
path->newfigure = FALSE;
path->pathdata.Count += 4;
return Ok;
}
GpStatus WINGDIPAPI GdipPathIterNextSubpathPath(GpPathIterator* iter, INT* result,
GpPath* path, BOOL* closed)
{
INT start, end;
TRACE("(%p, %p, %p, %p)\n", iter, result, path, closed);
if(!iter || !result || !closed)
return InvalidParameter;
GdipPathIterNextSubpath(iter, result, &start, &end, closed);
/* return path */
if(((*result) > 0) && path){
GdipResetPath(path);
if(!lengthen_path(path, *result))
return OutOfMemory;
memcpy(path->pathdata.Points, &(iter->pathdata.Points[start]), sizeof(GpPointF)*(*result));
memcpy(path->pathdata.Types, &(iter->pathdata.Types[start]), sizeof(BYTE)*(*result));
path->pathdata.Count = *result;
}
return Ok;
}
/*
* Set the buffer's encryption key if needed.
*/
int
vl_resetkey(BUFFER *bp,
const char *fname)
{
register int s; /* temporary return value */
/* flag the buffer as not having encryption */
ffdocrypt(FALSE);
/* if we want to encrypt */
if (b_val(bp, MDCRYPT)) {
char temp[NFILEN];
/* don't automatically inherit key from other buffers */
if (bp->b_cryptkey[0] != EOS
&& !b_is_argument(bp)
&& strcmp(lengthen_path(vl_strncpy(temp, fname, sizeof(temp))), bp->b_fname)) {
char prompt[80];
(void) lsprintf(prompt, "Use crypt-key from %s", bp->b_bname);
s = mlyesno(prompt);
if (s != TRUE)
return (s == FALSE);
}
/* make a key if we don't have one */
if (bp->b_cryptkey[0] == EOS) {
s = get_encryption_key(bp->b_cryptkey, sizeof(bp->b_cryptkey));
if (s != TRUE)
return (s == FALSE);
}
ffdocrypt(TRUE);
vl_setup_encrypt(bp->b_cryptkey, seed);
}
return TRUE;
}
static GpStatus read_element(struct memory_buffer *mbuf, GpRegion *region, region_element *node, INT *count)
{
GpStatus status;
const DWORD *type;
type = buffer_read(mbuf, sizeof(*type));
if (!type) return Ok;
TRACE("type %#x\n", *type);
node->type = *type;
switch (node->type)
{
case CombineModeReplace:
case CombineModeIntersect:
case CombineModeUnion:
case CombineModeXor:
case CombineModeExclude:
case CombineModeComplement:
{
region_element *left, *right;
left = heap_alloc_zero(sizeof(region_element));
if (!left) return OutOfMemory;
right = heap_alloc_zero(sizeof(region_element));
if (!right)
{
heap_free(left);
return OutOfMemory;
}
status = read_element(mbuf, region, left, count);
if (status == Ok)
{
status = read_element(mbuf, region, right, count);
if (status == Ok)
{
node->elementdata.combine.left = left;
node->elementdata.combine.right = right;
region->num_children += 2;
return Ok;
}
}
heap_free(left);
heap_free(right);
return status;
}
case RegionDataRect:
{
const GpRectF *rc;
rc = buffer_read(mbuf, sizeof(*rc));
if (!rc)
{
ERR("failed to read rect data\n");
return InvalidParameter;
}
node->elementdata.rect = *rc;
*count += 1;
return Ok;
}
case RegionDataPath:
{
GpPath *path;
const struct path_header *path_header;
const BYTE *types;
path_header = buffer_read(mbuf, sizeof(*path_header));
if (!path_header)
{
ERR("failed to read path header\n");
return InvalidParameter;
}
if (!VALID_MAGIC(path_header->magic))
{
ERR("invalid path header magic %#x\n", path_header->magic);
return InvalidParameter;
}
/* Windows always fails to create an empty path in a region */
if (!path_header->count)
{
TRACE("refusing to create an empty path in a region\n");
return GenericError;
}
status = GdipCreatePath(FillModeAlternate, &path);
if (status) return status;
node->elementdata.path = path;
if (!lengthen_path(path, path_header->count))
return OutOfMemory;
path->pathdata.Count = path_header->count;
if (path_header->flags & ~FLAGS_INTPATH)
FIXME("unhandled path flags %#x\n", path_header->flags);
if (path_header->flags & FLAGS_INTPATH)
{
const packed_point *pt;
DWORD i;
pt = buffer_read(mbuf, sizeof(*pt) * path_header->count);
if (!pt)
{
ERR("failed to read packed %u path points\n", path_header->count);
return InvalidParameter;
}
for (i = 0; i < path_header->count; i++)
{
path->pathdata.Points[i].X = (REAL)pt[i].X;
path->pathdata.Points[i].Y = (REAL)pt[i].Y;
}
}
else
{
const GpPointF *ptf;
ptf = buffer_read(mbuf, sizeof(*ptf) * path_header->count);
if (!ptf)
{
ERR("failed to read %u path points\n", path_header->count);
return InvalidParameter;
}
memcpy(path->pathdata.Points, ptf, sizeof(*ptf) * path_header->count);
}
types = buffer_read(mbuf, path_header->count);
if (!types)
{
ERR("failed to read %u path types\n", path_header->count);
return InvalidParameter;
}
memcpy(path->pathdata.Types, types, path_header->count);
if (path_header->count & 3)
{
if (!buffer_read(mbuf, 4 - (path_header->count & 3)))
{
ERR("failed to read rounding %u bytes\n", 4 - (path_header->count & 3));
return InvalidParameter;
}
}
*count += 1;
return Ok;
}
case RegionDataEmptyRect:
case RegionDataInfiniteRect:
*count += 1;
return Ok;
default:
FIXME("element type %#x is not supported\n", *type);
break;
}
return InvalidParameter;
}
