Import upstream version 5.3.

[mup] / mup / mup / prntmisc.c

/* Copyright (c) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006 by Arkkra Enterprises */
/* All rights reserved */

/* functions for printing endings, pedal marks, phrase marks, etc */

#include "defines.h"
#include "structs.h"
#include "globals.h"

/* width of tapered curve at endpoint relative to maximum width */
#define TAPERWID        (0.4)


/*
 * Define a structure for storing points of a curve, whether generated (like
 * for phrase marks) or user-specified.  It also stores information used in
 * calculating Bezier curves that will be drawn between each pair of
 * neighboring points.  The "control points" are points 1 and 2 for the
 * Bezier curve going from this point to the next point.  These structures
 * get their x and y filled in from CURVE or CRVLIST structures.
 */
struct CURVEINFO {
        float x, y;     /* point's coords */
        float len;      /* length of line segment from here to next point */
        float ang;      /* angle between the 2 segments at this point */
        int bend;       /* bend direction at point: 1=clockwise, -1=counter */
        float slopetan; /* slope of line "tangent" to this point if axes are */
                        /* rotated such that segment starting here is horiz. */
        float x1, y1;   /* control point 1 for segment starting at this point */
        float x2, y2;   /* control point 2 for segment starting at this point */
};

/* static functions */
static void do_endings P((struct MAINLL *first_p, struct MAINLL *last_p,
                char *endlabel, int carryout));
static void draw_ending P((int staffno, double ry, struct MAINLL *first_p,
                struct MAINLL *last_p, char *endlabel, int carryout));
static void pr_endlabel P((double x, double y, char *label));
static void pr_end_line P((double begin_x, double end_x, double y,
                int carryout));
static int is_top_visible_in_range P((int staffno, int top));
static void calccurve P((struct CURVEINFO v[], int num));
static void findcontrol P((struct CURVEINFO v[], int num));

\f

/* whenever we hit a FEED, draw any endings associated with the score */

void
pr_endings(main_feed_p)

struct MAINLL *main_feed_p;     /* FEED */

{
        static char *endlabel = (char *) 0;/* ending label if had to carry over
                                         * to next score */
        struct MAINLL *curr_p;          /* where we are in main list */
        struct MAINLL *first_p;         /* where an ending begins */
        struct MAINLL *last_bar_p = 0;  /* points to last bar on score so far */


        debug(512, "pr_endings");

        first_p = (struct MAINLL *) 0;

        /* go through the entire score line. For every set of measures that have
         * endings, draw them. */
        for (curr_p = main_feed_p->next; curr_p != (struct MAINLL *) 0;
                                        curr_p = curr_p->next) {

                /* go just to end of current score */
                if (curr_p->str == S_FEED) {
                        break;
                }

                /* if there is a pseudo bar, see if it is in an ending */
                if (curr_p->str == S_CLEFSIG) {
                        if (curr_p->u.clefsig_p->bar_p != (struct BAR *) 0 &&
                                        curr_p->u.clefsig_p->bar_p->endingloc
                                        != NOITEM) {
                                first_p = curr_p;
                                endlabel = curr_p->u.clefsig_p->bar_p->endinglabel;
                        }
                        continue;
                }

                /* for each bar, check its endingloc and act accordingly */
                else if (curr_p->str == S_BAR) {

                        switch(curr_p->u.bar_p->endingloc) {

                        case ENDITEM:
                                if (first_p == (struct MAINLL *) 0) {
                                        pfatal("ending without beginning");
                                }
                                /*FALLTHRU*/
                        case NOITEM:
                                /* if we were doing an ending, we reached the
                                 * end of it, so handle it */
                                if (first_p != (struct MAINLL *) 0) {
                                        /* it doesn't seem like it should be
                                         * possible to get inside this IF for
                                         * the NOITEM case, but it doesn't
                                         * hurt anything to have to code as it
                                         * is, and I don't want to change it for
                                         * fear it would break some obscure
                                         * circumstance I've forgotten about */
                                        do_endings(first_p, curr_p, endlabel, NO);
                                        endlabel = (char *) 0;
                                        first_p = (struct MAINLL *) 0;
                                }
                                break;

                        case STARTITEM:
                                /* if we are also implictly ending a previous
                                 * ending, do that first. In any case, keep
                                 * track of where this ending begins. */
                                if (first_p != (struct MAINLL *) 0) {
                                        do_endings(first_p, curr_p,
                                                                endlabel, NO);
                                }

                                first_p = curr_p;
                                endlabel = curr_p->u.bar_p->endinglabel;

                                break;

                        case INITEM:
                                break;

                        default:
                                pfatal("bad endingloc value");
                                /*NOTREACHED*/
                                break;
                        }
                        last_bar_p = curr_p;
                }
        }

        /* we must be at the end of the score. If we are in the middle
         * of an ending, draw this score's portion of it now */
        if ( (first_p != (struct MAINLL *) 0)
                                && (last_bar_p != (struct MAINLL *) 0)) {
                do_endings(first_p, last_bar_p, endlabel,
                                last_bar_p->u.bar_p->endingloc
                                == INITEM ? YES : NO);
        }
}
\f

/* now that we have identified an ending, print it above each
 * staff that is supposed to get endings */

static void
do_endings(first_p, last_p, endlabel, carryout)

struct MAINLL *first_p; /* where to begin drawing endings */
struct MAINLL *last_p;  /* where to end the endings */
char *endlabel;         /* if ending has a label, this will be
                         * that label, otherwise NULL */
int carryout;           /* YES if will carry over to next staff */

