struct _DrawingWand
{
- unsigned long
+ size_t
id;
char
mvg_alloc, /* total allocated memory */
mvg_length; /* total MVG length */
- unsigned long
+ size_t
mvg_width; /* current line width */
/* Pattern support */
pattern_offset;
/* Graphic wand */
- unsigned long
+ size_t
index; /* array index */
DrawInfo
filter_off; /* true if not filtering attributes */
/* Pretty-printing depth */
- unsigned long
+ size_t
indent_depth; /* number of left-hand pad characters */
/* Path operation support */
destroy,
debug;
- unsigned long
+ size_t
signature;
};
const unsigned char *);
void (*DrawArc)(DrawingWand *,const double,const double,const double,
const double,const double,const double);
- void (*DrawBezier)(DrawingWand *,const unsigned long,const PointInfo *);
+ void (*DrawBezier)(DrawingWand *,const size_t,const PointInfo *);
void (*DrawCircle)(DrawingWand *,const double,const double,const double,
const double);
void (*DrawColor)(DrawingWand *,const double,const double,const PaintMethod);
void (*DrawPathMoveToRelative)(DrawingWand *,const double,const double);
void (*DrawPathStart)(DrawingWand *);
void (*DrawPoint)(DrawingWand *,const double,const double);
- void (*DrawPolygon)(DrawingWand *,const unsigned long,const PointInfo *);
- void (*DrawPolyline)(DrawingWand *,const unsigned long,const PointInfo *);
+ void (*DrawPolygon)(DrawingWand *,const size_t,const PointInfo *);
+ void (*DrawPolyline)(DrawingWand *,const size_t,const PointInfo *);
void (*DrawPopClipPath)(DrawingWand *);
void (*DrawPopDefs)(DrawingWand *);
MagickBooleanType (*DrawPopPattern)(DrawingWand *);
void (*DrawSetFontSize)(DrawingWand *,const double);
void (*DrawSetFontStretch)(DrawingWand *,const StretchType);
void (*DrawSetFontStyle)(DrawingWand *,const StyleType);
- void (*DrawSetFontWeight)(DrawingWand *,const unsigned long);
+ void (*DrawSetFontWeight)(DrawingWand *,const size_t);
void (*DrawSetGravity)(DrawingWand *,const GravityType);
void (*DrawRotate)(DrawingWand *,const double);
void (*DrawScale)(DrawingWand *,const double,const double);
void (*DrawSetStrokeDashOffset)(DrawingWand *,const double);
void (*DrawSetStrokeLineCap)(DrawingWand *,const LineCap);
void (*DrawSetStrokeLineJoin)(DrawingWand *,const LineJoin);
- void (*DrawSetStrokeMiterLimit)(DrawingWand *,const unsigned long);
+ void (*DrawSetStrokeMiterLimit)(DrawingWand *,const size_t);
MagickBooleanType (*DrawSetStrokePatternURL)(DrawingWand *,const char *);
void (*DrawSetStrokeWidth)(DrawingWand *,const double);
void (*DrawSetTextAntialias)(DrawingWand *,const MagickBooleanType);
void (*DrawSetTextDecoration)(DrawingWand *,const DecorationType);
void (*DrawSetTextUnderColor)(DrawingWand *,const PixelWand *);
void (*DrawTranslate)(DrawingWand *,const double,const double);
- void (*DrawSetViewbox)(DrawingWand *,unsigned long,unsigned long,
- unsigned long,unsigned long);
+ void (*DrawSetViewbox)(DrawingWand *,size_t,size_t,
+ size_t,size_t);
void (*PeekDrawingWand)(DrawingWand *);
MagickBooleanType (*PopDrawingWand)(DrawingWand *);
MagickBooleanType (*PushDrawingWand)(DrawingWand *);
}
static void MvgAppendPointsCommand(DrawingWand *wand,const char *command,
- const unsigned long number_coordinates,const PointInfo *coordinates)
+ const size_t number_coordinates,const PointInfo *coordinates)
{
const PointInfo
*coordinate;
- unsigned long
+ size_t
i;
(void) MvgPrintf(wand,"%s",command);
for (i=number_coordinates, coordinate=coordinates; i != 0; i--)
{
- (void) MvgAutoWrapPrintf(wand," %.15g,%.15g",coordinate->x,coordinate->y);
+ (void) MvgAutoWrapPrintf(wand," %g,%g",coordinate->x,coordinate->y);
coordinate++;
}
(void) MvgPrintf(wand, "\n");
DrawingWand
*clone_wand;
- register long
+ register ssize_t
i;
assert(wand != (DrawingWand *) NULL);
"MemoryAllocationFailed",GetExceptionMessage(errno));
(void) ResetMagickMemory(clone_wand,0,sizeof(*clone_wand));
clone_wand->id=AcquireWandId();
- (void) FormatMagickString(clone_wand->name,MaxTextExtent,"DrawingWand-%lu",
- clone_wand->id);
+ (void) FormatMagickString(clone_wand->name,MaxTextExtent,"DrawingWand-%.20g",
+ (double) clone_wand->id);
clone_wand->exception=AcquireExceptionInfo();
InheritException(clone_wand->exception,wand->exception);
clone_wand->mvg=AcquireString(wand->mvg);
if (clone_wand->graphic_context == (DrawInfo **) NULL)
ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
GetExceptionMessage(errno));
- for (i=0; i <= (long) wand->index; i++)
+ for (i=0; i <= (ssize_t) wand->index; i++)
clone_wand->graphic_context[i]=
CloneDrawInfo((ImageInfo *) NULL,wand->graphic_context[i]);
clone_wand->filter_off=wand->filter_off;
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
assert(affine != (const AffineMatrix *) NULL);
AdjustAffine(wand,affine);
- (void) MvgPrintf(wand,"affine %.15g,%.15g,%.15g,%.15g,%.15g,%.15g\n",
+ (void) MvgPrintf(wand,"affine %g,%g,%g,%g,%g,%g\n",
affine->sx,affine->rx,affine->ry,affine->sy,affine->tx,affine->ty);
}
\f
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
assert(text != (const unsigned char *) NULL);
escaped_text=EscapeString((const char *) text,'\'');
- (void) MvgPrintf(wand,"text %.15g,%.15g '%s'\n",x,y,escaped_text);
+ (void) MvgPrintf(wand,"text %g,%g '%s'\n",x,y,escaped_text);
escaped_text=DestroyString(escaped_text);
}
\f
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"arc %.15g,%.15g %.15g,%.15g %.15g,%.15g\n",sx,sy,ex,
+ (void) MvgPrintf(wand,"arc %g,%g %g,%g %g,%g\n",sx,sy,ex,
ey,sd,ed);
}
\f
% The format of the DrawBezier method is:
%
% void DrawBezier(DrawingWand *wand,
-% const unsigned long number_coordinates,const PointInfo *coordinates)
+% const size_t number_coordinates,const PointInfo *coordinates)
%
% A description of each parameter follows:
%
%
*/
WandExport void DrawBezier(DrawingWand *wand,
- const unsigned long number_coordinates,const PointInfo *coordinates)
+ const size_t number_coordinates,const PointInfo *coordinates)
{
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"circle %.15g,%.15g %.15g,%.15g\n",ox,oy,px,py);
+ (void) MvgPrintf(wand,"circle %g,%g %g,%g\n",ox,oy,px,py);
}
\f
/*
register char
*p;
- register long
+ register ssize_t
i;
size_t
char
buffer[MaxTextExtent];
- (void) FormatMagickString(buffer,MaxTextExtent,"%ld bytes",
+ (void) FormatMagickString(buffer,MaxTextExtent,"%.20g bytes",(double)
(4L*blob_length/3L+4L));
ThrowDrawException(ResourceLimitWarning,"MemoryAllocationFailed",
wand->name);
return(MagickFalse);
}
- mode=MagickOptionToMnemonic(MagickComposeOptions,(long) compose);
+ mode=MagickOptionToMnemonic(MagickComposeOptions,(ssize_t) compose);
media_type=MagickToMime(image->magick);
- (void) MvgPrintf(wand,"image %s %.15g,%.15g %.15g,%.15g 'data:%s;base64,\n",
+ (void) MvgPrintf(wand,"image %s %g,%g %g,%g 'data:%s;base64,\n",
mode,x,y,width,height,media_type);
p=base64;
- for (i=(long) encoded_length; i > 0; i-=76)
+ for (i=(ssize_t) encoded_length; i > 0; i-=76)
{
(void) MvgPrintf(wand,"%.76s",p);
p+=76;
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"color %.15g,%.15g '%s'\n",x,y,MagickOptionToMnemonic(
- MagickMethodOptions,(long) paint_method));
+ (void) MvgPrintf(wand,"color %g,%g '%s'\n",x,y,MagickOptionToMnemonic(
+ MagickMethodOptions,(ssize_t) paint_method));
}
\f
/*
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"ellipse %.15g,%.15g %.15g,%.15g %.15g,%.15g\n",ox,oy,
+ (void) MvgPrintf(wand,"ellipse %g,%g %g,%g %g,%g\n",ox,oy,
rx,ry,start,end);
}
\f
%
% The format of the DrawGetFontWeight method is:
%
-% unsigned long DrawGetFontWeight(const DrawingWand *wand)
+% size_t DrawGetFontWeight(const DrawingWand *wand)
%
% A description of each parameter follows:
%
% o wand: the drawing wand.
%
*/
-WandExport unsigned long DrawGetFontWeight(const DrawingWand *wand)
+WandExport size_t DrawGetFontWeight(const DrawingWand *wand)
{
assert(wand != (const DrawingWand *) NULL);
assert(wand->signature == WandSignature);
% The format of the DrawGetStrokeDashArray method is:
%
% double *DrawGetStrokeDashArray(const DrawingWand *wand,
-% unsigned long *number_elements)
+% size_t *number_elements)
%
% A description of each parameter follows:
%
%
*/
WandExport double *DrawGetStrokeDashArray(const DrawingWand *wand,
- unsigned long *number_elements)
+ size_t *number_elements)
{
double
*dash_array;
register double
*q;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
n;
assert(wand != (const DrawingWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- assert(number_elements != (unsigned long *) NULL);
+ assert(number_elements != (size_t *) NULL);
n=0;
p=CurrentContext->dash_pattern;
if (p != (const double *) NULL)
sizeof(*dash_array));
p=CurrentContext->dash_pattern;
q=dash_array;
- for (i=0; i < (long) n; i++)
+ for (i=0; i < (ssize_t) n; i++)
*q++=(*p++);
}
return(dash_array);
%
% The format of the DrawGetStrokeMiterLimit method is:
%
-% unsigned long DrawGetStrokeMiterLimit(const DrawingWand *wand)
+% size_t DrawGetStrokeMiterLimit(const DrawingWand *wand)
%
% A description of each parameter follows:
%
% o wand: the drawing wand.
%
*/
-WandExport unsigned long DrawGetStrokeMiterLimit(const DrawingWand *wand)
+WandExport size_t DrawGetStrokeMiterLimit(const DrawingWand *wand)
{
assert(wand != (const DrawingWand *) NULL);
assert(wand->signature == WandSignature);
MagickPixelPacket
pixel;
- register long
+ register ssize_t
i;
XMLTreeInfo
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(
- MagickClipPathOptions,(long) CurrentContext->clip_units),MaxTextExtent);
+ MagickClipPathOptions,(ssize_t) CurrentContext->clip_units),MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"decorate",0);
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(
- MagickDecorateOptions,(long) CurrentContext->decorate),MaxTextExtent);
+ MagickDecorateOptions,(ssize_t) CurrentContext->decorate),MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"encoding",0);
child=AddChildToXMLTree(xml_info,"fill-opacity",0);
if (child != (XMLTreeInfo *) NULL)
{
- (void) FormatMagickString(value,MaxTextExtent,"%.15g",
+ (void) FormatMagickString(value,MaxTextExtent,"%g",
(double) QuantumScale*(QuantumRange-CurrentContext->fill.opacity));
(void) SetXMLTreeContent(child,value);
}
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(
- MagickFillRuleOptions,(long) CurrentContext->fill_rule),MaxTextExtent);
+ MagickFillRuleOptions,(ssize_t) CurrentContext->fill_rule),MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"font",0);
child=AddChildToXMLTree(xml_info,"font-size",0);
if (child != (XMLTreeInfo *) NULL)
{
- (void) FormatMagickString(value,MaxTextExtent,"%.15g",
+ (void) FormatMagickString(value,MaxTextExtent,"%g",
CurrentContext->pointsize);
(void) SetXMLTreeContent(child,value);
}
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(
- MagickStretchOptions,(long) CurrentContext->stretch),MaxTextExtent);
+ MagickStretchOptions,(ssize_t) CurrentContext->stretch),MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"font-style",0);
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(
- MagickStyleOptions,(long) CurrentContext->style),MaxTextExtent);
+ MagickStyleOptions,(ssize_t) CurrentContext->style),MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"font-weight",0);
if (child != (XMLTreeInfo *) NULL)
{
- (void) FormatMagickString(value,MaxTextExtent,"%lu",
+ (void) FormatMagickString(value,MaxTextExtent,"%.20g",(double)
CurrentContext->weight);
(void) SetXMLTreeContent(child,value);
}
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(MagickGravityOptions,
- (long) CurrentContext->gravity),MaxTextExtent);
+ (ssize_t) CurrentContext->gravity),MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"stroke",0);
{
if (i != 0)
(void) ConcatenateString(&dash_pattern,",");
- (void) FormatMagickString(value,MaxTextExtent,"%.15g",
+ (void) FormatMagickString(value,MaxTextExtent,"%g",
CurrentContext->dash_pattern[i]);
(void) ConcatenateString(&dash_pattern,value);
}
child=AddChildToXMLTree(xml_info,"stroke-dashoffset",0);
if (child != (XMLTreeInfo *) NULL)
{
- (void) FormatMagickString(value,MaxTextExtent,"%.15g",
+ (void) FormatMagickString(value,MaxTextExtent,"%g",
CurrentContext->dash_offset);
(void) SetXMLTreeContent(child,value);
}
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(MagickLineCapOptions,
- (long) CurrentContext->linecap),MaxTextExtent);
+ (ssize_t) CurrentContext->linecap),MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"stroke-linejoin",0);
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(
- MagickLineJoinOptions,(long) CurrentContext->linejoin),MaxTextExtent);
+ MagickLineJoinOptions,(ssize_t) CurrentContext->linejoin),
+ MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"stroke-miterlimit",0);
if (child != (XMLTreeInfo *) NULL)
{
- (void) FormatMagickString(value,MaxTextExtent,"%lu",
+ (void) FormatMagickString(value,MaxTextExtent,"%.20g",(double)
CurrentContext->miterlimit);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"stroke-opacity",0);
if (child != (XMLTreeInfo *) NULL)
{
- (void) FormatMagickString(value,MaxTextExtent,"%.15g",
+ (void) FormatMagickString(value,MaxTextExtent,"%g",
(double) QuantumScale*(QuantumRange-CurrentContext->stroke.opacity));
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"stroke-width",0);
if (child != (XMLTreeInfo *) NULL)
{
- (void) FormatMagickString(value,MaxTextExtent,"%.15g",
+ (void) FormatMagickString(value,MaxTextExtent,"%g",
CurrentContext->stroke_width);
(void) SetXMLTreeContent(child,value);
}
if (child != (XMLTreeInfo *) NULL)
{
(void) CopyMagickString(value,MagickOptionToMnemonic(MagickAlignOptions,
- (long) CurrentContext->align),MaxTextExtent);
+ (ssize_t) CurrentContext->align),MaxTextExtent);
(void) SetXMLTreeContent(child,value);
}
child=AddChildToXMLTree(xml_info,"text-antialias",0);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"line %.15g,%.15g %.15g,%.15g\n",sx,sy,ex,ey);
+ (void) MvgPrintf(wand,"line %g,%g %g,%g\n",sx,sy,ex,ey);
}
\f
/*
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"matte %.15g,%.15g '%s'\n",x,y,MagickOptionToMnemonic(
- MagickMethodOptions,(long) paint_method));
+ (void) MvgPrintf(wand,"matte %g,%g '%s'\n",x,y,MagickOptionToMnemonic(
+ MagickMethodOptions,(ssize_t) paint_method));
}
\f
/*
{
wand->path_operation=PathCurveToOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand, "%c%.15g,%.15g %.15g,%.15g %.15g,%.15g",
+ (void) MvgAutoWrapPrintf(wand, "%c%g,%g %g,%g %g,%g",
mode == AbsolutePathMode ? 'C' : 'c',x1,y1,x2,y2,x,y);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g,%.15g %.15g,%.15g %.15g,%.15g",x1,y1,
+ (void) MvgAutoWrapPrintf(wand," %g,%g %g,%g %g,%g",x1,y1,
x2,y2,x,y);
}
{
wand->path_operation=PathCurveToQuadraticBezierOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand, "%c%.15g,%.15g %.15g,%.15g",
+ (void) MvgAutoWrapPrintf(wand, "%c%g,%g %g,%g",
mode == AbsolutePathMode ? 'Q' : 'q',x1,y1,x,y);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g,%.15g %.15g,%.15g",x1,y1,x,y);
+ (void) MvgAutoWrapPrintf(wand," %g,%g %g,%g",x1,y1,x,y);
}
WandExport void DrawPathCurveToQuadraticBezierAbsolute(DrawingWand *wand,
{
wand->path_operation=PathCurveToQuadraticBezierSmoothOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand,"%c%.15g,%.15g",mode == AbsolutePathMode ?
+ (void) MvgAutoWrapPrintf(wand,"%c%g,%g",mode == AbsolutePathMode ?
'T' : 't',x,y);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g,%.15g",x,y);
+ (void) MvgAutoWrapPrintf(wand," %g,%g",x,y);
}
WandExport void DrawPathCurveToQuadraticBezierSmoothAbsolute(DrawingWand *wand,
{
wand->path_operation=PathCurveToSmoothOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand,"%c%.15g,%.15g %.15g,%.15g",
+ (void) MvgAutoWrapPrintf(wand,"%c%g,%g %g,%g",
mode == AbsolutePathMode ? 'S' : 's',x2,y2,x,y);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g,%.15g %.15g,%.15g",x2,y2,x,y);
+ (void) MvgAutoWrapPrintf(wand," %g,%g %g,%g",x2,y2,x,y);
}
WandExport void DrawPathCurveToSmoothAbsolute(DrawingWand *wand,const double x2,
{
wand->path_operation=PathEllipticArcOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand, "%c%.15g,%.15g %.15g %u %u %.15g,%.15g",
+ (void) MvgAutoWrapPrintf(wand, "%c%g,%g %g %u %u %g,%g",
mode == AbsolutePathMode ? 'A' : 'a',rx,ry,x_axis_rotation,
large_arc_flag,sweep_flag,x,y);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g,%.15g %.15g %u %u %.15g,%.15g",rx,ry,
+ (void) MvgAutoWrapPrintf(wand," %g,%g %g %u %u %g,%g",rx,ry,
x_axis_rotation,large_arc_flag,sweep_flag,x,y);
}
{
wand->path_operation=PathLineToOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand,"%c%.15g,%.15g",mode == AbsolutePathMode ?
+ (void) MvgAutoWrapPrintf(wand,"%c%g,%g",mode == AbsolutePathMode ?
'L' : 'l',x,y);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g,%.15g",x,y);
+ (void) MvgAutoWrapPrintf(wand," %g,%g",x,y);
}
WandExport void DrawPathLineToAbsolute(DrawingWand *wand,const double x,
{
wand->path_operation=PathLineToHorizontalOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand,"%c%.15g",mode == AbsolutePathMode ?
+ (void) MvgAutoWrapPrintf(wand,"%c%g",mode == AbsolutePathMode ?
'H' : 'h',x);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g",x);
+ (void) MvgAutoWrapPrintf(wand," %g",x);
}
WandExport void DrawPathLineToHorizontalAbsolute(DrawingWand *wand,
{
wand->path_operation=PathLineToVerticalOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand,"%c%.15g",mode == AbsolutePathMode ?
+ (void) MvgAutoWrapPrintf(wand,"%c%g",mode == AbsolutePathMode ?
'V' : 'v',y);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g",y);
+ (void) MvgAutoWrapPrintf(wand," %g",y);
}
WandExport void DrawPathLineToVerticalAbsolute(DrawingWand *wand,const double y)
{
wand->path_operation=PathMoveToOperation;
wand->path_mode=mode;
- (void) MvgAutoWrapPrintf(wand,"%c%.15g,%.15g",mode == AbsolutePathMode ?
+ (void) MvgAutoWrapPrintf(wand,"%c%g,%g",mode == AbsolutePathMode ?
'M' : 'm',x,y);
}
else
- (void) MvgAutoWrapPrintf(wand," %.15g,%.15g",x,y);
+ (void) MvgAutoWrapPrintf(wand," %g,%g",x,y);
}
WandExport void DrawPathMoveToAbsolute(DrawingWand *wand,const double x,
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"point %.15g,%.15g\n",x,y);
+ (void) MvgPrintf(wand,"point %g,%g\n",x,y);
}
\f
/*
% The format of the DrawPolygon method is:
%
% void DrawPolygon(DrawingWand *wand,
-% const unsigned long number_coordinates,const PointInfo *coordinates)
+% const size_t number_coordinates,const PointInfo *coordinates)
%
% A description of each parameter follows:
%
%
*/
WandExport void DrawPolygon(DrawingWand *wand,
- const unsigned long number_coordinates,const PointInfo *coordinates)
+ const size_t number_coordinates,const PointInfo *coordinates)
{
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
% The format of the DrawPolyline method is:
%
% void DrawPolyline(DrawingWand *wand,
-% const unsigned long number_coordinates,const PointInfo *coordinates)
+% const size_t number_coordinates,const PointInfo *coordinates)
%
% A description of each parameter follows:
%
%
*/
WandExport void DrawPolyline(DrawingWand *wand,
- const unsigned long number_coordinates,const PointInfo *coordinates)
+ const size_t number_coordinates,const PointInfo *coordinates)
{
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
}
(void) FormatMagickString(key,MaxTextExtent,"%s",wand->pattern_id);
(void) SetImageArtifact(wand->image,key,wand->mvg+wand->pattern_offset);
- (void) FormatMagickString(geometry,MaxTextExtent,"%lux%lu%+ld%+ld",
- wand->pattern_bounds.width,wand->pattern_bounds.height,
- wand->pattern_bounds.x,wand->pattern_bounds.y);
+ (void) FormatMagickString(geometry,MaxTextExtent,"%.20gx%.20g%+.20g%+.20g",
+ (double) wand->pattern_bounds.width,(double) wand->pattern_bounds.height,
+ (double) wand->pattern_bounds.x,(double) wand->pattern_bounds.y);
(void) SetImageArtifact(wand->image,key,geometry);
wand->pattern_id=DestroyString(wand->pattern_id);
wand->pattern_offset=0;
return(MagickFalse);
}
wand->filter_off=MagickTrue;
- (void) MvgPrintf(wand,"push pattern %s %.15g,%.15g %.15g,%.15g\n",pattern_id,
+ (void) MvgPrintf(wand,"push pattern %s %g,%g %g,%g\n",pattern_id,
x,y,width,height);
wand->indent_depth++;
wand->pattern_id=AcquireString(pattern_id);
- wand->pattern_bounds.x=(long) ceil(x-0.5);
- wand->pattern_bounds.y=(long) ceil(y-0.5);
- wand->pattern_bounds.width=(unsigned long) (width+0.5);
- wand->pattern_bounds.height=(unsigned long) (height+0.5);
+ wand->pattern_bounds.x=(ssize_t) ceil(x-0.5);
+ wand->pattern_bounds.y=(ssize_t) ceil(y-0.5);
+ wand->pattern_bounds.width=(size_t) floor(width+0.5);
+ wand->pattern_bounds.height=(size_t) floor(height+0.5);
wand->pattern_offset=wand->mvg_length;
return(MagickTrue);
}
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"rectangle %.15g,%.15g %.15g,%.15g\n",x1,y1,x2,y2);
+ (void) MvgPrintf(wand,"rectangle %g,%g %g,%g\n",x1,y1,x2,y2);
}
\f
/*
affine.ry=(-sin(DegreesToRadians(fmod(degrees,360.0))));
affine.sy=cos(DegreesToRadians(fmod(degrees,360.0)));
AdjustAffine(wand,&affine);
- (void) MvgPrintf(wand,"rotate %.15g\n",degrees);
+ (void) MvgPrintf(wand,"rotate %g\n",degrees);
}
\f
/*
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"roundrectangle %.15g,%.15g %.15g,%.15g %.15g,%.15g\n",
+ (void) MvgPrintf(wand,"roundrectangle %g,%g %g,%g %g,%g\n",
x1,y1,x2,y2,rx,ry);
}
\f
affine.sx=x;
affine.sy=y;
AdjustAffine(wand,&affine);
- (void) MvgPrintf(wand,"scale %.15g,%.15g\n",x,y);
+ (void) MvgPrintf(wand,"scale %g,%g\n",x,y);
}
\f
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DrawSetClipPath() associates a named clipping path with the image. Only
-% the areas drawn on by the clipping path will be modified as long as it
+% the areas drawn on by the clipping path will be modified as ssize_t as it
% remains in effect.
%
% The format of the DrawSetClipPath method is:
{
CurrentContext->fill_rule=fill_rule;
(void) MvgPrintf(wand, "clip-rule '%s'\n",MagickOptionToMnemonic(
- MagickFillRuleOptions,(long) fill_rule));
+ MagickFillRuleOptions,(ssize_t) fill_rule));
}
}
\f
AdjustAffine(wand,&affine);
}
(void) MvgPrintf(wand, "clip-units '%s'\n",MagickOptionToMnemonic(
- MagickClipPathOptions,(long) clip_units));
+ MagickClipPathOptions,(ssize_t) clip_units));
}
}
\f
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- opacity=RoundToQuantum((double) QuantumRange*(1.0-fill_opacity));
+ opacity=ClampToQuantum((double) QuantumRange*(1.0-fill_opacity));
if ((wand->filter_off != MagickFalse) ||
(CurrentContext->fill.opacity != opacity))
{
CurrentContext->fill.opacity=opacity;
- (void) MvgPrintf(wand,"fill-opacity %.15g\n",fill_opacity);
+ (void) MvgPrintf(wand,"fill-opacity %g\n",fill_opacity);
}
}
\f
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- quantum_opacity=RoundToQuantum((double) QuantumRange*(1.0-opacity));
+ quantum_opacity=ClampToQuantum((double) QuantumRange*(1.0-opacity));
if ((wand->filter_off != MagickFalse) ||
(CurrentContext->opacity != quantum_opacity))
{
- CurrentContext->opacity=opacity;
- (void) MvgPrintf(wand,"opacity %.15g\n",opacity);
+ CurrentContext->opacity=(Quantum) opacity;
+ (void) MvgPrintf(wand,"opacity %g\n",opacity);
}
}
\f
{
CurrentContext->fill_rule=fill_rule;
(void) MvgPrintf(wand, "fill-rule '%s'\n",MagickOptionToMnemonic(
- MagickFillRuleOptions,(long) fill_rule));
+ MagickFillRuleOptions,(ssize_t) fill_rule));
}
}
\f
(fabs(CurrentContext->pointsize-pointsize) > MagickEpsilon))
{
CurrentContext->pointsize=pointsize;
- (void) MvgPrintf(wand,"font-size %.15g\n",pointsize);
+ (void) MvgPrintf(wand,"font-size %g\n",pointsize);
}
}
\f
{
CurrentContext->stretch=font_stretch;
(void) MvgPrintf(wand, "font-stretch '%s'\n",MagickOptionToMnemonic(
- MagickStretchOptions,(long) font_stretch));
+ MagickStretchOptions,(ssize_t) font_stretch));
}
}
\f
{
CurrentContext->style=style;
(void) MvgPrintf(wand, "font-style '%s'\n",MagickOptionToMnemonic(
- MagickStyleOptions,(long) style));
+ MagickStyleOptions,(ssize_t) style));
}
}
\f
% The format of the DrawSetFontWeight method is:
%
% void DrawSetFontWeight(DrawingWand *wand,
-% const unsigned long font_weight)
+% const size_t font_weight)
%
% A description of each parameter follows:
%
%
*/
WandExport void DrawSetFontWeight(DrawingWand *wand,
- const unsigned long font_weight)
+ const size_t font_weight)
{
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
(CurrentContext->weight != font_weight))
{
CurrentContext->weight=font_weight;
- (void) MvgPrintf(wand,"font-weight %lu\n",font_weight);
+ (void) MvgPrintf(wand,"font-weight %.20g\n",(double) font_weight);
}
}
\f
{
CurrentContext->gravity=gravity;
(void) MvgPrintf(wand,"gravity '%s'\n",MagickOptionToMnemonic(
- MagickGravityOptions,(long) gravity));
+ MagickGravityOptions,(ssize_t) gravity));
}
}
\f
% The format of the DrawSetStrokeDashArray method is:
%
% MagickBooleanType DrawSetStrokeDashArray(DrawingWand *wand,
-% const unsigned long number_elements,const double *dash_array)
+% const size_t number_elements,const double *dash_array)
%
% A description of each parameter follows:
%
%
*/
WandExport MagickBooleanType DrawSetStrokeDashArray(DrawingWand *wand,
- const unsigned long number_elements,const double *dash_array)
+ const size_t number_elements,const double *dash_array)
{
MagickBooleanType
update;
register double
*q;
- register long
+ register ssize_t
i;
- unsigned long
+ size_t
n_new,
n_old;
{
p=dash_array;
q=CurrentContext->dash_pattern;
- for (i=0; i < (long) n_new; i++)
+ for (i=0; i < (ssize_t) n_new; i++)
{
if (fabs((*p)-(*q)) > MagickEpsilon)
{
}
q=CurrentContext->dash_pattern;
p=dash_array;
- for (i=0; i < (long) n_new; i++)
+ for (i=0; i < (ssize_t) n_new; i++)
*q++=(*p++);
*q=0;
}
else
{
p=dash_array;
- (void) MvgPrintf(wand,"%.15g",*p++);
- for (i=1; i < (long) n_new; i++)
- (void) MvgPrintf(wand,",%.15g",*p++);
+ (void) MvgPrintf(wand,"%g",*p++);
+ for (i=1; i < (ssize_t) n_new; i++)
+ (void) MvgPrintf(wand,",%g",*p++);
(void) MvgPrintf(wand,"\n");
}
}
(fabs(CurrentContext->dash_offset-dash_offset) > MagickEpsilon))
{
CurrentContext->dash_offset=dash_offset;
- (void) MvgPrintf(wand,"stroke-dashoffset %.15g\n",dash_offset);
+ (void) MvgPrintf(wand,"stroke-dashoffset %g\n",dash_offset);
}
}
\f
{
CurrentContext->linecap=linecap;
(void) MvgPrintf(wand,"stroke-linecap '%s'\n",MagickOptionToMnemonic(
- MagickLineCapOptions,(long) linecap));
+ MagickLineCapOptions,(ssize_t) linecap));
}
}
\f
{
CurrentContext->linejoin=linejoin;
(void) MvgPrintf(wand, "stroke-linejoin '%s'\n",MagickOptionToMnemonic(
- MagickLineJoinOptions,(long) linejoin));
+ MagickLineJoinOptions,(ssize_t) linejoin));
}
}
\f
% The format of the DrawSetStrokeMiterLimit method is:
%
% void DrawSetStrokeMiterLimit(DrawingWand *wand,
-% const unsigned long miterlimit)
+% const size_t miterlimit)
%
% A description of each parameter follows:
%
%
*/
WandExport void DrawSetStrokeMiterLimit(DrawingWand *wand,
- const unsigned long miterlimit)
+ const size_t miterlimit)
{
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
if (CurrentContext->miterlimit != miterlimit)
{
CurrentContext->miterlimit=miterlimit;
- (void) MvgPrintf(wand,"stroke-miterlimit %lu\n",miterlimit);
+ (void) MvgPrintf(wand,"stroke-miterlimit %.20g\n",(double) miterlimit);
}
}
\f
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- opacity=RoundToQuantum((double) QuantumRange*(1.0-stroke_opacity));
+ opacity=ClampToQuantum((double) QuantumRange*(1.0-stroke_opacity));
if ((wand->filter_off != MagickFalse) ||
(CurrentContext->stroke.opacity != opacity))
{
CurrentContext->stroke.opacity=opacity;
- (void) MvgPrintf(wand,"stroke-opacity %.15g\n",stroke_opacity);
+ (void) MvgPrintf(wand,"stroke-opacity %g\n",stroke_opacity);
}
}
\f
(fabs(CurrentContext->stroke_width-stroke_width) > MagickEpsilon))
{
CurrentContext->stroke_width=stroke_width;
- (void) MvgPrintf(wand,"stroke-width %.15g\n",stroke_width);
+ (void) MvgPrintf(wand,"stroke-width %g\n",stroke_width);
}
}
\f
{
CurrentContext->align=alignment;
(void) MvgPrintf(wand,"text-align '%s'\n",MagickOptionToMnemonic(
- MagickAlignOptions,(long) alignment));
+ MagickAlignOptions,(ssize_t) alignment));
}
}
\f
{
CurrentContext->decorate=decoration;
(void) MvgPrintf(wand,"decorate '%s'\n",MagickOptionToMnemonic(
- MagickDecorateOptions,(long) decoration));
+ MagickDecorateOptions,(ssize_t) decoration));
}
}
\f
{
value=GetXMLTreeContent(child);
if (value != (const char *) NULL)
- CurrentContext->fill.opacity=RoundToQuantum((MagickRealType)
+ CurrentContext->fill.opacity=ClampToQuantum((MagickRealType)
QuantumRange*(1.0-StringToDouble(value)));
}
child=GetXMLTreeChild(xml_info,"fill-rule");
const char
*q;
- long
+ ssize_t
j;
- register long
+ register ssize_t
x;
value=GetXMLTreeContent(child);
{
value=GetXMLTreeContent(child);
if (value != (const char *) NULL)
- CurrentContext->stroke.opacity=RoundToQuantum((MagickRealType)
+ CurrentContext->stroke.opacity=ClampToQuantum((MagickRealType)
QuantumRange*(1.0-StringToDouble(value)));
}
child=GetXMLTreeChild(xml_info,"stroke-width");
GetAffineMatrix(&affine);
affine.ry=tan(DegreesToRadians(fmod(degrees,360.0)));
AdjustAffine(wand,&affine);
- (void) MvgPrintf(wand,"skewX %.15g\n",degrees);
+ (void) MvgPrintf(wand,"skewX %g\n",degrees);
}
\f
/*
GetAffineMatrix(&affine);
affine.rx=tan(DegreesToRadians(fmod(degrees,360.0)));
DrawAffine(wand,&affine);
- (void) MvgPrintf(wand,"skewY %.15g\n",degrees);
+ (void) MvgPrintf(wand,"skewY %g\n",degrees);
}
\f
/*
affine.tx=x;
affine.ty=y;
AdjustAffine(wand,&affine);
- (void) MvgPrintf(wand,"translate %.15g,%.15g\n",x,y);
+ (void) MvgPrintf(wand,"translate %g,%g\n",x,y);
}
\f
/*
%
% The format of the DrawSetViewbox method is:
%
-% void DrawSetViewbox(DrawingWand *wand,unsigned long x1,
-% unsigned long y1,unsigned long x2,unsigned long y2)
+% void DrawSetViewbox(DrawingWand *wand,size_t x1,
+% size_t y1,size_t x2,size_t y2)
%
% A description of each parameter follows:
%
% o y2: bottom y ordinate
%
*/
-WandExport void DrawSetViewbox(DrawingWand *wand,unsigned long x1,
- unsigned long y1,unsigned long x2,unsigned long y2)
+WandExport void DrawSetViewbox(DrawingWand *wand,ssize_t x1,ssize_t y1,
+ ssize_t x2,ssize_t y2)
{
assert(wand != (DrawingWand *) NULL);
assert(wand->signature == WandSignature);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
- (void) MvgPrintf(wand,"viewbox %lu %lu %lu %lu\n",x1,y1,x2,y2);
+ (void) MvgPrintf(wand,"viewbox %.20g %.20g %.20g %.20g\n",(double) x1,
+ (double) y1,(double) x2,(double) y2);
}
\f
/*
DrawingWand
*wand;
- unsigned long
+ size_t
depth;
quantum=GetMagickQuantumDepth(&depth);
GetExceptionMessage(errno));
(void) ResetMagickMemory(wand,0,sizeof(*wand));
wand->id=AcquireWandId();
- (void) FormatMagickString(wand->name,MaxTextExtent,"%s-%lu",DrawingWandId,
- wand->id);
+ (void) FormatMagickString(wand->name,MaxTextExtent,"%s-%.20g",DrawingWandId,
+ (double) wand->id);
if (wand->debug != MagickFalse)
(void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
wand->mvg=(char *) NULL;
projects / imagemagick / blobdiff