/* $Xorg: paths.c,v 1.3 2000/08/17 19:46:31 cpqbld Exp $ */
/* Copyright International Business Machines, Corp. 1991
* All Rights Reserved
* Copyright Lexmark International, Inc. 1991
* All Rights Reserved
*
* License to use, copy, modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above copyright notice appear in all copies and that
* both that copyright notice and this permission notice appear in
* supporting documentation, and that the name of IBM or Lexmark not be
* used in advertising or publicity pertaining to distribution of the
* software without specific, written prior permission.
*
* IBM AND LEXMARK PROVIDE THIS SOFTWARE "AS IS", WITHOUT ANY WARRANTIES OF
* ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
* AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. THE ENTIRE RISK AS TO THE
* QUALITY AND PERFORMANCE OF THE SOFTWARE, INCLUDING ANY DUTY TO SUPPORT
* OR MAINTAIN, BELONGS TO THE LICENSEE. SHOULD ANY PORTION OF THE
* SOFTWARE PROVE DEFECTIVE, THE LICENSEE (NOT IBM OR LEXMARK) ASSUMES THE
* ENTIRE COST OF ALL SERVICING, REPAIR AND CORRECTION. IN NO EVENT SHALL
* IBM OR LEXMARK BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
* THIS SOFTWARE.
*/
/* $XFree86: xc/lib/font/Type1/paths.c,v 1.7tsi Exp $ */
/* PATHS CWEB V0021 ******** */
/*
:h1 id=paths.PATHS Module - Path Operator Handler
This is the module that is responsible for building and transforming
path lists.
&author. Jeffrey B. Lotspiech (lotspiech@almaden.ibm.com)
:h3.Include Files
The included files are:
*/
/* after the system includes (dsr) */
#ifdef HAVE_CONFIG_H
#include
#endif
#ifdef FONTMODULE
# include "os.h"
#endif
#include "objects.h"
#include "spaces.h"
#include "paths.h"
#include "regions.h" /* understands about Union */
#include "fonts.h" /* understands about TEXTTYPEs */
#include "pictures.h" /* understands about handles */
#include "strokes.h" /* understands how to coerce stroke paths */
#include "trig.h"
/*
:h3.Routines Available to the TYPE1IMAGER User
The PATHS routines that are made available to the outside user are:
*/
/*SHARED LINE(S) ORIGINATED HERE*/
/*
:h3.Functions Provided to Other Modules
The path routines that are made available to other TYPE1IMAGER modules
are defined here:
*/
/*SHARED LINE(S) ORIGINATED HERE*/
/*
NOTE: because of the casts put in the macros for Loc, ArcCA, Conic,
RoundConic, PathSegment, and JoinSegment, we cannot use the macro names
when the functions are actually defined. We have to use the unique
names with their unique first two characters. Thus, if anyone in the
future ever decided to change the first two characters, it would not be
enough just to change the macro (as it would for most other functions).
He would have to also change the function definition.
*/
/*
:h3.Macros Provided to Other Modules
The CONCAT macro is defined here and used in the STROKES module. See
:hdref refid=pathmac..
*/
/*SHARED LINE(S) ORIGINATED HERE*/
/*
:h2.Path Segment Structures
A path is represented as a linked list of the following structure:
*/
/*SHARED LINE(S) ORIGINATED HERE*/
/*
When 'link' is NULL, we are at the last segment in the path (surprise!).
'last' is only non-NULL on the first segment of a path,
for all the other segments 'last' == NULL. We test for a non-NULL
'last' (ISPATHANCHOR predicate) when we are given an alleged path
to make sure the user is not trying to pull a fast one on us.
A path may be a collection of disjoint paths. Every break in the
disjoint path is represented by a MOVETYPE segment.
Closed paths are discussed in :hdref refid=close..
:h3.CopyPath() - Physically Duplicating a Path
This simple function illustrates moving through the path linked list.
Duplicating a segment just involves making a copy of it, except for
text, which has some auxilliary things involved. We don't feel
competent to duplicate text in this module, so we call someone who
knows how (in the FONTS module).
*/
struct segment *
CopyPath(struct segment *p0) /* path to duplicate */
{
register struct segment *p,*n = NULL,*last = NULL,*anchor;
for (p = p0, anchor = NULL; p != NULL; p = p->link) {
ARGCHECK((!ISPATHTYPE(p->type) || (p != p0 && p->last != NULL)),
"CopyPath: invalid segment", p, NULL, (0), struct segment *);
if (p->type == TEXTTYPE)
n = (struct segment *) CopyText(p);
else
n = (struct segment *)Allocate(p->size, p, 0);
n->last = NULL;
if (anchor == NULL)
anchor = n;
else
last->link = n;
last = n;
}
/*
At this point we have a chain of newly allocated segments hanging off
'anchor'. We need to make sure the first segment points to the last:
*/
if (anchor != NULL) {
n->link = NULL;
anchor->last = n;
}
return(anchor);
}
/*
:h3.KillPath() - Destroying a Path
Destroying a path is simply a matter of freeing each segment in the
linked list. Again, we let the experts handle text.
*/
void
KillPath(struct segment *p) /* path to destroy */
{
register struct segment *linkp; /* temp register holding next segment*/
/* return conditional based on reference count 3-26-91 PNM */
if ( (--(p->references) > 1) ||
( (p->references == 1) && !ISPERMANENT(p->flag) ) )
return;
while (p != NULL) {
if (!ISPATHTYPE(p->type)) {
ArgErr("KillPath: bad segment", p, NULL);
return;
}
linkp = p->link;
if (p->type == TEXTTYPE)
KillText(p);
else
Free(p);
p = linkp;
}
}
/*
:h2 id=location."location" Objects
The TYPE1IMAGER user creates and destroys objects of type "location". These
objects locate points for the primitive path operators. We play a trick
here and store these objects in the same "segment" structure used for
paths, with a type field == MOVETYPE.
This allows the Line() operator, for example, to be very trivial:
It merely stamps its input structure as a LINETYPE and returns it to the
caller--assuming, of course, the input structure was not permanent (as
it usually isn't).
:h3.The "movesegment" Template Structure
This template is used as a generic segment structure for Allocate:
*/
/* added reference field 1 to temporary template below 3-26-91 PNM */
static struct segment movetemplate = { MOVETYPE, 0, 1, sizeof(struct segment), 0,
NULL, NULL, {0, 0} };
/*
:h3.Loc() - Create an "Invisible Line" Between (0,0) and a Point
*/
struct segment *
t1_Loc(struct XYspace *S, /* coordinate space to interpret X,Y */
double x, double y) /* destination point */
{
register struct segment *r;
r = (struct segment *)Allocate(sizeof(struct segment), &movetemplate, 0);
TYPECHECK("Loc", S, SPACETYPE, r, (0), struct segment *);
r->last = r;
r->context = S->context;
(*S->convert)(&r->dest, S, x, y);
ConsumeSpace(S);
return(r);
}
/*
:h3.ILoc() - Loc() With Integer Arguments
*/
struct segment *
ILoc(struct XYspace *S, /* coordinate space to interpret X,Y */
int x, int y) /* destination point */
{
register struct segment *r;
r = (struct segment *)Allocate(sizeof(struct segment), &movetemplate, 0);
TYPECHECK("Loc", S, SPACETYPE, r, (0), struct segment *);
r->last = r;
r->context = S->context;
(*S->iconvert)(&r->dest, S, (long) x, (long) y);
ConsumeSpace(S);
return(r);
}
/*
:h2.Straight Line Segments
:h3.PathSegment() - Create a Generic Path Segment
Many routines need a LINETYPE or MOVETYPE path segment, but do not
want to go through the external user's interface, because, for example,
they already know the "fractpel" destination of the segment and the
conversion is unnecessary. PathSegment() is an internal routine
provided to the rest of TYPE1IMAGER for handling these cases.
*/
struct segment *
t1_PathSegment(int type, /* LINETYPE or MOVETYPE */
fractpel x, fractpel y) /* where to go to, if known */
{
register struct segment *r; /* newly created segment */
r = (struct segment *)Allocate(sizeof(struct segment), &movetemplate, 0);
r->type = type;
r->last = r; /* last points to itself for singleton */
r->dest.x = x;
r->dest.y = y;
return(r);
}
/*
:h3.Line() - Create a Line Segment Between (0,0) and a Point P
This involves just creating and filling out a segment structure:
*/
struct segment *
Line(struct segment *P) /* relevant coordinate space */
{
ARGCHECK(!ISLOCATION(P), "Line: arg not a location", P, NULL, (0), struct segment *);
P = UniquePath(P);
P->type = LINETYPE;
return(P);
}
/*
:h2.Curved Path Segments
We need more points to describe curves. So, the structures for curved
path segments are slightly different. The first part is identical;
the curved structures are larger with the extra points on the end.
:h3.Bezier Segment Structure
We support third order Bezier curves. They are specified with four
control points A, B, C, and D. The curve starts at A with slope AB
and ends at D with slope CD. The curvature at the point A is inversely
related to the length |AB|, and the curvature at the point D is
inversely related to the length |CD|. Point A is always point (0,0).
*/
/*SHARED LINE(S) ORIGINATED HERE*/
/*
:h3.Bezier() - Generate a Bezier Segment
This is just a simple matter of filling out a 'beziersegment' structure:
*/
struct beziersegment *
Bezier(struct segment *B, /* second control point */
struct segment *C, /* third control point */
struct segment *D) /* fourth control point (ending point) */
{
/* added reference field of 1 to temporary template below 3-26-91 PNM */
static struct beziersegment template =
{ BEZIERTYPE, 0, 1, sizeof(struct beziersegment), 0,
NULL, NULL, { 0, 0 }, { 0, 0 }, { 0, 0 } };
register struct beziersegment *r; /* output segment */
ARGCHECK(!ISLOCATION(B), "Bezier: bad B", B, NULL, (2,C,D), struct beziersegment *);
ARGCHECK(!ISLOCATION(C), "Bezier: bad C", C, NULL, (2,B,D), struct beziersegment *);
ARGCHECK(!ISLOCATION(D), "Bezier: bad D", D, NULL, (2,B,C), struct beziersegment *);
r = (struct beziersegment *)Allocate(sizeof(struct beziersegment), &template, 0);
r->last = (struct segment *) r;
r->dest.x = D->dest.x;
r->dest.y = D->dest.y;
r->B.x = B->dest.x;
r->B.y = B->dest.y;
r->C.x = C->dest.x;
r->C.y = C->dest.y;
ConsumePath(B);
ConsumePath(C);
ConsumePath(D);
return(r);
}
/*SHARED LINE(S) ORIGINATED HERE*/
/*
POP removes the first segment in a path 'p' and Frees it. 'p' is left
pointing to the end of the path:
*/
#define POP(p) \
{ register struct segment *linkp; \
linkp = p->link; \
if (linkp != NULL) \
linkp->last = p->last; \
Free(p); \
p = linkp; }
/*
INSERT inserts a single segment in the middle of a chain. 'b' is
the segment before, 'p' the segment to be inserted, and 'a' the
segment after.
*/
#define INSERT(b,p,a) b->link=p; p->link=a; p->last=NULL
/*
:h3.Join() - Join Two Objects Together
If these are paths, this operator simply invokes the CONCAT macro.
Why so much code then, you ask? Well we have to check for object
types other than paths, and also check for certain path consistency
rules.
*/
struct segment *
Join(struct segment *p1, struct segment *p2)
{
/*
We start with a whole bunch of very straightforward argument tests:
*/
if (p2 != NULL) {
if (!ISPATHTYPE(p2->type)) {
if (p1 == NULL)
return((struct segment *)Unique(p2));
switch (p1->type) {
case REGIONTYPE:
case STROKEPATHTYPE:
p1 = CoercePath(p1);
break;
default:
return((struct segment *)BegHandle(p1, p2));
}
}
ARGCHECK((p2->last == NULL), "Join: right arg not anchor", p2, NULL, (1,p1), struct segment *);
p2 = UniquePath(p2);
/*
In certain circumstances, we don't have to duplicate a permanent
location. (We would just end up destroying it anyway). These cases
are when 'p2' begins with a move-type segment:
*/
if (p2->type == TEXTTYPE || p2->type == MOVETYPE) {
if (p1 == NULL)
return(p2);
if (ISLOCATION(p1)) {
p2->dest.x += p1->dest.x;
p2->dest.y += p1->dest.y;
ConsumePath(p1);
return(p2);
}
}
}
else
return((struct segment *)Unique(p1));
if (p1 != NULL) {
if (!ISPATHTYPE(p1->type))
switch (p2->type) {
case REGIONTYPE:
case STROKEPATHTYPE:
p2 = CoercePath(p2);
break;
default:
return((struct segment *)EndHandle(p1, p2));
}
ARGCHECK((p1->last == NULL), "Join: left arg not anchor", p1, NULL, (1,p2), struct segment *);
p1 = UniquePath(p1);
}
else
return(p2);
/*
At this point all the checking is done. We have two temporary non-null
path types in 'p1' and 'p2'. If p1 ends with a MOVE, and p2 begins with
a MOVE, we collapse the two MOVEs into one. We enforce the rule that
there may not be two MOVEs in a row:
*/
if (p1->last->type == MOVETYPE && p2->type == MOVETYPE) {
p1->last->flag |= p2->flag;
p1->last->dest.x += p2->dest.x;
p1->last->dest.y += p2->dest.y;
POP(p2);
if (p2 == NULL)
return(p1);
}
/*
Now we check for another silly rule. If a path has any TEXTTYPEs,
then it must have only TEXTTYPEs and MOVETYPEs, and furthermore,
it must begin with a TEXTTYPE. This rule makes it easy to check
for the special case of text. If necessary, we will coerce
TEXTTYPEs into paths so we don't mix TEXTTYPEs with normal paths.
*/
if (p1->type == TEXTTYPE) {
if (p2->type != TEXTTYPE && !ISLOCATION(p2))
p1 = CoerceText(p1);
}
else {
if (p2->type == TEXTTYPE) {
if (ISLOCATION(p1)) {
p2->dest.x += p1->dest.x;
p2->dest.y += p1->dest.y;
Free(p1);
return(p2);
}
else
p2 = CoerceText(p2);
}
}
/*
Thank God! Finally! It's hard to believe, but we are now able to
actually do the join. This is just invoking the CONCAT macro:
*/
CONCAT(p1, p2);
return(p1);
}
/*
:h3.JoinSegment() - Create a Path Segment and Join It to a Known Path
This internal function is quicker than a full-fledged join because
it can do much less checking.
*/
struct segment *
t1_JoinSegment(struct segment *before, /* path to join before new segment */
int type, /* type of new segment (MOVETYPE or LINETYPE) */
fractpel x, fractpel y, /* x,y of new segment */
struct segment *after) /* path to join after new segment */
{
register struct segment *r; /* returned path built here */
r = PathSegment(type, x, y);
if (before != NULL) {
CONCAT(before, r);
r = before;
}
else
r->context = after->context;
if (after != NULL)
CONCAT(r, after);
return(r);
}
/*
:h2.Other Path Functions
*/
struct segment *
t1_ClosePath(struct segment *p0, /* path to close */
int lastonly) /* flag deciding to close all subpaths or... */
{
register struct segment *p,*last = NULL,*start; /* used in looping through path */
register fractpel x,y; /* current position in path */
register fractpel firstx = 0,firsty = 0; /* start position of sub path */
register struct segment *lastnonhint = NULL; /* last non-hint segment in path */
if (p0 != NULL && p0->type == TEXTTYPE)
return(UniquePath(p0));
if (p0->type == STROKEPATHTYPE)
return((struct segment *)Unique(p0));
/*
* NOTE: a null closed path is different from a null open path
* and is denoted by a closed (0,0) move segment. We make
* sure this path begins and ends with a MOVETYPE:
*/
if (p0 == NULL || p0->type != MOVETYPE)
p0 = JoinSegment(NULL, MOVETYPE, 0, 0, p0);
TYPECHECK("ClosePath", p0, MOVETYPE, NULL, (0), struct segment *);
if (p0->last->type != MOVETYPE)
p0 = JoinSegment(p0, MOVETYPE, 0, 0, NULL);
p0 = UniquePath(p0);
/*
We now begin a loop through the path,
incrementing current 'x' and 'y'. We are searching
for MOVETYPE segments (breaks in the path) that are not already closed.
At each break, we insert a close segment.
*/
for (p = p0, x = y = 0, start = NULL;
p != NULL;
x += p->dest.x, y += p->dest.y, last = p, p = p->link)
{
if (p->type == MOVETYPE) {
if (start != NULL && (lastonly?p->link==NULL:TRUE) &&
!(ISCLOSED(start->flag) && LASTCLOSED(last->flag))) {
register struct segment *r; /* newly created */
start->flag |= ISCLOSED(ON);
r = PathSegment(LINETYPE, firstx - x,
firsty - y);
INSERT(last, r, p);
r->flag |= LASTCLOSED(ON);
/*< adjust 'last' if possible for a 0,0 close >*/
{
#define CLOSEFUDGE 3 /* if we are this close, let's change last segment */
if (r->dest.x != 0 || r->dest.y != 0) {
if (r->dest.x <= CLOSEFUDGE && r->dest.x >= -CLOSEFUDGE
&& r->dest.y <= CLOSEFUDGE && r->dest.y >= -CLOSEFUDGE) {
lastnonhint->dest.x += r->dest.x;
lastnonhint->dest.y += r->dest.y;
r->dest.x = r->dest.y = 0;
}
}
}
if (p->link != NULL) {
p->dest.x += x - firstx;
p->dest.y += y - firsty;
x = firstx;
y = firsty;
}
}
start = p;
firstx = x + p->dest.x;
firsty = y + p->dest.y;
}
else if (p->type != HINTTYPE)
lastnonhint = p;
}
return(p0);
}
/*
:h2.Transforming and Putting Handles on Paths
:h3.PathTransform() - Transform a Path
Transforming a path involves transforming all the points. In order
that closed paths do not become "unclosed" when their relative
positions are slightly changed due to loss of arithmetic precision,
all point transformations are in absolute coordinates.
(It might be better to reset the "absolute" coordinates every time a
move segment is encountered. This would mean that we could accumulate
error from subpath to subpath, but we would be less likely to make
the "big error" where our fixed point arithmetic "wraps". However, I
think I'll keep it this way until something happens to convince me
otherwise.)
The transform is described as a "space", that way we can use our
old friend the "iconvert" function, which should be very efficient.
*/
struct segment *
PathTransform(struct segment *p0, /* path to transform */
struct XYspace *S) /* pseudo space to transform in */
{
register struct segment *p; /* to loop through path with */
register fractpel newx,newy; /* current transformed position in path */
register fractpel oldx,oldy; /* current untransformed position in path */
register fractpel savex,savey; /* save path delta x,y */
p0 = UniquePath(p0);
newx = newy = oldx = oldy = 0;
for (p=p0; p != NULL; p=p->link) {
savex = p->dest.x; savey = p->dest.y;
(*S->iconvert)(&p->dest, S, p->dest.x + oldx, p->dest.y + oldy);
p->dest.x -= newx;
p->dest.y -= newy;
switch (p->type) {
case LINETYPE:
case MOVETYPE:
break;
case CONICTYPE:
{
register struct conicsegment *cp = (struct conicsegment *) p;
(*S->iconvert)(&cp->M, S, cp->M.x + oldx, cp->M.y + oldy);
cp->M.x -= newx;
cp->M.y -= newy;
/*
* Note roundness doesn't change... linear transform
*/
break;
}
case BEZIERTYPE:
{
register struct beziersegment *bp = (struct beziersegment *) p;
(*S->iconvert)(&bp->B, S, bp->B.x + oldx, bp->B.y + oldy);
bp->B.x -= newx;
bp->B.y -= newy;
(*S->iconvert)(&bp->C, S, bp->C.x + oldx, bp->C.y + oldy);
bp->C.x -= newx;
bp->C.y -= newy;
break;
}
case HINTTYPE:
{
register struct hintsegment *hp = (struct hintsegment *) p;
(*S->iconvert)(&hp->ref, S, hp->ref.x + oldx, hp->ref.y + oldy);
hp->ref.x -= newx;
hp->ref.y -= newy;
(*S->iconvert)(&hp->width, S, hp->width.x, hp->width.y);
/* Note: width is not relative to origin */
break;
}
case TEXTTYPE:
{
XformText(p,S);
break;
}
default:
Abort("PathTransform: invalid segment");
}
oldx += savex;
oldy += savey;
newx += p->dest.x;
newy += p->dest.y;
}
return(p0);
}
/*
:h3.PathDelta() - Return a Path's Ending Point
*/
void
PathDelta(struct segment *p, /* input path */
struct fractpoint *pt) /* pointer to x,y to set */
{
struct fractpoint mypoint; /* I pass this to TextDelta */
register fractpel x,y; /* working variables for path current point */
mypoint.x = mypoint.y = 0;
for (x=y=0; p != NULL; p=p->link) {
x += p->dest.x;
y += p->dest.y;
if (p->type == TEXTTYPE) {
TextDelta(p, &mypoint);
x += mypoint.x;
y += mypoint.y;
}
}
pt->x = x;
pt->y = y;
}
/*
:h2.Querying Locations and Paths
:h3.QueryLoc() - Return the X,Y of a Locition
*/
void
QueryLoc(struct segment *P, /* location to query, not consumed */
struct XYspace *S, /* XY space to return coordinates in */
double *xP, double *yP) /* coordinates returned here */
{
if (!ISLOCATION(P)) {
ArgErr("QueryLoc: first arg not a location", P, NULL);
return;
}
if (S->type != SPACETYPE) {
ArgErr("QueryLoc: second arg not a space", S, NULL);
return;
}
UnConvert(S, &P->dest, xP, yP);
}