{
        struct MARKCOORD *markc_p;      /* info about where to draw ending */


        /* for each staff that is supposed to have endings,
         * draw the ending */
        if (first_p->str == S_CLEFSIG) {
                /* pseudo-bar */
                markc_p = first_p->u.clefsig_p->bar_p->ending_p;
        }
        else {
                /* normal bar */
                markc_p = first_p->u.bar_p->ending_p;
        }

        /* if this is an endending and the bar line at the end is an ordinary
         * bar or an invisbar, then set the carryout flag so that the final
         * vertical line doesn't get drawn. */
        if (last_p->u.bar_p->endingloc == ENDITEM
                                && (last_p->u.bar_p->bartype == SINGLEBAR ||
                                last_p->u.bar_p->bartype == INVISBAR)) {
                /* But if this is the very end of the piece,
                 * then we *do* want to draw the final vertical */
                struct MAINLL* mll_p;
                for (mll_p = last_p->next; mll_p != 0; mll_p = mll_p->next) {
                        if (mll_p->str == S_STAFF) {
                                break;
                        }
                }
                if (mll_p != 0) {
                        carryout = YES;
                }
        }

        /* draw an ending for each item in MARKCOORD list */
        for (   ; markc_p != (struct MARKCOORD *) 0; markc_p = markc_p->next) {
                draw_ending(markc_p->staffno, (double) markc_p->ry,
                                        first_p, last_p, endlabel, carryout);
        }
}
\f

/* draw ending marks over specified staff */

static void
draw_ending(staffno, ry, first_p, last_p, endlabel, carryout)

int staffno;            /* which staff to draw over */
double ry;              /* relative y */
struct MAINLL *first_p; /* draw ending starting from here */
struct MAINLL *last_p;  /* ending end here */
char *endlabel;         /* if has label, this is the label, else is NULL */
int carryout;           /* if YES, will carry over to next score */

{
        float begin_x;          /* x coord of beginning and end of ending */
        float y;                /* vertical location of ending */


        /* first_p can point to either a CLEFSIG (if carrying over an
         * ending) or to a BAR. Find appropriate x coordinate */
        switch (first_p->str) {

        case S_CLEFSIG:
                begin_x = first_p->u.clefsig_p->bar_p->c[AX];
                break;

        case S_BAR:
                begin_x = first_p->u.bar_p->c[AX];
                break;

        default:
                /* shut up compilers that erroneously thinks begin_x
                 * could get used without being set. */
                begin_x = 0.0;
                pfatal("bad struct type passed to draw_ending");
                /*NOTREACHED*/
                break;
        }

        /* get vertical position */
        y = Staffs_y[staffno] + ry;

        /* now we know where to put it, so draw it */
        do_linetype(L_NORMAL);

        /* print the beginning vertical and label now if appropriate */
        if (endlabel != (char *) 0) {
                pr_endlabel( (double) begin_x, (double) y, endlabel);
        }

        pr_end_line ( (double) begin_x, (double) last_p->u.bar_p->c[AX],
                                                (double) y, carryout);
}
\f

/* print label at the beginning of an ending, along with the vertical line
 * to the left of the label */

static void
pr_endlabel(x, y, label)

double x;       /* coordinate of beginning of ending */
double y;
char *label;    /* the ending label or NULL */

{
        /* if there is a label, this is the beginning of an ending, so
         * print a vertical line followed by the label */
        if (label != (char *) 0) {
                x += (2.0 * STDPAD);
                draw_line(x, y + STDPAD, x, y + ENDINGHEIGHT - STDPAD);
                pr_string(x + (3.0 * STDPAD), y + (2.0 * STDPAD), label, J_LEFT,
                                        (char *) 0, -1);
        }
}
\f

/* print horizontal line above ending, possibly with ending vertical line */

static void
pr_end_line(begin_x, end_x, y, carryout)

double begin_x; /* horizontal coordinates of ending line */
double end_x;
double y;       /* vertical position */
int carryout;   /* if YES, continued on next score, so no end vertical */

{
        /* adjust to allow a little padding */
        begin_x += (2.0 * STDPAD);
        end_x -= (2.0 * STDPAD);
        y += ENDINGHEIGHT - STDPAD;

        /* draw the horizontal line above the ending */
        draw_line(begin_x, y, end_x, y);

        /* if the ending ends here, draw vertical line at end */
        if (carryout == NO) {
                draw_line(end_x, y, end_x, y - ENDINGHEIGHT + (2.0 * STDPAD));
        }
}
\f

/* function to tell whether a given staff should have ending put on it. Returns
 * YES if it does, NO if it doesn't */

int
has_ending(staffno)

int staffno;            /* which staff to check */

{
        register int s;         /* index through barstlist */


        /* if staff is invisible, ending doesn't count */
        if ( svpath(staffno, VISIBLE)->visible == NO) {
                return(NO);
        }
 
        switch ( Score.endingstyle ) {

        case ENDING_TOP:
                /* if there is an earlier staff that is visible, then no
                 * ending on this one. Otherwise there is */
                return( is_top_visible_in_range(staffno, 1) );

        case ENDING_BARRED:
                /* go through barstlist. If this
                 * staff is within a range and any staffs above it are
                 * invisible at the moment, it gets an ending. */
                for (s = 0; s < Score.nbarst;  s++) {

                        if ((staffno >= Score.barstlist[s].top) && (staffno
                                                <= Score.barstlist[s].bottom)) {

                                return( is_top_visible_in_range(staffno,
                                                Score.barstlist[s].top));
                        }
                }

                /* if wasn't in any of the ranges, then it must be barred
                 * by itself */
                return(YES);

        case ENDING_GROUPED:
                /* go through brace and bracket list. If the top visible
                 * of any of them match the given score, it gets an ending */
                for (s = 0; s < Score.nbrace; s++) {

                        if ((staffno >= Score.bracelist[s].topstaff)
                                        && (staffno
                                        <= Score.bracelist[s].botstaff)) {

                                return( is_top_visible_in_range(staffno,
                                        Score.bracelist[s].topstaff));
                        }
                }

                for (s = 0; s < Score.nbrack; s++) {

                        if ((staffno >= Score.bracklist[s].topstaff)
                                        && (staffno
                                        <= Score.bracklist[s].botstaff)) {

                                return( is_top_visible_in_range(staffno,
                                        Score.bracklist[s].topstaff));
                        }
                }

                /* wasn't in either list, so it probably shouldn't have an
                 * ending. However, if it happens to be the top staff, we
                 * better put one on anyway, because the top staff should
                 * always get an ending. */
                return( is_top_visible_in_range(staffno, 1) );

        default:
                pfatal("unknown endingstyle");
        }
        /*NOTREACHED*/
        return(NO);
}
\f

