--- /dev/null
+/* Copyright (c) 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005 by Arkkra Enterprises */
+/* All rights reserved */
+/*
+ * Name: abshorz.c
+ *
+ * Description: This file contains functions for setting absolute
+ * horizontal coordinates.
+ */
+
+#include <string.h>
+#include "defines.h"
+#include "structs.h"
+#include "globals.h"
+
+static void barclefsigs P((void));
+static int barwithssv P((struct MAINLL *mainll_p));
+static void setclefsigwid P((struct MAINLL *mainll_p, struct CHHEAD *chhead_p));
+static void abschunk P((struct MAINLL *mainll_p, struct MAINLL *end_p));
+static void tryabs P((struct MAINLL *mainll_p, double scale, int *scores_p,
+ short measinscore[]));
+static int endchunk P((struct MAINLL *mainll_p));
+static double adjust_measwid4mrpt P((double oldmeaswid, struct CHORD *ch_p));
+static void fillclefsig P((struct CLEFSIG *clefsig_p, struct MAINLL *feed_p));
+static struct MAINLL *trymeasure P((struct MAINLL *mainll_p, double scale,
+ float *measwidth_p, float *adjust_p, int *ressv_p));
+static void setabs P((struct MAINLL *start_p, int scores, short measinscore[]));
+static void chkrestart P((struct MAINLL *start_p, struct MAINLL *end_p));
+static void setabsscore P((struct MAINLL *start_p, struct MAINLL *end_p));
+static void setabschord P((struct CHORD *ch_p, double nomx));
+static double effwidth P((struct CHORD *ch_p));
+static double bardiff P((struct MAINLL *mainll_p, struct MAINLL *end_p));
+static void fixfullmeas P((struct CHORD *ch_p, double x));
+static void restore_grpsyl_west P((void));
+static void setipw P((void));
+static void setipwgrpsyl P((struct MAINLL *mainll_p, struct GRPSYL *gs_p));
+static void setipwchord P((struct MAINLL *mainll_p));
+static void fixendings P((void));
+static void fixreh P((void));
+static void clrinhprint P((void));
+static int hidestaffs P((struct MAINLL *mainll_p, struct MAINLL *ml2_p));
+static int silent P((struct MAINLL *mainll_p, struct MAINLL *ml2_p, int s,
+ int *ressv_p));
+static int getmultinum P((struct MAINLL *mll_p));
+
+/*
+ * Depending on which type of clefsig, get its full width, or its effective
+ * width. The latter is for user requested ones, which may overlap notes.
+ */
+#define EFF_WIDCLEFSIG(clefsig_p) \
+ ((clefsig_p)->clefsize == DFLT_SIZE ? width_clefsig(clefsig_p) : \
+ (clefsig_p)->effwidth)
+
+/*
+ * Define the padding after a clefsig. It's greater when there's a pseudobar,
+ * because we need to allow room for carry-in ties/slurs.
+ */
+#define CSP(clefsig_p) (((clefsig_p)->bar_p == 0 ? 2.0 : 9.0) * STDPAD)
+\f
+/*
+ * Name: abshorz()
+ *
+ * Abstract: Set absolute horizontal coordinates of everything.
+ *
+ * Returns: void
+ *
+ * Description: This function inserts the initial FEED of the piece. Then, for
+ * each section of the piece delimited by FEEDs (initial one and
+ * user-requested ones), it breaks it into the necessary number
+ * of scores (inserting more FEEDs), and sets all the horizontal
+ * absolute coordinates. Finally, it does some fix-up work.
+ */
+
+void
+abshorz()
+
+{
+ struct MAINLL *mainll_p; /* point at any MAINLL member */
+ struct MAINLL *ml2_p; /* point at another MAINLL member */
+ struct MAINLL *mainfeed_p; /* point at MAINLL containing a FEED */
+ struct MAINLL *end_p; /* point to end of a chunk of MAINLL */
+ int gotbar; /* found a bar in this chunk */
+
+
+ debug(16, "abshorz");
+ ml2_p = 0; /* prevent useless 'used before set' warning */
+
+ /*
+ * The parse phase put any user-requested score feeds in the main
+ * linked list. We must now insert a FEED before the first measure,
+ * unless the user already requested one there (unlikely!). Later
+ * we'll add more as needed.
+ */
+ for (mainll_p = Mainllhc_p;
+ mainll_p != 0 && mainll_p->str == S_SSV;
+ mainll_p = mainll_p->next)
+ ; /* skip by all initial SSVs */
+
+ if (mainll_p == 0)
+ pfatal("main linked list has nothing but SSVs");
+
+ if (mainll_p->str != S_FEED) {
+ mainfeed_p = newMAINLLstruct(S_FEED, 0);
+ insertMAINLL(mainfeed_p, mainll_p->prev);
+ }
+
+ /* whenever a CLEFSIG is needed after a bar line, put one there */
+ barclefsigs();
+
+ /*
+ * Find each section of the main linked list, delimited by FEEDs.
+ * For each such section, call abschunk() to set the absolute
+ * horizontal coords for things in that chunk. At the end of each
+ * chunk, back up to avoid including SSVs/PRHEADs/LINEs/CURVEs which
+ * might follow the last measure of the chunk. If a chunk contains no
+ * bar lines (like if there was a useless scorefeed at the end),
+ * don't call abschunk().
+ */
+ /* skip anything before first FEED first */
+ for (mainll_p = Mainllhc_p; mainll_p->str != S_FEED;
+ mainll_p = mainll_p->next)
+ ;
+ for (;;) {
+ gotbar = NO;
+ for (end_p = mainll_p->next;
+ end_p != 0 && end_p->str != S_FEED;
+ ml2_p = end_p, end_p = end_p->next) {
+
+ if (end_p->str == S_BAR)
+ gotbar = YES;
+ }
+
+ if (gotbar == NO) {
+ /*
+ * If end_p is 0, this must be the end of the MLL, and
+ * there was a final feed after all the music data.
+ * There is no need to process this chunk.
+ */
+ if (end_p == 0)
+ break;
+ /*
+ * This chunk must contain a BLOCKHEAD. There is no
+ * need to process it. Set the absolute horizontal
+ * coords. Then point mainll_p at the FEED at the end
+ * of the chunk, and go to the next loop.
+ */
+ mainll_p->u.feed_p->c[AW] = eff_leftmargin(mainll_p);
+ mainll_p->u.feed_p->c[AE] = PGWIDTH -
+ eff_rightmargin(end_p);
+ mainll_p->u.feed_p->c[AX] = (mainll_p->u.feed_p->c[AW]
+ + mainll_p->u.feed_p->c[AE]) / 2.0;
+ mainll_p = end_p;
+ continue;
+ }
+
+ while (ml2_p->str == S_SSV || ml2_p->str == S_PRHEAD ||
+ ml2_p->str == S_LINE || ml2_p->str == S_CURVE)
+ ml2_p = ml2_p->prev;
+ abschunk(mainll_p, ml2_p->next);
+ if (end_p == 0)
+ break;
+ mainll_p = end_p;
+ }
+
+ /* restore west boundaries of GRPSYLs that have associated clefs */
+ restore_grpsyl_west();
+
+ /* set inches per whole ( c[INCHPERWHOLE] ) in the relevant structs */
+ setipw();
+
+ /* move endings that start at end of score to the next score */
+ fixendings();
+
+ /* move rehearsal marks at end of a score to the next score */
+ fixreh();
+
+ /* clear the inhibitprint flag on tablature staffs when appropriate */
+ clrinhprint();
+}
+\f
+/*
+ * Name: barclefsigs()
+ *
+ * Abstract: Put a CLEFSIG after each bar line that requires one.
+ *
+ * Returns: void
+ *
+ * Description: This function loops through the main linked list, applying
+ * SSVs as it goes. Whenever an SSV changes clef, key, or time,
+ * it inserts a CLEFSIG into the list to show what will need to
+ * be printed at that point. It also inserts one after any bar
+ * that is a restart.
+ */
+
+static void
+barclefsigs()
+
+{
+ struct MAINLL *mainll_p; /* point at items in main linked list*/
+ struct MAINLL *maincs_p; /* point at MAINLL with CLEFSIG */
+ struct MAINLL *mll_p; /* point along MLL */
+ struct CLEFSIG *clefsig_p; /* point at CLEFSIG being filled in */
+ struct BAR *bar_p; /* point at the bar */
+ struct CHHEAD *chhead_p; /* point at the latest CHHEAD seen */
+ struct TIMEDSSV *tssv_p; /* point along timed SSV list */
+ struct GRPSYL *gs_p; /* point at a group */
+ int oldstaffs; /* no. of staffs before SSVs */
+ int oldvis[MAXSTAFFS + 1]; /* visibility of staffs before SSVs */
+ int oldclef[MAXSTAFFS + 1]; /* clefs before SSVs */
+ int newclef[MAXSTAFFS + 1]; /* clefs after SSVs */
+ int premidclef[MAXSTAFFS + 1]; /* clefs before applying midmeas SSVs*/
+ int oldkey[MAXSTAFFS + 1]; /* effective keys before SSVs */
+ int newkey[MAXSTAFFS + 1]; /* effective keys after SSVs */
+ int oldnorm[MAXSTAFFS + 1]; /* is staff "normal" (5 line, nontab)?*/
+ int newnorm[MAXSTAFFS + 1]; /* is staff "normal" (5 line, nontab)?*/
+ char oldtimerep[MAXTSLEN]; /* time sig before SSVs */
+ int oldclefsequal, oldkeysequal;/* were they equal on all staffs? */
+ int newclefsequal, newkeysequal;/* are they equal on all staffs? */
+ int gottimedssv; /* were there any timed SSVs? */
+ int vidx; /* voice index */
+ int lastclef; /* last clef printed */
+ RATIONAL offset; /* offset of a group in a measure */
+ RATIONAL lastclefoffset; /* offset of last midmeasure clef */
+ int timechg; /* did they change time sig info? */
+ int change; /* did they change clefs/keys/time? */
+ register int s; /* staff number */
+
+
+ debug(16, "barclefsigs");
+ initstructs(); /* clean out old SSV info */
+
+ /* apply any SSVs that come before the first measure */
+ mainll_p = Mainllhc_p;
+ while (mainll_p != 0 && mainll_p->str == S_SSV) {
+ asgnssv(mainll_p->u.ssv_p);
+ mainll_p = mainll_p->next;
+ }
+
+ chhead_p = 0; /* keep lint happy; will be set before used */
+
+ /*
+ * Loop once for each bar line in the piece that has SSV(s) after it,
+ * or is a RESTART. Whenever this occurs, insert a CLEFSIG after them
+ * if required. RESTART always requires it.
+ */
+ for (;;) {
+ /*
+ * Find the next bar that is either followed by an SSV or has
+ * timed SSVs for the preceding measure or is a restart. These
+ * are the cases where a CLEFSIG may be needed. If we hit the
+ * end of the MLL, break out.
+ */
+ while (mainll_p != 0 && ! (mainll_p->str == S_BAR &&
+ (barwithssv(mainll_p) == YES ||
+ mainll_p->u.bar_p->timedssv_p != 0 ||
+ mainll_p->u.bar_p->bartype == RESTART))) {
+ switch (mainll_p->str) {
+ case S_CHHEAD:
+ /* remember the last chhead */
+ chhead_p = mainll_p->u.chhead_p;
+ break;
+ case S_SSV:
+ /* apply SSVs */
+ asgnssv(mainll_p->u.ssv_p);
+ break;
+ }
+ mainll_p = mainll_p->next;
+ }
+ if (mainll_p == 0) {
+ break;
+ }
+ bar_p = mainll_p->u.bar_p;
+
+ /*
+ * If there were timed SSVs in the measure just ended, we need
+ * to make sure that any clef changes requested actually got
+ * printed before some GRPSYL. If the clef was changed on one
+ * staff by <<score clef = whatever>>, some other staff may be
+ * affected and yet not have a GRPSYL after that point before
+ * which the clef can be printed. In that case, we want to
+ * generate a CLEFSIG at this bar line, to print it.
+ */
+ tssv_p = bar_p->timedssv_p;
+ gottimedssv = tssv_p != 0; /* remember if we had any */
+ if (gottimedssv) {
+ /* get clef state before the timed SSVs */
+ for (s = 1; s <= Score.staffs; s++) {
+ premidclef[s] = svpath(s, CLEF)->clef;
+ }
+ /* assign the timed SSVs */
+ for ( ; tssv_p != 0; tssv_p = tssv_p->next) {
+ asgnssv(&tssv_p->ssv);
+ }
+ }
+
+ /*
+ * Save the current number of staffs, whether they are visible,
+ * and all clefs and effective keys in case the SSVs coming
+ * up will change some of these things. Also, save the timesig
+ * info so we can check if it changed (it is settable only in
+ * the score).
+ * Set oldnorm according to whether the staff is "normal",
+ * capable of having a clef or key sig.
+ * Set oldclefsequal and oldkeysequal according to whether all
+ * staffs have the same values for clef and key.
+ */
+ oldclefsequal = oldkeysequal = YES;
+ for (s = 1; s <= Score.staffs; s++) {
+ oldvis[s] = svpath(s, VISIBLE)->visible;
+ oldclef[s] = svpath(s, CLEF)->clef;
+ oldkey[s] = eff_key(s);
+ oldnorm[s] = svpath(s, STAFFLINES)->stafflines == 5 &&
+ svpath(s, STAFFLINES)->printclef == YES &&
+ ! is_tab_staff(s) ? YES : NO;
+ if (s > 1 && oldclef[s - 1] != oldclef[s])
+ oldclefsequal = NO;
+ if (s > 1 && oldkey[s - 1] != oldkey[s])
+ oldkeysequal = NO;
+ }
+ oldstaffs = Score.staffs;
+ strcpy(oldtimerep, Score.timerep);
+
+ /* see if clefs need printing due to timed SSVs */
+ if (gottimedssv) {
+ /* check this on every staff */
+ for (s = 1; s <= Score.staffs; s++) {
+ /* find this staff's MLL structure */
+ for (mll_p = mainll_p; mll_p->str != S_STAFF ||
+ mll_p->u.staff_p->staffno != s;
+ mll_p = mll_p->prev) {
+ ;
+ }
+ /* don't force clefsig for an invisible staff*/
+ if (mll_p->u.staff_p->visible == NO) {
+ continue;
+ }
+ /*
+ * Find last clef that was printed for this
+ * measure. Start with the value of the clef
+ * at the previous bar (before any midmeasure
+ * clefs). Then update with the ones that were
+ * printed midmeasure, until we have the last.
+ */
+ lastclef = premidclef[s];
+ lastclefoffset = rneg(One);
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ /* look down this voice */
+ offset = Zero;
+ for (gs_p = mll_p->u.staff_p->groups_p[
+ vidx]; gs_p != 0; gs_p = gs_p->next) {
+ if (gs_p->clef != NOCLEF &&
+ GT(offset, lastclefoffset)) {
+ lastclef = gs_p->clef;
+ lastclefoffset = offset;
+ }
+ offset = radd(offset,
+ gs_p->fulltime);
+ }
+ }
+ /*
+ * Set the oldclef to the last one printed.
+ * Then later code will create a CLEFSIG, if
+ * necessary.
+ */
+ oldclef[s] = lastclef;
+ }
+ }
+
+ /*
+ * Loop through this set of SSV(s), applying them. If we hit
+ * the end of the main linked list, break out. We don't want
+ * to put a CLEFSIG after the last bar line, regardless of
+ * whether it changed anything.
+ */
+ mainll_p = mainll_p->next;
+ while (mainll_p != 0 && mainll_p->str == S_SSV) {
+ asgnssv(mainll_p->u.ssv_p);
+ mainll_p = mainll_p->next;
+ }
+ /* Retain mainll_p for later; loop onwards using mll_p. Need */
+ /* to keep looking for SSVs in case there is a block here. */
+ mll_p = mainll_p;
+ while (mll_p != 0 && (mll_p->str == S_SSV ||
+ mll_p->str == S_FEED ||
+ mll_p->str == S_BLOCKHEAD)) {
+ if (mll_p->str == S_SSV) {
+ asgnssv(mll_p->u.ssv_p);
+ }
+ mll_p = mll_p->next;
+ }
+ if (mainll_p == 0)
+ break;
+
+
+ /*
+ * Get the new clefs and effective keys.
+ * Again, find out if the clefs and keys are equal on all
+ * staffs.
+ */
+ newclefsequal = newkeysequal = YES;
+ for (s = 1; s <= Score.staffs; s++) {
+ newclef[s] = svpath(s, CLEF)->clef;
+ newkey[s] = eff_key(s);
+ newnorm[s] = svpath(s, STAFFLINES)->stafflines == 5 &&
+ svpath(s, STAFFLINES)->printclef == YES &&
+ ! is_tab_staff(s) ? YES : NO;
+ if (s > 1 && newclef[s - 1] != newclef[s])
+ newclefsequal = NO;
+ if (s > 1 && newkey[s - 1] != newkey[s])
+ newkeysequal = NO;
+ }
+
+ /* first check if any time sig info changed */
+ if (strcmp(Score.timerep, oldtimerep) != 0)
+ timechg = YES;
+ else
+ timechg = NO;
+
+ /*
+ * If the bar was a restart, we treat it as if it were at the
+ * start of a score. That is, we always print the clefs and
+ * key signatures. The clefs are full size, and no naturals
+ * are printed. Print the time signature only if it changed.
+ */
+ if (bar_p->bartype == RESTART) {
+ /*
+ * We always require a CLEFSIG. Allocate one and put
+ * it between where we are now and the preceding
+ * structure.
+ */
+ maincs_p = newMAINLLstruct(S_CLEFSIG, 0);
+ insertMAINLL(maincs_p, mainll_p->prev);
+ clefsig_p = maincs_p->u.clefsig_p;
+
+ clefsig_p->clefsize = DFLT_SIZE; /* full size */
+ clefsig_p->multinum = getmultinum(maincs_p);
+
+ /*
+ * Note: If the number of staffs is changing here, the
+ * following might not be right. But it doesn't
+ * matter, because in that case this CLEFSIG will be
+ * thrown away later anyway.
+ */
+ for (s = 1; s <= oldstaffs; s++) {
+ /* draw nothing if this staff is not "normal" */
+ if (oldnorm[s] == NO || newnorm[s] == NO)
+ continue;
+ clefsig_p->prclef[s] = YES;
+ clefsig_p->sharps[s] = newkey[s];
+ }
+
+ /* print the time signature if it changed */
+ clefsig_p->prtimesig = timechg;
+
+ continue;
+ }
+
+ /*
+ * When the number of staffs changes, special rules apply.
+ * Handle this situation and continue.
+ */
+ if (oldstaffs != Score.staffs) {
+ /*
+ * Identify the cases where no clefsig is needed, and
+ * continue. This is when time didn't change, and no
+ * clefs or keys are to be printed. Clefs are to be
+ * printed only when all the old staffs had the same
+ * clef, all the new ones had the same clef, and the
+ * old and new clefs are different. The analogous rule
+ * holds for keys. This is because, when the number of
+ * staffs changes, we can't really tell which old staff
+ * corresponds to which new staff (if any), so it's
+ * silly to print a clef or key change on any.
+ */
+ if (timechg == NO &&
+ (oldclefsequal == NO ||
+ newclefsequal == NO ||
+ oldclef[1] == newclef[1]) &&
+ (oldkeysequal == NO ||
+ newkeysequal == NO ||
+ oldkey[1] == newkey[1])) {
+ /* no CLEFSIG needed here */
+ continue;
+ }
+
+ /*
+ * Something changed that requires a CLEFSIG. Allocate
+ * one and put it between where we are now and the
+ * preceding structure, the last SSV we applied.
+ */
+ maincs_p = newMAINLLstruct(S_CLEFSIG, 0);
+ insertMAINLL(maincs_p, mainll_p->prev);
+ clefsig_p = maincs_p->u.clefsig_p;
+
+ /* any clefs to be printed should be small size */
+ clefsig_p->clefsize = SMALLSIZE;
+ clefsig_p->multinum = getmultinum(maincs_p);
+
+ /*
+ * Since the number of staffs is changing, there will
+ * be a scorefeed here, and this CLEFSIG will be at the
+ * end of the first score. Every old staff will have
+ * the same info printed by the CLEFSIG, except that
+ * clef and key never exist on "abnormal" staffs. Check
+ * against staff 1 since we know that has to exist on
+ * both sides. It doesn't hurt to mark even invisible
+ * ones.
+ */
+ for (s = 1; s <= oldstaffs; s++) {
+
+ /* draw nothing if this staff is not "normal" */
+ if (oldnorm[s] == NO || newnorm[s] == NO)
+ continue;
+ /*
+ * Draw the new clef if the clefs on each score
+ * are consistent and they changed.
+ */
+ if (oldclefsequal && newclefsequal &&
+ oldclef[1] != newclef[1])
+ clefsig_p->prclef[s] = YES;
+
+ /*
+ * Draw the new key if the keys on each score
+ * are consistent and they changed. See below
+ * for a more detailed explanation.
+ */
+ if (oldkeysequal && newkeysequal &&
+ oldkey[1] != newkey[1]) {
+ clefsig_p->sharps[s] = newkey[1];
+
+ if (newkey[1] == 0) {
+ clefsig_p->naturals[s] =
+ oldkey[1];
+ } else if (svpath(s, CANCELKEY)->
+ cancelkey == YES) {
+ if (oldkey[1] * newkey[1] < 0) {
+ /* 1 has #s, 1 has &s */
+ clefsig_p->naturals[s] =
+ oldkey[1];
+ } else if (abs(oldkey[1]) >
+ abs(newkey[1])){
+ /* new has fewer accs*/
+ clefsig_p->naturals[s] =
+ oldkey[1] - newkey[1];
+ }
+ }
+ }
+ }
+
+ /* print the time signature if it changed */
+ if (timechg == YES)
+ clefsig_p->prtimesig = YES;
+
+ /* set clefsig's effective width */
+ setclefsigwid(maincs_p, chhead_p);
+
+ continue;
+ }
+
+
+ change = timechg;
+
+ /* see if anything else requiring a CLEFSIG changed */
+ for (s = 1; s <= oldstaffs; s++) {
+ if (oldvis[s] == NO ||
+ svpath(s, VISIBLE)->visible == NO)
+ continue;
+ if (oldclef[s] != newclef[s])
+ change = YES;
+ if (oldkey[s] != newkey[s])
+ change = YES;
+ if (change == YES)
+ break; /* don't waste any more time looping */
+ }
+ if (change == NO)
+ continue; /* no visible time, key, clef changed*/
+
+ /*
+ * If we get here, it means either the clef, effective key, or
+ * time changed on some visible staff. Allocate a CLEFSIG and
+ * put it between where we are now and the preceding structure,
+ * which is the last SSV we applied.
+ */
+ maincs_p = newMAINLLstruct(S_CLEFSIG, 0);
+ insertMAINLL(maincs_p, mainll_p->prev);
+ clefsig_p = maincs_p->u.clefsig_p;
+
+ /* any clefs to be printed should be small size */
+ clefsig_p->clefsize = SMALLSIZE;
+ clefsig_p->multinum = getmultinum(maincs_p);
+
+ /*
+ * Loop through the staffs, marking in the CLEFSIG what should
+ * be drawn.
+ */
+ for (s = 1; s <= Score.staffs; s++) {
+ /* draw nothing if this staff is invisible */
+ if (oldvis[s] == NO)
+ continue;
+
+ /* draw nothing if this staff is not "normal" */
+ if (oldnorm[s] == NO || newnorm[s] == NO)
+ continue;
+
+ /* draw the new clef if the clef changed */
+ if (oldclef[s] != newclef[s])
+ clefsig_p->prclef[s] = YES;
+
+ /*
+ * If the effective key changed, draw the new key
+ * signature. But if the new key has 0 sharps, we
+ * should draw naturals in the shape of the old key
+ * signature. And if cancelkey is set, and a sharp key
+ * is changing to a flat key or vice versa, or the
+ * number of sharps or flats is being reduced, we need
+ * enough naturals to cancel the ones being removed.
+ */
+ if (oldkey[s] != newkey[s]) {
+ clefsig_p->sharps[s] = newkey[s];
+ if (newkey[s] == 0) {
+ clefsig_p->naturals[s] = oldkey[s];
+ } else if (svpath(s, CANCELKEY)->
+ cancelkey == YES) {
+ if (oldkey[s] * newkey[s] < 0) {
+ /* 1 has sharps, 1 has flats */
+ clefsig_p->naturals[s] =
+ oldkey[s];
+ } else if (abs(oldkey[s]) >
+ abs(newkey[s])) {
+ /* new has fewer accidentals */
+ clefsig_p->naturals[s] =
+ oldkey[s] - newkey[s];
+ }
+ }
+ }
+ }
+
+ /*
+ * Finally, print the time signature if it changed.
+ */
+ if (timechg == YES)
+ clefsig_p->prtimesig = YES;
+
+ /* set clefsig's effective width, and widestclef */
+ setclefsigwid(maincs_p, chhead_p);
+ }
+}
+\f
+/*
+ * Name: barwithssv()
+ *
+ * Abstract: Is this bar followed by SSV(s), ignoring FEEDs and BLOCKHEADs?
+ *
+ * Returns: YES or NO
+ *
+ * Description: This function is called with the MLL structure for a BAR.
+ * Ignoring the possible presence of FEEDs and BLOCKHEADs, return
+ * YES if the next structure is an SSV.
+ */
+
+static int
+barwithssv(mainll_p)
+
+struct MAINLL *mainll_p; /* for the BAR */
+
+{
+ struct MAINLL *mll_p; /* loop after the BAR */
+
+
+ for (mll_p = mainll_p->next; mll_p != 0; mll_p = mll_p->next) {
+ switch (mll_p->str) {
+ case S_SSV:
+ return (YES);
+ case S_FEED:
+ case S_BLOCKHEAD:
+ break; /* ignore these, keep looking */
+ default:
+ return (NO);
+ }
+ }
+
+ return (NO); /* hit end of MLL */
+}
+\f
+/*
+ * Name: setclefsigwid()
+ *
+ * Abstract: Set effective width and widest clef of a user requested clefsig.
+ *
+ * Returns: void
+ *
+ * Description: This function is called with a user-requested clefsig. If it
+ * contains clefs, they should be printed before the bar line. If
+ * we are lucky, part or all of the clef's widths can overlap notes
+ * on other staffs. The effective width is the full width minus
+ * the amount that can overlap. This function sets the effective
+ * width of the clefsig, and the widest clef that it contains. We
+ * need to do this now, because we need to use the pseudo absolute
+ * coords set by relxchord() before they are overwritten later in
+ * abshorz.c.
+ */
+
+static void
+setclefsigwid(mainll_p, chhead_p)
+
+struct MAINLL *mainll_p; /* point at the given clefsig's MLL struct */
+struct CHHEAD *chhead_p; /* point at the preceding chhead */
+
+{
+ struct MAINLL *m2_p; /* another pointer down the MLL */
+ struct CLEFSIG *clefsig_p; /* point at a clefsig */
+ struct CHORD *ch_p; /* point at a chord */
+ struct STAFF *staff_p; /* point at a staff */
+ struct GRPSYL *gs_p; /* point at a group in a voice */
+ struct GRPSYL *gs2_p; /* point at a group in a chord */
+ float lasteast; /* phony AE of last chord in measure */
+ float size; /* to be used for clef */
+ float clefspace; /* space needed for printing clefs */
+ float clefwid; /* width of a clef */
+ float widestclef; /* width of the widest to be printed */
+ float staffscale; /* scale for a staff */
+ float gap; /* between last group & last chord */
+ int staffno; /* staff number, 1 to MAXSTAFFS */
+ int clef; /* clef type */
+ int v; /* voice number, 0 to 2 */
+
+
+ debug(16, "setclefsigwid");
+
+ clefsig_p = mainll_p->u.clefsig_p; /* convenient pointer */
+
+ /*
+ * Although relxchord() overlaps chords in various ways, it does not
+ * overlap the last chord in the measure with anything following.
+ * And it sets phony absolute coordinates for each chord, based on
+ * pretending that everything is packed as tight as possible. So, as
+ * the rightmost coord of all groups, we can use the AE of the last
+ * chord of the measure just ended.
+ */
+ for (ch_p = chhead_p->ch_p; ch_p->ch_p != 0; ch_p = ch_p->ch_p)
+ ;
+ lasteast = ch_p->c[AE];
+
+ /*
+ * Init the amount of space needed for clefs to be printed. We start
+ * at zero, and whenever a clef is to be printed, we find out how much
+ * of it can't be overlapped; and clefspace keeps track of the maximum
+ * of these for all staffs.
+ */
+ clefspace = 0.0;
+
+ widestclef = 0.0; /* max width of any clef to be printed */
+
+ size = 3.0/4.0 * DFLT_SIZE; /* small size clefs */
+
+ /*
+ * Loop backwards through the preceding measure, looking for visible
+ * staffs to process.
+ */
+ for (m2_p = mainll_p; m2_p->str != S_CHHEAD; m2_p = m2_p->prev) {
+
+ if (m2_p->str != S_STAFF || m2_p->u.staff_p->visible == NO)
+ continue;
+
+ staff_p = m2_p->u.staff_p;
+ staffno = staff_p->staffno;
+
+ /* if no clef, it doesn't need any space */
+ if (clefsig_p->prclef[staffno] == NO)
+ continue;
+
+ /* find width of this clef, including padding */
+ clef = svpath(staffno, CLEF)->clef;
+ staffscale = svpath(staffno, STAFFSCALE)->staffscale;
+ clefwid = (clefwidth(clef, YES) + CLEFPAD) * staffscale;
+
+ /* remember biggest clef width */
+ if (clefwid > widestclef)
+ widestclef = clefwid;
+
+ /* loop through all voices on this staff */
+ for (v = 0; v < MAXVOICES; v++) {
+
+ /* find last group in this voice */
+ gs_p = staff_p->groups_p[v];
+ if (gs_p == 0)
+ continue;
+ for ( ; gs_p->next != 0; gs_p = gs_p->next)
+ ;
+
+ /*
+ * Find out what chord this group belongs to, by
+ * searching down the GRPSYL list hanging off each
+ * chord in this measure.
+ */
+ for (ch_p = chhead_p->ch_p; ch_p != 0;
+ ch_p = ch_p->ch_p) {
+ for (gs2_p = ch_p->gs_p; gs2_p != 0;
+ gs2_p = gs2_p->gs_p) {
+ /* if found, or after the right staff*/
+ if (gs2_p == gs_p || gs2_p->staffno >
+ gs_p->staffno)
+ break;
+ }
+
+ /*
+ * If we found it, find the gap between this
+ * group's AE and the last chord's. If the
+ * amount of the clef's width that does not fit
+ * in that gap is the greatest so far, save it.
+ */
+ if (gs2_p == gs_p) {
+ gap = lasteast -
+ (ch_p->c[AX] + gs_p->c[RE]);
+
+ if (clefwid - gap > clefspace)
+ clefspace = clefwid - gap;
+
+ break; /* look no more */
+ }
+ }
+ } /* loop through voices on a staff */
+ } /* loop through staffs */
+
+ clefsig_p->widestclef = widestclef;
+
+ /* (effective width) = (real width) - (what can overlap) */
+ clefsig_p->effwidth = width_clefsig(clefsig_p) -
+ (widestclef - clefspace);
+}
+\f
+/*
+ * Name: abschunk()
+ *
+ * Abstract: Set the absolute horz. coords of everything in one chunk.
+ *
+ * Returns: void
+ *
+ * Description: This function is given a chunk of the piece, which is
+ * delimited by FEEDs. It estimates how many inches should
+ * be allocated to each whole note of time. Then it calls
+ * tryabs() repeatedly, trying to find a scale factor that
+ * will avoid having the last score be too empty. Finally,
+ * it calls setabs() to set the absolute horizontal coordinates
+ * of everything in the chunk.
+ */
+
+static void
+abschunk(start_p, end_p)
+
+struct MAINLL *start_p; /* FEED at start of chunk of MAINLL */
+struct MAINLL *end_p; /* points after last struct in chunk (or 0) */
+
+{
+ float totwidth; /* total minimal width of this chunk */
+ float totpseudodur; /* total pseudodur of measures in this chunk */
+ struct MAINLL *mainll_p;/* point at items in main linked list*/
+ struct CHORD *ch_p; /* point at a chord */
+ short *measinscore; /* malloc'ed array; bars in each score */
+ float packfact; /* as it was at the start of this score */
+ float lowscale; /* small guess at inches per whole */
+ float highscale; /* large guess at inches per whole */
+ float midscale; /* average of low and high scale */
+ float measwidth; /* width of a measure */
+ int numbars; /* number of measures in this chunk */
+ int scores; /* number of scores needed for this chunk */
+ int reqscores; /* the number of score required */
+ int trial; /* trial number for getting correct scale */
+
+
+ debug(16, "abschunk file=%s line=%d", start_p->inputfile,
+ start_p->inputlineno);
+
+ /*
+ * For our first estimate of how wide to make everything, we need to
+ * add up the total minimal width and total elapsed time.
+ */
+ /* must apply all SSVs from start, to get the right time sig */
+ initstructs(); /* clean out old SSV info */
+ for (mainll_p = Mainllhc_p; mainll_p != start_p;
+ mainll_p = mainll_p->next) {
+ if (mainll_p->str == S_SSV)
+ asgnssv(mainll_p->u.ssv_p);
+ }
+
+ packfact = Score.packfact; /* use current value (start of score) */
+ totwidth = 0; /* start totals at 0 */
+ totpseudodur = 0;
+ numbars = 0;
+
+ /* loop through chunk, adding up width and time */
+ for ( ; mainll_p != end_p; mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* assign to keep time sig accurate */
+ asgnssv(mainll_p->u.ssv_p);
+ break;
+
+ case S_CHHEAD:
+ /*
+ * Add in the minimum widths of all chords in the
+ * measure, and add up the pseudoduration. There are
+ * special things done for mrpt: 1) if all staff(s)
+ * have mrpt, we don't want them to "deserve" as much
+ * space as an mr, so reduce their pseudodur; 2) the
+ * minimum width of the measure must be made wide
+ * enough to contain the symbol. Also, allow room
+ * for any midmeasure clefs. (This will happen
+ * automatically, because the group boundaries still
+ * include their preceding midmeasure clefs at this
+ * point.)
+ */
+ measwidth = 0;
+ ch_p = mainll_p->u.chhead_p->ch_p;
+ if (ABSDIFF(ch_p->width, TEMPMRPTWIDTH) < 0.001) {
+ /* the 0.001 is to allow for roundoff error */
+ ch_p->pseudodur *= 0.5;
+ }
+ for ( ; ch_p != 0; ch_p = ch_p->ch_p) {
+ measwidth += ch_p->width;
+ /* only count time if there is a real width */
+ /* (nonspace, or "us", or padded "s") */
+ if (ch_p->width != 0)
+ totpseudodur += ch_p->pseudodur;
+ }
+ /* add this measure into the total */
+ totwidth += adjust_measwid4mrpt(measwidth,
+ mainll_p->u.chhead_p->ch_p);
+ break;
+
+ case S_CLEFSIG:
+ /* width of clef/key/time to print when changing */
+ totwidth += EFF_WIDCLEFSIG(mainll_p->u.clefsig_p) +
+ CSP(mainll_p->u.clefsig_p);
+ break;
+
+ case S_BAR:
+ /* add width of bar line, and incr no. of bars */
+ totwidth += width_barline(mainll_p->u.bar_p);
+ numbars++;
+ break;
+ }
+ }
+
+ /*
+ * Allocate the measinscore array. We need an element for each score
+ * that this chunk will be broken up into. We don't yet know how
+ * many that will be. So allocate enough for the worst case, where
+ * each measure is so wide that it has to go on a separate score.
+ */
+ MALLOCA(short, measinscore, numbars + 1);
+
+ /*
+ * Our first trial is to allow "packfact" times the minimal
+ * width we have just added up, partly to allow for the stuff at the
+ * start of each score (more CLEFSIGs to be inserted after we know
+ * where the FEEDs are going to be), and partly so things can spread
+ * out nicely.
+ */
+ lowscale = packfact * totwidth / totpseudodur;
+ tryabs(start_p, lowscale, &scores, measinscore);
+
+ /*
+ * If the whole chunk fits on one score, just set the absolute coords
+ * for this score and get out.
+ */
+ if (scores == 1) {
+ setabs(start_p, scores, measinscore);
+ FREE(measinscore);
+ return;
+ }
+
+ /*
+ * However many scores tryabs() says were needed, that is what we will
+ * require. But it's likely that the last score is far from filled up.
+ * It would look bad to just spread out the stuff in the last score.
+ * We want to "balance the load".
+ *
+ * So make up a new scale (highscale) which would probably force us to
+ * use an additional score. Then loop, binary searching, to find a
+ * value for scale almost as big as possible without forcing a new
+ * score.
+ */
+ reqscores = scores;
+ highscale = 3.0 * lowscale;
+ for (trial = 0; trial < 12; trial++) {
+ midscale = (lowscale + highscale) / 2;
+ tryabs(start_p, midscale, &scores, measinscore);
+ if (scores > reqscores) {
+ highscale = midscale;
+ } else { /* must be equal, can never be less */
+ lowscale = midscale;
+ }
+ }
+ /*
+ * If the last one we tried is not a good one, we have to run tryabs
+ * again to reset the scores array properly.
+ */
+ if (midscale != lowscale) {
+ tryabs(start_p, lowscale, &scores, measinscore);
+ }
+
+ setabs(start_p, scores, measinscore);
+
+ FREE(measinscore);
+}
+\f
+/*
+ * Name: tryabs()
+ *
+ * Abstract: Given trial scale, find how many scores are needed, etc.
+ *
+ * Returns: void
+ *
+ * Description: This function, given a proposed scale factor for a chunk
+ * delimited by FEEDs, figures out how many measures would
+ * fit on each score.
+ */
+
+static void
+tryabs(start_p, scale, scores_p, measinscore)
+
+struct MAINLL *start_p; /* FEED at start of chunk of MAINLL */
+double scale; /* inches per "whole" unit of time */
+int *scores_p; /* return number of scores needed */
+short measinscore[]; /* return number of measures in each score */
+
+{
+ struct MAINLL *mainll_p;/* points along main linked list */
+ struct MAINLL *new_p; /* points at first struct in new measure */
+ struct MAINLL *ml2_p; /* another general pointer into MAINLL */
+ struct MAINLL *prevfeed_p;/* where previous FEED is or would go */
+ float remwidth; /* width remaining on this score */
+ float userdelta; /* (user right margin) - (normal right margin)*/
+ int atend; /* are we at the end of the chunk? */
+ struct CLEFSIG clefsig; /* temporary CLEFSIG for start of each score */
+ struct BAR bar; /* temp BAR; may be need by the above CLEFSIG*/
+ float measwidth; /* width needed by one measure */
+ float adjust; /* bar line adjust if last measure in score */
+ int ressv; /* do we have to re-initstructs() and re-SSV?*/
+
+
+ debug(32, "tryabs file=%s line=%d scale=%f", start_p->inputfile,
+ start_p->inputlineno, (float)scale);
+ /* must apply all SSVs from start, to get the right clef/key/time; */
+ setssvstate(start_p);
+
+ mainll_p = start_p;
+
+ /*
+ * Set up for beginning of first score in this chunk.
+ * Find out how much width is available, allowing for
+ * margins and stuff to the left (labels, etc.).
+ */
+ *scores_p = 0; /* no scores yet */
+ /* left margin may have user override; for now, assume right doesn't */
+ remwidth = PGWIDTH - eff_rightmargin((struct MAINLL *)0)
+ - eff_leftmargin(start_p);
+ remwidth -= width_left_of_score(start_p);
+ measinscore[0] = 0;
+
+ /*
+ * If the user overrode the right margin at the end of this chunk, we
+ * need to know the difference between what they requested and what the
+ * normal value is. If they didn't, userdelta will be zero.
+ */
+ userdelta = eff_rightmargin(start_p->next) -
+ eff_rightmargin((struct MAINLL *)0);
+
+ prevfeed_p = start_p; /* init previous FEED to the start of chunk */
+
+ /*
+ * We need to set up a provisional CLEFSIG containing what would need
+ * to be printed at the start of this new score. We can't put it in
+ * the real MAINLL yet, since this function is just trying a
+ * possibility, and cannot alter MAINLL for real. Set a pointer to
+ * a bar, which in real life would be allocated by fillclefsig.
+ * Subtract the clefsig's width from what we have left to work with.
+ */
+ (void)memset((char *)&clefsig, 0, sizeof(clefsig));
+ (void)memset((char *)&bar, 0, sizeof(bar));
+ clefsig.bar_p = &bar;
+ fillclefsig(&clefsig, mainll_p);
+ remwidth -= width_clefsig(&clefsig) + CSP(&clefsig);
+
+ /* loop through chunk, once per measure, finding where FEEDs would go*/
+ for (;;) {
+ /* get width of this measure, and where next one starts */
+ new_p = trymeasure(mainll_p, scale, &measwidth, &adjust,&ressv);
+
+ atend = endchunk(new_p); /* last measure of chunk? */
+
+ if (!atend && (measwidth - adjust) <= remwidth ||
+ atend && (measwidth - adjust) <= remwidth - userdelta ||
+ measinscore[*scores_p] == 0) {
+ /*
+ * There is room for this measure on this score, or
+ * there are no measures here yet so we better force
+ * this one onto there. We'll fail later if this
+ * in fact cannot fit.
+ * Subtract its width from what's left on this score,
+ * and increment the number of measures on it. Point
+ * at the next measure.
+ */
+ remwidth -= measwidth;
+ measinscore[*scores_p]++;
+ mainll_p = new_p;
+
+ /* if we are at the end, inc no. of scores & return */
+ if (atend) {
+ (*scores_p)++;
+ return;
+ }
+ } else {
+ /*
+ * There is not room for this measure on this score.
+ * Increment the number of scores needed.
+ */
+ (*scores_p)++;
+
+ /*
+ * If this last measure ended with SSV(s) after the
+ * bar line that would cause a CLEFSIG, we need to
+ * undo the change so that the new score will start
+ * with the old info. Sadly, we'll have to init
+ * the SSVs and apply them over from the beginning.
+ */
+ if (ressv) {
+ setssvstate(mainll_p);
+ }
+
+ /*
+ * Find out how much width is available, allowing for
+ * margins and stuff to the left (labels, etc.).
+ * For now, assume this is not the last score, so no
+ * user margin override.
+ */
+ remwidth = PGWIDTH - eff_rightmargin((struct MAINLL *)0)
+ - eff_leftmargin((struct MAINLL *)0);
+ remwidth -= pwidth_left_of_score(mainll_p, prevfeed_p);
+
+ prevfeed_p = mainll_p; /* where feed would go */
+
+ /*
+ * We need to set up a provisional CLEFSIG containing
+ * what would need to be printed at the start of this
+ * new score. We can't put it in the real MAINLL yet,
+ * since this function is just trying a possibility,
+ * and cannot alter MAINLL for real. In case a repeat
+ * start is going to be needed, have a bar pointer
+ * ready. Subtract the clefsig's width from what we
+ * have left to work with.
+ */
+ (void)memset((char *)&clefsig, 0, sizeof(clefsig));
+ (void)memset((char *)&bar, 0, sizeof(bar));
+ clefsig.bar_p = &bar;
+ fillclefsig(&clefsig, mainll_p);
+ remwidth -= width_clefsig(&clefsig) + CSP(&clefsig);
+ measinscore[*scores_p] = 0; /* no bars here yet */
+
+ /*
+ * If the measure we just figured is too wide for the
+ * new score we are about to begin, it must be that
+ * we are just padding things too much. (If there
+ * really is too much stuff in the measure, we'll fail
+ * later.) So assume we'll cram in it anyway, set up
+ * 0 width remaining, and prepare for next measure.
+ * We have to reapply the SSVs we removed above, since
+ * we won't be calling trymeasure() again for that
+ * measure.
+ *
+ * If the measure fits, don't do any of this. Just let
+ * trymeasure figure the same one over again, next
+ * time around.
+ */
+ if (!atend && measwidth > remwidth ||
+ atend && measwidth > remwidth - userdelta) {
+ if (ressv) {
+ for (ml2_p = mainll_p; ml2_p != new_p;
+ ml2_p = ml2_p->next) {
+ if (ml2_p->str == S_SSV)
+ asgnssv(ml2_p->u.ssv_p);
+ }
+ }
+ remwidth = 0;
+ measinscore[*scores_p] = 1;
+ mainll_p = new_p;
+
+ /* if at the end, fix no. of scores & ret */
+ if (atend) {
+ (*scores_p)++;
+ return;
+ }
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: endchunk()
+ *
+ * Abstract: Is this MLL item near the end of a chunk?
+ *
+ * Returns: YES or NO
+ *
+ * Description: This function, given a main linked list structure, finds out
+ * whether there is nothing left in this chunk of the MLL other
+ * than possibly SSVs/PRHEADs/LINEs/CURVEs. The very end of a
+ * chunk is determined by the end of the MLL, or the FEED that
+ * begins the next chunk.
+ */
+
+static int
+endchunk(mainll_p)
+
+struct MAINLL *mainll_p; /* points into the MAINLL */
+
+{
+ /* loop past any SSVs or PRHEADs */
+ while (mainll_p != 0 && (mainll_p->str == S_SSV ||
+ mainll_p->str == S_PRHEAD ||
+ mainll_p->str == S_LINE ||
+ mainll_p->str == S_CURVE))
+ mainll_p = mainll_p->next;
+
+ /* if we hit the end or a FEED, we found the end of this chunk */
+ if (mainll_p == 0 || mainll_p->str == S_FEED)
+ return (YES);
+ return (NO);
+}
+\f
+/*
+ * Name: adjust_measwid4mrpt()
+ *
+ * Abstract: If the measure contains a mrpt, adjust the measure's width.
+ *
+ * Returns: the new (possibly increased) measure width
+ *
+ * Description: This function, given the supposed width of a measure and the
+ * first chord of the measure, looks to see if there is an mrpt
+ * in the measure. If so, it enlarges the chord(s) in the measure
+ * if necessary, to make sure there's enough room for the symbol.
+ */
+
+static double
+adjust_measwid4mrpt(oldmeaswid, ch_p)
+
+double oldmeaswid; /* old measure width */
+struct CHORD *ch_p; /* points at a chord, should be first chord in meas */
+
+{
+ int gotmrpt; /* is there an mrpt? */
+ struct GRPSYL *gs_p; /* point down list of GRPSYLs in chord */
+ float newmeaswid; /* possible new measure width */
+ float thismrpt; /* space needed by one mrpt and its padding */
+ float increase; /* how much bigger must we make the measure? */
+
+
+ /*
+ * Scan down the first chord and see if any groups have an mrpt.
+ */
+ gotmrpt = NO;
+ newmeaswid = 0.0;
+ for (gs_p = ch_p->gs_p; gs_p != 0; gs_p = gs_p->gs_p) {
+ if (is_mrpt(gs_p)) {
+ gotmrpt = YES;
+ /* get width of this mrpt + its padding, if any */
+ thismrpt = width(FONT_MUSIC, DFLT_SIZE, C_MEASRPT) *
+ svpath(gs_p->staffno, STAFFSCALE)->staffscale +
+ gs_p->padding;
+ if (thismrpt > newmeaswid) {
+ newmeaswid = thismrpt;
+ }
+ }
+ }
+
+ if (gotmrpt == NO)
+ return (oldmeaswid); /* no mrpt, return original width */
+
+ /* if measure is already wider than all mrpts, return unchanged */
+ if (oldmeaswid >= newmeaswid)
+ return (oldmeaswid);
+
+ /*
+ * Some staff(s) have mrpts, and the existing chord(s) add up to
+ * narrower than the width of an mrpt. It's really rare that this
+ * could happen if there is only one chord. So we will handle it by
+ * forcing the first chord to be wider, rather than allocating the
+ * extra amongst all the chords.
+ */
+ if (ABSDIFF(ch_p->width, TEMPMRPTWIDTH) < 0.001) {
+ /* first chord is all mrpt, so no other chords exist; */
+ /* the 0.001 is to allow for roundoff error */
+ ch_p->c[RE] = newmeaswid / 2.0;
+ ch_p->c[RW] = -newmeaswid / 2.0;
+ ch_p->width = newmeaswid;
+ } else {
+ /* add extra to the right side of the first chord */
+ increase = newmeaswid - oldmeaswid;
+ ch_p->c[RE] += increase;
+ ch_p->width += increase;
+ }
+
+ return (newmeaswid);
+}
+\f
+/*
+ * Name: fillclefsig()
+ *
+ * Abstract: Fill the CLEFSIG for after a FEED.
+ *
+ * Returns: void
+ *
+ * Description: This function, given an empty CLEFSIG structure and a pointer
+ * to a FEED structure in the MAINLL, fills the CLEFSIG according
+ * to what should be printed. If called from tryabs() (bar_p !=
+ * 0), the bar will be set to REPEATSTART if need be, based on the
+ * type of the preceding bar. If called from setabs() (bar_p ==
+ * 0), the same will be done, if need be, after allocating a BAR
+ * and setting the pointer to it. In one bizarre case, abschunk()
+ * calls here directly, and this is treated the same as tryabs();
+ * bar_p != 0.
+ */
+
+static void
+fillclefsig(clefsig_p, feed_p)
+
+struct CLEFSIG *clefsig_p; /* points at empty clefsig to be filled in */
+struct MAINLL *feed_p; /* points at a FEED in the MAINLL */
+
+{
+ struct MAINLL *mainll_p;/* points along the MAINLL */
+ struct BAR *realbar_p; /* point at bar before this feed */
+ float barpad; /* padding on that bar */
+ int s; /* staff number */
+
+
+ /*
+ * On every visible staff, the clef and key signature are to
+ * be printed.
+ */
+ for (s = 1; s <= Score.staffs; s++) {
+ if (svpath(s, VISIBLE)->visible == NO)
+ continue; /* invisible */
+ clefsig_p->prclef[s] = YES;
+ clefsig_p->sharps[s] = eff_key(s);
+ }
+
+ /* clefs to be printed should be regular size */
+ clefsig_p->clefsize = DFLT_SIZE;
+
+ /*
+ * The time signature is to be printed on the first score, or if
+ * it just changed. Search back to see if there was a CLEFSIG just
+ * before this FEED where the time changed, or if this is the first
+ * measure.
+ */
+ for (mainll_p = feed_p->prev; mainll_p != 0 &&
+ mainll_p->str != S_BAR && mainll_p->str != S_CLEFSIG;
+ mainll_p = mainll_p->prev)
+ ;
+
+ /* see chkrestart() for explanation of the bar_p->c[AY] part of this */
+ if (mainll_p == 0 ||
+ mainll_p->str == S_CLEFSIG &&
+ mainll_p->u.clefsig_p->prtimesig == YES ||
+ mainll_p->str == S_BAR &&
+ mainll_p->u.bar_p->c[AY] > 0.0)
+ clefsig_p->prtimesig = YES;
+
+ /*
+ * If the preceding BAR (if any) was a REPEATSTART or REPEATBOTH, it
+ * has to be "split up". Search back to find this bar.
+ */
+ for (mainll_p = feed_p->prev; mainll_p != 0 && mainll_p->str != S_BAR;
+ mainll_p = mainll_p->prev)
+ ;
+
+ if (clefsig_p->bar_p != 0) {
+ /*
+ * tryabs() called us. If there is a preceding bar, and it is
+ * REPEATSTART or REPEATBOTH, it would have to be "split", and
+ * our pseudo bar must be made a REPEATSTART. Otherwise, the
+ * the pseudo bar should be INVISBAR since nothing really
+ * should be printed there. Since tryabs() called us, we can't
+ * tamper with the preceding (real) bar. That's okay; the
+ * change would just make that bar slightly narrower, so
+ * things will still fit on that score.
+ */
+ if (mainll_p != 0 &&
+ (mainll_p->u.bar_p->bartype == REPEATSTART ||
+ mainll_p->u.bar_p->bartype == REPEATBOTH)) {
+ clefsig_p->bar_p->bartype = REPEATSTART;
+ } else {
+ clefsig_p->bar_p->bartype = INVISBAR;
+ }
+ } else {
+ /*
+ * setabs() called us, so we must allocate a pseudo bar and
+ * point the clefsig at it. The same splitting rules apply as
+ * for tryabs(), except since we're now doing it for real, we
+ * have to really alter the preceding bar's bar type in those
+ * cases. This preceding bar's AW and AX must also be
+ * adjusted, since the bar is now going to be narrower than it
+ * was before.
+ */
+ CALLOC(BAR, clefsig_p->bar_p, 1);
+
+ if (mainll_p != 0 &&
+ (mainll_p->u.bar_p->bartype == REPEATSTART ||
+ mainll_p->u.bar_p->bartype == REPEATBOTH)) {
+
+ realbar_p = mainll_p->u.bar_p;
+ realbar_p->bartype = realbar_p->bartype == REPEATSTART ?
+ realbar_p->precbartype : REPEATEND;
+ realbar_p->c[AW] = realbar_p->c[AE] -
+ width_barline(realbar_p);
+ /* to get AX, temporarily set padding to 0; find the */
+ /* width of the resulting nonpadded bar, and subtract*/
+ /* half of that from AE; then restore padding */
+ barpad = realbar_p->padding;
+ realbar_p->padding = 0;
+ realbar_p->c[AX] = realbar_p->c[AE] -
+ width_barline(realbar_p) / 2;
+ realbar_p->padding = barpad;
+ clefsig_p->bar_p->bartype = REPEATSTART;
+ } else {
+ clefsig_p->bar_p->bartype = INVISBAR;
+ }
+ }
+}
+\f
+/*
+ * Name: trymeasure()
+ *
+ * Abstract: Find trial width of a measure.
+ *
+ * Returns: Pointer to the first MAINLL structure of the next measure,
+ * or 0 if we hit the end of MAINLL.
+ *
+ * Description: This function, given a pointer to the first MAINLL structure
+ * in a measure (or the FEED preceding), finds and fills in the
+ * width of the measure.
+ */
+
+static struct MAINLL *
+trymeasure(mainll_p, scale, measwidth_p, adjust_p, ressv_p)
+
+struct MAINLL *mainll_p; /* points first thing in meas, or FEED */
+double scale; /* inches per "whole" unit of time */
+float *measwidth_p; /* width of measure to be filled in */
+float *adjust_p; /* bar line adjust, to be filled in; if last
+ * meas in score, bar shouldn't be padded on
+ * right, so subtract this for measwidth */
+int *ressv_p; /* did we apply a CLEFSIG-causing SSV? */
+
+{
+ struct CHORD *ch_p; /* point at a chord */
+ struct TIMEDSSV *tssv_p;/* point along timed SSV list */
+ float idealwidth; /* the width a chord should be, based on time*/
+
+
+ if (mainll_p == 0)
+ pfatal("invalid mainll_p argument (0) to trymeasure");
+
+ *ressv_p = NO; /* assume no SSVs for now */
+
+ /* every measure has one CHHEAD; find it */
+ while (mainll_p != 0 && mainll_p->str != S_CHHEAD)
+ mainll_p = mainll_p->next;
+ if (mainll_p == 0)
+ pfatal("missing CHHEAD near end of main linked list");
+
+ *measwidth_p = 0;
+
+ /*
+ * For each chord, find out how much width it "deserves",
+ * based on its pseudodur. But if it requires more space
+ * than that, give it what it needs. Accumulate in *measwidth_p.
+ */
+ for (ch_p = mainll_p->u.chhead_p->ch_p; ch_p != 0;
+ ch_p = ch_p->ch_p) {
+
+ idealwidth = scale * ch_p->pseudodur;
+ /* but a chord of all compressible, nonpadded spaces */
+ /* deserves no width */
+ if (ch_p->width == 0)
+ idealwidth = 0;
+ *measwidth_p += MAX(idealwidth, ch_p->width);
+ }
+
+ /*
+ * Find the bar line and add in its width.
+ */
+ while (mainll_p->str != S_BAR)
+ mainll_p = mainll_p->next;
+ *measwidth_p += width_barline(mainll_p->u.bar_p);
+
+ /* apply any timed SSVs */
+ for (tssv_p = mainll_p->u.bar_p->timedssv_p; tssv_p != 0;
+ tssv_p = tssv_p->next) {
+ asgnssv(&tssv_p->ssv);
+ *ressv_p = YES; /* remember we've assigned SSVs */
+ }
+
+ /* need this in case this will be the last measure in the score */
+ *adjust_p = eos_bar_adjust(mainll_p->u.bar_p);
+
+ mainll_p = mainll_p->next; /* point after bar line */
+ /* if end of MAINLL or next measure is starting up, return now */
+ if (mainll_p == 0 || (mainll_p->str != S_SSV &&
+ mainll_p->str != S_CLEFSIG))
+ return (mainll_p);
+
+ /* apply any SSVs at this point */
+ while (mainll_p != 0 && mainll_p->str == S_SSV) {
+ asgnssv(mainll_p->u.ssv_p);
+ mainll_p = mainll_p->next;
+ *ressv_p = YES; /* remember we've assigned SSVs */
+ }
+
+ if (mainll_p != 0 && mainll_p->str == S_CLEFSIG) {
+ *measwidth_p += EFF_WIDCLEFSIG(mainll_p->u.clefsig_p) +
+ CSP(mainll_p->u.clefsig_p);
+ mainll_p = mainll_p->next;
+ }
+
+ return (mainll_p);
+}
+\f
+/*
+ * Name: setabs()
+ *
+ * Abstract: Sets horizontal absolute coordinates for one chunk.
+ *
+ * Returns: void
+ *
+ * Description: This function, given a chunk of the piece delimited by FEEDs,
+ * and the number of measures to be put on each score, loops
+ * through the scores, inserting FEEDs between them, and calling
+ * setabsscore() to set the horizontal absolute coordinates.
+ */
+
+static void
+setabs(start_p, scores, measinscore)
+
+struct MAINLL *start_p; /* FEED at start of chunk of MAINLL */
+int scores; /* number of scores this chunk needs */
+short measinscore[]; /* number of measures in each score */
+
+{
+ struct MAINLL *mainll_p;/* points along main linked list */
+ struct MAINLL *ml2_p; /* another general pointer into MAINLL */
+ int score; /* score number, 0 to scores-1 */
+ int n; /* loop counter */
+
+
+ debug(16, "setabs file=%s line=%d scores=%d", start_p->inputfile,
+ start_p->inputlineno, scores);
+ /* must apply all SSVs from start, to get the right clef/key/time; */
+ setssvstate(start_p);
+
+ /* point at first item in first measure of chunk (skip initial FEED) */
+ mainll_p = start_p->next;
+
+ for (score = 0; score < scores; score++) {
+ /* the first score already has a FEED; insert if later score */
+ if (score != 0) {
+ ml2_p = newMAINLLstruct(S_FEED, 0);
+ insertMAINLL(ml2_p, mainll_p->prev);
+ }
+ mainll_p = mainll_p->prev; /* point at the FEED */
+
+ /*
+ * Insert CLEFSIG following the FEED, and fill as needed.
+ * fillclefsig() will also allocate a BAR, and point the
+ * clefsig at it. If the previous bar line was a REPEATSTART
+ * or REPEATBOTH, it will set REPEATSTART in the new pseudo
+ * BAR, and alter the preceding bar as necessary.
+ */
+ ml2_p = newMAINLLstruct(S_CLEFSIG, 0);
+ insertMAINLL(ml2_p, mainll_p);
+ fillclefsig(ml2_p->u.clefsig_p, mainll_p);
+ ml2_p->u.clefsig_p->multinum = getmultinum(ml2_p);
+
+ /*
+ * Find end of score by searching forward the correct number
+ * of measures. Each measure begins with a CHHEAD, and a block
+ * begins with a BLOCKHEAD, so stop at either of these. Call
+ * a subroutine to process this score.
+ */
+ ml2_p = ml2_p->next; /* point at CHHEAD */
+ for (n = 0; n < measinscore[score]; n++) {
+ do {
+ ml2_p = ml2_p->next;
+ } while (ml2_p != 0 && ml2_p->str != S_CHHEAD &&
+ ml2_p->str != S_BLOCKHEAD);
+ }
+ chkrestart(mainll_p, ml2_p);
+ if (hidestaffs(mainll_p, ml2_p) == YES) {
+ /* if we had to force any staffs invisible, we have to
+ * reapply SSVs so that the new ones we inserted take
+ * effect */
+ setssvstate(start_p);
+ }
+ setabsscore(mainll_p, ml2_p);
+ mainll_p = ml2_p;
+ }
+}
+\f
+/*
+ * Name: chkrestart()
+ *
+ * Abstract: Check for restart bars and remove if necessary.
+ *
+ * Returns: void
+ *
+ * Description: This function, given one score's worth of input, checks for
+ * restart bars. These are used for making a gap in the score.
+ * So when they are the first or last bar in a score, they don't
+ * make sense, and should be removed. Well, not simply removed;
+ * various things need to be done to the main linked list.
+ */
+
+static void
+chkrestart(start_p, end_p)
+
+struct MAINLL *start_p; /* point at the initial FEED of this score */
+struct MAINLL *end_p; /* point after the last thing on this score */
+
+{
+ struct MAINLL *mainll_p;/* points along main linked list */
+ struct MAINLL *m2_p; /* another pointer along main linked list */
+ int s; /* staff number */
+
+
+ /* find first bar on this score; there has to be at least one */
+ for (mainll_p = start_p; mainll_p->str != S_BAR;
+ mainll_p = mainll_p->next)
+ ;
+
+ if (mainll_p->u.bar_p->bartype == RESTART) {
+ /*
+ * The first bar on the score is a restart. So the score would
+ * start with whitespace followed by the restart bar, which
+ * would look bad. So make the restart into an invisbar (which
+ * eliminates the whitespace). A little negative padding is
+ * needed to make things line up. Clean out the beginning of
+ * score clefsig so that nothing prints there. The former
+ * restart's clefsig will print at the start of the line as if
+ * it were the beginning of line clefsig.
+ */
+ mainll_p->u.bar_p->bartype = INVISBAR;
+ mainll_p->u.bar_p->padding = -0.12;
+
+ start_p->next->u.clefsig_p->prtimesig = NO;
+ for (s = 1; s <= MAXSTAFFS; s++) {
+ start_p->next->u.clefsig_p->prclef[s] = NO;
+ start_p->next->u.clefsig_p->sharps[s] = 0;
+ /* no need to zap the naturals, already 0 */
+ }
+ }
+
+ /* find the last bar on this score */
+ m2_p = 0; /* keep lint happy */
+ for ( ; mainll_p != end_p; mainll_p = mainll_p->next) {
+ if (mainll_p->str == S_BAR)
+ m2_p = mainll_p;
+ }
+
+ if (m2_p->u.bar_p->bartype == RESTART) {
+ /*
+ * The last bar on the score is a restart. So the score would
+ * end with whitespace followed by a clefsig, which would look
+ * bad. So make the restart into an invisbar (which eliminates
+ * the whitespace) and remove the clefsig from the MLL, since
+ * we don't want to show those things at a restart. The next
+ * score will now be like a restart.
+ */
+ m2_p->u.bar_p->bartype = INVISBAR;
+ m2_p->u.bar_p->padding = 0;
+
+ mainll_p = m2_p; /* remember bar */
+
+ /* find the clefsig; defensive check for end of MLL */
+ for ( ; m2_p != 0 && m2_p->str != S_CLEFSIG; m2_p = m2_p->next)
+ ;
+ if (m2_p == 0)
+ pfatal("the last bar in the piece is a restart");
+
+ /*
+ * When it comes time to create the coming feed and clefsig,
+ * that clefsig's value for prtimesig depends on the one in the
+ * clefsig we are about to remove. So as a special kluge, if
+ * that value is YES, set the bar's AY to a positive number.
+ * It will get overwritten in absvert.c.
+ */
+ if (m2_p->u.clefsig_p->prtimesig == YES) {
+ mainll_p->u.bar_p->c[AY] = 1.0;
+ }
+
+ m2_p->prev->next = m2_p->next;
+ m2_p->next->prev = m2_p->prev;
+ FREE(m2_p->u.clefsig_p);
+ FREE(m2_p);
+ }
+}
+\f
+/*
+ * Name: setabsscore()
+ *
+ * Abstract: Sets horizontal absolute coordinates for one score.
+ *
+ * Returns: void
+ *
+ * Description: This function, given one score's worth of input, decides how
+ * to space everything horizontally to look pleasing, and then
+ * sets the horizontal absolute coordinates.
+ */
+
+static void
+setabsscore(start_p, end_p)
+
+struct MAINLL *start_p; /* point at the initial FEED of this score */
+struct MAINLL *end_p; /* point after the last thing on this score */
+
+{
+ struct MAINLL *mainll_p;/* points along main linked list */
+ struct MAINLL *m2_p; /* another pointer along main linked list */
+ struct CHORD *ch_p; /* point at a chord */
+ struct CHORD *firstch_p;/* point at first chord in a measure */
+ struct BAR *bar_p; /* convenient pointer at a clefsig's bar */
+ struct MAINLL *mm_p; /* another pointer along MLL */
+ struct MAINLL *lastbarmll_p; /* remember the last bar in the score */
+ struct CLEFSIG *clefsig_p; /* point at a clefsig */
+ struct TIMEDSSV *tssv_p;/* point along a timed SSV list */
+ float prevbarae; /* remember previous bar's AE */
+ float wid; /* temp variable, width of something */
+ float eff_right; /* effective right margin */
+ float scorewidth; /* total width allowed for the score */
+ float totwidth; /* total minimum width */
+ float totwhole; /* total equivalent whole notes of time */
+ float chw; /* total minimum width of chords */
+ float notespace; /* space for chords */
+ float nnotespace; /* space for expandable chords */
+ float ntotwhole; /* total equiv wholes for expandables */
+ float inchpwhole; /* inches each whole note should have */
+ float expanded; /* width of something after expansion */
+ float absx; /* absolute x coordinate */
+ float leftx, rightx; /* start and end positions of a measure */
+ float eff; /* effective width */
+ int toowide; /* number of chords wider than they deserve */
+ int ntoowide; /* new no. of chords wider than deserved */
+
+
+ debug(32, "setabsscore file=%s line=%d",
+ start_p->inputfile, start_p->inputlineno);
+ firstch_p = 0; /* keep lint happy; will be set before used */
+ prevbarae = 0.0; /* keep lint happy; will be set before used */
+ lastbarmll_p = 0; /* keep lint happy; will be set before used */
+
+ /*
+ * Get total available width on this score.
+ */
+ if (end_p == 0) {
+ /* find last feed or last bar, whichever comes last */
+ for (m2_p = Mainlltc_p; m2_p->str != S_FEED &&
+ m2_p->str != S_BAR; m2_p = m2_p->prev)
+ ;
+ if (m2_p->str == S_FEED) {
+ /* a feed after the last bar; use it */
+ eff_right = eff_rightmargin(m2_p);
+ } else {
+ /* no feed after the last bar */
+ eff_right = eff_rightmargin((struct MAINLL *)0);
+ }
+ } else {
+ /*
+ * end_p must be the chhead of the following measure. Its prev
+ * may be a user FEED. (The CLEFSIG which should be between
+ * them has not been inserted yet.)
+ */
+ if (end_p->prev->str == S_FEED) {
+ /* it is a feed, so use it */
+ eff_right = eff_rightmargin(end_p->prev);
+ } else {
+ /* no feed */
+ eff_right = eff_rightmargin((struct MAINLL *)0);
+ }
+ }
+
+ scorewidth = PGWIDTH - eff_right - eff_leftmargin(start_p);
+ scorewidth -= width_left_of_score(start_p);
+
+ /*
+ * Accumulate the total minimum width, total pseudodur in equivalent
+ * wholes, and the total minimum width needed by chords.
+ */
+ totwidth = 0;
+ totwhole = 0;
+ chw = 0;
+ for (mainll_p = start_p; mainll_p != end_p; mainll_p = mainll_p->next){
+ switch (mainll_p->str) {
+
+ case S_SSV:
+ /* assign to keep time sig accurate */
+ asgnssv(mainll_p->u.ssv_p);
+ break;
+
+ case S_CHHEAD:
+ /*
+ * Add in min widths & time of all chords in measure.
+ * Skip any leading space chords in determining first.
+ * (Actually, only compressible, nonpadded spaces.)
+ * The west part of the first chord is considered part
+ * a fixed width. The "effwidth" of a chord is its
+ * east part plus the west part of the next chord, if
+ * any.
+ */
+ for (ch_p = mainll_p->u.chhead_p->ch_p; ch_p != 0 &&
+ ch_p->width == 0; ch_p = ch_p->ch_p)
+ ;
+ if (ch_p == 0)
+ break;
+ totwidth -= ch_p->c[RW]; /* first nonspace */
+ for ( ; ch_p != 0; ch_p = ch_p->ch_p) {
+ totwidth += effwidth(ch_p);
+ chw += effwidth(ch_p);
+
+ /* count time only if not a chord of */
+ /* compressible, nonpadded spaces */
+ if (ch_p->width != 0)
+ totwhole += ch_p->pseudodur;
+ }
+ break;
+
+ case S_CLEFSIG:
+ /*
+ * If this clefsig is the last thing on this score
+ * (except possibly the FEED that starts the next chunk)
+ * find the preceding bar line. If that bar has
+ * hidechanges set, it means that we are not to print
+ * this clefsig.
+ */
+ if (mainll_p->next == end_p ||
+ mainll_p->next->str == S_FEED) {
+ for (m2_p = mainll_p; m2_p->str != S_BAR;
+ m2_p = m2_p->prev)
+ ;
+ if (m2_p->u.bar_p->hidechanges) {
+ mainll_p->u.clefsig_p->hide = YES;
+ mainll_p->u.clefsig_p->effwidth = 0.0;
+ }
+ }
+
+ /* width of clef/key/time/repeatstart when needed */
+ totwidth += EFF_WIDCLEFSIG(mainll_p->u.clefsig_p);
+ /* pad clefsig, unless it's the last thing on score */
+ if (mainll_p->next != end_p &&
+ mainll_p->next->str != S_FEED)
+ totwidth += CSP(mainll_p->u.clefsig_p);
+ break;
+
+ case S_BAR:
+ /* bar's width */
+ totwidth += width_barline(mainll_p->u.bar_p) +
+ mainll_p->u.bar_p->padding;
+ /* apply any timed SSVs */
+ for (tssv_p = mainll_p->u.bar_p->timedssv_p;
+ tssv_p != 0; tssv_p = tssv_p->next) {
+ asgnssv(&tssv_p->ssv);
+ }
+ lastbarmll_p = mainll_p;
+ break;
+ }
+ }
+
+ /*
+ * If the last bar is truly at the end of the line, it doesn't need its
+ * full width, because there is no padding after it. But when there is
+ * a visible clefsig with time or sig there, the bar is not at the end.
+ */
+ for (mm_p = lastbarmll_p; mm_p != 0; mm_p = mm_p->next) {
+ if (mm_p->str == S_STAFF || mm_p->str == S_CLEFSIG) {
+ break;
+ }
+ }
+ if (mm_p == 0 || mm_p->str != S_CLEFSIG ||
+ mm_p->u.clefsig_p->hide == YES) {
+ /* no visible clefsig; get rid of padding */
+ totwidth -= eos_bar_adjust(lastbarmll_p->u.bar_p);
+ } else {
+ /* If there is a clefsig, but it has hidechanges,
+ * or it has no time sigature or any key signatures,
+ * it needs to be moved to the edge of the score. */
+ if (mm_p->u.clefsig_p->prtimesig == NO) {
+ int s;
+ for (s = 1; s <= MAXSTAFFS; s++) {
+ if ((mm_p->u.clefsig_p->sharps[s] != 0 ||
+ mm_p->u.clefsig_p->naturals[s] != 0) &&
+ svpath(s, VISIBLE)->visible == YES) {
+ break;
+ }
+ }
+ if (s > MAXSTAFFS) {
+ totwidth -= eos_bar_adjust(
+ lastbarmll_p->u.bar_p);
+ }
+ }
+ }
+
+ /* fail if even the minimum size for everything doesn't fit */
+ if (totwidth > scorewidth) {
+ if (Score.units == INCHES) {
+ l_ufatal(start_p->inputfile, start_p->inputlineno,
+ "too much (%f inches) to put in score",
+ totwidth * Score.scale_factor);
+ } else {
+ l_ufatal(start_p->inputfile, start_p->inputlineno,
+ "too much (%f cm) to put in score",
+ totwidth * Score.scale_factor *
+ CMPERINCH);
+ }
+ }
+
+ /*
+ * Only chords are allowed to expand when there is extra space;
+ * other items have a fixed width. To find how much space is
+ * available for chords, take the total screen width minus the
+ * space needed by the fixed-size things.
+ */
+ notespace = scorewidth - (totwidth - chw);
+
+ /*
+ * Some chords' "effwidths" are already wider than what they deserve
+ * based on their pseudodur. Let them keep that minimum size. We
+ * will consider their size as fixed and allocate the remaining
+ * space among chords that deserve more. Remove the too-wide (and
+ * just right) chords from the totals. This has to be done
+ * repeatedly, since after each iteration the number of inches
+ * deserved by each remaining chord shrinks. Leave the loop when
+ * it is found that all remaining chords deserve to expand.
+ */
+ ntotwhole = totwhole; /* initially assume all may be expandable */
+ nnotespace = notespace;
+ ntoowide = 0;
+ do {
+ /*
+ * If there are no notes in this score, totwhole will already
+ * be 0 on the first loop iteration, and there is nothing that
+ * can expand. Each measure will be very small, just the width
+ * of the bar line and its padding, and the rightmost bar line
+ * won't be at the right edge of the score. This is usually a
+ * useless situation; but if invisbars are used, and "newscore"
+ * every measure, it provides a way to print blank music paper.
+ *
+ * inchpwhole won't ever get used, but we set it to something
+ * arbitrary in case lint cares. Then break out of this loop.
+ */
+ if (totwhole == 0.0) {
+ inchpwhole = 1.0;
+ break;
+ }
+ /*
+ * Find how much space each whole note worth of chords
+ * deserves, allocating proportionally. Consider just the
+ * ones not known to be too big already.
+ */
+ inchpwhole = nnotespace / ntotwhole;
+
+ /* start with all chords' time and space */
+ ntotwhole = totwhole;
+ nnotespace = notespace;
+
+ toowide = ntoowide; /* remember how many last time */
+ ntoowide = 0;
+
+ /* remove from consideration ones that are too big already */
+ for (mainll_p = start_p; mainll_p != end_p;
+ mainll_p = mainll_p->next) {
+
+ if (mainll_p->str == S_CHHEAD) {
+ /* loop through all chords doing this */
+ for (ch_p = mainll_p->u.chhead_p->ch_p;
+ ch_p != 0; ch_p = ch_p->ch_p) {
+ if (effwidth(ch_p) >=
+ ch_p->pseudodur * inchpwhole) {
+ ntotwhole -= ch_p->pseudodur;
+ nnotespace -= effwidth(ch_p);
+ ntoowide++;
+ }
+ }
+ }
+ }
+
+ /*
+ * In the (rare) case where nothing is now expandable (every-
+ * thing is packed perfectly tightly), we should break out now.
+ * The "<" is defensive.
+ */
+ if (ntotwhole <= 0)
+ break;
+
+ } while (ntoowide > toowide);
+
+ /*
+ * Now inchpwhole is the number of inches that should be given to each
+ * whole note worth of chords that deserve to be wider than their
+ * minimum. Allocate width proportionally to these chords.
+ */
+ for (mainll_p = start_p; mainll_p != end_p; mainll_p = mainll_p->next){
+ if (mainll_p->str == S_CHHEAD) {
+ for (ch_p = mainll_p->u.chhead_p->ch_p;
+ ch_p != 0; ch_p = ch_p->ch_p) {
+
+ /* normal case (proportional) */
+ expanded = ch_p->pseudodur * inchpwhole;
+
+ /* special case to fix space interaction */
+
+ /* but a chord of all compressible, */
+ /* nonpadded spaces deserves no width */
+ if (ch_p->width == 0)
+ expanded = 0;
+
+ /* get min dist needed from our X to next's X */
+ eff = effwidth(ch_p);
+
+ /* the dist we'll really have from X to X */
+ ch_p->fullwidth = MAX(eff, expanded);
+ }
+ }
+ }
+
+ /*
+ * Now that we know everything's width, set all absolute horizontal
+ * coordinates for this score. The absx variable keeps track of
+ * where we are, working from left to right. At all times, keep
+ * track of the start and end of each measure (leftx and rightx)
+ * and the first chord in it, so we can reposition measure rests.
+ */
+ /* first reset SSVs to how they were at start of this score */
+ setssvstate(start_p);
+
+ start_p->u.feed_p->c[AW] = eff_leftmargin(start_p);
+ start_p->u.feed_p->c[AE] = PGWIDTH - eff_right;
+ absx = eff_leftmargin(start_p) + width_left_of_score(start_p);
+ start_p->u.feed_p->c[AX] = absx;
+ leftx = 0.0; /* prevent useless 'used before set' warning */
+
+ for (mainll_p = start_p; mainll_p != end_p; mainll_p = mainll_p->next) {
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* assign to keep time sig accurate */
+ asgnssv(mainll_p->u.ssv_p);
+ break;
+
+ case S_CLEFSIG:
+ clefsig_p = mainll_p->u.clefsig_p;
+
+ /* this kind partly already handled by preceding bar */
+ if (clefsig_p->clefsize == SMALLSIZE &&
+ clefsig_p->hide == NO) {
+ /* absx points at AE of barline, so add width*/
+ /* of clef excluding any clef space */
+ absx += width_clefsig(clefsig_p) -
+ clefsig_p->widestclef +
+ CSP(clefsig_p);
+ leftx = absx;
+ break;
+ }
+
+ /* "beginning of line" or "restart" clefsig */
+ clefsig_p->wclefsiga = absx;
+ if (clefsig_p->hide == NO) {
+ absx += width_clefsig(clefsig_p) +
+ CSP(clefsig_p);
+ }
+ bar_p = clefsig_p->bar_p;
+ if (bar_p != 0) {
+ /* clefsig has a pseudo bar in it; set coords*/
+ bar_p->c[AE] = absx;
+ bar_p->c[AW] = absx - width_barline(bar_p);
+ bar_p->c[AX] = (bar_p->c[AW] + absx) / 2;
+
+ /* remember the AE of this pseudobar */
+ prevbarae = absx;
+ }
+ leftx = absx;
+ break;
+
+ case S_BAR:
+ bar_p = mainll_p->u.bar_p;
+ absx += bar_p->padding;
+
+ /* apply any timed SSVs */
+ for (tssv_p = bar_p->timedssv_p; tssv_p != 0;
+ tssv_p = tssv_p->next) {
+ asgnssv(&tssv_p->ssv);
+ }
+
+ /*
+ * If this bar is followed by a clefsig, any clefs in
+ * it must be printed before this bar. Note that any
+ * padding will go before the clef (see above). But
+ * the previous measure "ends" after the clefs.
+ */
+ for (m2_p = mainll_p; m2_p != 0 &&
+ m2_p->str != S_CLEFSIG &&
+ m2_p->str != S_CHHEAD;
+ m2_p = m2_p->next)
+ ;
+ /* if clefsig that belongs to this bar line . . . */
+ if (m2_p != 0 && m2_p->str == S_CLEFSIG && m2_p->u.
+ clefsig_p->clefsize == SMALLSIZE &&
+ m2_p->u.clefsig_p->hide == NO) {
+ clefsig_p = m2_p->u.clefsig_p;
+
+ /*
+ * Apply SSVs to get the time & clef changes
+ * that occur at this bar, if any, since we
+ * are going to print the new values of them.
+ * After the width_clefsig, restore the SSVs to
+ * the proper state at this bar line.
+ */
+ for (m2_p = mainll_p; m2_p->str != S_CLEFSIG;
+ m2_p = m2_p->next) {
+ if (m2_p->str == S_SSV) {
+ asgnssv(m2_p->u.ssv_p);
+ }
+ }
+ wid = width_clefsig(clefsig_p);
+ setssvstate(mainll_p);
+
+ /* if wid > effwid, this will overlap the */
+ /* widest clef by that difference */
+ clefsig_p->wclefsiga = absx -
+ (wid - clefsig_p->effwidth) +
+ bardiff(mainll_p, end_p);
+
+ /* point absx after any clefs in clefsig */
+ absx += clefsig_p->effwidth -
+ (wid - clefsig_p->widestclef);
+ rightx = clefsig_p->wclefsiga;
+ } else { /* no relevant clefsig */
+ rightx = absx; /* prev measure "ends" here */
+ }
+ bar_p->c[AW] = absx;
+ absx += width_barline(bar_p);
+ bar_p->c[AE] = absx;
+ bar_p->c[AX] = (bar_p->c[AW] + bar_p->c[AE]) / 2.0;
+ fixfullmeas(firstch_p, (leftx + rightx) / 2.0);
+ leftx = absx; /* next measure starts here */
+
+ /*
+ * for each staff in the measure just ended, set its AE
+ * to this bar's AW, and set AX to the midpoint now
+ * that we know both AW and AE.
+ */
+ for (m2_p = mainll_p; m2_p->str != S_CHHEAD;
+ m2_p = m2_p->prev) {
+ if (m2_p->str == S_STAFF) {
+ m2_p->u.staff_p->c[AE] = bar_p->c[AW];
+ m2_p->u.staff_p->c[AX] =
+ (m2_p->u.staff_p->c[AW] +
+ m2_p->u.staff_p->c[AE]) / 2.0;
+ }
+ }
+
+ /* remember the AE of this bar */
+ prevbarae = absx;
+ break;
+
+ case S_STAFF:
+ /* as we come to each staff, set AW to prev bar's AE */
+ mainll_p->u.staff_p->c[AW] = prevbarae;
+ break;
+
+ case S_CHHEAD:
+ for (ch_p = mainll_p->u.chhead_p->ch_p; ch_p != 0 &&
+ ch_p->width == 0; ch_p = ch_p->ch_p)
+ setabschord(ch_p, absx);
+ if ((firstch_p = ch_p) == 0)
+ break;
+ absx -= firstch_p->c[RW];
+ for (ch_p = firstch_p; ch_p != 0; ch_p = ch_p->ch_p) {
+ setabschord(ch_p, absx);
+ absx += ch_p->fullwidth;
+ }
+ break;
+ }
+ }
+}
+\f
+/*
+ * Name: setabschord()
+ *
+ * Abstract: Sets horizontal absolute coordinates for everything in a chord.
+ *
+ * Returns: void
+ *
+ * Description: This function, given a chord, and its absolute offset, sets
+ * the horizontal absolute coordinates of everything in it.
+ */
+
+static void
+setabschord(ch_p, nomx)
+
+struct CHORD *ch_p; /* point at the chord */
+double nomx; /* nominal X coord; may shift it right a bit */
+
+{
+ struct GRPSYL *gs_p; /* point at a group or syllable in chord */
+ struct GRPSYL *g_p; /* point at a group with notes */
+ float extra; /* width available beyond what chord needs */
+ int n; /* loop counter */
+
+
+ /*
+ * Set the CHORD's horizonal absolute coordinates. If the chord had
+ * no room to expand (effwidth == fullwidth), there's no question
+ * where its AX has to be. But otherwise, we want to place it close
+ * to as far left as it can go, but not jammed up against there.
+ */
+ if ((extra = ch_p->fullwidth - effwidth(ch_p)) > 0) {
+ nomx += (extra > 1.20 ? 0.20 : extra / 6);
+ }
+
+ ch_p->c[AX] = nomx;
+ ch_p->c[AW] = nomx + ch_p->c[RW];
+ ch_p->c[AE] = nomx + ch_p->c[RE];
+
+ /*
+ * Loop through all GRPSYLs in this chord, setting absolute horizontal
+ * coordinates. To avoid the aggravation of dealing with SSVs again,
+ * don't bother checking if the staffs in question are visible, just
+ * do it. It doesn't hurt anything to increment garbage.
+ */
+ for (gs_p = ch_p->gs_p; gs_p != 0; gs_p = gs_p->gs_p) {
+ /*
+ * For groups, do the group itself and all the notes in it (if
+ * any), and do the same for all preceding grace groups.
+ */
+ if (gs_p->grpsyl == GS_GROUP) {
+ g_p = gs_p; /* init to the normal group */
+ do {
+ /* do the group itself, based off the chord */
+ g_p->c[AX] = ch_p->c[AX] + g_p->c[RX];
+ g_p->c[AW] = ch_p->c[AX] + g_p->c[RW];
+ g_p->c[AE] = ch_p->c[AX] + g_p->c[RE];
+
+ /* do each note, based off the group */
+ for (n = 0; n < g_p->nnotes; n++) {
+ g_p->notelist[n].c[AX] = g_p->c[AX] +
+ g_p->notelist[n].c[RX];
+ g_p->notelist[n].c[AW] = g_p->c[AX] +
+ g_p->notelist[n].c[RW];
+ g_p->notelist[n].c[AE] = g_p->c[AX] +
+ g_p->notelist[n].c[RE];
+ }
+ g_p = g_p->prev;
+ } while (g_p != 0 && g_p->grpvalue == GV_ZERO);
+ } else {
+ /* this is a syllable; just do the syllable */
+ gs_p->c[AX] = ch_p->c[AX] + gs_p->c[RX];
+ gs_p->c[AW] = ch_p->c[AX] + gs_p->c[RW];
+ gs_p->c[AE] = ch_p->c[AX] + gs_p->c[RE];
+ }
+ }
+}
+\f
+/*
+ * Name: effwidth()
+ *
+ * Abstract: Find "effective" width of a chord.
+ *
+ * Returns: the width
+ *
+ * Description: This function returns the "effective width" of a chord. This
+ * is the (minimum) width of its east part, plus the width of the
+ * west part of the following chord, if there is one.
+ */
+
+static double
+effwidth(ch_p)
+
+struct CHORD *ch_p; /* point at the chord */
+
+{
+ struct CHORD *next_p;
+
+
+ /* compressible, nonpadded spaces count for nothing */
+ if (ch_p->width == 0)
+ return (0.0);
+
+ /* find the next chord, if any, that is not all compressible, */
+ /* nonpadded spaces */
+ for (next_p = ch_p->ch_p; next_p != 0; next_p = next_p->ch_p) {
+ if (next_p->width != 0)
+ break;
+ }
+
+ /*
+ * If it's the last one in the measure, return the east side of the
+ * current chord. Otherwise, return that plus the west side of the
+ * next nonspace chord.
+ */
+ if (next_p == 0)
+ return (ch_p->c[RE]);
+ else
+ return (ch_p->c[RE] - next_p->c[RW]);
+}
+\f
+/*
+ * Name: bardiff()
+ *
+ * Abstract: Find size difference of end of score bar vs. what it will be.
+ *
+ * Returns: void
+ *
+ * Description: When a REPEATSTART occurs at the end of a score, it gets
+ * changed to a SINGLEBAR, and a REPEATBOTH becomes a REPEATEND
+ * (the following pseudobar getting set to REPEATSTART). Other
+ * bartypes are left alone. This function, given the MLL of a bar,
+ * just returns zero if the bar is not at the end of a score; but
+ * otherwise it returns the size of that bartype minus the size of
+ * what it will be replaced by.
+ */
+
+static double
+bardiff(mainll_p, end_p)
+
+struct MAINLL *mainll_p; /* MLL for the bar line */
+struct MAINLL *end_p; /* MLL after end of the score */
+
+{
+ struct MAINLL *mll_p; /* for searching the MLL */
+ struct BAR bar; /* phony BAR structure */
+ double temp; /* hold the width of the orginal bar */
+
+
+ /*
+ * Search forward from the bar. If we hit a CHHEAD before hitting the
+ * end of the score, then this is not the last barline in the score, so
+ * return zero.
+ */
+ for (mll_p = mainll_p; mll_p != end_p; mll_p = mll_p->next) {
+ if (mll_p->str == S_CHHEAD)
+ return (0.0);
+ }
+
+ /* last bar in the score, so do the arithmetic */
+ switch (mainll_p->u.bar_p->bartype) {
+ case REPEATSTART:
+ bar.bartype = REPEATSTART;
+ temp = width_barline(&bar);
+ bar.bartype = SINGLEBAR;
+ return (temp - width_barline(&bar));
+
+ case REPEATBOTH:
+ bar.bartype = REPEATBOTH;
+ temp = width_barline(&bar);
+ bar.bartype = REPEATEND;
+ return (temp - width_barline(&bar));
+ }
+
+ return (0.0); /* all other types remain the same; difference = 0 */
+}
+\f
+/*
+ * Name: fixfullmeas()
+ *
+ * Abstract: Adjust the AE of full measure symbols (mr, multirest, mrpt).
+ *
+ * Returns: void
+ *
+ * Description: This function, given the first chord in a measure (the only
+ * one that can contain a one of these symbols), adjusts the AE
+ * coord of each GRPSYL in the chords that is one of these. AW
+ * stays where it is, near the left bar line, except that for
+ * multirests it moves it to the right, especially for ones
+ * that are drawn with rest symbols. For multirests and
+ * measure repeats, AX gets moved leftwards a little, to be
+ * where it would have been for a measure rest, but for measure
+ * rests, it stays where it is, not far to the right of that.
+ * For all three things, AE is put near the right bar line, the
+ * same distance from it that AW is from the left.
+ */
+
+static void
+fixfullmeas(ch_p, x)
+
+struct CHORD *ch_p; /* point at the chord */
+double x; /* absolute X coord of center of measure */
+
+{
+ struct GRPSYL *gs_p; /* point at a group or syllable in chord */
+
+
+ /* in case we have all spaces */
+ if (ch_p == 0)
+ return;
+
+ debug(32, "fixfullmeas file=%s line=%d x=%f", ch_p->gs_p->inputfile,
+ ch_p->gs_p->inputlineno, (float)x);
+
+ /* loop through all GRPSYLs, resetting AE/AW for full measure symbols */
+ for (gs_p = ch_p->gs_p; gs_p != 0; gs_p = gs_p->gs_p) {
+ /* skip syllables */
+ if (gs_p->grpsyl != GS_GROUP) {
+ continue;
+ }
+
+ if (gs_p->is_meas == YES) {
+ gs_p->c[AE] = x + (x - gs_p->c[AW]);
+ } else if (gs_p->basictime < -1) {
+ /* multirest; move the left end to the right a little */
+ set_staffscale(gs_p->staffno);
+ gs_p->c[AW] += 2.0 * Stepsize;
+ /*
+ * For multirests that are drawn with rest symbols,
+ * the width may need to be reduced. If half the
+ * multirest's width exceeds 10 stepsizes, reduce it
+ * by 0.8 of the excess.
+ */
+ if (gs_p->basictime >= -8 && svpath(gs_p->staffno,
+ RESTSYMMULT)->restsymmult) {
+ if (x - gs_p->c[AW] > 10.0 * Stepsize) {
+ gs_p->c[AW] += ((x - gs_p->c[AW]) -
+ (10.0 * Stepsize)) * 0.8;
+ }
+ }
+ gs_p->c[AE] = x + (x - gs_p->c[AW]);
+ }
+ }
+
+ /* for multirest/mrpt, put AX where it would have been for a mr */
+ if (ch_p->gs_p->basictime < -1 || is_mrpt(gs_p)) {
+ ch_p->c[AX] = ch_p->c[AW] +
+ width(FONT_MUSIC, DFLT_SIZE, C_1REST) / 2;
+ }
+}
+\f
+/*
+ * Name: restore_grpsyl_west()
+ *
+ * Abstract: Restore all GRPSYLs' west coords when there was a clef there.
+ *
+ * Returns: void
+ *
+ * Description: In fixclef() in restsyl.c, we altered the west of any GRPSYL
+ * that was associated with a midmeasure clef. This was needed so
+ * that room would be made for the clefs. Now that the packing
+ * part of abshorz.c is done, we can restore these coords, for the
+ * benefit of the print phrase.
+ */
+
+static void
+restore_grpsyl_west()
+
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct GRPSYL *gs_p; /* point along a GRPSYL list */
+ struct GRPSYL *gs2_p; /* look for a grace group's main grp */
+ int vidx; /* voice index */
+ float size; /* to be used for clef */
+ float staffscale; /* scale for a staff */
+ float clefwid; /* width of a clef */
+
+
+ size = 3.0/4.0 * DFLT_SIZE; /* small size clefs */
+ initstructs();
+
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* keep staffscale up to date */
+ asgnssv(mainll_p->u.ssv_p);
+ continue;
+ case S_STAFF:
+ /* break out to handle staff */
+ break;
+ default:
+ continue;
+ }
+
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ for (gs_p = mainll_p->u.staff_p->groups_p[vidx];
+ gs_p != 0; gs_p = gs_p->next) {
+ if (gs_p->clef == NOCLEF) {
+ continue; /* no clef, nothing to do */
+ }
+
+ staffscale = svpath(gs_p->staffno,
+ STAFFSCALE)->staffscale;
+ clefwid = (clefwidth(gs_p->clef, YES) +
+ CLEFPAD) * staffscale;
+ gs_p->c[RW] += clefwid;
+ gs_p->c[AW] += clefwid;
+
+ /*
+ * If we are a grace group, look ahead to the
+ * main group and restore it too.
+ */
+ if (gs_p->grpvalue == GV_ZERO) {
+ for (gs2_p = gs_p; gs2_p->grpvalue ==
+ GV_ZERO; gs2_p = gs2_p->next) {
+ ;
+ }
+ gs2_p->c[RW] += clefwid;
+ gs2_p->c[AW] += clefwid;
+ }
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: setipw()
+ *
+ * Abstract: Set INCHPERWHOLE "coordinate" for all structures having it.
+ *
+ * Returns: void
+ *
+ * Description: This function sets the special pseudocoord "c[INCHPERWHOLE]"
+ * for all nongrace GRPSYLs, notes, chords, and BARs. BARs is
+ * done right here; for the others, it calls subroutines.
+ */
+
+static void
+setipw()
+
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct MAINLL *m2_p; /* look forward for bar line */
+ struct GRPSYL *gs_p; /* point along a GRPSYL list */
+ int timeden; /* denominator of a time signature */
+ int v; /* index into voices or verses */
+
+
+ debug(16, "setipw");
+ initstructs(); /* clean out old SSV info */
+
+ /*
+ * Loop through MLL, applying SSVs and processing each visible linked
+ * list of GRPSYLs.
+ */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+ case S_SSV:
+ /* this is needed to keep time sig up to date */
+ asgnssv(mainll_p->u.ssv_p);
+ break;
+
+ case S_CHHEAD:
+ /* set the thing for all chords in this measure */
+ setipwchord(mainll_p);
+ break;
+
+ case S_STAFF:
+ /* skip this staff if it's invisible */
+ if (mainll_p->u.staff_p->visible == NO)
+ break;
+
+ /* do all the voices on this staff */
+ for (v = 0; v < MAXVOICES && (gs_p = mainll_p->u.
+ staff_p->groups_p[v]) != 0; v++) {
+ setipwgrpsyl(mainll_p, gs_p);
+ }
+
+ /* do all the verses on this staff */
+ for (v = 0; v < mainll_p->u.staff_p->nsyllists; v++) {
+ gs_p = mainll_p->u.staff_p->syls_p[v];
+ setipwgrpsyl(mainll_p, gs_p);
+ }
+
+ break;
+
+ case S_BAR:
+ /*
+ * If this is the ending bar line of a score, ignore
+ * it. The following measure would refer to its
+ * preceding CLEFSIG's pseudo bar instead. So see if
+ * we hit a FEED while trying to find the next CHHEAD.
+ * While doing this, keep track of the denominator of
+ * the time signature, in case it changes at this bar.
+ */
+ timeden = Score.timeden;
+ for (m2_p = mainll_p; m2_p != 0 && m2_p->str != S_FEED
+ && m2_p->str != S_CHHEAD;
+ m2_p = m2_p->next) {
+ if (m2_p->str == S_SSV && m2_p->u.ssv_p->used[
+ TIME] == YES) {
+ timeden = m2_p->u.ssv_p->timeden;
+ }
+ }
+ if (m2_p == 0 || m2_p->str == S_FEED)
+ break;
+
+ /*
+ * This is not the last bar of a score, and m2_p points
+ * at the CHHEAD of the following measure, with timeden
+ * being the denominator of the time sig. The space
+ * between the bar ("count 0") and the first chord
+ * ("count 1") must be multiplied by the number of
+ * counts in a whole note (timeden).
+ */
+ mainll_p->u.bar_p->c[INCHPERWHOLE] = timeden *
+ (m2_p->u.chhead_p->ch_p->c[AX] -
+ mainll_p->u.bar_p->c[AX]);
+ break;
+
+ case S_CLEFSIG:
+ /*
+ * If this clefsig is not at the start of a score,
+ * ignore it. If it is, it will contain a pseudo bar
+ * line, and we need to set that bar's coord just like
+ * for a normal bar line.
+ */
+ if (mainll_p->u.clefsig_p->bar_p == 0)
+ break;
+
+ if (mainll_p->next->str != S_CHHEAD)
+ pfatal("CLEFSIG with pseudo bar not followed by CHHEAD");
+
+ mainll_p->u.clefsig_p->bar_p->c[INCHPERWHOLE] =
+ Score.timeden *
+ (mainll_p->next->u.chhead_p->ch_p->c[AX] -
+ mainll_p->u.clefsig_p->bar_p->c[AX]);
+ break;
+ }
+ }
+}
+\f
+/*
+ * Name: setipwgrpsyl()
+ *
+ * Abstract: Set INCHPERWHOLE "coordinate" for the GRPSYLs in one list.
+ *
+ * Returns: void
+ *
+ * Description: This function sets the special pseudocoord "c[INCHPERWHOLE]"
+ * for all the nongrace GRPSYLs and notes in one voice or verse
+ * list hanging off a STAFF.
+ */
+
+static void
+setipwgrpsyl(mainll_p, gs_p)
+
+struct MAINLL *mainll_p; /* point along main linked list */
+struct GRPSYL *gs_p; /* point along this GRPSYL list */
+
+{
+ struct MAINLL *m2_p; /* look forward for bar line */
+ struct GRPSYL *ngs_p; /* the next nongrace GRPSYL in list */
+ float inchperwhole; /* inches per whole note */
+ int n; /* loop variable */
+
+
+ debug(32, "setipwgrpsyl file=%s line=%d", gs_p->inputfile,
+ gs_p->inputlineno);
+ /* get first nongrace GRPSYL */
+ for ( ; gs_p != 0 && gs_p->grpsyl == GS_GROUP &&
+ gs_p->grpvalue == GV_ZERO; gs_p = gs_p->next)
+ ;
+ if (gs_p == 0)
+ pfatal("nothing but grace notes in measure");
+
+ /*
+ * Loop down the list of GRPSYLs. gs_p always points the current
+ * (nongrace) GRPSYL, whose inches per whole we want to set. ngs_p
+ * points at the next nongrace GRPSYL.
+ */
+ for (;;) {
+ /* find next nongrace GRPSYL; break if none */
+ for (ngs_p = gs_p->next;
+ ngs_p != 0 && ngs_p->grpsyl == GS_GROUP &&
+ ngs_p->grpvalue == GV_ZERO;
+ ngs_p = ngs_p->next)
+ ;
+ if (ngs_p == 0)
+ break;
+
+ /*
+ * Distance between them divided by time gives the space a
+ * a whole note theoretically would have been given.
+ */
+ inchperwhole = (ngs_p->c[AX] - gs_p->c[AX]) /
+ RAT2FLOAT(gs_p->fulltime);
+
+ /* store in GRPSYL & each note (if notes) */
+ gs_p->c[INCHPERWHOLE] = inchperwhole;
+ if (gs_p->grpsyl == GS_GROUP && gs_p->grpcont == GC_NOTES) {
+ for (n = 0; n < gs_p->nnotes; n++)
+ gs_p->notelist[n].c[INCHPERWHOLE]
+ = inchperwhole;
+ }
+
+ /* point current at next, for next iteration */
+ gs_p = ngs_p;
+ }
+
+ /*
+ * We've hit the end of the measure. Loop forward through the MLL
+ * until we find the bar line.
+ */
+ for (m2_p = mainll_p;
+ m2_p != 0 && m2_p->str != S_BAR;
+ m2_p = m2_p->next)
+ ;
+ if (m2_p == 0)
+ pfatal("no bar at end of last measure");
+
+ /* this time use bar line as terminating point */
+ inchperwhole = (m2_p->u.bar_p->c[AX] - gs_p->c[AX]) /
+ RAT2FLOAT(gs_p->fulltime);
+
+ gs_p->c[INCHPERWHOLE] = inchperwhole;
+ if (gs_p->grpsyl == GS_GROUP && gs_p->grpcont == GC_NOTES) {
+ for (n = 0; n < gs_p->nnotes; n++)
+ gs_p->notelist[n].c[INCHPERWHOLE] = inchperwhole;
+ }
+}
+\f
+/*
+ * Name: setipwchord()
+ *
+ * Abstract: Set INCHPERWHOLE "coordinate" for the CHORDs in one list.
+ *
+ * Returns: void
+ *
+ * Description: This function sets the special pseudocoord "c[INCHPERWHOLE]"
+ * for all the CHORDs in the list hanging off of one CHHEAD.
+ */
+
+static void
+setipwchord(mainll_p)
+
+struct MAINLL *mainll_p; /* point at the CHHEAD */
+
+{
+ struct MAINLL *m2_p; /* look forward for bar line */
+ struct CHORD *ch_p, *nch_p; /* point at chords */
+
+
+ debug(32, "setipwchord file=%s line=%d", mainll_p->inputfile,
+ mainll_p->inputlineno);
+ /*
+ * Loop down the list of CHORDs. ch_p always points the current
+ * CHORD, whose inches per whole we want to set. nch_p points at
+ * the next CHORD. When nch_p is 0, ch_p is the last chord, and we
+ * get out of the loop.
+ */
+ for (ch_p = mainll_p->u.chhead_p->ch_p, nch_p = ch_p->ch_p;
+ nch_p != 0; ch_p = nch_p, nch_p = nch_p->ch_p) {
+ /*
+ * Distance between them divided by time gives the space a
+ * a whole note theoretically would have been given.
+ */
+ ch_p->c[INCHPERWHOLE] = (nch_p->c[AX] - ch_p->c[AX]) /
+ RAT2FLOAT(ch_p->duration);
+ }
+
+ /*
+ * We've hit the end of the measure. Loop forward through the MLL
+ * until we find the bar line.
+ */
+ for (m2_p = mainll_p;
+ m2_p != 0 && m2_p->str != S_BAR;
+ m2_p = m2_p->next)
+ ;
+ if (m2_p == 0)
+ pfatal("no bar at end of last measure");
+
+ /* this time use bar line as terminating point */
+ ch_p->c[INCHPERWHOLE] = (m2_p->u.bar_p->c[AX] - ch_p->c[AX]) /
+ RAT2FLOAT(ch_p->duration);
+}
+\f
+/*
+ * Name: fixendings()
+ *
+ * Abstract: Fix endings at end of score and in pseudobars.
+ *
+ * Returns: void
+ *
+ * Description: This function finds endings that start at the final bar of a
+ * score. It moves them so that they will start at the pseudobar
+ * at the start of the next score. Then, wherever an ending is
+ * continuing through a scorefeed, set the pseudobar's endingloc.
+ */
+
+static void
+fixendings()
+
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct MAINLL *m2_p; /* look forward for bar line */
+ struct BAR *bar_p; /* point at preceding bar */
+ char *str_p; /* point at an ending string */
+
+
+ debug(16, "fixendings");
+ /*
+ * Loop through the main linked list, looking for endings that start at
+ * the end of a score, and moving them. We do it in reverse, to make
+ * it slightly easier to deal with the case of scores that have only
+ * one measure on them. (Previous endings won't have been moved yet.)
+ */
+ for (mainll_p = Mainlltc_p; mainll_p != 0; mainll_p = mainll_p->prev) {
+ if (mainll_p->str != S_BAR)
+ continue;
+ if (mainll_p->u.bar_p->endingloc != STARTITEM)
+ continue;
+
+ /*
+ * We are at a bar where an ending starts. Find out if this is
+ * at the end of a score, by seeing if we find a FEED before
+ * the next bar.
+ */
+ for (m2_p = mainll_p->next; m2_p != 0 && m2_p->str != S_BAR &&
+ m2_p->str != S_FEED; m2_p = m2_p->next)
+ ;
+ if (m2_p == 0)
+ pfatal("unterminated ending");
+ if (m2_p->str == S_BAR)
+ continue;
+
+ /*
+ * The ending starts at the last bar of a score. We need to
+ * know whether a previous ending also ends there, or not. So
+ * search back to the previous bar. Since we're doing the main
+ * loop in reverse, we don't have to look at pseudobars, only
+ * real ones.
+ */
+ for (m2_p = mainll_p->prev; m2_p != 0 && m2_p->str != S_BAR;
+ m2_p = m2_p->prev)
+ ;
+
+ /*
+ * If the previous bar was the end of an ending or not involved
+ * in one at all, the bar at the end of the score should not be
+ * involved. Otherwise, there was a preceding ending which
+ * ends here (where the new one starts), so mark that it ends.
+ */
+ if (m2_p == 0 || m2_p->u.bar_p->endingloc == ENDITEM ||
+ m2_p->u.bar_p->endingloc == NOITEM)
+
+ mainll_p->u.bar_p->endingloc = NOITEM;
+ else
+ mainll_p->u.bar_p->endingloc = ENDITEM;
+
+ str_p = mainll_p->u.bar_p->endinglabel;
+ mainll_p->u.bar_p->endinglabel = 0;
+
+ /*
+ * Find the first feed after this bar that is not at the start
+ * of a "block", and mark in the following pseudobar that an
+ * ending starts there.
+ */
+ for (m2_p = mainll_p->next; m2_p != 0 && (m2_p->str != S_FEED ||
+ m2_p->next != 0 && m2_p->next->str == S_BLOCKHEAD);
+ m2_p = m2_p->next)
+ ;
+ if (m2_p == 0) {
+ pfatal("can't find any music after ending begins");
+ }
+ m2_p->next->u.clefsig_p->bar_p->endingloc = STARTITEM;
+ m2_p->next->u.clefsig_p->bar_p->endinglabel = str_p;
+ }
+
+ /*
+ * Loop again through the main linked list, this time forwards.
+ * Remember each bar as we find one. Then, adjust the following
+ * pseudobar if need be.
+ */
+ bar_p = 0; /* no previous bar yet */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ if (mainll_p->str == S_BAR)
+ bar_p = mainll_p->u.bar_p;
+ if (mainll_p->str == S_CLEFSIG &&
+ mainll_p->u.clefsig_p->bar_p != 0) {
+ /*
+ * We're at a pseudobar. If the preceding bar was
+ * inside an ending, mark the pseudobar that way too.
+ * (If this is the first pseudobar, there won't have
+ * been any preceding bar.)
+ */
+ if (bar_p != 0 && bar_p->endingloc == INITEM)
+ mainll_p->u.clefsig_p->bar_p->endingloc
+ = INITEM;
+ }
+ }
+}
+\f
+/*
+ * Name: fixreh()
+ *
+ * Abstract: Move rehearsal marks at end of a score to the next score.
+ *
+ * Returns: void
+ *
+ * Description: This function finds rehearsal marks at the final bar of a
+ * score. It moves them so that they will be at the pseudobar
+ * at the start of the next score.
+ */
+
+static void
+fixreh()
+
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct MAINLL *m2_p; /* look forward for bar line */
+
+
+ debug(16, "fixreh");
+ /*
+ * Loop through the main linked list, looking for rehearsal marks at
+ * the end of a score, and moving them.
+ */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+ if (mainll_p->str != S_BAR)
+ continue;
+ if (mainll_p->u.bar_p->reh_type == REH_NONE)
+ continue;
+
+ /*
+ * We are at a bar with a rehearsal mark. Find out if this is
+ * at the end of a score, by seeing if we find a FEED before
+ * the next bar.
+ */
+ for (m2_p = mainll_p->next; m2_p != 0 && m2_p->str != S_BAR &&
+ m2_p->str != S_FEED; m2_p = m2_p->next)
+ ;
+ if (m2_p == 0)
+ return; /* nothing more we can do in this case */
+ if (m2_p->str == S_BAR)
+ continue;
+
+ /*
+ * The ending starts at the last bar of a score. m2_p is at
+ * the FEED there, but what follows could be either music or a
+ * "block". If it is a block, we need to keep moving forward
+ * until we find a FEED followed by music.
+ */
+ while (m2_p != 0 && ! IS_CLEFSIG_FEED(m2_p)) {
+ m2_p = m2_p->next;
+ }
+ if (m2_p == 0) {
+ return; /* there is no more music, can't move reh */
+ }
+
+ /*
+ * We found the FEED. Move the rehearsal mark to the pseudo
+ * bar after the FEED.
+ */
+ m2_p->next->u.clefsig_p->bar_p->reh_type =
+ mainll_p->u.bar_p->reh_type;
+ mainll_p->u.bar_p->reh_type = REH_NONE;
+
+ m2_p->next->u.clefsig_p->bar_p->reh_string =
+ mainll_p->u.bar_p->reh_string;
+ mainll_p->u.bar_p->reh_string = 0;
+
+ m2_p->next->u.clefsig_p->bar_p->dist =
+ mainll_p->u.bar_p->dist;
+ mainll_p->u.bar_p->dist = 0;
+
+ m2_p->next->u.clefsig_p->bar_p->dist_usage =
+ mainll_p->u.bar_p->dist_usage;
+ mainll_p->u.bar_p->dist_usage = SD_NONE;
+ }
+}
+\f
+/*
+ * Name: clrinhprint()
+ *
+ * Abstract: Clear the inhibitprint on tablature staffs when appropriate.
+ *
+ * Returns: void
+ *
+ * Description: This function clears the inhibitprint bit in the first group
+ * of a tablature staff after a scorefeed. (Because in that
+ * situation, the group should be printed regardless of the usual
+ * conditions that inhibit printing.) Also, parentheses should be
+ * put around every note (fret number) in such groups.
+ */
+
+static void
+clrinhprint()
+
+{
+ struct MAINLL *mainll_p; /* point along main linked list */
+ struct GRPSYL *gs_p; /* point at first group */
+ int sawscorefeed; /* did we just see a scorefeed? */
+ int vidx; /* voice index */
+ int n; /* loop through the notes */
+
+
+ debug(16, "clrinhprint");
+ sawscorefeed = YES; /* "new score" at start of song */
+
+ /*
+ * Loop through main linked list, looking for visible tablature STAFFs,
+ * scorefeeds, and bar lines.
+ */
+ for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {
+
+ switch (mainll_p->str) {
+ case S_FEED:
+ sawscorefeed = YES; /* just saw a feed */
+ continue;
+ case S_BAR:
+ sawscorefeed = NO; /* next bar, forget the feed */
+ continue;
+ case S_STAFF:
+ /*
+ * If we just saw a scorefeed, and this is a visible
+ * tablature staff, break to handle it. Otherwise
+ * continue to the next loop iteration.
+ */
+ if (sawscorefeed == YES &&
+ mainll_p->u.staff_p->visible == YES &&
+ is_tab_staff(mainll_p->u.staff_p->staffno))
+ break;
+ continue;
+ default:
+ continue;
+ }
+
+ /* loop through each possible voice on tab staff */
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+
+ /* if voice doesn't exist, break out */
+ gs_p = mainll_p->u.staff_p->groups_p[vidx];
+ if (gs_p == 0)
+ break;
+
+ /* if not a note group, there's nothing to do */
+ if (gs_p->grpcont != GC_NOTES)
+ continue;
+
+ /*
+ * If inhibitprint was set, we need to put parens
+ * around the notes (frets) and clear the bit.
+ */
+ if (gs_p->inhibitprint == YES) {
+ for (n = 0; n < gs_p->nnotes; n++)
+ gs_p->notelist[n].FRET_HAS_PAREN = YES;
+ gs_p->inhibitprint = NO;
+ }
+ }
+ }
+}
+\f
+/*
+ * Name: hidestaffs()
+ *
+ * Abstract: Make staffs invisible if visible=whereused and they're empty.
+ *
+ * Returns: void
+ *
+ * Description: If the user set visible=whereused for staffs, up until now we
+ * have been treating it as visible=y, because the internal field
+ * visible==YES. But now that we know where all the scorefeeds
+ * are, this function looks at hidesilent for the given score, and
+ * when a staff should be invisible based on that, inserts SSVs
+ * and sets the visible field in the STAFF structures to make it
+ * invisible.
+ */
+
+static int
+hidestaffs(mainll_p, ml2_p)
+
+struct MAINLL *mainll_p; /* point at feed at start of score */
+struct MAINLL *ml2_p; /* point at last thing on the score */
+
+{
+ struct SSV *ssv_p; /* a static SSV containing visibility */
+ int s; /* staff number */
+ int firstvis; /* first visible staff in a score */
+ int foundvis; /* is a staff after first still visible? */
+ int forced_invis; /* did we force any staffs invisible? */
+ int ressv; /* must we reapply SSVs from the start? */
+
+
+ debug(16, "hidestaffs");
+
+ /*
+ * Loop through main linked list, applying SSVs and looking for FEEDs.
+ * When a FEED is found, check all the staffs and make the appropriate
+ * ones invisible.
+ */
+ /* find the first (currently) visible staff in this score */
+ firstvis = 0;
+ for (s = 1; s <= Score.staffs; s++) {
+ if (svpath(s, VISIBLE)->visible == YES) {
+ firstvis = s;
+ break;
+ }
+ }
+ if (firstvis == 0) {
+ pfatal("no visible staffs in score");
+ }
+
+ /*
+ * Working bottom up, check each currently visible staff to see whether
+ * it should be made invisible. If so, make it so. But if nothing
+ * below the first visible staff ends up visible, we leave it alone,
+ * since at least one staff must always be visible.
+ * There are cases when silent() has to apply some SSVs. In such
+ * cases, it sets ressv=YES. Sadly, we have to reapply SSVs from the
+ * start in that case.
+ */
+ foundvis = NO;
+ forced_invis = NO;
+ for (s = Score.staffs; s >= firstvis; s--) {
+ if (s == firstvis && foundvis == NO) {
+ /* only the top visible staff remains visible */
+ break;
+ }
+ ssv_p = svpath(s, VISIBLE);
+ if (ssv_p->visible == NO) { /* already invisible */
+ continue;
+ }
+ if (ssv_p->hidesilent == YES) {
+ if (silent(mainll_p, ml2_p, s, &ressv) == YES) {
+ /* silent() forced it invisible */
+ forced_invis = YES;
+ } else {
+ /* silent() left it visible */
+ foundvis = YES;
+ }
+ if (ressv == YES) {
+ setssvstate(mainll_p);
+ }
+ } else { /* hidesilent == NO */
+ foundvis = YES; /* leave it visible */
+ }
+ }
+
+ return (forced_invis);
+}
+\f
+/*
+ * Name: silent()
+ *
+ * Abstract: Make a staff invisible for this score, if appropriate.
+ *
+ * Returns: YES if we made it invisible, else NO
+ *
+ * Description: This function decides whether the given staff should be made
+ * invisible on the given score (line). It should be called only
+ * when visible==YES and hidesilent==YES. If it should be made
+ * invisible, it does that by inserting new "input" SSVs into the
+ * MLL before and after that line, and setting the visible field
+ * in the staffs to NO. There are cases where this function calls
+ * asgnssv(); in those cases it sets *ressv_p to YES, otherwise NO.
+ */
+
+static int
+silent(feedmll_p, ml2_p, s, ressv_p)
+
+struct MAINLL *feedmll_p; /* point along main linked list */
+struct MAINLL *ml2_p; /* point at MLL item at end of this score */
+int s; /* staff number */
+int *ressv_p; /* must the caller reapply SSVs? */
+
+{
+ struct MAINLL *mll_p; /* point along MLL */
+ struct MAINLL *lastbar_p; /* last bar line in score */
+ struct MAINLL *ins_p; /* point at MLL after which a new SSV goes */
+ struct MAINLL *new_p; /* point at MLL struct for a new SSV */
+ struct SSV *ssv_p; /* an SSV */
+ struct STAFF *staff_p; /* point at a STAFF */
+ struct STAFF *pstaff_p; /* point at the previous STAFF */
+ struct GRPSYL *gs_p; /* point at a group or syllable */
+ struct STUFF *stuff_p; /* point along a STUFF list */
+ int vidx; /* voice or verse index */
+
+
+ *ressv_p = NO; /* no SSVs have been applied yet */
+
+ /* find the last bar line in this score; it's where we should stop */
+ lastbar_p = 0;
+ for (mll_p = feedmll_p->next; mll_p != ml2_p && mll_p->str != S_FEED;
+ mll_p = mll_p->next) {
+ if (mll_p->str == S_BAR) {
+ lastbar_p = mll_p;
+ }
+ }
+ /* if none, there is no music here */
+ if (lastbar_p == 0) {
+ return (NO); /* nothing to hide */
+ }
+
+ /*
+ * Loop through this score, checking SSVs and looking in the STAFFs for
+ * this staff number, looking for reasons we must keep the staff
+ * visible.
+ */
+ for (mll_p = feedmll_p; mll_p != lastbar_p; mll_p = mll_p->next) {
+ switch (mll_p->str) {
+ case S_SSV:
+ /*
+ * To minimize the chances that we will apply an SSV
+ * and thus have to initstructs() and reapply from the
+ * beginning, apply only if it is relevent to what we
+ * are doing.
+ */
+ ssv_p = mll_p->u.ssv_p;
+ if (ssv_p->context != C_SCORE && ssv_p->staffno != s) {
+ /* this SSV is irrelevant to our staff */
+ continue;
+ }
+ if (ssv_p->used[VISIBLE] != NO) {
+ /*
+ * This SSV could affect our staff's visibility.
+ * Apply it, and remember that we've now messed
+ * with the fixed SSVs, and so we'll have to
+ * reapply from the start.
+ */
+ asgnssv(ssv_p);
+ *ressv_p = YES;
+ }
+ /*
+ * This staff started this score with visible==YES and
+ * hidesilent==YES. We know we are not going to see an
+ * SSV that causes our staff to go invisible, since
+ * that would have forced a scorefeed. But we could
+ * see one that causes our hidesilent value to be NO,
+ * and in that case we can immediately return NO, since
+ * it must remain visible.
+ */
+ if (svpath(s, VISIBLE)->hidesilent == NO) {
+ return (NO);
+ }
+ continue;
+
+ case S_STAFF:
+ staff_p = mll_p->u.staff_p;
+ if (staff_p->staffno != s) {
+ continue; /* some other staff, ignore */
+ }
+ break; /* break out to handle our staff */
+
+ default:
+ continue;
+ }
+
+ /* decide whether this staff can be made invisible */
+
+ /*
+ * Look at each group in each possible voice. If any contain
+ * notes, our staff must remain visible.
+ */
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ for (gs_p = staff_p->groups_p[vidx]; gs_p != 0;
+ gs_p = gs_p->next) {
+ if (gs_p->grpcont == GC_NOTES) {
+ return (NO);
+ }
+ }
+ }
+
+ /* if there are any syllables, our staff must remain visible */
+ if (staff_p->nsyllists != 0) {
+ return (NO);
+ }
+
+ /* if there is any stuff, our staff must remain visible */
+ if (staff_p->stuff_p != 0) {
+ return (NO);
+ }
+
+ /*
+ * If the previous MLL structure is a staff, it could have
+ * lyrics or "stuff" between it and our staff. If this
+ * previous staff is already invisible, ignore it since these
+ * things would be invisible. But the previous staff is
+ * visible, check for any of them being "between", in which
+ * case our staff must remain visible.
+ */
+ if (mll_p->prev->str == S_STAFF) {
+ pstaff_p = mll_p->prev->u.staff_p;
+ if (pstaff_p->visible == YES) {
+ for (vidx = 0; vidx < pstaff_p->nsyllists;
+ vidx++) {
+ if (pstaff_p->sylplace[vidx] ==
+ PL_BETWEEN) {
+ return (NO);
+ }
+ }
+ for (stuff_p = pstaff_p->stuff_p; stuff_p != 0;
+ stuff_p = stuff_p->next) {
+ if (stuff_p->place == PL_BETWEEN) {
+ return (NO);
+ }
+ }
+ }
+ }
+ }
+
+ /*
+ * At this point we've looked through everything and found that there
+ * is no need to keep this staff visible. So we are going to force it
+ * invisible. If a staff's SSV says visible==NO but it has voice(s)
+ * with visible==YES, it ends up being visible anyhow. So in addition
+ * to forcing the staff to visible=NO, we will unset all its voices'
+ * visibility. Rather than checking how many voices there are, it's
+ * easiest just to force all possible ones invisible.
+ */
+
+ /*
+ * Set ins_p to the SSV after which the new ones should be put. There
+ * may be a CLEFSIG before the FEED; if so, they should be put before
+ * there, otherwise just before the FEED. This is to maintain the
+ * correct ordering of structures; see comment at the end of structs.h.
+ * If the FEED is at the start, ins_p will be 0.
+ */
+ ins_p = feedmll_p->prev;
+ if (ins_p != 0 && ins_p->str == S_CLEFSIG) {
+ ins_p = ins_p->prev;
+ }
+
+ /* force staff's visible to NO */
+ new_p = newMAINLLstruct(S_SSV, -1);
+ ssv_p = new_p->u.ssv_p;
+ ssv_p->context = C_STAFF;
+ ssv_p->staffno = s;
+ ssv_p->used[VISIBLE] = YES;
+ ssv_p->visible = NO;
+ insertMAINLL(new_p, ins_p);
+
+ /* force voices' visible to unset */
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ new_p = newMAINLLstruct(S_SSV, -1);
+ ssv_p = new_p->u.ssv_p;
+ ssv_p->context = C_VOICE;
+ ssv_p->staffno = s;
+ ssv_p->voiceno = vidx + 1;
+ ssv_p->used[VISIBLE] = UNSET;
+ insertMAINLL(new_p, ins_p);
+ }
+
+ /* do not let any SSVs on this line alter this staff's visibility */
+ for (mll_p = feedmll_p; mll_p != lastbar_p; mll_p = mll_p->next) {
+ if (mll_p->str != S_SSV) {
+ continue;
+ }
+ ssv_p = mll_p->u.ssv_p;
+ /*
+ * Since we know we are overriding the score, we don't care if
+ * the score is changing. Just force all staff and voice SSVs
+ * for this staff to not be setting VISIBLE.
+ */
+ if (ssv_p->context != C_SCORE && ssv_p->staffno == s) {
+ ssv_p->used[VISIBLE] = NO;
+ }
+ }
+
+ /* the SSVs to be put at the end go after the last bar line */
+ ins_p = lastbar_p;
+
+ /*
+ * Insert "input" SSVs that will cause the staff's fixed SSV and its
+ * voices' fixed SSVs to be restored to how they would have been if we
+ * hadn't changed anything. That is the state they are in right now.
+ */
+ new_p = newMAINLLstruct(S_SSV, -1);
+ ssv_p = new_p->u.ssv_p;
+ ssv_p->context = C_STAFF;
+ ssv_p->staffno = s;
+ if (Staff[s-1].used[VISIBLE] == YES) {
+ ssv_p->used[VISIBLE] = YES;
+ ssv_p->visible = Staff[s-1].visible;
+ ssv_p->hidesilent = Staff[s-1].hidesilent;
+ } else {
+ ssv_p->used[VISIBLE] = UNSET;
+ }
+ insertMAINLL(new_p, ins_p);
+
+ for (vidx = 0; vidx < MAXVOICES; vidx++) {
+ new_p = newMAINLLstruct(S_SSV, -1);
+ ssv_p = new_p->u.ssv_p;
+ ssv_p->context = C_VOICE;
+ ssv_p->staffno = s;
+ ssv_p->voiceno = vidx + 1;
+ if (Voice[s-1][vidx].used[VISIBLE] == YES) {
+ ssv_p->used[VISIBLE] = YES;
+ ssv_p->visible = Voice[s-1][vidx].visible;
+ ssv_p->hidesilent = Voice[s-1][vidx].hidesilent;
+ } else {
+ ssv_p->used[VISIBLE] = UNSET;
+ }
+ insertMAINLL(new_p, ins_p);
+ }
+
+ /* set visible to NO in every staff of this number on this line */
+ for (mll_p = feedmll_p; mll_p != lastbar_p; mll_p = mll_p->next) {
+ if (mll_p->str == S_STAFF) {
+ staff_p = mll_p->u.staff_p;
+ if (staff_p->staffno == s) {
+ staff_p->visible = NO;
+ }
+ }
+ }
+
+ return (YES);
+}
+\f
+/*
+ * Name: getmultinum()
+ *
+ * Abstract: Find number of measures in the next staff's multirest.
+ *
+ * Returns: The number, or 0 if next staff is not a multirest.
+ *
+ * Description: This function is given an MLL struct, and if it's not a STAFF,
+ * searches forward to the next STAFF. It returns as stated above.
+ */
+
+static int
+getmultinum(mll_p)
+
+struct MAINLL *mll_p; /* point along MLL, starts at the CLEFSIG */
+
+{
+ int basictime; /* of the first group in the first following staff */
+
+
+ /* find the first staff after this clefsig */
+ for ( ; mll_p != 0 && mll_p->str != S_STAFF; mll_p = mll_p->next) {
+ ;
+ }
+
+ /* if no staff, there is no multirest */
+ if (mll_p == 0) {
+ return (0);
+ }
+
+ basictime = mll_p->u.staff_p->groups_p[0]->basictime;
+ return (basictime < -1 ? -basictime : 0);
+}
~mdw / mup / blobdiff