--- /dev/null
+/* Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ * 2005, 2006 by Arkkra Enterprises */
+/* All rights reserved */
+/*
+ * Name: absvert.c
+ *
+ * Description: This file contains functions for setting all absolute
+ * vertical coordinates.
+ */
+
+#include "defines.h"
+#include "structs.h"
+#include "globals.h"
+
+/*
+ * Define the maximum number of scores that could ever fit on a page, when all
+ * staffs and scores are packed as tightly as possible. The 8 * STEPSIZE is
+ * the height of the five lines of a staff, and the other factor in the
+ * denominator is the minimum distance between staffs or scores, whichever is
+ * smaller. If a staff has less than 5 lines, it is still given as much space
+ * as a 5 line staff, so that's why we can use 8 * STEPSIZE here as the
+ * smallest possible staff size.
+ */
+#define MAXSCORES ( (int)(PGHEIGHT / \
+ (MINSTFSCALE * STEPSIZE * (8 + MIN(MINMINSTSEP, MINMINSCSEP)))) + 1 )
+
+#define FUDGE 0.001 /* fudge factor for round off error */
+
+/* determine what clef, if any, will be printed on a staff */
+#define CLEF2PRINT(staffno) \
+ (svpath(staffno, STAFFLINES)->printclef == SS_NORMAL ? \
+ svpath(staffno, CLEF)->clef : NOCLEF)
+
+/* define amount of horz and vert padding between at-end grids */
+#define HPADGRID (2.0 * STEPSIZE)
+#define VPADGRID (2.0 * STEPSIZE)
+
+/* maximum length of a chord name that we care about for sorting purposes */
+#define MAXCHNAME (100)
+
+static void relscore P((struct MAINLL *mllfeed_p));
+static void relstaff P((struct MAINLL *feed_p, int s1, int s2, double botoff,
+ double betweendist));
+static void posscores P((void));
+static void abspage P((struct MAINLL *page_p, float cursep[], float maxsep[],
+ float curpad[], float maxpad[], int totscores,
+ double remheight, double y_start));
+static void absstaff P((struct FEED *feed_p, struct STAFF *staff_p));
+static double grids_atend P((double vertavail, int firstpage,
+ struct FEED *mfeed_p, struct FEED *gfeed_p));
+static int compgrids P((const void *g1_p_p, const void *g2_p_p));
+static void proc_css P((void));
+static void one_css P((struct STAFF *ts_p, struct STAFF *os_p,
+ struct GRPSYL *tg_p, RATIONAL time));
+static void horzavoid P((void));
+static void avoidone P((struct MAINLL *mainll_p, struct GRPSYL *cssg_p,
+ RATIONAL time));
+static void set_csb_stems P((void));
+static void onecsb P((struct GRPSYL *gs1_p, struct GRPSYL *gs2_p));
+static int calcline P((struct GRPSYL *start1_p, struct GRPSYL *end1_p,
+ struct GRPSYL *start2_p, struct GRPSYL *end2_p,
+ struct GRPSYL *first_p, struct GRPSYL *last_p,
+ int topdir, int botdir,
+ float *b0_p, float *b1_p));
+static void samedir P((struct GRPSYL *first_p, struct GRPSYL *last_p,
+ struct GRPSYL *start1_p, struct GRPSYL *start2_p,
+ struct GRPSYL *end1_p, float *b0_p, float *b1_p,
+ double deflen, int one_end_forced, int slope_forced,
+ double forced_slope));
+static void oppodir P((struct GRPSYL *first_p, struct GRPSYL *last_p,
+ struct GRPSYL *start1_p, struct GRPSYL *start2_p,
+ float *b0_p, float *b1_p, double deflen, int one_end_forced,
+ int slope_forced, double forced_slope));
+static struct GRPSYL *nextcsb P((struct GRPSYL *gs_p));
+static struct GRPSYL *nxtbmnote P((struct GRPSYL *gs_p, struct GRPSYL *first_p,
+ struct GRPSYL *endnext_p));
+\f
+/*
+ * Name: absvert()
+ *
+ * Abstract: Set all absolute vertical coordinates.
+ *
+ * Returns: void
+ *
+ * Description: This function sets all absolute vertical coordinates. First it
+ * calls relscore() for each score, to position the staffs in that
+ * score relative to the score. Then it calls posscores() to
+ * decide how many scores to put on each page, and set all the
+ * absolute coordinates. Finally it completes the work for
+ * cross staff stemming (CSS) and cross staff beaming (CSB).
+ */
+
+void
+absvert()
+
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+
+
+ debug(16, "absvert");
+ /*
+ * Find each section of the main linked list, delimited by FEEDs. For
+ * each such section, call relscore() to fix the score internally
+ * (relative to itself, all staffs and between stuff). Keep SSVs
+ * up to date so that we always know what the user requested
+ * separations are.
+ */
+ initstructs(); /* clean out old SSV info */
+
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ switch (mainll_p->str) {
+ case S_SSV:
+ asgnssv(mainll_p->u.ssv_p);
+ break;
+
+ case S_FEED:
+ relscore(mainll_p);
+ break;
+ }
+ }
+
+ /*
+ * Position the scores on the pages, setting all absolute vertical
+ * coordinates.
+ */
+ posscores();
+
+ /*
+ * Process groups that have cross staff stemming, if there were any.
+ */
+ if (CSSused == YES) {
+ proc_css();
+ }
+
+ /*
+ * Set stem lengths for groups involved in cross staff beaming, if
+ * there were any.
+ */
+ if (CSBused == YES) {
+ set_csb_stems();
+ }
+}
+\f
+/*
+ * Name: relscore()
+ *
+ * Abstract: Set certain relative coords to be relative to score.
+ *
+ * Returns: void
+ *
+ * Description: This function loops through the part of the main linked list
+ * for this score. It adjusts the relative vertical coords of
+ * STAFFs, and also of GRPSYLs (syllables) and STUFFs of the
+ * things that are "between" staffs. In the end, the STAFFs will
+ * be relative to the score (FEED), and the between things will
+ * be relative to the staff above them. Yes, I suppose this
+ * belongs in relvert.c, but relvert.c has enough work to do.
+ */
+
+static void
+relscore(mllfeed_p)
+
+struct MAINLL *mllfeed_p; /* FEED at start of this score */
+
+{
+ struct MAINLL *mainll_p;/* point along main linked list */
+ struct STAFF *cstaff_p; /* point at current staff */
+ struct STAFF *pstaff_p; /* point at previous staff */
+ struct FEED *feed_p; /* point at FEED structure itself */
+ float cstaffoffset; /* current staff offset from score */
+ float staffdist; /* dist between prev & cur staff inner lines*/
+ float halfnonbetween; /* (staffdist - heightbetween) / 2 */
+ float betweendist; /* from prev staff center line to base line */
+ float prevhalf; /* half the height of previous staff */
+ float curhalf; /* half the height of current staff */
+ float limit; /* smallest dist allowed between inner lines */
+ float needed; /* dist between inner lines to avoid collis */
+ int prevclef; /* clef on the previous staff */
+ float prevscale; /* staffscale of the previous staff */
+ float spad; /* staffpad (inches) below previous staff */
+ float clefroom; /* room for clefs and/or measure numbers */
+ static int first = YES; /* is this the first score in the song? */
+
+
+ debug(32, "relscore file=%s line=%d", mllfeed_p->inputfile,
+ mllfeed_p->inputlineno);
+ feed_p = mllfeed_p->u.feed_p;
+
+ /*
+ * If this score is actually a block, all we have to do is set the
+ * relative vertical coords of the FEED. We set RY to be the center.
+ */
+ if (mllfeed_p->next != 0 && mllfeed_p->next->str == S_BLOCKHEAD) {
+ feed_p->c[RN] = mllfeed_p->next->u.blockhead_p->height / 2.0;
+ feed_p->c[RY] = 0; /* RY is always 0 */
+ feed_p->c[RS] = -feed_p->c[RN];
+ feed_p->lastdist = 0.0;
+ return;
+ }
+
+ /*
+ * Find the first STAFF in this score (will be in first measure).
+ */
+ for (mainll_p = mllfeed_p->next; mainll_p != 0 &&
+ mainll_p->str != S_FEED && mainll_p->str != S_STAFF;
+ mainll_p = mainll_p->next)
+ ;
+ if (mainll_p == 0 || mainll_p->str != S_STAFF)
+ return; /* ignore items when there's a feed at end of song */
+
+ /* init variables for main loop */
+ cstaffoffset = 0; /* top staff Y == score Y */
+ pstaff_p = 0; /* there is no previous staff */
+ prevclef = NOCLEF;
+ prevscale = 1.0;
+ spad = 0.0; /* keep lint happy; will be set before used */
+
+ /*
+ * Loop through all STAFF structures in the first measure of this
+ * score. Skip invisible ones. cstaff_p always points at the staff
+ * we are working on, and pstaff_p always points to the previous
+ * visible staff (so is 0 while we are working on the first visible
+ * staff of the score). For each visible staff except the first, we
+ * figure out how far down it should be from the one above it, and
+ * set its relative vertical coords relative to the score. Also, we
+ * figure out where to put the things that are "between" this staff
+ * and the one above, and set them relative to the above staff.
+ */
+ for ( ; mainll_p->str == S_STAFF; mainll_p = mainll_p->next) {
+
+ cstaff_p = mainll_p->u.staff_p;
+
+ /*
+ * If this staff is invisible, ignore it completely.
+ */
+ if (cstaff_p->visible == NO)
+ continue;
+
+ /*
+ * If it's the first visible staff, there are no coords to set,
+ * since its offset is 0 and the "between" objects below it
+ * will be handled by the next loop. Also set first and last
+ * visible staff numbers in the FEED in this loop, and the
+ * relative vertical coords of the score.
+ */
+ if (pstaff_p == 0) {
+ /* set first visible staff number */
+ feed_p->firstvis = cstaff_p->staffno;
+
+ /* feed's RN is same as first visible staff's RN */
+ feed_p->c[RN] = cstaff_p->c[RN];
+ feed_p->c[RY] = 0; /* RY is always 0 */
+
+ /* these next 3 will be changed later if more staffs */
+ feed_p->c[RS] = cstaff_p->c[RS];
+ feed_p->lastvis = cstaff_p->staffno;
+ feed_p->lastdist = cstaff_p->c[RY] - cstaff_p->c[RS] -
+ staffvertspace(cstaff_p->staffno) / 2.0;
+
+ pstaff_p = cstaff_p; /* previous visible staff */
+ prevclef = CLEF2PRINT(pstaff_p->staffno);
+ prevscale = svpath(pstaff_p->staffno, STAFFSCALE)->
+ staffscale;
+ spad = svpath(pstaff_p->staffno, STAFFPAD)->staffpad
+ * STEPSIZE * prevscale;
+ continue; /* no coords to set */
+ }
+
+ /* set half the height of the previous and current staffs */
+ prevhalf = staffvertspace(pstaff_p->staffno) / 2.0;
+ curhalf = staffvertspace(cstaff_p->staffno) / 2.0;
+
+ /*
+ * The space needed between the bottom line of the previous
+ * staff and the top line of the current staff to avoid
+ * collisions is how far up from the current staff things
+ * stick, plus how far down from the previous staff things
+ * stick, plus the height of anything "between" the two.
+ * To this we add spad for extra padding (overlap if negative).
+ */
+ needed = (cstaff_p->c[RN] - curhalf) +
+ ((pstaff_p->c[RY] - pstaff_p->c[RS]) - prevhalf) +
+ pstaff_p->heightbetween + spad;
+ /*
+ * Set the distance between those two lines to be what the
+ * user requested, or what was calculated above as "needed",
+ * whichever is greater. Set halfnonbetween to be half of
+ * this result, minus half the height of the "between" items.
+ */
+ /* never closer than this */
+ limit = svpath(pstaff_p->staffno,MINSTSEP)->minstsep * STEPSIZE;
+ clefroom = clefspace(prevclef, prevscale,
+ CLEF2PRINT(cstaff_p->staffno),
+ svpath(cstaff_p->staffno, STAFFSCALE)->staffscale,
+ Score.measnum == YES && has_ending(cstaff_p->staffno)
+ && first == NO);
+ limit = MAX(limit, clefroom);
+
+ staffdist = MAX(limit, needed); /* between prev & current */
+
+ /*
+ * Find half the room between the inner staff lines that is not
+ * going to be used by the "between" items. But pretend that
+ * the "between" items are bigger by "spad" than they really
+ * are, so that half of staffpad will go on each side of them.
+ */
+ halfnonbetween = (staffdist - (pstaff_p->heightbetween + spad))
+ / 2.0;
+
+ /* set cstaffoffset for relative to score */
+ cstaffoffset -= (prevhalf + staffdist + curhalf);
+
+ /*
+ * The "between" items are currently placed relative to a base
+ * line that they were piled onto. We would like to center
+ * them between the staffs, but if one staff sticks out more
+ * than the other, it may not be possible. Center as close as
+ * possible. betweendist is how far the base line is from the
+ * center line of the previous staff.
+ */
+ if ((pstaff_p->c[RY] - pstaff_p->c[RS]) - prevhalf >
+ halfnonbetween) {
+ /*
+ * The top staff sticks down far enough that we have
+ * to put the "between" items below center. Jam them
+ * against the top staff.
+ */
+ betweendist = (pstaff_p->c[RY] - pstaff_p->c[RS]) +
+ pstaff_p->heightbetween + spad;
+ } else if (cstaff_p->c[RN] - curhalf > halfnonbetween) {
+ /*
+ * The bottom staff sticks up far enough that we have
+ * to put the "between" items above center. Jam them
+ * against the bottom staff.
+ */
+ betweendist = (prevhalf + staffdist + curhalf) -
+ cstaff_p->c[RN];
+ } else {
+ /*
+ * There is room to center the between items.
+ */
+ betweendist = prevhalf + staffdist - halfnonbetween;
+ }
+
+ /* change baseline of padding to actual baseline */
+ betweendist -= spad / 2.0;
+
+ /*
+ * For all STAFF structures of these staff numbers in this
+ * score, change relative coords as described below.
+ */
+ relstaff(mllfeed_p, pstaff_p->staffno, cstaff_p->staffno,
+ cstaffoffset, betweendist);
+
+ /* last loop iteration leaves right value in these variables */
+ feed_p->lastvis = cstaff_p->staffno;
+ feed_p->c[RS] = cstaff_p->c[RS];
+ feed_p->lastdist = cstaff_p->c[RY] - cstaff_p->c[RS] - curhalf;
+
+ pstaff_p = cstaff_p;
+ prevclef = CLEF2PRINT(pstaff_p->staffno);
+ prevscale = svpath(pstaff_p->staffno, STAFFSCALE)->staffscale;
+ spad = svpath(pstaff_p->staffno, STAFFPAD)->staffpad
+ * STEPSIZE * prevscale;
+ }
+
+ first = NO; /* next score will not be the first */
+}
+\f
+/*
+ * Name: relstaff()
+ *
+ * Abstract: Set certain relative coords to be relative to score.
+ *
+ * Returns: void
+ *
+ * Description: This function is given two staff structures for consecutive
+ * visible staffs. For all STAFF structures of these staff
+ * numbers in this score, set the bottom staff's coords relative
+ * to the score, and set the "between" items' coords (for what's
+ * between top and bottom staff) relative to the top staff.
+ */
+
+static void
+relstaff(feed_p, s1, s2, botoff, betweendist)
+
+struct MAINLL *feed_p; /* pointer to FEED for this score */
+int s1; /* number of top staff */
+int s2; /* number of bottom staff */
+double botoff; /* center line of bottom, relative to score */
+double betweendist; /* center line of top to base line of between*/
+
+{
+ struct MAINLL *mainll_p;/* point along main linked list */
+ struct STAFF *staff_p; /* pointer to a staff */
+ struct GRPSYL *syl_p; /* pointer to a syllable */
+ struct STUFF *stuff_p; /* pointer to stuff to draw */
+ int n; /* loop variable */
+
+
+ debug(32, "relstaff file=%s line=%d s1=%d s2=%d botoff=%f betweendist=%f",
+ feed_p->inputfile, feed_p->inputlineno, s1, s2,
+ (float)botoff, (float)betweendist);
+ /*
+ * Loop through the section of the main linked list for this score,
+ * looking for every STAFF for one of the two given staffs.
+ */
+ for (mainll_p = feed_p->next; mainll_p != 0 && mainll_p->str != S_FEED;
+ mainll_p = mainll_p->next) {
+
+ if (mainll_p->str == S_STAFF &&
+ mainll_p->u.staff_p->staffno == s1) {
+
+ staff_p = mainll_p->u.staff_p;
+
+ /*
+ * Subtract betweendist from all relative coords of
+ * "between" items hanging off this staff, to make them
+ * relative to this staff instead of the base line.
+ */
+ for (n = 0; n < staff_p->nsyllists; n++) {
+ if (staff_p->sylplace[n] == PL_BETWEEN) {
+ for (syl_p = staff_p->syls_p[n];
+ syl_p != 0;
+ syl_p = syl_p->next) {
+ syl_p->c[RN] -= betweendist;
+ syl_p->c[RY] -= betweendist;
+ syl_p->c[RS] -= betweendist;
+ }
+ }
+ }
+ for (stuff_p = staff_p->stuff_p; stuff_p != 0;
+ stuff_p = stuff_p->next) {
+ if (stuff_p->place == PL_BETWEEN) {
+ stuff_p->c[RN] -= betweendist;
+ stuff_p->c[RY] -= betweendist;
+ stuff_p->c[RS] -= betweendist;
+ }
+ }
+ }
+
+ if (mainll_p->str == S_STAFF &&
+ mainll_p->u.staff_p->staffno == s2) {
+
+ staff_p = mainll_p->u.staff_p;
+
+ /*
+ * Make this staff relative to the score instead of
+ * relative to its own center line.
+ */
+ staff_p->c[RN] += botoff;
+ staff_p->c[RY] = botoff;
+ staff_p->c[RS] += botoff;
+ }
+ }
+}
+\f
+/*
+ * Name: posscores()
+ *
+ * Abstract: Place which scores on which pages, and set all vertical coords.
+ *
+ * Returns: void
+ *
+ * Description: This function decides how many scores are going to fit on each
+ * page, based on how big they are and how much minimum space the
+ * user wants put between them. It calls abspage() for each page
+ * to do final positioning and coordinate setting.
+ */
+
+static void
+posscores()
+
+{
+ struct MAINLL *mainll_p;/* point along main LL */
+ struct TIMEDSSV *tssv_p;/* point along timed SSV lists */
+ struct MAINLL *page_p; /* point at first FEED of a page */
+ struct MAINLL *ppage_p; /* point at first FEED of previous page */
+ struct MAINLL *gridpage_p; /* point at FEED for grids-at-end */
+ struct MAINLL *origpage_p; /* remember original page_p */
+ struct FEED *cfeed_p; /* point at current scorefeed */
+ struct FEED *pfeed_p; /* point at previous scorefeed */
+ float availheight; /* available height on page (middle window) */
+ float remheight; /* remaining height on page */
+ float y_start; /* where y begins (at top of _win) */
+ float limit; /* smallest distance allowed between scores */
+ int prevclef; /* clef on last visible staff of prev score */
+ float clefroom; /* room for clefs and/or measure numbers */
+ float excess; /* extra room needed for top score */
+ float abovetopline; /* dist from top line of score to top of score*/
+ float ink; /* distance ink extends between inner lines */
+ float padding; /* space between farthest extents */
+ float scoreheight; /* height of current score */
+ float topheight, botheight; /* height of a "top" or "bot" block */
+ int aftertitle; /* is this the page after a title page? */
+ int firstpage; /* are we working on the first page? */
+ int totscores; /* number of scores on a page */
+
+ /* the following are all in inches, unlike scorepad/scoresep parms */
+ float curminpad; /* current minscpad */
+ float curmaxpad; /* current maxscpad */
+ float *curpad; /* malloc: pad above each score */
+ float *maxpad; /* malloc: maxscpad above each score */
+ float curminsep; /* current minscsep */
+ float curmaxsep; /* current maxscsep */
+ float *cursep; /* malloc: sep above each score */
+ float *maxsep; /* malloc: maxscsep above each score */
+
+ int is_block; /* is there a block after this FEED? */
+ struct BLOCKHEAD *rememtop2_p, *remembot2_p; /* remember most current*/
+ struct BLOCKHEAD *head_p; /* point at Header or Header2 */
+ struct BLOCKHEAD *foot_p; /* point at Footer or Footer2 */
+
+
+ debug(16, "posscores");
+ /*
+ * In each of these arrays, array[idx] refers to distance below score
+ * number idx on a page, numbering the scores from 1 to N. For sep,
+ * only indices 1 through N-1 are used. For pad, indices 0 through N
+ * are used, where 0 means above the first score and N below the last.
+ * The "sep" arrays are for distances between the outermost staff lines
+ * of neighboring scores. The "pad" arrays are for distances between
+ * the outermost thing sticking out of those scores. The "above"
+ * arrays are for distance currently allocated. The "max" arrays are
+ * for the max limits we impose (when we can).
+ */
+ MALLOCA(float, cursep, MAXSCORES);
+ MALLOCA(float, curpad, MAXSCORES + 1);
+ MALLOCA(float, maxsep, MAXSCORES);
+ MALLOCA(float, maxpad, MAXSCORES + 1);
+
+ initstructs(); /* init SSVs */
+
+ /* the following need to be initialized for the coming loop */
+ curminsep = Score.minscsep * STEPSIZE;
+ curminpad = Score.minscpad * STEPSIZE;
+ curmaxsep = Score.maxscsep * STEPSIZE;
+ curmaxpad = Score.maxscpad * STEPSIZE;
+ pfeed_p = 0;
+ firstpage = YES;
+ mainll_p = Mainllhc_p;
+ rememtop2_p = remembot2_p = 0;
+
+ /* the following don't really need to be initialized; we're doing it */
+ /* just to prevent useless 'used before set' warnings */
+ page_p = 0;
+ ppage_p = 0;
+ remheight = 0;
+ y_start = 0;
+ totscores = 0;
+ prevclef = NOCLEF;
+ botheight = 0.0;
+ foot_p = 0;
+
+ /*
+ * Loop through the main linked list, looking at each feed. Assuming
+ * the scores are packed as tightly as allowed, see how many will fit
+ * on each page. Whenever a page fills up, call abspage() to
+ * distribute the extra white space as well as possible and set all
+ * the absolute vertical coords for that page. At the end, call it
+ * again for the last page.
+ */
+ while (mainll_p != 0) {
+ switch (mainll_p->str) {
+ case S_FEED:
+ break; /* go handle this score */
+ case S_SSV:
+ /* apply, and reset vars in case some changed */
+ asgnssv(mainll_p->u.ssv_p);
+ curminsep = Score.minscsep * STEPSIZE;
+ curmaxsep = Score.maxscsep * STEPSIZE;
+ curminpad = Score.minscpad * STEPSIZE;
+ curmaxpad = Score.maxscpad * STEPSIZE;
+ mainll_p = mainll_p->next;
+ continue;
+ case S_BAR:
+ /* apply timed SSVs; they won't affect the above
+ * variables, but they could affect clef, which we
+ * will need later */
+ for (tssv_p = mainll_p->u.bar_p->timedssv_p;
+ tssv_p != 0; tssv_p = tssv_p->next) {
+ asgnssv(&tssv_p->ssv);
+ }
+ mainll_p = mainll_p->next;
+ continue;
+ default:
+ mainll_p = mainll_p->next;
+ continue;
+ }
+
+ /* if there is nothing after this FEED, break out */
+ if (mainll_p->next == 0) {
+ break;
+ }
+
+ cfeed_p = mainll_p->u.feed_p; /* set convenient pointer */
+
+ /*
+ * If firstpage is set, normally there would be no pagefeed,
+ * because the first FEED on that page is marked as a pagefeed
+ * only if the user requested it. If they did, that means
+ * there was a title page with no music on it. We need to
+ * remember this fact, so that we know to use header2/footer2
+ * instead of header/footer. Only the title page would use
+ * header/footer.
+ */
+ aftertitle = firstpage == YES && cfeed_p->pagefeed == YES;
+
+ /* see if there is a block after this feed */
+ is_block = mainll_p->next != 0 &&
+ mainll_p->next->str == S_BLOCKHEAD;
+
+ scoreheight = cfeed_p->c[RN] - cfeed_p->c[RS];
+
+ if (pfeed_p == 0) {
+ /*
+ * We are at the top of a page. Point at the header
+ * and footer that apply. Note that if the header or
+ * footer is unused, its height will be 0.
+ */
+ if (firstpage == YES && aftertitle == NO) {
+ head_p = &Header;
+ foot_p = &Footer;
+ } else {
+ head_p = &Header2;
+ foot_p = &Footer2;
+ }
+
+ /* if not the first page, set pagefeed */
+ if (firstpage == NO) {
+ cfeed_p->pagefeed = YES;
+ }
+
+ /* remember most recent settings of top2 and bot2 */
+ if (cfeed_p->top2_p != 0) {
+ rememtop2_p = cfeed_p->top2_p;
+ }
+ if (cfeed_p->bot2_p != 0) {
+ remembot2_p = cfeed_p->bot2_p;
+ }
+
+ /*
+ * Decide what is to be printed at the top and
+ * bottom (inside the header(2)/footer(2) if any).
+ * On the first page and at every pagefeed where top_p
+ * is set, that is to be used, so leave it alone.
+ * Otherwise use the most recent top2_p setting, so
+ * save the value into top_p. Later in this function,
+ * and also in the print phase, top_p is used, not
+ * top2_p, with exception of grids-at-end pages.
+ */
+ if (firstpage == NO && cfeed_p->top_p == 0) {
+ cfeed_p->top_p = rememtop2_p;
+ }
+ /* analogous for bottom */
+ if (firstpage == NO && cfeed_p->bot_p == 0) {
+ cfeed_p->bot_p = remembot2_p;
+ }
+
+ /* set height of "top" & "bot" if they exist, else 0 */
+ topheight = cfeed_p->top_p != 0 ?
+ cfeed_p->top_p->height : 0.0;
+ botheight = cfeed_p->bot_p != 0 ?
+ cfeed_p->bot_p->height : 0.0;
+
+ /*
+ * Remove these items' size from the space available
+ * for music, and set music's starting point.
+ */
+ availheight = PGHEIGHT - EFF_TOPMARGIN - EFF_BOTMARGIN
+ - head_p->height - foot_p->height
+ - topheight - botheight;
+
+ y_start = PGHEIGHT - EFF_TOPMARGIN
+ - head_p->height - topheight;
+
+ /*
+ * If a header or top exists on this page, we need to
+ * have pad below it. Since we're initially packing as
+ * tightly as possible, assume the minimum. Reduce the
+ * available room by that amount. Analogous for
+ * footer/bottom.
+ */
+ if (head_p->height + topheight > 0.0) {
+ availheight -= curminpad;
+ }
+ if (foot_p->height + botheight > 0.0) {
+ availheight -= curminpad;
+ }
+
+ /* increase score's RN and scoreheight if need be */
+ if (is_block) {
+ /*
+ * Blocks have no clef or measure number, but
+ * clefspace() still will return a little
+ * something for padding, so add that in.
+ */
+ excess = clefspace(NOCLEF, 1.0, NOCLEF, 1.0,NO);
+ cfeed_p->c[RN] += excess;
+ scoreheight += excess;
+ } else {
+ /*
+ * If clef (and measure number if that is to be
+ * printed) stick up higher than anything else,
+ * adjust the size of the score to allow for it.
+ */
+ clefroom = clefspace(NOCLEF, 1.0,
+ CLEF2PRINT(cfeed_p->firstvis), 1.0,
+ Score.measnum == YES &&firstpage == NO);
+ abovetopline = cfeed_p->c[RN] -
+ staffvertspace(cfeed_p->firstvis) / 2.0;
+ excess = clefroom - abovetopline;
+ if (excess > 0.0) {
+ cfeed_p->c[RN] += excess;
+ scoreheight += excess;
+ }
+ }
+
+ if (scoreheight > availheight) {
+ if (Score.units == INCHES) {
+ ufatal("score is too high (%.2f inches) to fit on one page (limit %.2f)",
+ scoreheight * Score.scale_factor,
+ availheight * Score.scale_factor);
+ } else {
+ ufatal("score is too high (%.2f cm) to fit on one page (limit %.2f)",
+ scoreheight * Score.scale_factor *
+ CMPERINCH, availheight *
+ Score.scale_factor * CMPERINCH);
+ }
+ }
+
+ /*
+ * Set pad above the top score. If there is a header
+ * or top, use the values from scorepad. If not, force
+ * both to 0, so that none will be allowed.
+ */
+ if (head_p->height + topheight > 0.0) {
+ curpad[0] = curminpad;
+ maxpad[0] = curmaxpad;
+ } else {
+ curpad[0] = 0.0;
+ maxpad[0] = 0.0;
+ }
+
+ remheight = availheight - scoreheight;
+ totscores = 1;
+ pfeed_p = cfeed_p;
+ ppage_p = page_p;
+ page_p = mainll_p;
+ mainll_p = mainll_p->next;
+ firstpage = NO;
+ if (is_block)
+ prevclef = NOCLEF;
+ else
+ prevclef = CLEF2PRINT(pfeed_p->lastvis);
+
+ } else {
+
+ /*
+ * This will be the second or later score on this page,
+ * if it fits, and the user did not request a manual
+ * pagefeed. Figure out what the minimum padding can
+ * be between this score and the previous. "ink" is
+ * the distance things on the bottom visible staff of
+ * the previous score extend from its bottom line down,
+ * plus the distance things on the top visible staff of
+ * the current score extend from its top line up.
+ * curminpad is the minimum white space the user wants
+ * to allow between scores.
+ */
+ if (is_block) {
+ ink = pfeed_p->lastdist;
+ clefroom = clefspace(prevclef, 1.0, NOCLEF,
+ 1.0, NO);
+ } else {
+ ink = pfeed_p->lastdist + (cfeed_p->c[RN] -
+ staffvertspace(cfeed_p->firstvis)/2.0);
+ clefroom = clefspace(prevclef, 1.0,
+ CLEF2PRINT(cfeed_p->firstvis), 1.0,
+ Score.measnum);
+ }
+ limit = MAX(curminsep, clefroom);
+ if (ink < limit - curminpad) {
+ padding = limit - ink;
+ } else {
+ padding = curminpad;
+ }
+
+ if (padding + scoreheight <= remheight &&
+ cfeed_p->pagefeed == NO) {
+ /* this score fits on this page */
+ remheight -= padding + scoreheight;
+ cursep[totscores] = ink + padding;
+ maxsep[totscores] = curmaxsep;
+ curpad[totscores] = padding;
+ maxpad[totscores] = curmaxpad;
+ totscores++;
+ pfeed_p = cfeed_p;
+ mainll_p = mainll_p->next;
+ if (is_block)
+ prevclef = NOCLEF;
+ else
+ prevclef = CLEF2PRINT(pfeed_p->lastvis);
+ } else {
+ /* the score does not fit */
+ /*
+ * Set pad below the bottom score. If there is
+ * a footer or bottom, use the values from
+ * scorepad. If not, force both to 0, so that
+ * none will be allowed.
+ */
+ if (foot_p->height + botheight > 0.0) {
+ curpad[totscores] = curminpad;
+ maxpad[totscores] = curmaxpad;
+ } else {
+ curpad[totscores] = 0.0;
+ maxpad[totscores] = 0.0;
+ }
+
+ abspage(page_p, cursep, maxsep, curpad,
+ maxpad, totscores,
+ remheight, y_start);
+ pfeed_p = 0;
+ }
+ }
+ }
+
+ /* in case it changes, remember the original page_p */
+ origpage_p = page_p;
+
+ /* find out what is after the last FEED */
+ if (page_p->next != 0 && (page_p->next->str == S_CLEFSIG ||
+ page_p->next->str == S_BLOCKHEAD)) {
+ /*
+ * The last top-of-page feed has music/block(s) after it. Let
+ * page_p continue to point at it, and for now let gridpage_p
+ * be null.
+ */
+ gridpage_p = 0;
+ } else {
+ /*
+ * The last top-of-page feed is after all music/blocks. Point
+ * page_p at the previous one, and use this one for gridpage_p.
+ */
+ gridpage_p = page_p;
+ page_p = ppage_p;
+ }
+
+ /*
+ * Before distributing the scores on the last page, if there are chord
+ * grids to be printed at the end, find whether they fit on this page
+ * (their height doesn't exceed remheight minus white). If so, the
+ * subroutine places them at the bottom and returns their height. If
+ * they don't fit, it returns zero and puts them on a separate page.
+ */
+ if (Atend_info.grids_used > 0) {
+ float gridheight;
+
+ /*
+ * In case grids need to go on later page(s), we need to make
+ * sure there is a FEED at the end of the MLL. Its top_p and
+ * bot_p will be used on the first grid page, and top2_p and
+ * bot2_p will be used on later pages.
+ */
+ if (gridpage_p == 0) {
+ /* find last thing in MLL that's not LINE/CURVE/PRHEAD*/
+ for (mainll_p = Mainlltc_p;
+ mainll_p->str == S_LINE ||
+ mainll_p->str == S_CURVE ||
+ mainll_p->str == S_PRHEAD;
+ mainll_p = mainll_p->prev)
+ ;
+ if (mainll_p->str == S_FEED) {
+ /* FEED, so reuse for gridpage FEED */
+ /* (it wasn't a top-of-page FEED before) */
+ gridpage_p = mainll_p;
+ } else {
+ /* alloc new FEED to be used for grid pages */
+ gridpage_p = newMAINLLstruct(S_FEED, -1);
+ insertMAINLL(gridpage_p, Mainlltc_p);
+ }
+
+ /*
+ * Both the first and later grid pages should use what
+ * is currently remembered for top2 and bot2.
+ */
+ gridpage_p->u.feed_p->top_p =
+ gridpage_p->u.feed_p->top2_p = rememtop2_p;
+ gridpage_p->u.feed_p->bot_p =
+ gridpage_p->u.feed_p->bot2_p = remembot2_p;
+ } else {
+ /* set pointers that are not already set */
+ if (gridpage_p->u.feed_p->top2_p == 0) {
+ gridpage_p->u.feed_p->top2_p = rememtop2_p;
+ }
+ if (gridpage_p->u.feed_p->top_p == 0) {
+ gridpage_p->u.feed_p->top_p =
+ gridpage_p->u.feed_p->top2_p;
+ }
+ if (gridpage_p->u.feed_p->bot2_p == 0) {
+ gridpage_p->u.feed_p->bot2_p = remembot2_p;
+ }
+ if (gridpage_p->u.feed_p->bot_p == 0) {
+ gridpage_p->u.feed_p->bot_p =
+ gridpage_p->u.feed_p->bot2_p;
+ }
+ }
+
+ /*
+ * (remheight - curminpad) is how much space is available on the
+ * last page for grids. firstpage is needed to know whether
+ * to use Header or Header2 (etc.) in calculations. The next
+ * two parms are needed for finding the correct top and bottom
+ * sizes for the last music page, and any grid-only pages.
+ */
+ gridheight = grids_atend(remheight - curminpad, firstpage,
+ page_p->u.feed_p, gridpage_p->u.feed_p);
+
+ if (gridheight > 0.0) {
+ /* reduce remaining height by grids and curminpad */
+ remheight -= gridheight + curminpad;
+ }
+ }
+
+ /*
+ * Set pad below the bottom score. If there is a footer
+ * or bottom, use the values from scorepad. If not, force
+ * both to 0, so that none will be allowed.
+ */
+ if (foot_p->height + botheight > 0.0) {
+ curpad[totscores] = curminpad;
+ maxpad[totscores] = curmaxpad;
+ } else {
+ curpad[totscores] = 0.0;
+ maxpad[totscores] = 0.0;
+ }
+
+ abspage(origpage_p, cursep, maxsep, curpad, maxpad, totscores,
+ remheight, y_start);
+
+ FREE(cursep);
+ FREE(maxsep);
+ FREE(curpad);
+ FREE(maxpad);
+}
+\f
+/*
+ * Name: abspage()
+ *
+ * Abstract: Set all absolute vertical coordinates on a page.
+ *
+ * Returns: void
+ *
+ * Description: This function positions the scores on this page as well as
+ * possible, and then sets all the absolute vertical coordinates
+ * for the scores and everything in them.
+ */
+
+static void
+abspage(page_p, cursep, maxsep, curpad, maxpad, totscores, remheight,
+ y_start)
+
+struct MAINLL *page_p; /* point at first FEED for this page */
+float cursep[]; /* this score's top line to above score's bottom line */
+float maxsep[]; /* the max we'd like to expand cursep to */
+float curpad[]; /* white pad between this score and above score */
+float maxpad[]; /* the max we'd like to expand curpad to */
+int totscores; /* number of scores on this page */
+double remheight; /* extra vertical space available, to be distributed */
+double y_start; /* Y coord of top of first score (before padding) */
+
+{
+ struct MAINLL *mainll_p;/* point along main LL */
+ struct FEED *feed_p; /* point at a score feed on this page */
+ struct CHORD *ch_p; /* point at a chord on this page */
+ struct STAFF *staff_p; /* point at a staff on this page */
+ float min; /* smallest number in curpad or cursep */
+ float min2; /* second smallest number in curpad or sep */
+ float share; /* space to add to the min numbers each loop */
+ int mins; /* how many numbers are tied for min */
+ int n; /* loop variable */
+ int *is_min; /* pointer to array malloc'ed below */
+ int *hit_max; /* pointer to array malloc'ed below */
+ int allmax; /* have all scores used the max sep allowed? */
+
+
+ debug(32,"abspage file=%s line=%d totscores=%d remheight=%f y_start=%f",
+ page_p->inputfile, page_p->inputlineno, totscores,
+ (float)remheight, (float)y_start);
+ /*
+ * Array to hold which of the distances in curpad or cursep are
+ * minimal.
+ */
+ MALLOCA(int, is_min, MAXSCORES + 1);
+ /*
+ * Malloc an array to hold YES or NO as to whether this score's
+ * curpad or cursep has reached the maximum allowed.
+ */
+ MALLOCA(int, hit_max, MAXSCORES + 1);
+
+ /*
+ * The current values in curpad[] and cursep[] are for the case of
+ * the scores being packed as tightly as the stuff sticking out of them
+ * and the user's specification of minscpad and minscsep allow.
+ * maxpad[] and maxsep[] have the values of maxscpad and maxscsep
+ * above each. Now we need to spread the score out, distributing
+ * remheight appropriately.
+ */
+ /*
+ * First, "smooth out" curpad[], so that the numbers in it will be as
+ * equal as possible, subject to maxpad[], but ignoring maxsep[].
+ */
+ while (remheight > FUDGE) {
+ /*
+ * For each score, remember in hit_max whether its curpad
+ * meets or exceeds the max pad allowed. The fudge factor is
+ * so we'll pretend we made it, even if there is roundoff
+ * error. If all scores' curpads have reached that, we're
+ * done, so break out.
+ */
+ allmax = YES;
+ for (n = 0; n <= totscores; n++) {
+ if (curpad[n] >= maxpad[n] - FUDGE) {
+ hit_max[n] = YES;
+ } else {
+ hit_max[n] = NO;
+ allmax = NO;
+ }
+ }
+ if (allmax == YES) {
+ break;
+ }
+
+ /*
+ * Find the smallest curpad among scores that haven't hit
+ * their max.
+ */
+ min = 1000;
+ for (n = 0; n <= totscores; n++) {
+ if (hit_max[n] == NO && curpad[n] < min)
+ min = curpad[n];
+ }
+
+ mins = 0; /* number of curpads tied for min */
+ min2 = 1000; /* second smallest curpad value */
+
+ /*
+ * In this loop, mark which of the curpads are tied for the
+ * "min" value, and count how many are tied (mins). Also, find
+ * the second smallest value (min2). All this is done only for
+ * scores that haven't hit their max.
+ */
+ for (n = 0; n <= totscores; n++) {
+ if (hit_max[n] == NO) {
+ if (curpad[n] == min) {
+ is_min[n] = YES;
+ mins++;
+ } else {
+ is_min[n] = NO;
+ if (curpad[n] < min2) {
+ min2 = curpad[n];
+ }
+ }
+ }
+ }
+
+ /*
+ * Don't let min2 exceed the maxpad of any eligible score.
+ * That way, when we spread the scores out to min2, we won't be
+ * spreading any of them beyond where they are allowed to go.
+ * In the next loop, ones that have reached their limit will
+ * get hit_max[] == YES, while other scores can continue to be
+ * spread more.
+ */
+ for (n = 0; n <= totscores; n++) {
+ if (hit_max[n] == NO && min2 > maxpad[n]) {
+ min2 = maxpad[n];
+ }
+ }
+
+ /*
+ * We're going to add to all those minimum curpads, either
+ * using up all of remheight, or bringing them up equal to
+ * min2, whichever is lower. We add the same amount to the
+ * curseps, since they change by the same amount as we move
+ * a score.
+ */
+ share = remheight / mins;
+ if (share > min2 - min) {
+ share = min2 - min;
+ }
+ for (n = 0; n <= totscores; n++) {
+ if (hit_max[n] == NO && is_min[n] == YES) {
+ curpad[n] += share;
+ cursep[n] += share;
+ }
+ }
+
+ /* decrement remheight by the amount we just used */
+ remheight -= mins * share;
+ }
+
+ /*
+ * "Smooth out" cursep[], so that the numbers in it will be as
+ * equal as possible, subject to maxsep[], but ignoring maxpad[].
+ * If there is only one score, the first "for" loop won't execute, and
+ * we'll break out.
+ */
+ while (remheight > FUDGE) {
+ /*
+ * For each score, remember in hit_max whether its cursep
+ * meets or exceeds the max sep allowed. The fudge factor is
+ * so we'll pretend we made it, even if there is roundoff
+ * error. If all scores' curseps have reached that, we're
+ * done, so break out.
+ */
+ allmax = YES;
+ for (n = 1; n < totscores; n++) {
+ if (cursep[n] >= maxsep[n] - FUDGE) {
+ hit_max[n] = YES;
+ } else {
+ hit_max[n] = NO;
+ allmax = NO;
+ }
+ }
+ if (allmax == YES) {
+ break;
+ }
+
+ /*
+ * Find the smallest cursep among scores that haven't hit
+ * their max.
+ */
+ min = 1000;
+ for (n = 1; n < totscores; n++) {
+ if (hit_max[n] == NO && cursep[n] < min)
+ min = cursep[n];
+ }
+
+ mins = 0; /* number of curseps tied for min */
+ min2 = 1000; /* second smallest cursep value */
+
+ /*
+ * In this loop, mark which of the curseps are tied for the
+ * "min" value, and count how many are tied (mins). Also, find
+ * the second smallest value (min2). All this is done only for
+ * scores that haven't hit their max.
+ */
+ for (n = 1; n < totscores; n++) {
+ if (hit_max[n] == NO) {
+ if (cursep[n] == min) {
+ is_min[n] = YES;
+ mins++;
+ } else {
+ is_min[n] = NO;
+ if (cursep[n] < min2) {
+ min2 = cursep[n];
+ }
+ }
+ }
+ }
+
+ /*
+ * Don't let min2 exceed the maxsep of any eligible score.
+ * That way, when we spread the scores out to min2, we won't be
+ * spreading any of them beyond where they are allowed to go.
+ * In the next loop, ones that have reached their limit will
+ * get hit_max[] == YES, while other scores can continue to be
+ * spread more.
+ */
+ for (n = 1; n < totscores; n++) {
+ if (hit_max[n] == NO && min2 > maxsep[n]) {
+ min2 = maxsep[n];
+ }
+ }
+
+ /*
+ * We're going to add to all those minimum curseps, either
+ * using up all of remheight, or bringing them up equal to
+ * min2, whichever is lower.
+ */
+ share = remheight / mins;
+ if (share > min2 - min) {
+ share = min2 - min;
+ }
+ for (n = 1; n < totscores; n++) {
+ if (hit_max[n] == NO && is_min[n] == YES) {
+ cursep[n] += share;
+ }
+ }
+
+ /* decrement remheight by the amount we just used */
+ remheight -= mins * share;
+ }
+
+ /* move to top of first score */
+ y_start -= curpad[0];
+
+ feed_p = 0; /* flag that we haven't seen the first FEED yet */
+
+ /*
+ * Loop through the main linked list for this page, setting all
+ * absolute vertical coordinates.
+ */
+ for (mainll_p = page_p, n = 0; mainll_p != 0 && ! (n == totscores &&
+ mainll_p->str == S_FEED); mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* by end of page, SSVs will be up to date for there */
+ asgnssv(mainll_p->u.ssv_p);
+ break;
+
+ case S_FEED:
+ /*
+ * If this is the first FEED on the page, and what
+ * follows is music (not a block), move to the top line
+ * of the first score.
+ */
+ if (feed_p == 0 && IS_CLEFSIG_FEED(mainll_p)) {
+ y_start = y_start - page_p->u.feed_p->c[RN] +
+ staffvertspace(page_p->u.feed_p->firstvis)/2.0;
+ }
+
+ /*
+ * Set the score's absolute coordinates. The feed_p
+ * pointer will be used by other cases in later loops.
+ */
+ feed_p = mainll_p->u.feed_p;
+
+ /* if next is 0, this is a trailing feed, and it */
+ /* really has no meaningful coords */
+ if (mainll_p->next == 0)
+ continue;
+
+ if (mainll_p->next->str == S_BLOCKHEAD) {
+ /* move from top of block to middle of block */
+ y_start -= feed_p->c[RN];
+ } else {
+ /* move from top line of score to middle of
+ * first staff */
+ y_start -= staffvertspace(feed_p->firstvis)/2.0;
+ }
+
+ feed_p->c[AN] = y_start + feed_p->c[RN];
+ feed_p->c[AY] = y_start;
+ feed_p->c[AS] = y_start + feed_p->c[RS];
+
+ /* unless last score, set up y_start for next one */
+ if (n < totscores - 1) {
+ /* top line of next score */
+ y_start = y_start + feed_p->c[RS] +
+ feed_p->lastdist - cursep[n + 1];
+ }
+
+ n++;
+ break;
+
+ case S_CHHEAD:
+ /*
+ * Set each chord's absolute coordinates the same as
+ * the feed. These are pretty arbitrary, since they
+ * are using only for drawing boxes with the MUP_BB
+ * environment variable.
+ */
+ for (ch_p = mainll_p->u.chhead_p->ch_p; ch_p != 0;
+ ch_p = ch_p->ch_p) {
+ ch_p->c[AN] = feed_p->c[AN];
+ ch_p->c[AY] = feed_p->c[AY];
+ ch_p->c[AS] = feed_p->c[AS];
+ }
+ break;
+
+ case S_BAR:
+ /*
+ * Set absolute N, Y, and S for the bar line. Y can be
+ * copied from the score's Y; they are both the center
+ * line of the top visible staff. But the score's N
+ * S can stick out, based on the groups present,
+ * whereas the bar line's N is the top line of the top
+ * staff, and its S is the bottom line of the bottom
+ * staff.
+ */
+ mainll_p->u.bar_p->c[AN] = feed_p->c[AY] +
+ halfstaffhi(feed_p->firstvis);
+ mainll_p->u.bar_p->c[AY] = feed_p->c[AY];
+ mainll_p->u.bar_p->c[AS] = feed_p->c[AS] +
+ feed_p->lastdist;
+ break;
+
+ case S_CLEFSIG:
+ /*
+ * If the clefsig doesn't contain a pseudo bar, just
+ * break. But otherwise, set this bar's coords just
+ * like a normal bar.
+ */
+ if (mainll_p->u.clefsig_p->bar_p == 0)
+ break;
+ mainll_p->u.clefsig_p->bar_p->c[AN] = feed_p->c[AY] +
+ halfstaffhi(feed_p->firstvis);
+ mainll_p->u.clefsig_p->bar_p->c[AY] = feed_p->c[AY];
+ mainll_p->u.clefsig_p->bar_p->c[AS] = feed_p->c[AS] +
+ feed_p->lastdist - halfstaffhi(feed_p->lastvis);
+ break;
+
+ case S_STAFF:
+ /* if visible, set all abs vertical coords on staff */
+ staff_p = mainll_p->u.staff_p;
+ if (staff_p->visible == YES)
+ absstaff(feed_p, staff_p);
+ break;
+ }
+
+ }
+
+ FREE(is_min);
+ FREE(hit_max);
+}
+\f
+/*
+ * Name: absstaff()
+ *
+ * Abstract: Set all absolute vertical coordinates for a STAFF structure.
+ *
+ * Returns: void
+ *
+ * Description: This function sets all the absolute vertical coords for a
+ * STAFF structure; those of the staff itself, and those of
+ * everything hanging off it.
+ */
+
+static void
+absstaff(feed_p, staff_p)
+
+struct FEED *feed_p; /* FEED for the score we're on */
+struct STAFF *staff_p; /* the staff to be set */
+
+{
+ struct GRPSYL *gs_p; /* point at a group of syllable */
+ struct STUFF *stuff_p; /* point at a STUFF structure */
+ struct CRVLIST *pp_p; /* point at a coord for phrase point */
+ int v; /* index to voices or verses */
+ int n; /* loop variable */
+
+
+ debug(32, "absstaff file=%s line=%d", staff_p->groups_p[0]->inputfile,
+ staff_p->groups_p[0]->inputlineno);
+ /* set the staff's own coords */
+ staff_p->c[AN] = feed_p->c[AY] + staff_p->c[RN];
+ staff_p->c[AY] = feed_p->c[AY] + staff_p->c[RY];
+ staff_p->c[AS] = feed_p->c[AY] + staff_p->c[RS];
+
+ /* do the voice(s) */
+ for (v = 0; v < MAXVOICES; v++) {
+ for (gs_p = staff_p->groups_p[v]; gs_p != 0; gs_p = gs_p->next){
+ gs_p->c[AY] = staff_p->c[AY] + gs_p->c[RY];
+ gs_p->c[AN] = staff_p->c[AY] + gs_p->c[RN];
+ gs_p->c[AS] = staff_p->c[AY] + gs_p->c[RS];
+
+ /* if it's a group with notes, do the notes too */
+ if (gs_p->grpcont == GC_NOTES) {
+ for (n = 0; n < gs_p->nnotes; n++) {
+ gs_p->notelist[n].c[AY] = staff_p->c[AY]
+ + gs_p->notelist[n].c[RY];
+ gs_p->notelist[n].c[AN] = staff_p->c[AY]
+ + gs_p->notelist[n].c[RN];
+ gs_p->notelist[n].c[AS] = staff_p->c[AY]
+ + gs_p->notelist[n].c[RS];
+ }
+ }
+ }
+ }
+
+ /* do the verse(s) */
+ for (v = 0; v < staff_p->nsyllists; v++) {
+ for (gs_p = staff_p->syls_p[v]; gs_p != 0; gs_p = gs_p->next){
+ gs_p->c[AY] = staff_p->c[AY] + gs_p->c[RY];
+ gs_p->c[AN] = staff_p->c[AY] + gs_p->c[RN];
+ gs_p->c[AS] = staff_p->c[AY] + gs_p->c[RS];
+ }
+ }
+
+ /* do the stuff */
+ for (stuff_p = staff_p->stuff_p; stuff_p != 0; stuff_p = stuff_p->next){
+ stuff_p->c[AY] = staff_p->c[AY] + stuff_p->c[RY];
+ stuff_p->c[AN] = staff_p->c[AY] + stuff_p->c[RN];
+ stuff_p->c[AS] = staff_p->c[AY] + stuff_p->c[RS];
+
+ /* if it's a phrase/tie/slur, do the phrase points too */
+ if (stuff_p->stuff_type == ST_PHRASE ||
+ stuff_p->stuff_type == ST_TIESLUR ||
+ stuff_p->stuff_type == ST_TABSLUR ||
+ stuff_p->stuff_type == ST_BEND) {
+ for (pp_p = stuff_p->crvlist_p; pp_p != 0;
+ pp_p = pp_p->next)
+ pp_p->y += staff_p->c[AY];
+ }
+ }
+}
+\f
+/*
+ * Name: grids_atend()
+ *
+ * Abstract: Determine placement of chord grids to be printed at the end.
+ *
+ * Returns: height of all the grids printed on this page
+ *
+ * Description: This function determines the placement of chord grids that are
+ * to be printed at the end of the song, and sets up the data in
+ * Atend_info accordingly.
+ */
+
+static double
+grids_atend(vertavail, firstpage, mfeed_p, gfeed_p)
+
+double vertavail; /* space available for grids and spreading out scores*/
+int firstpage; /* is this first page (there's only 1 page of music)?*/
+struct FEED *mfeed_p; /* FEED at start of last music page */
+struct FEED *gfeed_p; /* FEED applying to grid-only pages (may be same) */
+
+{
+ struct GRID *grid_p; /* point at a grid */
+ int ngrids; /* no. of grids used */
+ float north, south, east, west; /* coords for one grid */
+ float farnorth, farsouth, fareast, farwest; /* farthest for any grid */
+ float hstrwid; /* half the width of chord string */
+ float havail; /* horizonal space available */
+ int inrow; /* no. of grids in one row */
+ int nrows; /* no. of rows of grids */
+ float totalheight; /* of all the rows */
+ float white; /* scorepad in inches */
+ float upheight; /* height of header + top */
+ float downheight; /* height of bottom + footer */
+
+
+ debug(32, "grids_atend vertavail=%f", (float)vertavail);
+
+ /* malloc array of pointers to the grids that were used */
+ MALLOCA(struct GRID *, Atend_info.grid_p, Atend_info.grids_used);
+
+ /*
+ * Set pointers to the grids that were used. While doing this, find
+ * the farthest extent of any grid, for each of the 4 directions. The
+ * size of the chord string must also be considered in this.
+ */
+ ngrids = 0;
+ farnorth = farsouth = fareast = farwest = 0.0;
+ for (grid_p = 0; (grid_p = nextgrid(grid_p)) != 0; ) {
+ if (grid_p->used == NO)
+ continue;
+ Atend_info.grid_p[ngrids++] = grid_p;
+ gridsize(grid_p, -1, &north, &south, &east, &west);
+ north += strheight(grid_p->name);
+ hstrwid = strwidth(grid_p->name) / 2.0;
+ if (north > farnorth)
+ farnorth = north;
+ if (south < farsouth)
+ farsouth = south;
+ if (hstrwid > east)
+ east = hstrwid;
+ if (east > fareast)
+ fareast = east;
+ if (-hstrwid < west)
+ west = -hstrwid;
+ if (west < farwest)
+ farwest = west;
+ }
+
+ /* sort the pointers by grid name */
+ qsort((char *)Atend_info.grid_p, ngrids, sizeof (struct GRID *),
+ compgrids);
+
+ /* horizontal available width to use */
+ havail = PGWIDTH - eff_leftmargin((struct MAINLL *)0)
+ - eff_rightmargin((struct MAINLL *)0);
+
+ /*
+ * Find max we could put in one row, allowing padding. Note that we do
+ * not try to optimize the packing at all: the biggest grid coord in
+ * any direction is what we use. The "padding" to the right of the
+ * rightmost grid is not needed, so let it hang into the margin.
+ */
+ inrow = (havail + HPADGRID) / (fareast - farwest + HPADGRID);
+ if (inrow == 0) {
+ ufatal("chord grid is too wide to fit on a page");
+ }
+
+ /* this determines how many rows there will be; it will not change */
+ nrows = (ngrids + inrow - 1) / inrow;
+
+ /*
+ * It could be that the last row would be far from full. So attempt to
+ * spread the grids more equally between rows.
+ */
+ while (nrows > 1 && inrow > 1) {
+ inrow--; /* try one less grid per row */
+ if ((ngrids + inrow - 1) / inrow > nrows) {
+ /* whoops, no. of rows increased, so undo last decr. */
+ inrow++;
+ break;
+ }
+ }
+
+ Atend_info.grids_per_row = inrow;
+
+ /* spread them out appropriately */
+ Atend_info.horz_sep = havail / (nrows == 1 ? ngrids : inrow);
+
+ /*
+ * Normally, the first grid's X is as far from the left margin as the
+ * last (on that line) grid's X is from the right margin. But if any
+ * grids have "N fr", fareast may be bigger than -farwest. So move
+ * everything to the left by half the difference.
+ */
+ Atend_info.firstgrid_x = eff_leftmargin((struct MAINLL *)0) +
+ Atend_info.horz_sep / 2.0 - (fareast + farwest) / 2.0;
+
+ /*
+ * Base the vertical separation on the maximum case plus padding. Of
+ * course, no padding is needed below the bottom row, so subtract it.
+ */
+ Atend_info.vert_sep = farnorth - farsouth + VPADGRID;
+ totalheight = nrows * Atend_info.vert_sep - VPADGRID;
+
+ white = Score.minscpad * STEPSIZE;
+
+ if (totalheight <= vertavail && gfeed_p->pagefeed == NO) {
+ /*
+ * It fits on the last page of music. Set the absolute coord
+ * so that it rests above the footer and/or bottom block (if
+ * any) and bottom margin.
+ */
+ Atend_info.firstgrid_y = EFF_BOTMARGIN + totalheight - farnorth;
+
+ downheight = (firstpage == YES ? &Footer : &Footer2)->height +
+ (mfeed_p->bot_p != 0 ? mfeed_p->bot_p->height : 0.0);
+ if (downheight > 0) {
+ Atend_info.firstgrid_y += downheight + white;
+ }
+
+ Atend_info.rows_per_page = nrows;
+
+ return (totalheight);
+ }
+
+ /*
+ * All grids must go on later page(s). Find how much height must be
+ * reserved for header/top and bottom/footer on those pages. Since
+ * this cannot be the first page, we always use Header2 and Footer2.
+ */
+ upheight = Header2.height +
+ (gfeed_p->top_p != 0 ? gfeed_p->top_p->height : 0.0);
+ downheight = Footer2.height +
+ (gfeed_p->bot_p != 0 ? gfeed_p->bot_p->height : 0.0);
+
+ /* make the grid page FEED a pagefeed, in case it isn't already */
+ gfeed_p->pagefeed = YES;
+
+ /*
+ * It will have to go on other page(s). Set the absolute coord to put
+ * it at the top.
+ */
+ Atend_info.separate_page = YES;
+ Atend_info.firstgrid_y = PGHEIGHT - EFF_TOPMARGIN -
+ upheight - farnorth;
+ if (upheight > 0) {
+ Atend_info.firstgrid_y -= white;
+ }
+
+ /* reset vertavail to the amount of space on a whole page */
+ vertavail = PGHEIGHT - EFF_TOPMARGIN - EFF_BOTMARGIN;
+ if (upheight > 0)
+ vertavail -= upheight + white;
+ if (downheight > 0)
+ vertavail -= downheight + white;
+
+ /* find number of rows per page; must be at least 1 */
+ Atend_info.rows_per_page = (vertavail + VPADGRID) / Atend_info.vert_sep;
+ if (Atend_info.rows_per_page == 0)
+ ufatal("chords grids are too high to fit on a page");
+
+ /*
+ * If there is at least 1 full page, spread the rows out evenly. The
+ * same spacing will be used on later pages, even though the last page
+ * may not be full. That's okay.
+ */
+ if (nrows >= Atend_info.rows_per_page) {
+ Atend_info.vert_sep = (vertavail + VPADGRID) /
+ Atend_info.rows_per_page;
+ }
+
+ return (0.0); /* nothing goes on the last page of music */
+}
+\f
+/*
+ * Name: compgrids()
+ *
+ * Abstract: Compare grid names; used by qsort.
+ *
+ * Returns: negative or positive
+ *
+ * Description: This function returns its result based on whether the grid
+ * pointed to by g1_p should precede or follow g2_p. It uses
+ * their names in alphabetical order, basically, but it also
+ * understands accidentals. They will never be equal because the
+ * grids are all unique.
+ */
+
+static int
+compgrids(g1_p_p, g2_p_p)
+
+#ifdef __STDC__
+const void *g1_p_p; /* the two grid pointers to compare */
+const void *g2_p_p;
+#else
+char *g1_p_p; /* the two grid pointers to compare */
+char *g2_p_p;
+#endif
+
+{
+ char *name[2]; /* pointers into first and second names */
+ char *asc_ptr; /* point at the first name in ASCII */
+ char chbuff[MAXCHNAME]; /* hold the ASCII name of the first chord */
+ int accnum[2]; /* accidental number, -2 to 2 (&& to x) */
+ int ridx[2]; /* index to rest of string */
+ int k; /* loop variable */
+
+
+ /*
+ * Translate the chords names to the way the user entered them (as
+ * closely as possible). Since ascii_str() overwrites the same static
+ * area each time, we have to copy the first name to our own buffer.
+ * Rather than wasting time using malloc(), just put it in a fixed
+ * buffer. If someone has an absurd name longer than MAXCHNAME, just
+ * cut it off.
+ */
+ asc_ptr = ascii_str((*(struct GRID **)g1_p_p)->name, YES, NO, TM_CHORD);
+ if ((int)strlen(asc_ptr) < MAXCHNAME) {
+ (void)strcpy(chbuff, asc_ptr);
+ } else {
+ (void)strncpy(chbuff, asc_ptr, MAXCHNAME - 1);
+ chbuff[MAXCHNAME - 1] = '\0';
+ }
+ name[0] = chbuff;
+ name[1] = ascii_str((*(struct GRID **)g2_p_p)->name, YES, NO, TM_CHORD);
+
+ /*
+ * If chord letters differ, return based on that. For bizarre cases
+ * like letters not A through G, or null string, que sera sera.
+ */
+ if (name[0][0] != name[1][0])
+ return (name[0][0] - name[1][0]);
+
+ /*
+ * The first chars (presumably chord letters) were the same. They
+ * can't be \0 because then the whole strings would be equal (null
+ * string) but we know chord names are unique. For each name, set a
+ * number for its accidental, and index to what follows, if anything.
+ */
+ for (k = 0; k < 2; k++) {
+ switch (name[k][1]) {
+ case '&':
+ if (name[k][2] == '&') {
+ accnum[k] = -2; /* double flat */
+ ridx[k] = 3;
+ } else {
+ accnum[k] = -1; /* flat */
+ ridx[k] = 2;
+ }
+ break;
+ case '#':
+ accnum[k] = 1; /* sharp */
+ ridx[k] = 2;
+ break;
+ case 'x':
+ accnum[k] = 2; /* double sharp */
+ ridx[k] = 2;
+ break;
+ default:
+ accnum[k] = 0; /* no acc is like a natural */
+ ridx[k] = 1;
+ break;
+ }
+ }
+
+ /* if accidentals differ, that rules */
+ if (accnum[0] != accnum[1])
+ return (accnum[0] - accnum[1]);
+
+ /* else the rest of it decides */
+ return (strcmp(&name[0][ridx[0]], &name[1][ridx[1]]));
+}
+\f
+/*
+ * Name: proc_css()
+ *
+ * Abstract: Process groups involved with cross staff stemming.
+ *
+ * Returns: void
+ *
+ * Description: This function does all the remaining work necessary for groups
+ * involved in cross staff stemming.
+ */
+
+static void
+proc_css()
+
+{
+ struct MAINLL *mainll_p; /* point along main LL */
+ struct MAINLL *prevvis_p; /* previous visible staff */
+ struct MAINLL *nextvis_p; /* next visible staff */
+ struct TIMEDSSV *tssv_p; /* point along a timed SSV list */
+ struct STAFF *thisstaff_p; /* point at a staff */
+ struct GRPSYL *thisg_p; /* point at a group */
+ struct STUFF *stuff_p; /* point at a stuff structure */
+ struct CRVLIST *pp_p; /* point at a coord for phrase point */
+ RATIONAL vtime; /* start time of groups */
+ int vidx; /* voice index */
+
+
+ debug(16, "proc_css");
+ initstructs(); /* clean out old SSV info */
+
+ /*
+ * Loop through the whole MLL, looking for visible staffs, and keeping
+ * SSVs up to date (including midmeasure SSVs, since CSS notes are
+ * affected by clef changes).
+ */
+ prevvis_p = 0;
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+ case S_STAFF:
+ thisstaff_p = mainll_p->u.staff_p;
+ /* if staff is invisible, skip it */
+ if (thisstaff_p->visible == NO) {
+ continue;
+ }
+ break; /* go handle this visible staff */
+ case S_SSV:
+ /* assign normal SSV */
+ asgnssv(mainll_p->u.ssv_p);
+ continue;
+ case S_BAR:
+ /* assign preceding measure's timed SSVs */
+ for (tssv_p = mainll_p->u.bar_p->timedssv_p;
+ tssv_p != 0;
+ tssv_p = tssv_p->next) {
+ asgnssv(&tssv_p->ssv);
+ }
+ /* FALL THROUGH */
+ default:
+ /* set prev to null in preparation for next measure */
+ prevvis_p = 0;
+ continue;
+ }
+
+ /* look for next visible staff, skipping invisible */
+ for (nextvis_p = mainll_p->next; nextvis_p != 0 &&
+ nextvis_p->str == S_STAFF &&
+ nextvis_p->u.staff_p->visible == NO;
+ nextvis_p = nextvis_p->next) {
+ ;
+ }
+ /* if no more visible staffs in score, set next to null */
+ if (nextvis_p != 0 && nextvis_p->str != S_STAFF) {
+ nextvis_p = 0;
+ }
+
+ /*
+ * thisstaff_p is a visible staff, and prevvis_p and nextvis_p
+ * are the MLL structs for the previous and next visible staffs,
+ * if they exist. Loop through the voices on the this staff.
+ */
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ /*
+ * Loop through the groups of this voice, keeping track
+ * of the elapsed time, looking for groups that have
+ * CSS, and calling one_css() for them.
+ */
+ vtime = Zero;
+ for (thisg_p = thisstaff_p->groups_p[vidx]; thisg_p !=0;
+ vtime = radd(vtime, thisg_p->fulltime),
+ thisg_p = thisg_p->next) {
+
+ switch (thisg_p->stemto) {
+ case CS_SAME:
+ continue;
+ case CS_ABOVE:
+ if (prevvis_p == 0) {
+ l_ufatal(mainll_p->inputfile,
+ mainll_p->inputlineno,
+ "cannot cross staff stem 'with above' from top visible staff");
+ }
+ one_css(thisstaff_p,
+ prevvis_p->u.staff_p,
+ thisg_p, vtime);
+ break;
+ case CS_BELOW:
+ if (nextvis_p == 0) {
+ l_ufatal(mainll_p->inputfile,
+ mainll_p->inputlineno,
+ "cannot cross staff stem 'with below' from bottom visible staff");
+ }
+ one_css(thisstaff_p,
+ nextvis_p->u.staff_p,
+ thisg_p, vtime);
+ break;
+ }
+ }
+ }
+
+ prevvis_p = mainll_p;
+ }
+
+ /*
+ * Now we have to call beamstem() again, to do the work that it
+ * couldn't do before on groups affected by CSS.
+ */
+ CSSpass = YES;
+ beamstem();
+
+ /*
+ * Do "horizontal avoidance": moving CSS groups sideways if necessary
+ * because they would collide with groups on the other staff.
+ */
+ horzavoid();
+
+ /*
+ * Back in relvert.c, we skipped placing tie/slur/bend/phrases whose
+ * endpoint groups were affected by CSS. Now that we know where the
+ * final group boundaries are, we set up the coords for these items.
+ * tieslur_points and phrase_points destroy groups' AN and AS, and
+ * depends on them starting out as zero. So zero them now and restore
+ * them later. Because these items can cross bar lines, we need
+ * to zap all of these coords in this first loop, and have a separate
+ * loop to do the main work (and restore the groups' coords).
+ */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ if (mainll_p->str != S_STAFF) {
+ continue;
+ }
+ thisstaff_p = mainll_p->u.staff_p;
+
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ for (thisg_p = thisstaff_p->groups_p[vidx];
+ thisg_p != 0; thisg_p = thisg_p->next) {
+ thisg_p->c[AN] = 0.0;
+ thisg_p->c[AS] = 0.0;
+ }
+ }
+ }
+
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ if (mainll_p->str != S_STAFF) {
+ continue;
+ }
+ thisstaff_p = mainll_p->u.staff_p;
+
+ /*
+ * Find and handle every tie/slur/bend/phrase starting in this
+ * staff.
+ */
+ for (stuff_p = thisstaff_p->stuff_p;
+ stuff_p != 0; stuff_p = stuff_p->next) {
+ switch (stuff_p->stuff_type) {
+ case ST_PHRASE:
+ if (css_affects_phrase(stuff_p,
+ mainll_p) == YES) {
+ phrase_points(mainll_p, stuff_p);
+
+ stuff_p->c[AY] = thisstaff_p->c[AY]
+ + stuff_p->c[RY];
+ stuff_p->c[AN] = thisstaff_p->c[AY]
+ + stuff_p->c[RN];
+ stuff_p->c[AS] = thisstaff_p->c[AY]
+ + stuff_p->c[RS];
+
+ /* do the phrase points too */
+ for (pp_p = stuff_p->crvlist_p;
+ pp_p != 0; pp_p = pp_p->next) {
+
+ pp_p->y += thisstaff_p->c[AY];
+ }
+ }
+ break;
+ case ST_TIESLUR:
+ case ST_BEND:
+ if (css_affects_tieslurbend(stuff_p,
+ mainll_p) == YES) {
+ if (stuff_p->stuff_type == ST_TIESLUR) {
+ tieslur_points(mainll_p, stuff_p);
+ } else {
+ bend_points(mainll_p, stuff_p);
+ }
+
+ stuff_p->c[AY] = thisstaff_p->c[AY]
+ + stuff_p->c[RY];
+ stuff_p->c[AN] = thisstaff_p->c[AY]
+ + stuff_p->c[RN];
+ stuff_p->c[AS] = thisstaff_p->c[AY]
+ + stuff_p->c[RS];
+
+ /* do the tie/slur/bend points too */
+ for (pp_p = stuff_p->crvlist_p;
+ pp_p != 0; pp_p = pp_p->next) {
+
+ pp_p->y += thisstaff_p->c[AY];
+ }
+ }
+ break;
+ }
+ }
+
+ /*
+ * phrase_points destroys groups' AN and AS. And some code in
+ * the second pass of beamstem.c doesn't set the absolute
+ * coords of groups. So go through now and set the absolute
+ * coords of all groups.
+ */
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ for (thisg_p = thisstaff_p->groups_p[vidx];
+ thisg_p != 0; thisg_p = thisg_p->next) {
+ thisg_p->c[AN] = thisstaff_p->c[AY]
+ + thisg_p->c[RN];
+ thisg_p->c[AY] = thisstaff_p->c[AY]
+ + thisg_p->c[RY];
+ thisg_p->c[AS] = thisstaff_p->c[AY]
+ + thisg_p->c[RS];
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: one_css()
+ *
+ * Abstract: Process one group involved with cross staff stemming.
+ *
+ * Returns: void
+ *
+ * Description: This function processes one CSS group. It moves the CSS notes
+ * in the group to fall into the correct place on the other staff.
+ * When necessary, it also adjusts the group boundary.
+ */
+
+static void
+one_css(ts_p, os_p, tg_p, time)
+
+struct STAFF *ts_p; /* This Staff, the normal one for the grpsyl */
+struct STAFF *os_p; /* Other Staff that the grpsyl has notes on */
+struct GRPSYL *tg_p; /* This Grpsyl */
+RATIONAL time; /* time offset of this grpsyl */
+
+{
+ struct GRPSYL *og_p; /* Other Grpsyl (some grpsyl on other staff) */
+ int foundclef; /* found a clef change on other staff? */
+ RATIONAL cleftime; /* time at which the last clef change happens*/
+ RATIONAL tt; /* temporary time variable */
+ float offset; /* distance from old note position to new */
+ int upfromc4; /* steps up from middle C */
+ int clef; /* clef in force on other staff */
+ int vidx; /* voice index */
+ int n; /* loop variable */
+
+
+ /*
+ * Set globals like Staffscale according our staff. The parse phase
+ * ensures that the two staffs have the same staffscale.
+ */
+ set_staffscale(ts_p->staffno);
+
+ /*
+ * We need to find out what clef is in force on the other staff. We
+ * start with the current value; but it may change midmeasure. We
+ * can't just use the timed SSVs, because there are weird cases
+ * where the clef got put farther to the right (because the clef was
+ * changed before rests or spaces). So we have to search all the
+ * voices for clefs. We look for the rightmost clef that does not
+ * exceed the given time value.
+ */
+ /* find clef in force on other staff at start of this measure */
+ clef = svpath(os_p->staffno, CLEF)->clef;
+ foundclef = NO;
+ cleftime = Zero;
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ tt = Zero;
+ for (og_p = os_p->groups_p[vidx]; og_p != 0 && LE(tt, time);
+ og_p = og_p->next) {
+ /* if group has a clef, and either it's the first group
+ * found to have one or it's later than the latest such
+ * group found so far . . . */
+ if (og_p->clef != NOCLEF &&
+ (foundclef == NO || GT(tt, cleftime))) {
+ foundclef = YES;
+ clef = og_p->clef; /* remember this clef*/
+ cleftime = tt; /* and when it was */
+ }
+ tt = radd(tt, og_p->fulltime);
+ }
+ }
+
+ /*
+ * Everything that has to move will move by the same offset. Calculate
+ * it, using the first CSS note. First find its stepsup on the new
+ * staff, like setnotes.c does for the normal staff. Subtract new
+ * minus old vertical positions.
+ */
+ n = FCNI(tg_p);
+ upfromc4 = (tg_p->notelist[n].octave - 4) * 7 +
+ Letshift[ tg_p->notelist[n].letter - 'a' ];
+ tg_p->notelist[n].stepsup = upfromc4 + clef - ALTO;
+ offset = (os_p->c[AY] + tg_p->notelist[n].stepsup * Stepsize) -
+ tg_p->notelist[n].c[AY];
+
+ /* move all the CSS notes and their dots */
+ for ( ; n <= LCNI(tg_p); n++) {
+ upfromc4 = (tg_p->notelist[n].octave - 4) * 7 +
+ Letshift[ tg_p->notelist[n].letter - 'a' ];
+ tg_p->notelist[n].stepsup = upfromc4 + clef - ALTO;
+ tg_p->notelist[n].c[RN] += offset;
+ tg_p->notelist[n].c[RY] += offset;
+ tg_p->notelist[n].c[RS] += offset;
+ tg_p->notelist[n].c[AN] += offset;
+ tg_p->notelist[n].c[AY] += offset;
+ tg_p->notelist[n].c[AS] += offset;
+ if (tg_p->dots > 0) {
+ tg_p->notelist[n].ydotr += offset;
+ }
+ }
+
+ /*
+ * If the CSS note(s) were not on the stemside, stemlen and group
+ * boundaries were set already in beamstem.c, but we need to fix them
+ * here to account for moving the CSS notes.
+ */
+ if (STEMSIDE_CSS(tg_p) == NO) {
+ if (tg_p->stemlen != 0.0) {
+ tg_p->stemlen += fabs(offset);
+ }
+ if (tg_p->stemdir == UP) {
+ tg_p->c[RS] = tg_p->notelist[tg_p->nnotes - 1].c[RS]
+ - Stdpad;
+ tg_p->c[AS] = tg_p->notelist[tg_p->nnotes - 1].c[AS]
+ - Stdpad;
+ } else {
+ tg_p->c[RN] = tg_p->notelist[0].c[RN] + Stdpad;
+ tg_p->c[AN] = tg_p->notelist[0].c[AN] + Stdpad;
+ }
+ }
+}
+\f
+/*
+ * Name: horzavoid()
+ *
+ * Abstract: Move CSS groups horizontally to avoid collisions on other staff.
+ *
+ * Returns: void
+ *
+ * Description: This function goes through the MLL, and for each CSS group,
+ * calls a function to do horizontal avoidance.
+ */
+
+static void
+horzavoid()
+
+{
+ struct MAINLL *mainll_p; /* point along main LL */
+ struct GRPSYL *gs_p; /* point at a group */
+ int vidx; /* voice index */
+ RATIONAL time; /* start time of a group */
+
+
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ if (mainll_p->str != S_STAFF) {
+ continue;
+ }
+
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ time = Zero;
+ for (gs_p = mainll_p->u.staff_p->groups_p[vidx];
+ gs_p != 0; gs_p = gs_p->next) {
+ if (gs_p->stemto != CS_SAME) {
+ avoidone(mainll_p, gs_p, time);
+ }
+ time = radd(time, gs_p->fulltime);
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: avoidone()
+ *
+ * Abstract: Move CSS group horizontally to avoid collisions on other staff.
+ *
+ * Returns: void
+ *
+ * Description: This function finds whether the given group collides with any
+ * groups on the other staff. If so, it moves that group, along
+ * with all other groups on its staff and their preceding grace
+ * groups, to the right enough so that the group no longer
+ * collides. But it won't move it so far that it would collide
+ * with a later group on its own staff.
+ */
+
+static void
+avoidone(mainll_p, cssg_p, time)
+
+struct MAINLL *mainll_p; /* the MLL for our group's staff */
+struct GRPSYL *cssg_p; /* the CSS group we are working on */
+RATIONAL time; /* time offset of this group */
+
+{
+ struct MAINLL *mll_p; /* point along main LL */
+ int otherstaffno; /* staff where the CSS notes are */
+ struct GRPSYL *gs_p; /* point along grpsyl lists */
+ struct GRPSYL *gs2_p; /* another pointer along grpsyl lists */
+ struct CHORD *ch_p; /* point at chord we're in */
+ float movedist; /* distance to move groups */
+ float otherhorz; /* east boundary of groups on other staff */
+ float slope; /* slope of a beam */
+ float deltax; /* change in X coord of stem tip */
+ int gotone; /* flag variable */
+ int n; /* loop variable */
+
+
+ /* never move the group if the user is forcing it with "ho" */
+ if (cssg_p->ho_usage != HO_NONE) {
+ return;
+ }
+
+ /*
+ * Find the other staff's number.
+ */
+ if (cssg_p->stemto == CS_ABOVE) {
+ for (mll_p = mainll_p->prev; mll_p != 0 && mll_p->str == S_STAFF
+ && mll_p->u.staff_p->visible == NO; mll_p = mll_p->prev) {
+ ;
+ }
+ } else {
+ for (mll_p = mainll_p->next; mll_p != 0 && mll_p->str == S_STAFF
+ && mll_p->u.staff_p->visible == NO; mll_p = mll_p->next) {
+ ;
+ }
+ }
+ if (mll_p == 0 || mll_p->str != S_STAFF) {
+ pfatal("missing staff in avoidone");
+ }
+ otherstaffno = mll_p->u.staff_p->staffno;
+
+ /*
+ * Find what groups, if any, the other staff has at this time value.
+ * First we find the GPRSYL at which the search begins.
+ */
+ if (cssg_p->stemto == CS_ABOVE) {
+ /*
+ * We will start the search at this first grpsyl in the chord.
+ */
+ ch_p = gs2ch(mainll_p, cssg_p);
+ gs_p = ch_p->gs_p;
+ } else {
+ /*
+ * We will start the search at our group, or if it is grace,
+ * the main group that follows.
+ */
+ for (gs_p = cssg_p; gs_p->grpvalue == GV_ZERO;
+ gs_p = gs_p->next) {
+ ;
+ }
+ ch_p = 0; /* remember we don't know the chord */
+ }
+
+ /* find the first GRPSYL, if any, on the other staff at this time */
+ for ( ; gs_p != 0 && gs_p->staffno < otherstaffno; gs_p = gs_p->gs_p) {
+ ;
+ }
+
+ /* if no groups on the other staff, there is no need to move anything */
+ if (gs_p == 0 || gs_p->grpsyl == GS_SYLLABLE ||
+ gs_p->staffno > otherstaffno) {
+ return;
+ }
+
+ /*
+ * Find the easternmost extent of any group on the other staff that
+ * extends far enough vertically to run into our group. We don't care
+ * about grace groups, because they are on the west side, and we are
+ * going to move our group to the east side.
+ */
+ gotone = NO;
+ otherhorz = 0.0; /* avoid "used before set" warning */
+ for ( ; gs_p != 0 && gs_p->grpsyl == GS_GROUP &&
+ gs_p->staffno == otherstaffno; gs_p = gs_p->gs_p) {
+ /* spaces never interfere; mr and mrpt rarely do, and their
+ * coords make them seem really wide, so ignore them too */
+ if (gs_p->grpcont == GC_SPACE || gs_p->is_meas == YES) {
+ continue;
+ }
+ if (cssg_p->stemto == CS_ABOVE && cssg_p->c[AN] <= gs_p->c[AS]){
+ continue;
+ }
+ if (cssg_p->stemto == CS_BELOW && cssg_p->c[AS] >= gs_p->c[AN]){
+ continue;
+ }
+ if (gotone == NO || gs_p->c[AE] > otherhorz) {
+ otherhorz = gs_p->c[AE];
+ gotone = YES;
+ }
+ }
+
+ /*
+ * If our group doesn't reach the other staff's groups vertically,
+ * there is no need to move anything.
+ */
+ if (gotone == NO) {
+ return;
+ }
+
+ /*
+ * Find how far we'd need to move our group to the right to be beyond
+ * any of the other staff's groups. If somehow that is not positive,
+ * there is no need to move.
+ */
+ movedist = otherhorz - cssg_p->c[AW];
+ if (movedist <= 0.0) {
+ return;
+ }
+
+ /* find the first nongrace group at this time on our staff */
+ if (cssg_p->vno == 1) {
+ for (gs_p = cssg_p; gs_p->grpvalue == GV_ZERO;
+ gs_p = gs_p->next) {
+ ;
+ }
+ } else {
+ if (ch_p == 0) {
+ ch_p = gs2ch(mainll_p, cssg_p);
+ }
+ /* find the first GRPSYL, if any, on our staff at this time */
+ for (gs_p = ch_p->gs_p; gs_p != 0 && gs_p->staffno <
+ cssg_p->staffno; gs_p = gs_p->gs_p) {
+ ;
+ }
+ }
+
+ /*
+ * For each group on this staff in this chord, and for all their
+ * preceding grace groups, move them to the east. Adjust stem lengths
+ * of beamed groups.
+ */
+ for ( ; gs_p != 0 && gs_p->grpsyl == GS_GROUP &&
+ gs_p->staffno == cssg_p->staffno; gs_p = gs_p->gs_p) {
+
+ /* never move the group if the user is forcing it with "ho" */
+ if (gs_p->ho_usage != HO_NONE) {
+ continue;
+ }
+
+ /*
+ * If the group is beamed and the beam is not horizontal, the
+ * stem length needs to be changed so it will meet the beam.
+ */
+ if (gs_p->beamloc != NOITEM && gs_p->grpcont == GC_NOTES) {
+ /*
+ * Find a neighboring group in the beamed set so we can
+ * find the beam's slope. The prev group is already
+ * corrected; our group and the next group haven't been
+ * moved yet; so the stems of all 3 are currently
+ * touching the beam and are valid for finding slope.
+ */
+ if (gs_p->beamloc == STARTITEM) {
+ gs2_p = nextsimilar(gs_p);
+ } else {
+ gs2_p = prevsimilar(gs_p);
+ }
+ slope = (find_y_stem(gs2_p) - find_y_stem(gs_p)) /
+ (find_x_stem(gs2_p) - find_x_stem(gs_p));
+
+ deltax = slope * movedist;
+
+ if (gs_p->stemdir == UP) {
+ gs_p->stemlen += deltax;
+ gs_p->c[RN] += deltax;
+ gs_p->c[AN] += deltax;
+ } else {
+ gs_p->stemlen -= deltax;
+ gs_p->c[RS] += deltax;
+ gs_p->c[AS] += deltax;
+ }
+ }
+
+ /*
+ * Always do our group (a nongrace group), then loop
+ * additionally for all preceding graces.
+ */
+ gs2_p = gs_p;
+ do {
+ gs2_p->c[AW] += movedist;
+ gs2_p->c[AX] += movedist;
+ gs2_p->c[AE] += movedist;
+
+ /* if it's a group with notes, do the notes too */
+ if (gs2_p->grpcont == GC_NOTES) {
+ for (n = 0; n < gs2_p->nnotes; n++) {
+ gs2_p->notelist[n].c[AW] += movedist;
+ gs2_p->notelist[n].c[AX] += movedist;
+ gs2_p->notelist[n].c[AE] += movedist;
+ }
+ }
+
+ gs2_p = gs2_p->prev;
+ } while (gs2_p != 0 && gs2_p->grpvalue == GV_ZERO);
+ }
+}
+\f
+/*
+ * Name: set_csb_stems()
+ *
+ * Abstract: Set stem lengths for groups involved in cross staff beaming.
+ *
+ * Returns: void
+ *
+ * Description: This function searches the MLL for cross staff beaming places.
+ * For each one, it calls onecsb() to set the stem lengths.
+ */
+
+static void
+set_csb_stems()
+
+{
+ struct MAINLL *mainll_p; /* point along main LL */
+ struct MAINLL *mll_p; /* point along main LL again */
+ struct STAFF *staff1_p, *staff2_p; /* point at top and bottom staffs */
+ struct GRPSYL *gs1_p, *gs2_p; /* point at top and bottom groups */
+ int v, bv; /* loop thru voices, top and bottom */
+ RATIONAL vtime1, vtime2; /* start time of groups */
+
+
+ debug(16, "set_csb_stems");
+ initstructs(); /* clean out old SSV info */
+
+ /*
+ * Loop through the whole MLL, looking for visible staffs that are
+ * not the last visible staff in their score. Then find cross staff
+ * beamings and call a function to set stem lengths.
+ */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ /* apply SSVs to keep staffscale up to date */
+ if (mainll_p->str == S_SSV) {
+ asgnssv(mainll_p->u.ssv_p);
+ continue;
+ }
+
+ if (mainll_p->str != S_STAFF)
+ continue;
+
+ /* if staff is invisible, skip it */
+ staff1_p = mainll_p->u.staff_p;
+ if (staff1_p->visible == NO)
+ continue;
+
+ /* look for next visible staff, skipping invisible */
+ for (mll_p = mainll_p->next; mll_p != 0 && mll_p->str ==
+ S_STAFF && mll_p->u.staff_p->visible == NO;
+ mll_p = mll_p->next)
+ ;
+ /* if no more visible staffs in score, skip */
+ if (mll_p == 0 || mll_p->str != S_STAFF)
+ continue;
+
+ staff2_p = mll_p->u.staff_p;
+
+ /*
+ * staff1_p and staff2_p are two neighboring visible staffs
+ * (possibly with invisible ones in between). Loop through the
+ * voices on the top staff. For ones that don't exist, their
+ * pointers will be 0 and the inside loop will do nothing.
+ */
+ for (v = 0; v < MAXVOICES; v++) {
+ /*
+ * Loop through the groups of this voice, keeping track
+ * of the elapsed time, looking for the first group of
+ * each CSB set that is joined with the staff below.
+ * It could be any of the voices on the staff below.
+ * The parser deals with any checks concerning voices
+ * being in the way of each other.
+ */
+ vtime1 = Zero;
+ for (gs1_p = staff1_p->groups_p[v]; gs1_p != 0;
+ vtime1 = radd(vtime1, gs1_p->fulltime),
+ gs1_p = gs1_p->next) {
+
+ if (gs1_p->beamto != CS_BELOW ||
+ gs1_p->beamloc != STARTITEM)
+ continue;
+
+ for (bv = 0; bv < MAXVOICES; bv++) {
+ vtime2 = Zero;
+ for (gs2_p = staff2_p->groups_p[bv];
+ gs2_p != 0 &&
+ (LT(vtime2, vtime1) ||
+ gs2_p->grpvalue ==
+ GV_ZERO);
+ gs2_p = gs2_p->next) {
+ vtime2 = radd(vtime2,
+ gs2_p->fulltime);
+ }
+ if (gs2_p != 0 && EQ(vtime2, vtime1) &&
+ gs2_p->beamto == CS_ABOVE &&
+ gs2_p->beamloc == STARTITEM) {
+
+ onecsb(gs1_p, gs2_p);
+ }
+ }
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: onecsb()
+ *
+ * Abstract: Set stem lengths for one instance of cross staff beaming.
+ *
+ * Returns: void
+ *
+ * Description: This function finds the stem directions on the two staffs of
+ * a CSB and the first and last groups of it that are note groups.
+ * If the user didn't specify the stem lengths for those outer
+ * groups (which determines the equation of the beams), it calls a
+ * function to decide what the equation should be; otherwise it
+ * finds the equation in-line. Then it sets all the groups' stem
+ * lengths.
+ */
+
+/*
+ * Given the STARTITEM group of a CSB (whether notes or space), return the
+ * first CSB group that is notes. Embedded grace groups are not part of CSB.
+ */
+#define FIRSTCSB(gs_p) (gs_p->grpcont == GC_NOTES ? gs_p : nextcsb(gs_p))
+
+static void
+onecsb(start1_p, start2_p)
+
+struct GRPSYL *start1_p; /* first GRPSYL on top staff */
+struct GRPSYL *start2_p; /* first GRPSYL on bottom staff */
+
+{
+ struct GRPSYL *gs_p; /* point at a group */
+ int topdir, botdir; /* stem directions of the two lists */
+ struct GRPSYL *end1_p, *end2_p; /* ending group in each list */
+ struct GRPSYL *first_p, *last_p;/* first and last note groups in CSB */
+ float firstx, lastx; /* x coords of end of stems */
+ float firsty, lasty; /* y coords of stems */
+ float b0, b1; /* y intercept and slope of the beam */
+ float stemshift; /* x distance of stem from center of note */
+ float x; /* x coord of a stem */
+ float outstem; /* the part of the stemlen outside notes of group */
+ float hi; /* height of a "with" list item */
+ int n; /* loop variable */
+
+
+ /*
+ * Set globals like Staffscale for use by the rest of the file. The
+ * parse phase ensures that the two staffs have the same staffscale.
+ */
+ set_staffscale(start1_p->staffno);
+
+ topdir = botdir = UP; /* prevent useless 'used before set' warnings */
+
+ /*
+ * Find stemdir of the top groups. (They will be consistent; that was
+ * enforced in dobunch().) Set end1_p to the last group.
+ */
+ for (gs_p = FIRSTCSB(start1_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ if (gs_p->grpcont == GC_NOTES)
+ topdir = gs_p->stemdir;
+ }
+ for (end1_p = start1_p; end1_p != 0 && end1_p->beamloc != ENDITEM;
+ end1_p = nextnongrace(end1_p))
+ ;
+ if (end1_p == 0)
+ pfatal("no ENDITEM in beamed set (onecsb[1])");
+
+ /* do the same for the bottom groups */
+ for (gs_p = FIRSTCSB(start2_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ if (gs_p->grpcont == GC_NOTES)
+ botdir = gs_p->stemdir;
+ }
+ for (end2_p = start2_p; end2_p != 0 && end2_p->beamloc != ENDITEM;
+ end2_p = nextnongrace(end2_p))
+ ;
+ if (end2_p == 0)
+ pfatal("no ENDITEM in beamed set (onecsb[2])");
+
+ if (topdir == UP && botdir == DOWN) {
+ l_ufatal(start2_p->inputfile, start2_p->inputlineno,
+ "when beaming across staffs, cannot have stems up on top staff and down on bottom");
+ }
+
+ /*
+ * Set first_p and last_p to the first and last note groups, whichever
+ * staff(s) they are on.
+ */
+ first_p = start1_p->grpcont == GC_NOTES ? start1_p : start2_p;
+ last_p = end1_p->grpcont == GC_NOTES ? end1_p : end2_p;
+
+ /*
+ * Find half the width of a note head; the stems will need to be
+ * shifted by that amount from the center of the notes so that they
+ * will meet the edge of the notes properly.
+ */
+ stemshift = getstemshift(first_p);
+
+
+ /*
+ * The user must either specify a stem length for both first and last
+ * groups, or neither. (The parse phase enforces that.) If neither,
+ * call a function to determine a line for a beam. It sets b0 and b1
+ * for that line.
+ */
+ if (IS_STEMLEN_UNKNOWN(first_p->stemlen) ||
+ IS_STEMLEN_UNKNOWN(last_p->stemlen)) {
+ /*
+ * User did not provide both outer stem lengths. Find the best
+ * line. But if the stemlen parm was zero, we get back "NO",
+ * and we set all stems to zero.
+ */
+ if (calcline(start1_p, end1_p, start2_p, end2_p, first_p,
+ last_p, topdir, botdir, &b0, &b1) == NO) {
+ for (gs_p = first_p; gs_p != end1_p->next;
+ gs_p = nxtbmnote(gs_p, start1_p, end1_p->next)) {
+ gs_p->stemlen = 0.0;
+ }
+ return;
+ }
+ } else {
+ /*
+ * User provided outer stem lengths. If they are zero, force
+ * all groups to zero and get out. There will be no stems and
+ * no beams.
+ */
+ if (first_p->stemlen == 0.0 && last_p->stemlen == 0.0) {
+ for (gs_p = first_p; gs_p != end1_p->next;
+ gs_p = nxtbmnote(gs_p, start1_p, end1_p->next)) {
+ gs_p->stemlen = 0.0;
+ }
+ return;
+ }
+
+ /*
+ * User provided outer stem lengths; calculate b0 and b1.
+ * First get Y coords of endpoints of first and last stems.
+ */
+ first_p->stemlen *= Staffscale;
+ last_p->stemlen *= Staffscale;
+ firsty = first_p->stemdir == UP ?
+ first_p->notelist[0].c[AY] + first_p->stemlen :
+ first_p->notelist[ first_p->nnotes - 1 ].c[AY]
+ - first_p->stemlen;
+ lasty = last_p->stemdir == UP ?
+ last_p->notelist[0].c[AY] + last_p->stemlen :
+ last_p->notelist[ last_p->nnotes - 1 ].c[AY]
+ - last_p->stemlen;
+ /*
+ * If first and last are opposite, adjust the right end of
+ * the line.
+ */
+ if (first_p->stemdir != last_p->stemdir)
+ lasty += end_bm_offset(start1_p, last_p, 8);
+
+ /* get X coords; calculate b0 and b1 */
+ firstx = first_p->c[AX] + stemshift *
+ (first_p->stemdir == DOWN ? -1 : 1);
+ lastx = last_p->c[AX] + stemshift *
+ (last_p->stemdir == DOWN ? -1 : 1);
+ b1 = (lasty - firsty) / (lastx - firstx); /* slope */
+ b0 = firsty - b1 * firstx; /* y intercept */
+ }
+
+
+ /*
+ * At this point we know the equation for the beams. Figure out and
+ * set the correct stem lengths for all of these beamed groups.
+ */
+ if (topdir == botdir) { /* all stems have the same direction */
+ if (first_p->stemdir == DOWN)
+ stemshift = -stemshift;
+
+ /* loop through the top staff's groups */
+ for (gs_p = FIRSTCSB(start1_p); gs_p != 0; gs_p=nextcsb(gs_p)){
+ x = gs_p->c[AX] + stemshift;
+
+ /* first set stemlen to beam's Y coord minus note's */
+ gs_p->stemlen = (b0 + b1 * x) - BNOTE(gs_p).c[AY];
+
+ /* if stems are down, reverse it */
+ if (gs_p->stemdir == DOWN)
+ gs_p->stemlen = -(gs_p->stemlen);
+
+ finalstemadjust(gs_p);
+ }
+ /* loop through the bottom staff's groups */
+ for (gs_p = FIRSTCSB(start2_p); gs_p != 0; gs_p=nextcsb(gs_p)){
+ x = gs_p->c[AX] + stemshift;
+
+ /* first set stemlen to beam's Y coord minus note's */
+ gs_p->stemlen = (b0 + b1 * x) - BNOTE(gs_p).c[AY];
+
+ /* if stems are down, reverse it */
+ if (gs_p->stemdir == DOWN)
+ gs_p->stemlen = -(gs_p->stemlen);
+
+ /* if negative (note on wrong side of beam), error */
+ if (gs_p->stemlen < 0) {
+ l_ufatal(gs_p->inputfile, gs_p->inputlineno,
+ "stem length was forced negative");
+ }
+
+ finalstemadjust(gs_p);
+ }
+ } else { /* topdir != botdir; some stems have different dir */
+
+ struct GRPSYL *prev_p; /* previous CSB group */
+ struct GRPSYL *firstsub_p; /* first group of a subbeam */
+ struct GRPSYL *lastsub_p; /* last group of a subbeam */
+ struct GRPSYL *sub_p; /* a group in a subbeam */
+ int minbeams; /* no. of beams all share */
+ int beams; /* no. of beams of a group */
+ int slowbasic; /* slowest basictime in CSB */
+ int fastbasic; /* fastest basictime in CSB */
+ int basic; /* a basictime value */
+ float bhigh; /* height of beams */
+ float extra; /* amount to lengthen all stems by */
+
+
+ /*
+ * Find the minimum number of beams of the groups in the CSB
+ * set. That will be the number of beams that they all share.
+ */
+ minbeams = 999; /* way more than there could ever be */
+ for (gs_p = first_p; gs_p != end1_p->next;
+ gs_p = nxtbmnote(gs_p, start1_p, end1_p->next)){
+ beams = drmo(gs_p->basictime) - 2;
+ if (beams < minbeams)
+ minbeams = beams;
+ }
+
+ /*
+ * Find height of all the beams: the distance between the
+ * centers of the outer beams. This should agree with
+ * the numbers in prntdata.c.
+ */
+ bhigh = (minbeams - 1) * Staffscale *
+ (first_p->grpsize == GS_NORMAL ? FLAGSEP : 4.0 * POINT);
+
+ /*
+ * Change the y intercept such that the first stem is lengthened
+ * by half of this height. The line is at the outer beam, from
+ * the perspective of the first group.
+ */
+ b0 += first_p->stemdir == UP ? bhigh / 2.0 : -bhigh / 2.0;
+
+ /*
+ * First set stem lengths to reach the line of the main beam.
+ * At this point, we don't yet include the distance between the
+ * notes of multinote groups. While we're at it, find the
+ * slowest basictime of any group in the CSB set.
+ * Also find the fastest basictime.
+ */
+ slowbasic = 1024; /* faster than any could be */
+ fastbasic = 8; /* slowest that any could be */
+ /* loop through the top staff's groups: all stems down */
+ for (gs_p = FIRSTCSB(start1_p); gs_p != 0; gs_p=nextcsb(gs_p)){
+ x = gs_p->c[AX] - stemshift;
+
+ /* first set stemlen to note's Y coord minus beam's */
+ gs_p->stemlen = gs_p->notelist[ gs_p->nnotes - 1 ].
+ c[AY] - (b0 + b1 * x);
+
+ slowbasic = MIN(slowbasic, gs_p->basictime);
+ fastbasic = MAX(fastbasic, gs_p->basictime);
+ }
+ /* loop through the bottom staff's groups; all stems up */
+ for (gs_p = FIRSTCSB(start2_p); gs_p != 0; gs_p=nextcsb(gs_p)){
+ x = gs_p->c[AX] + stemshift;
+
+ /* first set stemlen to beam's Y coord minus note's */
+ gs_p->stemlen = (b0 + b1 * x) - gs_p->notelist[0].c[AY];
+
+ slowbasic = MIN(slowbasic, gs_p->basictime);
+ fastbasic = MAX(fastbasic, gs_p->basictime);
+ }
+
+ /*
+ * Find the minimum number of beams (based on the slowest
+ * basictime) and subtract 1 to find the number of additional
+ * beams that all groups share beyond the first beam. Multiply
+ * by the distance the centers of neighboring beams.
+ */
+ extra = ((drmo(slowbasic) - 2) - 1) * Staffscale *
+ (first_p->grpsize == GS_NORMAL ? FLAGSEP : 4.0 * POINT);
+
+ /*
+ * For each group with stemdir opposite to that of the first
+ * group, lengthen its stemlen by that amount.
+ */
+ for (gs_p = first_p; gs_p != end1_p->next; gs_p =
+ nxtbmnote(gs_p, start1_p, end1_p->next)) {
+
+ if (gs_p->stemdir != first_p->stemdir)
+ gs_p->stemlen += extra;
+ }
+
+ /*
+ * Loop for each basictime being used that is shorter than the
+ * longest one; that is, for each level of subbeam that is
+ * needed anywhere.
+ */
+ for (basic = slowbasic * 2; basic <= fastbasic; basic *= 2) {
+
+ /* loop through all note groups in the CSB */
+ for (prev_p = 0, gs_p = first_p;
+ gs_p != end1_p->next;
+ prev_p = gs_p, gs_p = nxtbmnote(gs_p, start1_p,
+ end1_p->next)) {
+ /*
+ * If this group has at least as fast a basic-
+ * time as the one we're now dealing with, and
+ * the previous group doesn't (or there is no
+ * previous group), a new subbeam must begin
+ * here (or it could be just a partial beam).
+ * If not, "continue" here.
+ */
+ if (gs_p->basictime < basic || (gs_p != first_p
+ && prev_p->basictime >= basic)){
+ continue;
+ }
+
+ /* point at the start of this subbeam */
+ firstsub_p = gs_p;
+
+ /*
+ * Set lastsub_p to right end of the subbeam,
+ * the group right before the basictime becomes
+ * slower than the level we are dealing with.
+ */
+ for (lastsub_p = sub_p = firstsub_p; sub_p !=
+ end1_p->next; sub_p = nxtbmnote(sub_p,
+ start1_p, end1_p->next)) {
+
+ if (sub_p == 0 ||
+ sub_p->basictime < basic) {
+ break;
+ }
+ lastsub_p = sub_p;
+ }
+
+ /*
+ * Loop through subbeam, lengthening the stems
+ * of all the note groups whose stem direction
+ * is opposite to the first group's. Lengthen
+ * them enough for one more beam.
+ */
+ for (sub_p = firstsub_p; sub_p != end1_p->next;
+ sub_p = nxtbmnote(sub_p, start1_p,
+ end1_p->next)) {
+
+ if (sub_p->stemdir != firstsub_p->
+ stemdir) {
+ sub_p->stemlen +=
+ (sub_p->grpsize == GS_NORMAL ?
+ FLAGSEP : 4.0 * POINT) *
+ Staffscale;
+ }
+
+ if (sub_p == lastsub_p) {
+ break;
+ }
+ }
+ }
+ }
+
+ /* adjust all stems in the CSB */
+ for (gs_p = first_p;
+ gs_p != end1_p->next;
+ gs_p = nxtbmnote(gs_p, start1_p, end1_p->next)) {
+
+ /* if negative (note on wrong side of beam), error */
+ if (gs_p->stemlen < 0) {
+ l_ufatal(gs_p->inputfile, gs_p->inputlineno,
+ "stem length was forced negative");
+ }
+
+ /* add distance between outer notes of group */
+ gs_p->stemlen += (gs_p->notelist[0].stepsup -
+ gs_p->notelist[ gs_p->nnotes - 1 ].stepsup) * Stepsize;
+ }
+
+ }
+
+ /*
+ * In beamstem.c, setgroupvert() expanded the north and south
+ * boundaries of groups to allow for stems (except for CSB groups) and
+ * "with" items (except for CSB where normwith was NO). The exceptions
+ * were because in those cases we needed to know the stem lengths and
+ * we didn't yet. Well, now we know. So do the job here.
+ *
+ * The extension for the stem is the length of the exterior part of it
+ * minus half the size of the stem side note (about a STEPSIZE), since
+ * the note itself is already included in the group boundary. Each
+ * "with" item is allowed enough space for its height, or MINWITHHEIGHT,
+ * whichever is greater. In the print phase, items of height less than
+ * MINWITHHEIGHT will be placed so as to avoid staff lines as much as
+ * possible.
+ */
+ for (gs_p = first_p; gs_p != end1_p->next; gs_p = nxtbmnote(gs_p,
+ start1_p, end1_p->next)) {
+ outstem = gs_p->stemlen
+ - (gs_p->notelist[0].c[RY]
+ - gs_p->notelist[ gs_p->nnotes - 1 ].c[RY]);
+ if (gs_p->stemdir == UP)
+ gs_p->c[AN] += outstem - Stepsize;
+ else
+ gs_p->c[AS] -= outstem - Stepsize;
+
+ if (gs_p->normwith == NO) {
+ for (n = 0; n < gs_p->nwith; n++) {
+ hi = strheight(gs_p->withlist[n]);
+ hi = MAX(hi, Staffscale * MINWITHHEIGHT);
+ if (gs_p->stemdir == UP)
+ gs_p->c[AN] += hi;
+ else
+ gs_p->c[AS] -= hi;
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: calcline()
+ *
+ * Abstract: Calculate the equation of the line for the beams of a CSB set.
+ *
+ * Returns: YES if an equation was calculated, NO if there are no stems.
+ *
+ * Description: This function uses linear regression to figure out where the
+ * best place to put the beam is, for a CSB set. Then, based on
+ * whether the stems on the two staffs have the same direction, it
+ * calls the appropriate function to adjust the results of the
+ * linear regression as needed.
+ */
+
+static int
+calcline(start1_p, end1_p, start2_p, end2_p, first_p, last_p, topdir, botdir,
+ b0_p, b1_p)
+
+struct GRPSYL *start1_p; /* first group in first voice */
+struct GRPSYL *start2_p; /* first group in second voice */
+struct GRPSYL *end1_p; /* last group in first voice */
+struct GRPSYL *end2_p; /* last group in second voice */
+struct GRPSYL *first_p; /* first note group in either voice */
+struct GRPSYL *last_p; /* last note group in either voice */
+int topdir, botdir; /* stem directions of top and bottom voices */
+float *b0_p, *b1_p; /* y intercept and slope to return */
+
+{
+ float defstemsteps; /* default stem length */
+ int one_end_forced; /* is stem len forced on one end only? */
+ int slope_forced; /* is the slope of the beam forced? */
+ float forced_slope; /* slope that the user forced */
+ struct GRPSYL *gs_p; /* loop through the groups in the beamed set */
+ float sx, sy; /* sum of x and y coords of notes */
+ float xbar, ybar; /* average x and y coords of notes */
+ float top, bottom; /* numerator & denominator for finding b1 */
+ float temp; /* scratch variable */
+ float b0, b1; /* y intercept and slope */
+ float deflen; /* default len of a stem, based on basictime */
+ int num; /* number of notes */
+
+
+ if (fabs(first_p->beamslope - NOBEAMANGLE) < 0.001) {
+ slope_forced = NO;
+ forced_slope = 0.0; /* not used, keep lint happy */
+ } else {
+ slope_forced = YES;
+ forced_slope = tan(first_p->beamslope * PI / 180.0);
+ }
+ one_end_forced = IS_STEMLEN_KNOWN(first_p->stemlen) !=
+ IS_STEMLEN_KNOWN(last_p->stemlen);
+
+ /*
+ * Find how long we'd like stems to be, ignoring for the moment groups
+ * that need to be longer due to multiple beams.
+ */
+ /* average default stems lengths of the two voices */
+ defstemsteps = (vvpath(start1_p->staffno, start1_p->vno, STEMLEN)->
+ stemlen +
+ vvpath(start2_p->staffno, start2_p->vno, STEMLEN)->
+ stemlen) / 2.0;
+ /* if this is zero, both stemlens must be zero, so no stems */
+ if (defstemsteps == 0.0 && ! slope_forced && ( ! one_end_forced ||
+ first_p->stemlen == 0.0 || last_p->stemlen == 0.0)) {
+ return (NO);
+ }
+ if (allsmall(start1_p, end1_p) == NO ||
+ allsmall(start2_p, end2_p) == NO) {
+ /* at least one group has a normal size note */
+ deflen = defstemsteps * Stepsize;
+ } else {
+ /* all groups have all small notes */
+ deflen = defstemsteps * SM_STEMFACTOR * Stepsize;
+ }
+
+ /*
+ * Use linear regression to find the best-fit line through where the
+ * ends of the stems would be if they were the standard length. In
+ * setbeam() where a similar thing was done for non-CSB beams, we used
+ * the centers of the notes, which was okay because at this point in
+ * the game we're really just interested in finding the slope. But
+ * in CSB, sometimes the stems of the two staffs go in opposite
+ * directions, so we really need to consider the ends of the stems.
+ *
+ * In this function, we will always be concerned with the X coord of
+ * the group as a whole (disregarding any notes that are on the "wrong"
+ * side of the stem) but the Y coord of the note of the group that's
+ * nearest to the beam (thus the BNOTE macro).
+ *
+ * First get sum of x and y coords, to find averages.
+ */
+ sx = sy = 0;
+ num = 0;
+ for (gs_p = FIRSTCSB(start1_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ sx += gs_p->c[AX];
+ sy += BNOTE(gs_p).c[AY] + (topdir == UP ? deflen : -deflen);
+ num++; /* count number of notes */
+ }
+ for (gs_p = FIRSTCSB(start2_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ sx += gs_p->c[AX];
+ sy += BNOTE(gs_p).c[AY] + (botdir == UP ? deflen : -deflen);
+ num++; /* count number of notes */
+ }
+
+ xbar = sx / num;
+ ybar = sy / num;
+
+ /* accumulate numerator & denominator of regression formula for b1 */
+ top = bottom = 0;
+ for (gs_p = FIRSTCSB(start1_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ temp = gs_p->c[AX] - xbar;
+ top += temp * (BNOTE(gs_p).c[AY] +
+ (topdir == UP ? deflen : -deflen) - ybar);
+ bottom += temp * temp;
+ }
+ for (gs_p = FIRSTCSB(start2_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ temp = gs_p->c[AX] - xbar;
+ top += temp * (BNOTE(gs_p).c[AY] +
+ (botdir == UP ? deflen : -deflen) - ybar);
+ bottom += temp * temp;
+ }
+
+ b1 = top / bottom; /* slope */
+ b0 = ybar - b1 * xbar; /* y intercept */
+
+ /* equation of regression line: y = b0 + b1 * x */
+
+ if (topdir == botdir) {
+ samedir(first_p, last_p, start1_p, start2_p, end1_p, &b0, &b1,
+ deflen, one_end_forced, slope_forced,
+ forced_slope);
+ } else {
+ oppodir(first_p, last_p, start1_p, start2_p, &b0, &b1, deflen,
+ one_end_forced, slope_forced, forced_slope);
+ }
+
+ /* return the calculated slope and intercept */
+ *b0_p = b0;
+ *b1_p = b1;
+
+ return (YES);
+}
+\f
+/*
+ * Name: samedir()
+ *
+ * Abstract: Adjust b0 and b1 when stems are all the same direction.
+ *
+ * Returns: void
+ *
+ * Description: This function is used in the case that the stems on the two
+ * staffs of the CSB have the same direction. It is given the
+ * y intercept and slope of the beam as calculated by linear
+ * regression. It adjusts these values if need be. The algorithm
+ * is similar to the one in setbeam() in beamstem.c. But here we
+ * have to deal with two linked lists of groups, and we don't have
+ * to deal with grace notes or alternations.
+ */
+
+static void
+samedir(first_p, last_p, start1_p, start2_p, end1_p, b0_p, b1_p, deflen,
+ one_end_forced, slope_forced, forced_slope)
+
+struct GRPSYL *first_p, *last_p; /* first and last note groups in CSB */
+struct GRPSYL *start1_p, *start2_p; /* first groups of 1st & 2nd voices */
+struct GRPSYL *end1_p; /* last group of 1st voice */
+float *b0_p, *b1_p; /* y intercept and slope */
+double deflen; /* default len of a stem, based on group size*/
+int one_end_forced; /* is stem len forced on one end only? */
+int slope_forced; /* is the slope of the beam forced? */
+double forced_slope; /* slope that the user forced */
+
+{
+ struct GRPSYL *gs_p; /* loop through the groups in the beamed set */
+ float firstx, lastx; /* x coord of first & last note (end of stem)*/
+ float firsty, lasty; /* y coord of first & last note (end of stem)*/
+ float maxb0, minb0; /* max and min y intercepts */
+ float stemshift; /* x distance of stem from center of note */
+ float b0, b1; /* working copy of y intercept and slope */
+ float temp; /* temp variable */
+ float shortdist; /* amount of stem shortening allowed (inches)*/
+ int bf; /* number of beams/flags */
+ int shortest; /* basictime of shortest note in group */
+
+
+ /* set working copies from the original values */
+ b0 = *b0_p;
+ b1 = *b1_p;
+
+ /*
+ * Find half the width of a note head; the stems will need to be
+ * shifted by that amount from the center of the notes so that they
+ * will meet the edge of the notes properly. If the stems are up,
+ * they will be on the right side of (normal) notes, else left. Set
+ * the X positions for the first and last stems.
+ */
+ stemshift = getstemshift(first_p);
+ if (first_p->stemdir == DOWN)
+ stemshift = -stemshift;
+ firstx = first_p->c[AX] + stemshift; /* first group's stem */
+ lastx = last_p->c[AX] + stemshift; /* last group's stem */
+
+ /*
+ * The original line derived by linear regression must be adjusted in
+ * certain ways. First, override it if the user wants that; otherwise
+ * adjust according to the beamslope parameter.
+ */
+ if (slope_forced) {
+ b1 = forced_slope;
+ } else {
+ b1 = adjslope(start1_p, b1, NO);
+ }
+
+ /*
+ * Calculate a new y intercept (b0). First pass parallel lines
+ * through each note, and record the maximum and minimum y intercepts
+ * that result.
+ */
+ b0 = BNOTE(first_p).c[AY] - b1 * first_p->c[AX];
+ maxb0 = minb0 = b0; /* init to value for first note */
+ /* look at rest of them on each of the two staffs */
+ for (gs_p = FIRSTCSB(start1_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ b0 = BNOTE(gs_p).c[AY] - b1 * gs_p->c[AX];
+ if (b0 > maxb0)
+ maxb0 = b0;
+ else if (b0 < minb0)
+ minb0 = b0;
+ }
+ for (gs_p = FIRSTCSB(start2_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ b0 = BNOTE(gs_p).c[AY] - b1 * gs_p->c[AX];
+ if (b0 > maxb0)
+ maxb0 = b0;
+ else if (b0 < minb0)
+ minb0 = b0;
+ }
+
+ /*
+ * Find the basictime of the shortest note in the CSB set, considering
+ * also any slashes on it. Then update the default stem length based
+ * on that.
+ */
+ shortest = 0;
+ for (gs_p = first_p; gs_p != end1_p->next; gs_p = nxtbmnote(gs_p,
+ start1_p, end1_p->next)) {
+ bf = drmo(gs_p->basictime) - 2; /* no. of beams/flags */
+ bf += abs(gs_p->slash_alt); /* slashes */
+ /*
+ * In certain cases where there are accidentals, we need to
+ * artificially increase bf to keep the beams from overlapping
+ * with the accidental.
+ */
+ if (gs_p != first_p && gs_p->stemdir == UP &&
+ gs_p->notelist[0].accidental != '\0' &&
+ gs_p->notelist[0].accidental != 'x' &&
+ b1 > 0 && bf > 1) {
+ bf += 3.5 * b1 * (STEPSIZE / FLAGSEP) * ((bf > 1) +
+ (gs_p->notelist[0].accidental == 'B'));
+ }
+ if (bf > shortest)
+ shortest = bf;
+ }
+
+ if (shortest > 2) {
+ /* don't use "==" due to floating point roundoff error */
+ if (deflen > 6 * Stepsize) {
+ /* at least one group has a normal size note */
+ deflen += (shortest - 2) * Flagsep;
+ } else {
+ /* all groups have all small notes */
+ deflen += (shortest - 2) * 4.0 * POINT * Staffscale;
+ }
+ }
+
+ /*
+ * The outer edge of the beam should be deflen steps away from the
+ * average position of the notes, as defined by the linear regression
+ * line. But don't allow any note to be closer than a certain number
+ * of steps less than that, the number as given by the stemshorten parm.
+ * We use the average of the two stemshorten values for the two voices.
+ */
+ shortdist = (vvpath(start1_p->staffno, start1_p->vno, STEMSHORTEN)
+ ->stemshorten +
+ vvpath(start2_p->staffno, start2_p->vno, STEMSHORTEN)
+ ->stemshorten) / 2.0 * Stepsize;
+ if (first_p->stemdir == UP) {
+ if (maxb0 - minb0 > shortdist)
+ b0 = maxb0 + deflen - shortdist;
+ else
+ b0 += deflen;
+ } else { /* DOWN */
+ if (maxb0 - minb0 > shortdist)
+ b0 = minb0 - deflen + shortdist;
+ else
+ b0 -= deflen;
+ }
+
+ firsty = b0 + b1 * firstx; /* y coord near left end of beam */
+ lasty = b0 + b1 * lastx; /* y coord near right end of beam */
+
+ /*
+ * At this point, like setbeam(), we could force the stems of notes
+ * that are pointing to the center of their staffs to reach that center
+ * line. But it's questionable whether that should be done in cross
+ * staff beaming situations. We choose not to.
+ */
+
+ /*
+ * If y at the ends of the beam differs by less than a step (allowing a
+ * fudge factor for roundoff error), force the beam horizontal by
+ * setting one end farther away from the notes. But don't do it if the
+ * user is forcing a particular slope.
+ */
+ if ( ! slope_forced && fabs(firsty - lasty) < Stepsize - 0.001) {
+ if (first_p->stemdir == UP) {
+ if (firsty > lasty) {
+ lasty = firsty;
+ } else {
+ firsty = lasty;
+ }
+ } else { /* DOWN */
+ if (firsty < lasty) {
+ lasty = firsty;
+ } else {
+ firsty = lasty;
+ }
+ }
+ }
+
+ /* recalculate slope and y intercept from (possibly) new endpoints */
+ b1 = (lasty - firsty) / (lastx - firstx); /* slope */
+ b0 = firsty - b1 * firstx; /* y intercept */
+
+ /*
+ * At this point, like setbeam(), we could do the equivalent of
+ * embedgrace() and avoidothervoice(). But those functions themselves
+ * wouldn't work here as they are, and/or we don't have the necessary
+ * info handy for calling them. These problems are fairly rare, on top
+ * of cross staff beaming already being fairly rare. If something
+ * collides, the user can always manually set the stem lengths.
+ */
+
+ /*
+ * If one end's stem len was forced but not the other, now is the time
+ * to apply that forcing. So in effect, we have taken the beam as
+ * determined by the normal algorithm and now we change the vertical
+ * coord of this end. If the slope was also forced, move the other
+ * end by the same amount so that the slope won't change.
+ */
+ if (one_end_forced) {
+ if (IS_STEMLEN_KNOWN(first_p->stemlen)) {
+ first_p->stemlen *= Staffscale;
+ temp = firsty;
+ firsty = BNOTE(first_p).c[AY] + first_p->stemlen *
+ (first_p->stemdir == UP ? 1.0 : -1.0);
+ if (slope_forced) {
+ lasty += firsty - temp;
+ }
+ } else {
+ last_p->stemlen *= Staffscale;
+ temp = lasty;
+ lasty = BNOTE(last_p).c[AY] + last_p->stemlen *
+ (last_p->stemdir == UP ? 1.0 : -1.0);
+ if (slope_forced) {
+ firsty += lasty - temp;
+ }
+ }
+
+ /* recalculate */
+ b1 = (lasty - firsty) / (lastx - firstx); /* slope */
+ b0 = firsty - b1 * firstx; /* y intercept */
+ }
+
+ /* send back the newly calculated values */
+ *b0_p = b0;
+ *b1_p = b1;
+}
+\f
+/*
+ * Name: oppodir()
+ *
+ * Abstract: Adjust b0 and b1 when stems are in opposite directions.
+ *
+ * Returns: void
+ *
+ * Description: This function is used in the case that the stems on the two
+ * staffs of the CSB all have opposite directions. It is given
+ * the y intercept and slope of the beam as calculated by linear
+ * regression. It adjusts these values if need be.
+ */
+
+static void
+oppodir(first_p, last_p, start1_p, start2_p, b0_p, b1_p, deflen,
+ one_end_forced, slope_forced, forced_slope)
+
+struct GRPSYL *first_p, *last_p; /* first and last note groups in CSB */
+struct GRPSYL *start1_p, *start2_p; /* first groups of 1st & 2nd voices */
+float *b0_p, *b1_p; /* y intercept and slope */
+double deflen; /* default len of a stem, based on group size*/
+int one_end_forced; /* is stem len forced on one end only? */
+int slope_forced; /* is the slope of the beam forced? */
+double forced_slope; /* slope that the user forced */
+
+{
+ struct GRPSYL *gs_p; /* loop through the groups in the beamed set */
+ float firstx, lastx; /* x coord of first & last note (end of stem)*/
+ float firsty, lasty; /* y coord of first & last note (end of stem)*/
+ float maxb0, minb0; /* max and min y intercepts */
+ float stemshift; /* x distance of stem from center of note */
+ float b0, b1; /* working copy of y intercept and slope */
+ float temp; /* temp variable */
+
+
+ /* set working copies from the original values */
+ b0 = *b0_p;
+ b1 = *b1_p;
+
+ /*
+ * Find half the width of a note head; the stems will need to be
+ * shifted by that amount from the center of the notes so that they
+ * will meet the edge of the notes properly. If the stems are up,
+ * they will be on the right side of (normal) notes, else left. Set
+ * the X positions for the first and last stems.
+ */
+ stemshift = getstemshift(first_p);
+ if (first_p->stemdir == DOWN)
+ stemshift = -stemshift;
+ firstx = first_p->c[AX] + stemshift; /* first group's stem */
+ lastx = last_p->c[AX] + stemshift; /* last group's stem */
+
+ /*
+ * The original line derived by linear regression must be adjusted in
+ * certain ways. First, override it if the user wants that; otherwise
+ * adjust according to the beamslope parameter.
+ */
+ if (slope_forced) {
+ b1 = forced_slope;
+ } else {
+ b1 = adjslope(start1_p, b1, YES);
+ }
+
+ /*
+ * Calculate a new y intercept (b0). First pass parallel lines
+ * through each note, and record the minimum y intercept for the top
+ * staff and the maximum for the bottom staff that result.
+ */
+ minb0 = 1000.0; /* init way positive */
+ /* look at rest of them on each of the two staffs */
+ for (gs_p = FIRSTCSB(start1_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ b0 = BNOTE(gs_p).c[AY] - b1 * gs_p->c[AX];
+ if (b0 < minb0)
+ minb0 = b0;
+ }
+ maxb0 = -1000.0; /* init way negative */
+ for (gs_p = FIRSTCSB(start2_p); gs_p != 0; gs_p = nextcsb(gs_p)) {
+ b0 = BNOTE(gs_p).c[AY] - b1 * gs_p->c[AX];
+ if (b0 > maxb0)
+ maxb0 = b0;
+ }
+
+ /*
+ * Make the y intercept be the average of these. That means the top
+ * staff's shortest stem will be equal in length to the bottom staff's.
+ */
+ b0 = (maxb0 + minb0) / 2.0;
+
+ firsty = b0 + b1 * firstx; /* y coord near left end of beam */
+ lasty = b0 + b1 * lastx; /* y coord near right end of beam */
+
+ /*
+ * If y at the ends of the beam differs by less than a step (allowing a
+ * fudge factor for roundoff error), force the beam horizontal,
+ * averaging the two values.
+ */
+ if ( ! slope_forced && fabs(firsty - lasty) < Stepsize - 0.001) {
+ lasty = (firsty + lasty) / 2.;
+ firsty = lasty;
+ }
+
+ /* recalculate slope and y intercept from (possibly) new endpoints */
+ b1 = (lasty - firsty) / (lastx - firstx); /* slope */
+ b0 = firsty - b1 * firstx; /* y intercept */
+
+ /*
+ * If one end's stem len was forced but not the other, now is the time
+ * to apply that forcing. So in effect, we have taken the beam as
+ * determined by the normal algorithm and now we change the vertical
+ * coord of this end. If the slope was also forced, move the other
+ * end by the same amount so that the slope won't change.
+ */
+ if (one_end_forced) {
+ if (IS_STEMLEN_KNOWN(first_p->stemlen)) {
+ first_p->stemlen *= Staffscale;
+ temp = firsty;
+ firsty = BNOTE(first_p).c[AY] + first_p->stemlen *
+ (first_p->stemdir == UP ? 1.0 : -1.0);
+ if (slope_forced) {
+ lasty += firsty - temp;
+ }
+ } else {
+ last_p->stemlen *= Staffscale;
+ temp = lasty;
+ lasty = BNOTE(last_p).c[AY] + last_p->stemlen *
+ (last_p->stemdir == UP ? 1.0 : -1.0);
+ if (slope_forced) {
+ firsty += lasty - temp;
+ }
+ }
+
+ /* recalculate */
+ b1 = (lasty - firsty) / (lastx - firstx); /* slope */
+ b0 = firsty - b1 * firstx; /* y intercept */
+ }
+
+ /* send back the newly calculated values */
+ *b0_p = b0;
+ *b1_p = b1;
+}
+\f
+/*
+ * Name: nextcsb()
+ *
+ * Abstract: Find the next note group on this staff in this CSB.
+ *
+ * Returns: pointer to next note group in CSB on this staff, 0 if none
+ *
+ * Description: This function looks for the next group on this staff that is
+ * still in this CSB set (therefore nongrace), and contains notes
+ * (not a space).
+ */
+
+static struct GRPSYL *
+nextcsb(gs_p)
+
+struct GRPSYL *gs_p; /* current group, must be in a CSB */
+
+{
+ /* if we are already at the last group in the set, no next group */
+ if (gs_p->beamloc == ENDITEM)
+ return (0);
+
+ /* loop forward, considering only nongrace groups */
+ for (gs_p = nextnongrace(gs_p); gs_p != 0; gs_p = nextnongrace(gs_p)) {
+ /* if we find a note group, return it */
+ if (gs_p->grpcont == GC_NOTES)
+ return (gs_p);
+ /* must be a space (rests not allowed); if enditem, give up */
+ if (gs_p->beamloc == ENDITEM)
+ return (0);
+ }
+
+ return (0); /* hit the end of the measure (shouldn't happen) */
+}
+\f
+/*
+ * Name: nxtbmnote()
+ *
+ * Abstract: Find the next note group in this CSB (this staff or the other).
+ *
+ * Returns: pointer to next note group in CSB, endnext_p if none
+ *
+ * Description: This function looks for the next group that is still in this
+ * CSB set (therefore nongrace), and contains notes (not a space
+ * or a rest), whichever staff it may be on.
+ */
+
+static struct GRPSYL *
+nxtbmnote(gs_p, first_p, endnext_p)
+
+struct GRPSYL *gs_p; /* current group, must be in a CSB */
+struct GRPSYL *first_p; /* first group in top staff of the CSB */
+struct GRPSYL *endnext_p; /* what to return if we hit the end */
+
+{
+ /*
+ * Keep finding the next nonspace group, until we hit the end or we
+ * find one that is not a rest.
+ */
+ do {
+ gs_p = nxtbmgrp(gs_p, first_p, endnext_p);
+ } while (gs_p != endnext_p && gs_p->grpcont != GC_NOTES);
+ return (gs_p);
+}
~mdw / mup / blobdiff