/* given a staff number and the top of a range of staffs, return YES if the
 * given staff is the top visible staff in the range, otherwise return NO.
 * Assume that staffno itself is for a visible staff */

int
is_top_visible_in_range(staffno, top)

int staffno;    /* which staff to check */
int top;        /* top of range to check */

{
        for (staffno--; staffno >= top; staffno--) {
                if ( svpath(staffno, VISIBLE)->visible == YES) {
                        /* something above it is visible */
                        return(NO);
                }
        }
        return(YES);
}
\f

/* functions for printing piano pedals marks */

/* keep track of where last coordinate of pedal mark was for each staff.
 * If no pedal currently on a staff, set to 0.0 */
static float Last_ped_x[MAXSTAFFS + 1];
static float Last_ped_y[MAXSTAFFS + 1];


/* return the distance to offset the 'P' of "Ped." from the group X to
 * center it on the group. The first time called, calculate the width,
 * after that, just return it */

double
ped_offset()

{
        static double width = 0.0;
        char pstr[4];

        if (width == 0.0) {
                /* first time, make string with just P and get width of that */
                (void) strncpy(pstr, Ped_start, 3);
                pstr[3] = '\0';
                width = strwidth(pstr) / 2.0;
        }
        return(width);
}
\f

/* when we encounter a ST_PEDAL, print the pedal character and save the
 * east boundary as the last pedal x value, for later use. If is endped,
 * set this last pedal x value to 0.0 */

void
pr_ped_char(stuff_p, staffno)

struct STUFF *stuff_p;          /* pedal info */
int staffno;                    /* which staff */

{
        int font;
        int size;
        char *string;
        int pedstyle;   /* P_PEDSTAR or P_ALTPEDSTAR or P_LINE */
        int pedchar;    /* pedal music character code */
        double overlap; /* to avoid tiny gaps in pedal line due to roundoff */
        char *adj_pstart;       /* Ped_start adjusted for Staffscale */
        char *adj_pstop;        /* Ped_stop adjusted for Staffscale */


        if (stuff_p->string == (char *) 0) {
                /* must be a pedal mark carried over from a previous
                 * score. Just need to save away the coordinate. */
                Last_ped_x[staffno] = stuff_p->c[AX];
                Last_ped_y[staffno] = stuff_p->c[AY];
                return;
        }

        pedstyle = svpath(staffno, PEDSTYLE)->pedstyle;

        /* extract the pedal character to be printed */
        font = stuff_p->string[0];
        size = stuff_p->string[1];
        string = stuff_p->string + 2;
        pedchar = next_str_char(&string, &font, &size) & 0xff;

        /* overlap lines just slightly with pedal characters, to compensate
         * for any rounding of the bounding box which might cause a tiny
         * gap to appear between the line and the pedal character */
        overlap = Stdpad / 3.0;

        /* draw line from previous pedal character, if any, to this one */
        if (pedstyle == P_LINE && Last_ped_x[staffno] != 0.0) {
                if (stuff_p->c[AW] + overlap - Last_ped_x[staffno] > 0) {
                        do_linetype(L_NORMAL);
                        draw_line(Last_ped_x[staffno], stuff_p->c[AY],
                                stuff_p->c[AW] + overlap, stuff_p->c[AY]);
                }
        }

        Last_ped_y[staffno] = stuff_p->c[AY];

        switch (pedchar) {

        case C_BEGPED:
                if (Last_ped_x[staffno] != 0.0) {
                        /* This used to be a pfatal, because it should
                         * never happen. But it can happen
                         * due to user error: if user does something like
                         *      pedal ....
                         *      repeatend
                         *      ....
                         *      pedal ...
                         *      repeatend
                         * Having two repeatends without an intervening
                         * repeatstart is illegal.
                         * It has never shown up as a true pfatal in millions
                         * of test runs, so if it is ever hit,
                         * it's probably the user error case.
                         */
                        ufatal("got begin pedal when already doing pedal, staff %d", staffno);
                }
                Last_ped_x[staffno] = stuff_p->c[AE] - overlap;
                break;
                
        case C_PEDAL:
                if (Last_ped_x[staffno] == 0.0) {
                        pfatal("got pedal without begped, staff %d", staffno);
                }
                Last_ped_x[staffno] = stuff_p->c[AE] - overlap;
                break;

        case C_ENDPED:
                if (Last_ped_x[staffno] == 0.0) {
                        pfatal("got endped without begped, staff %d", staffno);
                }
                Last_ped_x[staffno] = 0.0;
                break;
                
        default:
                pfatal("bad character 0x%x in pedal string", pedchar);
                /*NOTREACHED*/
                break;
        }

        /* now print the appropriate pedal character */
        if (pedstyle == P_LINE) {
                /* We used to print the pedal characters from FONT_MUSIC,
                 * but Ghostscript sometimes misaligned them with the
                 * pedal lines, so now we draw the characters "manually."
                 */
                do_linetype(L_NORMAL);
                switch (pedchar) {
                case C_BEGPED:
                        draw_line(stuff_p->c[AX], stuff_p->c[AN],
                                stuff_p->c[AX], stuff_p->c[AY]);
                        draw_line(stuff_p->c[AX], stuff_p->c[AY],
                                stuff_p->c[AE] + overlap, stuff_p->c[AY]);
                        break;
                case C_PEDAL:
                        draw_line(stuff_p->c[AW], stuff_p->c[AY],
                                stuff_p->c[AX], stuff_p->c[AN]);
                        draw_line(stuff_p->c[AX], stuff_p->c[AN],
                                stuff_p->c[AE], stuff_p->c[AY]);
                        break;
                case C_ENDPED:
                        draw_line(stuff_p->c[AW] - overlap, stuff_p->c[AY],
                                stuff_p->c[AX], stuff_p->c[AY]);
                        draw_line(stuff_p->c[AX], stuff_p->c[AN],
                                stuff_p->c[AX], stuff_p->c[AY]);
                        break;

                }
                        
        }
        else {
                /* If we need to adjust for Staffscale, make a temp copy */
                if (Staffscale != 1.0) {
                        adj_pstart = copy_string(Ped_start + 2,
                                (int) Ped_start[0],
                                adj_size( (int) Ped_start[1], Staffscale,
                                (char *) 0, -1));
                        adj_pstop = copy_string(Ped_stop + 2,
                                (int) Ped_stop[0],
                                adj_size( (int) Ped_stop[1], Staffscale,
                                (char *) 0, -1));
                }
                else {
                        adj_pstart = Ped_start;
                        adj_pstop = Ped_stop;
                }

                /* In alt pedstar style, a PEDAL is treated exactly like
                 * a BEGPED, so pretend that's what we got. */
                if (pedstyle == P_ALTPEDSTAR && pedchar == C_PEDAL) {
                        pedchar = C_BEGPED;
                }

                switch (pedchar) {

                case C_BEGPED:
                        pr_string(stuff_p->c[AX] - (strwidth(adj_pstart) / 2.0),
                                        stuff_p->c[AY], adj_pstart,
                                        J_CENTER, stuff_p->inputfile,
                                        stuff_p->inputlineno);
                        break;

                case C_PEDAL:
                        pr_string(stuff_p->c[AX] - strwidth(adj_pstop)
                                        - ped_offset() * Staffscale,
                                        stuff_p->c[AY], adj_pstop,
                                        J_RIGHT, stuff_p->inputfile,
                                        stuff_p->inputlineno);
                        pr_string(stuff_p->c[AX] - ped_offset() * Staffscale,
                                        stuff_p->c[AY], adj_pstart,
                                        J_LEFT, stuff_p->inputfile,
                                        stuff_p->inputlineno);
                        break;

                case C_ENDPED:
                        pr_string(stuff_p->c[AX] - (strwidth(adj_pstop) / 2.0),
                                        stuff_p->c[AY], adj_pstop,
                                        J_CENTER, stuff_p->inputfile,
                                        stuff_p->inputlineno);
                        break;

                default:
                        pfatal("bad character 0x%x in pedal string", pedchar);
                        /*NOTREACHED*/
                        break;
                }

                /* If we had to make a temp copy to account for Staffscale,
                 * free the temp copy. */
                if (Staffscale != 1.0) {
                        FREE(adj_pstart);
                        FREE(adj_pstop);
                }
        }
}
\f

