+++ /dev/null
-/* $XConsortium: paths.c,v 1.4 91/10/10 11:18:40 rws 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.
- */
- /* 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) */
-#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"
-static UnClose();
-
-/*
-: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(p0)
- register struct segment *p0; /* path to duplicate */
-{
- register struct segment *p,*n,*last,*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(p)
- register 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(S, x, y)
- register struct XYspace *S; /* coordinate space to interpret X,Y */
- double x,y; /* destination point */
-{
- register struct segment *r;
-
-
- IfTrace3((MustTraceCalls),"..Loc(S=%z, x=%f, y=%f)\n", S, &x, &y);
-
- 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(S, x, y)
- register struct XYspace *S; /* coordinate space to interpret X,Y */
- register int x,y; /* destination point */
-{
- register struct segment *r;
-
- IfTrace3((MustTraceCalls),"..ILoc(S=%z, x=%d, y=%d)\n",
- S, (long) x, (long) y);
- 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);
-}
-
-/*
-:h3.SubLoc() - Vector Subtraction of Two Locition Objects
-
-This user operator subtracts two location objects, yielding a new
-location object that is the result.
-
-The symmetrical function AddLoc() is totally redundent with Join(),
-so it is not provided.
-*/
-
-struct segment *SubLoc(p1, p2)
- register struct segment *p1;
- register struct segment *p2;
-{
- IfTrace2((MustTraceCalls),"SubLoc(%z, %z)\n", p1, p2);
-
- ARGCHECK(!ISLOCATION(p1), "SubLoc: bad first arg", p1, NULL, (0), struct segment *);
- ARGCHECK(!ISLOCATION(p2), "SubLoc: bad second arg", p2, NULL, (0), struct segment *);
- p1 = UniquePath(p1);
- p1->dest.x -= p2->dest.x;
- p1->dest.y -= p2->dest.y;
- ConsumePath(p2);
- return(p1);
-}
-
-/*
-: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(type, x, y)
- int type; /* LINETYPE or MOVETYPE */
- fractpel x,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(P)
- register struct segment *P; /* relevant coordinate space */
-{
-
- IfTrace1((MustTraceCalls),"..Line(%z)\n", P);
- 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(B, C, D)
- register struct segment *B; /* second control point */
- register struct segment *C; /* third control point */
- register 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 */
-
- IfTrace3((MustTraceCalls),"..Bezier(%z, %z, %z)\n", B, C, D);
- 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);
-}
-
-/*
-:h2.Font "Hint" Segments
-
-:h3.Hint() - A Font 'Hint' Segment
-
-This is temporary code while we experiment with hints.
-*/
-
-/*SHARED LINE(S) ORIGINATED HERE*/
-struct hintsegment *Hint(S, ref, width, orientation, hinttype, adjusttype, direction, label)
- struct XYspace *S;
- float ref;
- float width;
- char orientation;
- char hinttype;
- char adjusttype;
- char direction;
- int label;
-{
-/* added reference field of 1 to hintsegment template below 3-26-91 PNM */
- static struct hintsegment template = { HINTTYPE, 0, 1, sizeof(struct hintsegment), 0,
- NULL, NULL, { 0, 0 }, { 0, 0 }, { 0, 0 },
- ' ', ' ', ' ', ' ', 0};
-
- register struct hintsegment *r;
-
- r = (struct hintsegment *)Allocate(sizeof(struct hintsegment), &template, 0);
-
- r->orientation = orientation;
- if (width == 0.0) width = 1.0;
-
- if (orientation == 'h') {
- (*S->convert)(&r->ref, S, 0.0, ref);
- (*S->convert)(&r->width, S, 0.0, width);
- }
- else if (orientation == 'v') {
- (*S->convert)(&r->ref, S, ref, 0.0);
- (*S->convert)(&r->width, S, width, 0.0);
- }
- else
- return((struct hintsegment *)ArgErr("Hint: orient not 'h' or 'v'", NULL, NULL));
- if (r->width.x < 0) r->width.x = - r->width.x;
- if (r->width.y < 0) r->width.y = - r->width.y;
- r->hinttype = hinttype;
- r->adjusttype = adjusttype;
- r->direction = direction;
- r->label = label;
- r->last = (struct segment *) r;
- ConsumeSpace(S);
- 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(p1, p2)
- register struct segment *p1,*p2;
-{
- IfTrace2((MustTraceCalls && PathDebug > 1),"..Join(%z, %z)\n", p1, p2);
- IfTrace2((MustTraceCalls && PathDebug <=1),"..Join(%x, %x)\n", p1, 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(before, type, x, y, after)
- register struct segment *before; /* path to join before new segment */
- int type; /* type of new segment (MOVETYPE or LINETYPE) */
- fractpel x,y; /* x,y of new segment */
- register 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(p0,lastonly)
- register struct segment *p0; /* path to close */
- register int lastonly; /* flag deciding to close all subpaths or... */
-{
- register struct segment *p,*last,*start; /* used in looping through path */
- register fractpel x,y; /* current position in path */
- register fractpel firstx,firsty; /* start position of sub path */
- register struct segment *lastnonhint; /* last non-hint segment in path */
-
- IfTrace1((MustTraceCalls),"ClosePath(%z)\n", p0);
- 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) {
- IfTrace2((PathDebug),
- "ClosePath forced closed by (%p,%p)\n",
- r->dest.x, r->dest.y);
- 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.Reversing the Direction of a Path
-
-This turned out to be more difficult than I thought at first. The
-trickiness was due to the fact that closed paths must remain closed,
-etc.
-
-We need three subroutines:
-*/
-
-static struct segment *SplitPath(); /* break a path at any point */
-static struct segment *DropSubPath(); /* breaks a path after first sub-path */
-static struct segment *ReverseSubPath(); /* reverses a single sub-path */
-
-/*
-:h3.Reverse() - User Operator to Reverse a Path
-
-This operator reverses the entire path.
-*/
-
-struct segment *Reverse(p)
- register struct segment *p; /* full path to reverse */
-{
- register struct segment *r; /* output path built here */
- register struct segment *nextp; /* contains next sub-path */
-
- IfTrace1((MustTraceCalls),"Reverse(%z)\n", p);
-
- if (p == NULL)
- return(NULL);
-
- ARGCHECK(!ISPATHANCHOR(p), "Reverse: invalid path", p, NULL, (0), struct segment *);
-
- if (p->type == TEXTTYPE)
- p = CoerceText(p);
- p = UniquePath(p);
-
- r = NULL;
-
- do {
- nextp = DropSubPath(p);
- p = ReverseSubPath(p);
- r = Join(p, r);
- p = nextp;
-
- } while (p != NULL);
-
- return(r);
-}
-
-/*
-:h4.ReverseSubPath() - Subroutine to Reverse a Single Sub-Path
-*/
-
-static struct segment *ReverseSubPath(p)
- register struct segment *p; /* input path */
-{
- register struct segment *r; /* reversed path will be created here */
- register struct segment *nextp; /* temporary variable used in loop */
- register int wasclosed; /* flag, path was closed */
-
- if (p == NULL)
- return(NULL);
-
- wasclosed = ISCLOSED(p->flag);
- r = NULL;
-
- do {
-/*
-First we reverse the direction of this segment and clean up its flags:
-*/
- p->dest.x = - p->dest.x; p->dest.y = - p->dest.y;
- p->flag &= ~(ISCLOSED(ON) | LASTCLOSED(ON));
-
- switch (p->type) {
-
- case LINETYPE:
- case MOVETYPE:
- break;
-
- case CONICTYPE:
- {
-/*
-The logic of this is that the new M point (stored relative to the new
-beginning) is (M - C). However, C ("dest") has already been reversed
-So, we add "dest" instead of subtracting it:
-*/
- register struct conicsegment *cp = (struct conicsegment *) p;
-
- cp->M.x += cp->dest.x; cp->M.y += cp->dest.y;
- }
- break;
-
- case BEZIERTYPE:
- {
- register struct beziersegment *bp = (struct beziersegment *) p;
-
- bp->B.x += bp->dest.x; bp->B.y += bp->dest.y;
- bp->C.x += bp->dest.x; bp->C.y += bp->dest.y;
- }
- break;
-
- case HINTTYPE:
- {
- register struct hintsegment *hp = (struct hintsegment *) p;
-
- hp->ref.x = -hp->ref.x; hp->ref.y = -hp->ref.y;
- }
- break;
-
- default:
- abort("Reverse: bad path segment");
- }
-/*
-We need to reverse the order of segments too, so we break this segment
-off of the input path, and tack it on the front of the growing path
-in 'r':
-*/
- nextp = p->link;
- p->link = NULL;
- p->last = p;
- if (r != NULL)
- CONCAT(p,r); /* leaves result in 'p'... not what we want */
- r = p;
- p = nextp; /* advance to next segment in input path */
-
- } while (p != NULL);
-
- if (wasclosed)
- r = ClosePath(r);
-
- return(r);
-}
-
-/*
-:h4.DropSubPath() - Drops the First Sub-Path Off a Path
-
-This subroutine returns the remaining sub-path(s). While doing so, it
-breaks the input path after the first sub-path so that a pointer to
-the original path now contains the first sub-path only.
-*/
-
-static struct segment *DropSubPath(p0)
- register struct segment *p0; /* original path */
-{
- register struct segment *p; /* returned remainder here */
-
- for (p = p0; p->link != NULL; p = p->link) {
- if (p->link->type == MOVETYPE)
- break;
- }
-
- return(SplitPath(p0, p));
-}
-
-static struct segment *SplitPath(anchor, before)
- register struct segment *anchor;
- register struct segment *before;
-{
- register struct segment *r;
-
- if (before == anchor->last)
- return(NULL);
-
- r = before->link;
- r->last = anchor->last;
- anchor->last = before;
- before->link = NULL;
-
- return(r);
-}
-
-
-/*
-:h3.ReverseSubPaths() - Reverse the Direction of Sub-paths Within a Path
-
-This user operator reverses the sub-paths in a path, but leaves the
-'move' segments unchanged. It builds on top of the subroutines
-already established.
-*/
-
-struct segment *ReverseSubPaths(p)
- register struct segment *p; /* input path */
-{
- register struct segment *r; /* reversed path will be created here */
- register struct segment *nextp; /* temporary variable used in loop */
- int wasclosed; /* flag; subpath was closed */
- register struct segment *nomove; /* the part of sub-path without move segment */
- struct fractpoint delta;
-
- IfTrace1((MustTraceCalls),"ReverseSubPaths(%z)\n", p);
-
- if (p == NULL)
- return(NULL);
-
- ARGCHECK(!ISPATHANCHOR(p), "ReverseSubPaths: invalid path", p, NULL, (0), struct segment *);
-
- if (p->type == TEXTTYPE)
- p = CoerceText(p);
- if (p->type != MOVETYPE)
- p = JoinSegment(NULL, MOVETYPE, 0, 0, p);
-
- p = UniquePath(p);
-
- r = NULL;
-
- for (; p != NULL;) {
- nextp = DropSubPath(p);
- wasclosed = ISCLOSED(p->flag);
- if (wasclosed)
- UnClose(p);
-
- nomove = SplitPath(p, p);
- r = Join(r, p);
-
- PathDelta(nomove, &delta);
-
- nomove = ReverseSubPath(nomove);
- p->dest.x += delta.x;
- p->dest.y += delta.y;
- if (nextp != NULL) {
- nextp->dest.x += delta.x;
- nextp->dest.y += delta.y;
- }
- if (wasclosed) {
- nomove = ClosePath(nomove);
- nextp->dest.x -= delta.x;
- nextp->dest.y -= delta.y;
- }
- r = Join(r, nomove);
- p = nextp;
-
- }
-
- return(r);
-}
-
-static UnClose(p0)
- register struct segment *p0;
-{
- register struct segment *p;
-
- for (p=p0; p->link->link != NULL; p=p->link) { ; }
-
- if (!LASTCLOSED(p->link->flag))
- abort("UnClose: no LASTCLOSED");
-
- Free(SplitPath(p0, p));
- p0->flag &= ~ISCLOSED(ON);
-}
-
-/*
-: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(p0, S)
- register struct segment *p0; /* path to transform */
- register 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:
- IfTrace1(TRUE,"path = %z\n", p);
- 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(p, pt)
- register struct segment *p; /* input path */
- register 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 */
-
- 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;
-}
-
-/*
-:h3.BoundingBox() - Produce a Bounding Box Path
-
-This function is called by image code, when we know the size of the
-image in pels, and need to get a bounding box path that surrounds it.
-The starting/ending handle is in the lower right hand corner.
-*/
-struct segment *BoundingBox(h, w)
- register pel h,w; /* size of box */
-{
- register struct segment *path;
-
- path = PathSegment(LINETYPE, -TOFRACTPEL(w), 0);
- path = JoinSegment(NULL, LINETYPE, 0, -TOFRACTPEL(h), path);
- path = JoinSegment(NULL, LINETYPE, TOFRACTPEL(w), 0, path);
- path = ClosePath(path);
-
- return(path);
-}
-
-/*
-:h2.Querying Locations and Paths
-
-:h3.QueryLoc() - Return the X,Y of a Locition
-*/
-
-void QueryLoc(P, S, xP, yP)
- register struct segment *P; /* location to query, not consumed */
- register struct XYspace *S; /* XY space to return coordinates in */
- register double *xP,*yP; /* coordinates returned here */
-{
- IfTrace4((MustTraceCalls),"QueryLoc(P=%z, S=%z, (%x, %x))\n",
- P, S, xP, yP);
- 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);
-}
-/*
-:h3.QueryPath() - Find Out the Type of Segment at the Head of a Path
-
-This is a very simple routine that looks at the first segment of a
-path and tells the caller what it is, as well as returning the control
-point(s) of the path segment. Different path segments have different
-number of control points. If the caller knows that the segment is
-a move segment, for example, he only needs to pass pointers to return
-one control point.
-*/
-
-void QueryPath(path, typeP, Bp, Cp, Dp, fP)
- register struct segment *path; /* path to check */
- register int *typeP; /* return the type of path here */
- register struct segment **Bp; /* return location of first point */
- register struct segment **Cp; /* return location of second point */
- register struct segment **Dp; /* return location of third point */
- register double *fP; /* return Conic sharpness */
-{
- register int coerced = FALSE; /* did I coerce a text path? */
-
- IfTrace3((MustTraceCalls), "QueryPath(%z, %x, %x, ...)\n",
- path, typeP, Bp);
- if (path == NULL) {
- *typeP = -1;
- return;
- }
- if (!ISPATHANCHOR(path)) {
- ArgErr("QueryPath: arg not a valid path", path, NULL);
- }
- if (path->type == TEXTTYPE) {
- path = CoerceText(path);
- coerced = TRUE;
- }
-
- switch (path->type) {
-
- case MOVETYPE:
- *typeP = 0;
- *Bp = PathSegment(MOVETYPE, path->dest.x, path->dest.y);
- break;
-
- case LINETYPE:
- *typeP = (LASTCLOSED(path->flag)) ? 4 : 1;
- *Bp = PathSegment(MOVETYPE, path->dest.x, path->dest.y);
- break;
-
- case CONICTYPE:
- {
- register struct conicsegment *cp = (struct conicsegment *) path;
-
- *typeP = 2;
- *Bp = PathSegment(MOVETYPE, cp->M.x, cp->M.y);
- *Cp = PathSegment(MOVETYPE, cp->dest.x, cp->dest.y);
- *fP = cp->roundness;
- }
- break;
-
- case BEZIERTYPE:
- {
- register struct beziersegment *bp = (struct beziersegment *) path;
-
- *typeP = 3;
- *Bp = PathSegment(MOVETYPE, bp->B.x, bp->B.y);
- *Cp = PathSegment(MOVETYPE, bp->C.x, bp->C.y);
- *Dp = PathSegment(MOVETYPE, bp->dest.x, bp->dest.y);
- }
- break;
-
- case HINTTYPE:
- *typeP = 5;
- break;
-
- default:
- abort("QueryPath: unknown segment");
- }
- if (coerced)
- KillPath(path);
-}
-/*
-:h3.QueryBounds() - Return the Bounding Box of a Path
-
-Returns the bounding box by setting the user's variables.
-*/
-
-void QueryBounds(p0, S, xminP, yminP, xmaxP, ymaxP)
- register struct segment *p0; /* object to check for bound */
- struct XYspace *S; /* coordinate space of returned values */
- double *xminP,*yminP; /* lower left hand corner (set by routine) */
- double *xmaxP,*ymaxP; /* upper right hand corner (set by routine) */
-{
- register struct segment *path; /* loop variable for path segments */
- register fractpel lastx,lasty; /* loop variables: previous endingpoint */
- register fractpel x,y; /* loop variables: current ending point */
- struct fractpoint min; /* registers to keep lower left hand corner */
- struct fractpoint max; /* registers to keep upper right hand corner */
- int coerced = FALSE; /* we have coerced the path from another object */
- double x1,y1,x2,y2,x3,y3,x4,y4; /* corners of rectangle in space X */
-
- IfTrace2((MustTraceCalls), "QueryBounds(%z, %z,", p0, S);
- IfTrace4((MustTraceCalls), " %x, %x, %x, %x)\n",
- xminP, yminP, xmaxP, ymaxP);
- if (S->type != SPACETYPE) {
- ArgErr("QueryBounds: bad XYspace", S, NULL);
- return;
- }
-
- min.x = min.y = max.x = max.y = 0;
- if (p0 != NULL) {
- if (!ISPATHANCHOR(p0)) {
- switch(p0->type) {
- case STROKEPATHTYPE:
- /* replaced DupStrokePath() with Dup() 3-26-91 PNM */
- p0 = (struct segment *) DoStroke(Dup(p0));
- /* no break here, we have a region in p0 */
- case REGIONTYPE:
- p0 = RegionBounds(p0);
- break;
-
- case PICTURETYPE:
- p0 = PictureBounds(p0);
- break;
-
- default:
- ArgErr("QueryBounds: bad object", p0, NULL);
- return;
- }
- coerced = TRUE;
- }
- if (p0->type == TEXTTYPE) {
- /* replaced CopyPath() with Dup() 3-26-91 PNM */
- p0 = (struct segment *)CoerceText(Dup(p0)); /* there are faster ways */
- coerced = TRUE;
- }
- if (p0->type == MOVETYPE) {
- min.x = max.x = p0->dest.x;
- min.y = max.y = p0->dest.y;
- }
- }
- lastx = lasty = 0;
-
- for (path = p0; path != NULL; path = path->link) {
-
- x = lastx + path->dest.x;
- y = lasty + path->dest.y;
-
- switch (path->type) {
-
- case LINETYPE:
- break;
-
- case CONICTYPE:
- {
- register struct conicsegment *cp = (struct conicsegment *) path;
- register fractpel Mx = lastx + cp->M.x;
- register fractpel My = lasty + cp->M.y;
- register fractpel deltax = 0.5 * cp->roundness * cp->dest.x;
- register fractpel deltay = 0.5 * cp->roundness * cp->dest.y;
- register fractpel Px = Mx - deltax;
- register fractpel Py = My - deltay;
- register fractpel Qx = Mx + deltax;
- register fractpel Qy = My + deltay;
-
-
- if (Mx < min.x) min.x = Mx;
- else if (Mx > max.x) max.x = Mx;
- if (My < min.y) min.y = My;
- else if (My > max.y) max.y = My;
-
- if (Px < min.x) min.x = Px;
- else if (Px > max.x) max.x = Px;
- if (Py < min.y) min.y = Py;
- else if (Py > max.y) max.y = Py;
-
- if (Qx < min.x) min.x = Qx;
- else if (Qx > max.x) max.x = Qx;
- if (Qy < min.y) min.y = Qy;
- else if (Qy > max.y) max.y = Qy;
- }
- break;
-
-
- case MOVETYPE:
- /*
- * We can't risk adding trailing Moves to the
- * bounding box:
- */
- if (path->link == NULL)
- goto done; /* God forgive me */
- break;
-
- case BEZIERTYPE:
- {
- register struct beziersegment *bp = (struct beziersegment *) path;
- register fractpel Bx = lastx + bp->B.x;
- register fractpel By = lasty + bp->B.y;
- register fractpel Cx = lastx + bp->C.x;
- register fractpel Cy = lasty + bp->C.y;
-
- if (Bx < min.x) min.x = Bx;
- else if (Bx > max.x) max.x = Bx;
- if (By < min.y) min.y = By;
- else if (By > max.y) max.y = By;
-
- if (Cx < min.x) min.x = Cx;
- else if (Cx > max.x) max.x = Cx;
- if (Cy < min.y) min.y = Cy;
- else if (Cy > max.y) max.y = Cy;
- }
- break;
-
- case HINTTYPE:
- break;
- default:
- abort("QueryBounds: unknown type");
- }
-
- if (x < min.x) min.x = x;
- else if (x > max.x) max.x = x;
- if (y < min.y) min.y = y;
- else if (y > max.y) max.y = y;
-
- lastx = x; lasty = y;
- }
-done:
- UnConvert(S, &min, &x1, &y1);
- UnConvert(S, &max, &x4, &y4);
- x = min.x; min.x = max.x; max.x = x;
- UnConvert(S, &min, &x2, &y2);
- UnConvert(S, &max, &x3, &y3);
-
- *xminP = *xmaxP = x1;
- if (x2 < *xminP) *xminP = x2;
- else if (x2 > *xmaxP) *xmaxP = x2;
- if (x3 < *xminP) *xminP = x3;
- else if (x3 > *xmaxP) *xmaxP = x3;
- if (x4 < *xminP) *xminP = x4;
- else if (x4 > *xmaxP) *xmaxP = x4;
-
- *yminP = *ymaxP = y1;
- if (y2 < *yminP) *yminP = y2;
- else if (y2 > *ymaxP) *ymaxP = y2;
- if (y3 < *yminP) *yminP = y3;
- else if (y3 > *ymaxP) *ymaxP = y3;
- if (y4 < *yminP) *yminP = y4;
- else if (y4 > *ymaxP) *ymaxP = y4;
-
- if (coerced)
- Destroy(p0);
-}
-/*
-:h3.BoxPath()
-*/
-struct segment *BoxPath(S, h, w)
- struct XYspace *S;
- int h,w;
-{
- struct segment *path;
-
- path = Join( Line(ILoc(S, w, 0)), Line(ILoc(S, 0, h)) );
- path = JoinSegment(path, LINETYPE, -path->dest.x, -path->dest.y, NULL);
- return(ClosePath(path));
-}
-
-/*
-:h3.DropSegment() - Drop the First Segment in a Path
-
-This routine takes the path and returns a new path that is one segment
-shorter. It can be used in conjunction with QueryPath(), for example,
-to ask about an entire path.
-*/
-
-struct segment *DropSegment(path)
- register struct segment *path;
-{
- IfTrace1((MustTraceCalls),"DropSegment(%z)\n", path);
- if (path != NULL && path->type == STROKEPATHTYPE)
- path = CoercePath(path);
- ARGCHECK((path == NULL || !ISPATHANCHOR(path)),
- "DropSegment: arg not a non-null path", path, path, (0), struct segment *);
- if (path->type == TEXTTYPE)
- path = CoerceText(path);
- path = UniquePath(path);
-
- POP(path);
- return(path);
-}
-/*
-:h3.HeadSegment() - Return the First Segment in a Path
-
-This routine takes the path and returns a new path consists of the
-first segment only.
-*/
-
-struct segment *HeadSegment(path)
- register struct segment *path; /* input path */
-{
- IfTrace1((MustTraceCalls),"HeadSegment(%z)\n", path);
- if (path == NULL)
- return(NULL);
- if (path->type == STROKEPATHTYPE)
- path = CoercePath(path);
- ARGCHECK(!ISPATHANCHOR(path), "HeadSegment: arg not a path", path, path, (0), struct segment *);
- if (path->type == TEXTTYPE)
- path = CoerceText(path);
- path = UniquePath(path);
-
- if (path->link != NULL)
- KillPath(path->link);
- path->link = NULL;
- path->last = path;
- return(path);
-}
-
-/*
-:h2.Path Debug Routines
-
-:h3.DumpPath() - Display a Path on the Trace File
-*/
-
-void DumpPath(p)
- register struct segment *p;
-{
- register fractpel x,y;
- register fractpel lastx,lasty;
- double roundness;
-
- IfTrace1(TRUE,"Dumping path, anchor=%x:\n", p);
- lastx = lasty = 0;
-
- for (;p != NULL; p=p->link) {
-
- IfTrace0(TRUE,". ");
- x = p->dest.x;
- y = p->dest.y;
- switch (p->type) {
-
- case LINETYPE:
- IfTrace1(TRUE,". line<%x> to", (long) p->flag);
- IfTrace4(TRUE," (%p,%p), delta=(%p,%p)",
- x + lastx, y + lasty, x, y);
- break;
-
- case MOVETYPE:
- IfTrace1(TRUE,"MOVE<%x> to", (long) p->flag);
- IfTrace4(TRUE,"(%p,%p), delta=(%p,%p)",
- x + lastx, y + lasty, x, y);
- break;
-
- case CONICTYPE:
- {
- register struct conicsegment *cp = (struct conicsegment *) p;
-
- roundness = cp->roundness;
- IfTrace2(TRUE, ". conic to (%p,%p),",
- x + lastx, y + lasty);
- IfTrace3(TRUE," M=(%p,%p), r=%f", cp->M.x + lastx,
- cp->M.y + lasty, &roundness);
- }
- break;
-
- case BEZIERTYPE:
- {
- register struct beziersegment *bp = (struct beziersegment *) p;
-
- IfTrace4(TRUE,". bezier to (%p,%p), B=(%p,%p)",
- x + lastx, y + lasty,
- bp->B.x + lastx, bp->B.y + lasty);
- IfTrace2(TRUE, ", C=(%p,%p)",
- bp->C.x + lastx, bp->C.y + lasty);
- }
- break;
-
- case HINTTYPE:
- {
- register struct hintsegment *hp = (struct hintsegment *) p;
-
- IfTrace4(TRUE,". hint ref=(%p,%p), width=(%p,%p)",
- hp->ref.x + lastx, hp->ref.y + lasty,
- hp->width.x, hp->width.y);
- IfTrace4(TRUE, ", %c %c %c %c",
- hp->orientation, hp->hinttype,
- hp->adjusttype, hp->direction);
- IfTrace1(TRUE, ", %ld", (long) hp->label);
- }
- break;
-
- case TEXTTYPE:
- DumpText(p);
- break;
-
- default:
- IfTrace0(TRUE, "bad path segment?");
- }
- IfTrace1(TRUE," at %x\n", p);
- lastx += x;
- lasty += y;
- }
-}
-
-
projects / rdpsrv / blobdiff