/* when we hit a bar line, extend any pedal marks to the bar line. Since things
 * are stored in units of bars, easier to do this than keep track of the
 * entire length and have to worry about page feeds, etc. This is just for
 * normal bars, not pseudo-bars. They are handled separately. */

void
pr_ped_bar(mll_p, bar_p)

struct MAINLL *mll_p;   /* print pedal mark up to bar hangs off of here */
struct BAR *bar_p;      /* print pedal marks up to this bar */

{
        register int s;
        float endadj;           /* adjustment for endings */


        /* for each staff that has pedal marks pending, draw an extension
         * line to where this bar line is and reset Last_ped_x */
        for (s = 1; s <= Score.staffs; s++) {

                if (Last_ped_x[s] != 0.0) {

                        if (Last_ped_y[s] <= 0.0) {
                                pfatal("don't have y coordinate for drawing pedal mark");
                        }

                        endadj = 0.0;
                        if (svpath(s, PEDSTYLE)->pedstyle == P_LINE) {
                                do_linetype(L_NORMAL);
                                if (Ped_snapshot[0] == YES &&
                                                bar_p->endingloc == STARTITEM) {

                                        /* going into 2nd ending, so shorten
                                         * this pedal to not reach bar */
                                        endadj = (2.0 * STEPSIZE);
                                        /* if line length is positive,  
                                         * draw it */
                                        if (bar_p->c[AX] - endadj
                                                        > Last_ped_x[s]) {

                                                draw_line(Last_ped_x[s],
                                                        Last_ped_y[s],
                                                        bar_p->c[AX] - endadj,
                                                        Last_ped_y[s]);
                                        }
                                }
                                else {
                                        if (bar_p->c[AX] - STDPAD >
                                                        Last_ped_x[s]) {
                                                draw_line(Last_ped_x[s],
                                                                Last_ped_y[s],
                                                                bar_p->c[AX]
                                                                - STDPAD,
                                                                Last_ped_y[s]);
                                                endadj = -STDPAD;
                                        }
                                        else {
                                                endadj = -(bar_p->c[AX]
                                                        - Last_ped_x[s]);
                                        }
                                }
                        }

                        Last_ped_x[s] = bar_p->c[AX] + endadj;
                }
        }
        saveped(mll_p, bar_p);
}
\f

/* handle pedal going into endings. When we hit a first ending, save the
 * state of the pedal for all staffs. On subsequent endings in the set,
 * reset the pedal state to what it was at the beginning of the first ending.
 * At the endending, go back to normal operation. */

void
saveped(mll_p, bar_p)

struct MAINLL *mll_p;   /* bar is connected here */
struct BAR *bar_p;

{
        register int s;         /* staff index */


        if (mll_p == (struct MAINLL *) 0) {
                pfatal("null pointer in saveped");
        }

        if (bar_p->endingloc == STARTITEM) {

                if (Ped_snapshot[0] == YES) {

                        /* starting 2nd ending: restore pedal state as it was
                         * at beginning of first ending */
                        for (s = 1; s <= Score.staffs; s++) {
                                if (Ped_snapshot[s] == YES) {
                                        Last_ped_x[s] = bar_p->c[AX]
                                                        + (2.0 * STEPSIZE);
                                }
                                else {
                                        Last_ped_x[s] = 0.0;
                                }
                        }
                }

                else {
                        /* starting a set of endings,
                         * need to save pedal state at this
                         * point so we can carry it into subsequent endings */
                        for (s = 1; s <= Score.staffs; s++) {
                                /* set to YES if pedal is on */
                                Ped_snapshot[s] = (Last_ped_x[s] == 0.0 ? NO : YES);
                        }
                        /* make sure any remaining staffs are set to pedal off,
                         * in case user increases the number of staffs
                         * during the endings... */
                        for (   ; s <= MAXSTAFFS; s++) {
                                Ped_snapshot[s] = NO;
                        }

                        /* mark that we now have a snapshot */
                        Ped_snapshot[0] = YES;
                }
        }

        else if (bar_p->endingloc == ENDITEM) {
                /* at end of endings, discard snapshot of pedal states.
                 * However, we have to make sure this is really the end of
                 * endings, and not just a bar that was marked as end
                 * because the start of the next was moved from here to
                 * the pseudo bar. So we search forward, if we find a
                 * clefsig with pseudo-bar before finding a chhead,
                 * and that pseudo bar endingloc is STARTITEM, then this
                 * isn't really the end of endings, and should be ignored. */
                for (   ; mll_p != (struct MAINLL *) 0; mll_p = mll_p->next) {
                        if (mll_p->str == S_CHHEAD) {
                                /* is end of endings */
                                break;
                        }
                        else if (mll_p->str == S_CLEFSIG &&
                                        mll_p->u.clefsig_p->bar_p !=
                                        (struct BAR *) 0 &&
                                        mll_p->u.clefsig_p->bar_p->endingloc
                                        == STARTITEM) {
                                /* not really end of endings */
                                return;
                        }
                }
                Ped_snapshot[0] = NO;
        }
}
\f

/* given a list of phrase mark curve coordinates, print the curve */
/* output each x,y, coordinate pair, then the number of coordinates and
 * finally the "curve" function name */

void
pr_phrase(crvlist_p, linetype, tapered, staffno)

struct CRVLIST *crvlist_p;      /* the curve to print */
int linetype;                   /* if not tapered, may be L_DOTTED or L_DASHED*/
int tapered;                    /* YES or NO */
int staffno;                    /* which staff, to get staffscale */

{
        int n;
        struct CRVLIST *c_p;
        float *xlist,* ylist;

        /* count up number of coordinates */
        for (n = 0, c_p = crvlist_p; c_p != (struct CRVLIST *) 0;
                                        c_p = c_p->next) {
                n++;
        }

        MALLOCA(float, xlist, n);
        MALLOCA(float, ylist, n);
        for (n = 0, c_p = crvlist_p; c_p != (struct CRVLIST *) 0;
                                        c_p = c_p->next, n++) {
                xlist[n] = c_p->x;
                ylist[n] = c_p->y;
        }
        if (tapered == NO) {
                do_linetype(linetype);
        }
        pr_allcurve(xlist, ylist, n,
                svpath(staffno, STAFFSCALE)->staffscale * W_MEDIUM / PPI,
                tapered);
        FREE(xlist);
        FREE(ylist);
}
\f
/*
 * Name:        pr_allcurve()
 *
 * Abstract:    Print a curve, either generated (e.g., tie) or user-defined.
 *
 * Returns:     void
 *
 * Description: This function is given an array of CURVEINFOs, one for each
 *              point of a curve, where x and y have been filled in.  It fills
 *              the rest of the items in the structures, and prints PostScript
 *              commands for drawing the curve.  If the curve is to be dashed
 *              or dotted, the calling function must put out the PostScript
 *              commands for that.  It does not handle "wavy".
 */


void
pr_allcurve(x, y, num, cwid, tapered)

float x[], y[];         /* coordinates of the curve's points */
int num;                /* number of elements (points) in the array */
double cwid;            /* (max) width of the curve, in inches */
int tapered;            /* YES or NO */

{
        struct CURVEINFO *v;    /* malloc structs for holding point info */
        float *slen;            /* malloc length of each segment */
        float *xoff;            /* malloc x offset of curve boundary from mid*/
        float *yoff;            /* malloc y offset of curve boundary from mid*/
        float *off;             /* malloc total offset of curve boundary */
        float totlen;           /* len of curve, along segments */
        float maxplace;         /* distance from end where a tapered curve */
                                /* reaches its maximum thickness */
        float cumlen, remlen, fromend;  /* used in tapering curve */
        float dx, dy;           /* for finding x and y offsets */
        float temp;             /* temp variable */
        int n;                  /* loop through points */


        /*
         * If the curve is not to be tapered, calculate Bezier curves joining
         * these points, and stroke the resulting path.
         */
        if (tapered == NO) {
                /* load coords into structures, and calculate control points */
                MALLOC(CURVEINFO, v, num);
                for (n = 0; n < num; n++) {
                        v[n].x = x[n];
                        v[n].y = y[n];
                }
                calccurve(v, num);

                /* output results in PostScript */
                do_moveto(v[0].x, v[0].y);

                for (n = 0; n < num - 1; n++) {
                        do_curveto( v[n].x1, v[n].y1, v[n].x2, v[n].y2,
                                        v[n+1].x, v[n+1].y);
                }
                do_stroke();

                FREE(v);
                return;
        }

        /*
         * The curve is to be tapered.  We're going to draw two series of
         * Bezier curves, forming the boundaries of the whole curve, and then
         * fill.  Note that this will always result in a solid curve,
         * regardless of any earlier request for dashes or dots.
         */
        /* first allocate the arrays we're going to need */
        MALLOC(CURVEINFO, v, num);
        MALLOCA(float, slen, num);
        MALLOCA(float, xoff, num);
        MALLOCA(float, yoff, num);
        MALLOCA(float, off, num);

        /* find and save len of each segment, and accumulate total len */
        totlen = 0;
        for (n = 0; n < num - 1; n++) {
                slen[n] = sqrt( (double) (SQUARED(x[n+1] - x[n]) +
                                SQUARED(y[n+1] - y[n]) ) );
                totlen += slen[n];
        }

        /*
         * Tapering occurs up to a max of 1/3 inches from the end of a curve.
         * maxplace is set up such that it is normally the distance from the
         * end where the max thickness is attained.  However, if a curve is
         * shorter than 2/3 inches, it will never attain this max thickness.
         */
        if (totlen > 0.5) {
                maxplace = 1.0/3.0;
        } else {
                maxplace = totlen * (2.0/3.0);
        }

        cumlen = 0.0;           /* none accumulated so far */
        remlen = totlen;        /* all of it remains */
        for (n = 0; n < num; n++) {
                /* whichever end this point is closer to, note distance */
                if (cumlen < remlen) {
                        fromend = cumlen;
                }
                else {
                        fromend = remlen;
                }

                /* set the offset for this point for achieving tapering */
                if (fromend > maxplace) {
                        off[n] = cwid / 2.0;
                } else {
                        float taperwid;
                        /*
                         * For curves longer than 2/3, taperwid should be only
                         * half of TAPERWID; for zero length curves, it should
                         * be full TAPERWID; in between, adjust linearly.  Then,
                         * at the ends, the width is taperwid times the full
                         * standard thickness (the middle of a long curve); and
                         * ramp up linearly towards 1/3 inches from the end.
                         */
                        taperwid = totlen > 2.0/3.0 ? TAPERWID / 2.0 :
                                        TAPERWID * (1.0 - 0.75 * totlen);
                        off[n] = (cwid / 2.0) *
                        ((1.0 - taperwid) * fromend / maxplace + taperwid);
                }

                /*
                 * Break offset into x and y components, based on the slope
                 * between the two surrounding points.  For the endpoints,
                 * there are not two surrounding points, so use the slope of
                 * the neighboring segment.
                 */
                /*
                 * First get deltas; x and y are switched and sign reversed
                 * on one, because we're concerned with the line perpendicular
                 * to the line joining the two points.  (Its slope is the
                 * negative inverse.)  Only the ratio dx/dy matters, not the
                 * values.
                 */
                if (n == 0) {
                        dx = y[1] - y[0];
                        dy = x[0] - x[1];
                } else if (n == num - 1) {
                        dx = y[num-1] - y[num-2];
                        dy = x[num-2] - x[num-1];
                } else {
                        dx = y[n+1] - y[n-1];
                        dy = x[n-1] - x[n+1];
                }

                /* get hypotenuse of something */
                temp = off[n] / sqrt( (double) (SQUARED(dx) + SQUARED(dy)) );

                /* get x and y offsets; may need to switch signs */
                xoff[n] = fabs(temp * dx);
                yoff[n] = fabs(temp * dy);
                if (dx > 0)
                        xoff[n] *= -1;
                if (dy > 0)
                        yoff[n] *= -1;

                /* update cumulative and remaining length if not at end */
                if (n < num - 1) {
                        cumlen += slen[n];
                        remlen -= slen[n];
                }
        }

        /*
         * Load coords into structures, and calculate control points, for one
         * boundary of the curve.
         */
        for (n = 0; n < num; n++) {
                v[n].x = x[n] + xoff[n];
                v[n].y = y[n] + yoff[n];
        }
        calccurve(v, num);

        /*
         * Move to the center of the curve's thickness at the beginning point.
         * Draw a perpendicular line to the curve's boundary.  Then generate
         * the curves that form this side's boundary.
         */
        do_moveto(x[0], y[0]);
        do_line(v[0].x, v[0].y);
        for (n = 0; n < num - 1; n++) {
                do_curveto( v[n].x1, v[n].y1, v[n].x2, v[n].y2,
                                v[n+1].x, v[n+1].y);
        }

        /*
         * Load coords into structures, and calculate control points, for the
         * other boundary of the curve.  We're going to do this side in
         * reverse, back to the beginning.
         */
        for (n = 0; n < num; n++) {
                v[n].x = x[num - 1 - n] - xoff[num - 1 - n];
                v[n].y = y[num - 1 - n] - yoff[num - 1 - n];
        }
        calccurve(v, num);

        /*
         * Draw a line across the curve's thickness at this end.  Then
         * generate the curves that form this side's boundary.
         */
        do_line( v[0].x, v[0].y);
        for (n = 0; n < num - 1; n++) {
                do_curveto( v[n].x1, v[n].y1, v[n].x2, v[n].y2,
                                v[n+1].x, v[n+1].y);
        }

        /* fill to form the full, solid curve */
        do_fill();

        FREE(slen);
        FREE(xoff);
        FREE(yoff);
        FREE(off);
        FREE(v);
}
\f
/*
 * Name:        calccurve()
 *
 * Abstract:    Calculate info for drawing cubic arcs through a curve's points.
 *
 * Returns:     void
 *
 * Description: This function is given an array of CURVEINFOs, one for each
 *              point of a curve, where x and y have been filled in.  It fills
 *              in the rest of the items in the structures.  Specifically, in
 *              each structure, (x1, y1) and (x2, y2) are the control points
 *              for drawing a Bezier curve (using curveto) from this point to
 *              the next one.  These points are chosen in such a way that the
 *              slopes at the end of one curve and the start of the next are
 *              equal, to avoid a sharp corner.  Also, the angles this slope
 *              forms with straight line segments connecting the points are
 *              equal.  The angle at the start of the first curve is set equal
 *              to the angle at the end of it, and the angle at the end of the
 *              last curve is set equal to the angle at the beginning of it.
 *              The other fields in the CURVEINFOs are set but aren't useful to
 *              the caller.  In the last point's CURVEINFO, some of the fields
 *              are not used (including x1, y1, x2, y2).
 */


static void
calccurve(v, num)

struct CURVEINFO v[];   /* array of curve points, x and y must be filled in */
int num;                /* number of elements (points) in the array */

{
        int n;                          /* loop through the points */
        float temp, delx, dely;         /* temp variables */
        float slope, intercept;         /* for equation of a segment */


        /* find the length of each segment connecting neighboring points */
        for (n = 0; n < num - 1; n++) {
                /* use Pythagorean theorem; put result in 1st point's "len" */
                delx = v[n+1].x - v[n].x;
                dely = v[n+1].y - v[n].y;
                v[n].len = sqrt( (double) (SQUARED(delx) + SQUARED(dely)) );
                if (v[n].len == 0)
                        ufatal("two curve points are equal");
        }

        /* find the angle at each point other than the endpoints */
        for (n = 1; n < num - 1; n++) {
                /*
                 * Use the law of cosines on the triangle formed by this point
                 * and the preceding and following points.  First get the delta
                 * from the preceding point to the following point.
                 */
                delx = v[n+1].x - v[n-1].x;
                dely = v[n+1].y - v[n-1].y;

                /*
                 * The law of cosines:  c^2  =  a^2  +  b^2  -  2 a b cos(C).
                 * Solve this for the cosine of our point's angle (angle "C").
                 */
                temp = ( SQUARED(v[n-1].len) + SQUARED(v[n].len) -
                        (SQUARED(delx) + SQUARED(dely)) ) /
                        ( 2.0 * v[n-1].len * v[n].len );

                /* if angle is 180, should be -1, but guard against roundoff */
                if (temp < -1)
                        temp = -1;      /* should have been exactly -1 */

                /* if angle is 0, this is not allowed in our curve */
                if (temp >= 1)
                        ufatal("curve bends all the way back on itself");

                v[n].ang = acos(temp);
        }

        /* set the bend direction at each point other than the endpoints */
        for (n = 1; n < num - 1; n++) {
                /* handle special case where previous segment is vertical */
                if (v[n-1].x == v[n].x) {
                        if (v[n-1].y < v[n].y) {
                                if (v[n+1].x >= v[n].x)
                                        v[n].bend = 1;
                                else
                                        v[n].bend = -1;
                        } else {
                                if (v[n+1].x >= v[n].x)
                                        v[n].bend = -1;
                                else
                                        v[n].bend = 1;
                        }
                        continue;       /* go to next loop iteration */
                }

                /*
                 * Find the equation of the previous segment.  Plug the
                 * following point's x into that equation to get where its y
                 * would have been if the angle were 180.  Comparing that y to
                 * the actual y, we can determine the bend direction.
                 */
                slope = (v[n].y - v[n-1].y) / (v[n].x - v[n-1].x);
                intercept = v[n-1].y - slope * v[n-1].x;
                temp = slope * v[n+1].x + intercept;

                if (v[n].x > v[n-1].x) {
                        if (v[n+1].y < temp)
                                v[n].bend = 1;
                        else
                                v[n].bend = -1;
                } else {
                        if (v[n+1].y < temp)
                                v[n].bend = -1;
                        else
                                v[n].bend = 1;
                }
        }

        /*
         * At the endpoints, there is only one segment, so no angle or bend
         * direction is defined.  But we need to have something.  So we semi-
         * arbitrarily set these to the same value as their neighboring points.
         */
        v[0].ang = v[1].ang;
        v[0].bend = v[1].bend;
        v[num-1].ang = v[num-2].ang;
        v[num-1].bend = v[num-2].bend;

        /*
         * For all points, set the slope of the line tangent to the curves
         * we're going to draw, in the coordinate system where the segment
         * starting at this point is horizontal.  (This is the coordinate
         * system that findcontrol() uses.)  Since the angle between segments
         * is not allowed to be 0, this slope is never vertical (infinity).
         */
        for (n = 0; n < num; n++)
                v[n].slopetan = -v[n].bend * tan( v[n].ang / 2 + PI / 2);

        /*
         * For each segment, calculate control points to define a Bezier curve
         * connecting the endpoints, according to the specifications.
         */
        for (n = 0; n < num - 1; n++)
                findcontrol(v, n);
}
\f
/*
 * Name:        findcontrol()
 *
 * Abstract:    Find Bezier control points for one segment of the curve.
 *
 * Returns:     void
 *
 * Description: This function is given an array of CURVEINFOs, one for each
 *              point, with everything filled in except the control points.  It
 *              calculates them and fills them in.
 */


static void
findcontrol(v, n)

struct CURVEINFO v[];
int n;

{
        float costheta, sintheta;       /* for rotating axes by theta */

        /*
         * All of the following variables refer to the rotated/translated
         * position of the segment (see comment below).  Point 0 is the
         * starting point, point 3 is the ending point, and points 1 and 2
         * are the Bezier control points.
         */
        float x1, x2, y1, y2;   /* control points */
        float x3;               /* end point (y3 is always 0) */
        float slope0, slope3;   /* slope of tangent lines at endpoints */
        float b, c;             /* some coefficients of cubic y = f(x) */
        float cx, by, cy;       /* Bezier coefficients */


        /*
         * Rotate and translate the axes so that the starting point (point 0)
         * is at the origin, and the ending point (3) is on the positive
         * x axis.  Their coords are (0, 0) and (v[n].len, 0).  We are going
         * to find a cubic equation that intersects the endpoints, and has the
         * necessary slope at those points such that the tangent line's slope
         * is halfway between horizontal (this segment) and the slope of the
         * neighboring segment.  The equation is
         *      y  =  a x^3  +  b x^2  +  c x  +  d
         * so the slope is
         *      y' =  3 a x^2  +  2 b x  +  c
         * By plugging the two points into these, you get 4 equations in the 4
         * unknowns a, b, c, d.
         */
        x3 = v[n].len;

        /* find the slope of the tangent lines at the first & second points */
        slope0 = v[n].slopetan;
        slope3 = -v[n+1].slopetan;

        /* set values of a, b, c (d turns out to be always 0) */
        /* a = (slope0 + slope3) / SQUARED(x3); don't really need this one */
        b = (-2 * slope0 - slope3) / x3;
        c = slope0;

        /*
         * For Bezier version of this, let x = t / x3, and for y, plug this
         * into the cubic we have found.  This gives us the Bezier coeff.:
         *      x = ax t^3  +  bx t^2  +  cx t  +  x0
         *      y = ay t^3  +  by t^2  +  cy t  +  y0
         */
        /* ax and bx are always 0 */
        cx = x3;
        /* ay = a * CUBED(x3);          this one is not needed */
        by = b * SQUARED(x3);
        cy = c * x3;

        /* get control points 1 and 2 from Bezier coefficients & endpoints */
        x1 = cx / 3;
        y1 = cy / 3;
        x2 = x1 + cx / 3;
        y2 = y1 + (by + cy) / 3;

        /*
         * Rotate and translate the axes back to where they really were.  Store
         * these real positions of the control points.
         */
        costheta = (v[n+1].x - v[n].x) / v[n].len;
        sintheta = (v[n+1].y - v[n].y) / v[n].len;

        v[n].x1 = v[n].x + x1 * costheta - y1 * sintheta;
        v[n].x2 = v[n].x + x2 * costheta - y2 * sintheta;
        v[n].y1 = v[n].y + y1 * costheta + x1 * sintheta;
        v[n].y2 = v[n].y + y2 * costheta + x2 * sintheta;
}
\f

/* draw a V-shaped bend indicator by drawing two line segments */

void
pr_bend(crvlist_p)

struct CRVLIST *crvlist_p;

{
        if (crvlist_p == (struct CRVLIST *) 0
                        || crvlist_p->next == (struct CRVLIST *) 0
                        || crvlist_p->next->next == (struct CRVLIST *) 0) {
                pfatal("invalid bend crvlist");
        }

        do_linetype(L_NORMAL);
        draw_line(crvlist_p->x, crvlist_p->y, crvlist_p->next->x, crvlist_p->next->y);
        draw_line(crvlist_p->next->x, crvlist_p->next->y,
                        crvlist_p->next->next->x, crvlist_p->next->next->y);
}
\f

/* draw a slide for a tab or tabnote staff. Slides are stored internally
 * like slurs. Here we just draw a line between the appropriate coordinates */

void
pr_tabslur(crvlist_p, ts_style)

struct CRVLIST *crvlist_p;
int ts_style;

{
        if (crvlist_p == (struct CRVLIST *) 0
                                || crvlist_p->next == (struct CRVLIST *) 0) {
                pfatal("invalid tabslur crvlist");
        }

        do_linetype(ts_style);
        draw_line(crvlist_p->x, crvlist_p->y, crvlist_p->next->x, crvlist_p->next->y);
}
\f

/* print a small curve to indicate a 1/4 step bend on a tabnote */

void
pr_sm_bend(x, y)

double x, y;    /* where to start the curve. This is the bottom left end */

{
        float xlist[4], ylist[4];       /* coordinates of the curve */


        /* fill in the relative horizontal and vertical offsets. These
         * are hand picked to give a nice looking curve */
        xlist[0] = x;
        ylist[0] = y;
        xlist[1] = x + 0.5 * STEPSIZE;
        ylist[1] = y + 0.2 * STEPSIZE;
        xlist[2] = x + 1.2 * STEPSIZE;
        ylist[2] = y + 1.2 * STEPSIZE;
        xlist[3] = x + 1.3 * STEPSIZE;
        ylist[3] = y + 1.75 * STEPSIZE;

        /* now print the curve */
        pr_allcurve(xlist, ylist, 4, W_NORMAL, NO);
}
\f

/* Print 'atend' grids */

void
pr_atend()

{
        float x;                /* of first grid of row */
        float y;                /* of row; top line of grid */
        float gridx;            /* x of grid being printed */
        float north;            /* of the grid */
        float space;            /* distance between grid lines */
        struct GRID *grid_p;
        int g;                  /* index through grid_p array */
        int staff = -1;         /* always -1 to indicate atend. Using a
                                 * variable rather than hard-coding where
                                 * used just on general principles. */
        int column;             /* how many columns printed so far in row */
        int rows_to_print;      /* how many rows to print per page. */
        struct MAINLL *main_feed_p;     /* for getting top/bottom blocks */
        struct FEED *feed_p;    /* for getting top/bottom blocks */


        x = Atend_info.firstgrid_x;
        y = Atend_info.firstgrid_y;
        rows_to_print = Atend_info.rows_per_page;
        space = gridspace(staff);
        column = 0;

        /* Find the last FEED. We use that to get top/bottom blocks */
        for (main_feed_p = Mainlltc_p; main_feed_p->str != S_FEED;
                                        main_feed_p= main_feed_p->prev) {
                ;
        }
        feed_p = main_feed_p->u.feed_p;
        for (g = 0; g < Atend_info.grids_used; g++) {
                grid_p = Atend_info.grid_p[g];
                gridsize(grid_p, staff, &north, (float *) 0, (float *) 0, (float *) 0);
                /* calculate horizontal position of this grid */
                gridx = x + column * Atend_info.horz_sep;

                /* print the name of the grid */
                pr_string(gridx - strwidth(grid_p->name) / 2.0,
                                y + north + strdescent(grid_p->name),
                                grid_p->name, J_LEFT, (char *) 0, -1);

                /* print the grid itself */
                do_grid(gridx - space * (grid_p->numstr - 1) / 2.0,
                                        y, space, grid_p, staff);

                if (++column >= Atend_info.grids_per_row &&
                                g < Atend_info.grids_used - 1) {
                        /* move to next row */
                        column = 0;
                        y -= Atend_info.vert_sep;
                        rows_to_print--;
                        if (Atend_info.separate_page == YES &&
                                                rows_to_print <= 0) {
                                rows_to_print = Atend_info.rows_per_page;
                                y = Atend_info.firstgrid_y;
                                /* print top/bottom blocks, if any */
                                /* use *2 blocks for any subsequent pages */
                                feed_p->top_p = feed_p->top2_p;
                                feed_p->bot_p = feed_p->bot2_p;
                                pr_feed(main_feed_p);
                        }
                }
        }
}