--- /dev/null
+/* Copyright (c) 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2003 by Arkkra Enterprises */
+/* All rights reserved */
+
+/* This file contains functions that deal with
+ * extending underscores and dashes on lyric syllables.
+ */
+
+#include "defines.h"
+#include "structs.h"
+#include "globals.h"
+
+static double end_dashes P((struct MAINLL *mll_p, struct GRPSYL *syl_p,
+ int verse, int place, int *carryover_p));
+static double end_underscore P((struct MAINLL *mll_p, struct GRPSYL *syl_p,
+ int verse, int place, int *carryover_p));
+static double endx P((struct GRPSYL *last_grp_p, double end));
+static int has_above_lyr P((struct MAINLL *mll_p, RATIONAL begin_time,
+ struct GRPSYL *group_p, int verse));
+static int voice_is_above P((int v1, int v2));
+static struct GRPSYL *find_verse_place P((struct STAFF *staff_p,
+ int verse, int place));
+static RATIONAL default_end P((struct MAINLL *mll_p, struct GRPSYL *syl_p,
+ RATIONAL start_time, double *end_p));
+static int bar_ends_extender P((struct BAR *bar_p, struct MAINLL *mll_p,
+ int staffno, int verse, int place,
+ struct GRPSYL **nextsyl_p_p));
+static void pr_extender P((int ch, double start, double end, double y,
+ int font, int size));
+static void insert_carryover_syllable P((struct MAINLL *mll_p, int staffno,
+ int sylplace, int verseno, char *dash_or_underscore,
+ int font, int size));
+static void add_syllable P((struct STAFF *staff_p, int sylplace, int verseno,
+ char *dash_or_underscore, int font, int size,
+ double begin_x, struct CHORD *chord_p));
+static void stitch_syl_into_chord P((struct CHORD *chord_p,
+ struct GRPSYL *syl_gs_p));
+\f
+
+/* This function is called on lyric syllables in two cases:
+ * 1) During placement phase to determine if an extender needs to
+ * be carried over to a following staff. In this case, really_print
+ * will be NO. (The easiest way to see if an extender needs to carry
+ * over is to pretend to print an extender). The return value will
+ * be YES if there should be a carryover.
+ * 2) When printing the syllable, to draw an extender after it,
+ * if appropriate. In this case, really_print will be YES,
+ * and the return value is meaningless.
+ *
+ * If a syllable ends with a dash, the dash should be placed halfway between
+ * where this syllable ends and the next begins. Or if there is a big space,
+ * multiple dashes should be spread out in that space. If it ends with an
+ * underscore, then an underline should be drawn from the end of this
+ * syllable to the east edge of the notes in the last chord before
+ * the next syllable for the same staff/verse/place.
+ * But if there is a carryover, this just does the extender up to the
+ * end of the current score; it will get called again on the next score
+ * to continue the extender.
+ * If an underscore is used on a single chord, rather than a mellisma
+ * (which might technically be considered an "incorrect" usage of underscore),
+ * we figure the underscore should be drawn to just before the next syllable,
+ * unless there is a rest earlier. Or if the next syllable begins a measure,
+ * the underscore ends before the bar line, to look better.
+ * If really printing, the dash or underscore is removed
+ * from the end of the string so it won't get printed
+ * with the syllable.
+ */
+
+int
+spread_extender(syl_p, mll_p, verse, sylplace, really_print)
+
+struct GRPSYL *syl_p; /* current syllable */
+struct MAINLL *mll_p; /* which MAINLL struct it's hanging off of */
+int verse; /* verse number */
+int sylplace; /* PL_ABOVE, etc */
+int really_print; /* if YES, actually print, otherwise just return
+ * whether needs to be carried over to next score */
+
+{
+ char *syl; /* to walk through characters of the syllable */
+ int font;
+ int size;
+ double start; /* dash area or underscore starts here */
+ double end; /* dash area or underscore ends here */
+ int ch; /* current character in syllable */
+ int last_ch = '\0'; /* final character in syllable */
+ int extndr_font; /* in case user changes font/size after
+ * extender, keep track of what font/size the
+ * extender was */
+ int extndr_size = -1;
+ char *ch_p; /* pointer to where - or _ is in string */
+ int carryover; /* YES if will carry over to next staff */
+
+
+
+ /* See if there is a dash or underscore at the end of the syllable.
+ * If so, save pointer to it. Note that this may not be the last
+ * byte in the string, because there could be font/size changes
+ * after it. */
+ font = syl_p->syl[0];
+ size = syl_p->syl[1];
+ syl = syl_p->syl + 2;
+
+ /* These two assignments avoid "used without being set" warnings */
+ extndr_font = font;
+ ch_p = syl;
+
+ /* Find last character of syllable */
+ while ( (ch = next_str_char( &syl, &font, &size)) != '\0') {
+#ifdef EXTCHAR
+ if ( ( ch == '-' || ch == '_') && ! IS_MUSIC_FONT(font)
+ && (font < FONT_XTR) ) {
+#else
+ if ( ( ch == '-' || ch == '_') && ! IS_MUSIC_FONT(font) ) {
+#endif
+ ch_p = syl - 1;
+ extndr_font = font;
+ extndr_size = size;
+ last_ch = ch;
+ }
+ else {
+ last_ch = '\0';
+ }
+ }
+
+ /* If there is an extender, handle it */
+ if (last_ch != '\0') {
+ if ( last_ch == '-') {
+ end = end_dashes(mll_p, syl_p, verse, sylplace,
+ &carryover);
+ }
+ else {
+ end = end_underscore(mll_p, syl_p, verse, sylplace,
+ &carryover);
+ }
+
+ if (really_print == NO) {
+ return(carryover);
+ }
+
+ /* Move the rest of the string
+ * over the dash or underscore,
+ * so it won't get printed with the syllable */
+ do {
+ *ch_p = *(ch_p + 1);
+ } while ( *++ch_p != '\0');
+ start = syl_p->c[AE];
+
+ /* procsyls() adjusted the east in certain cases for
+ * placement purposes. For printing we need to cancel out
+ * those adjustments. */
+ if (syl_p->next != 0 && last_ch != '-') {
+ start -= width(extndr_font, extndr_size, ' ');
+ }
+ if (syl_p->next == 0 && last_ch == '-') {
+ start += width(extndr_font, extndr_size, ' ');
+ }
+
+ /* actually print the extender */
+ pr_extender(last_ch, start, end, syl_p->c[AY],
+ extndr_font, extndr_size);
+ }
+ return(NO);
+}
+\f
+
+/* Given a syllable ending with a dash, and some other info,
+ * return where to end the dash(es). If the dashes carry over
+ * to the following score, this will return a point near the east end of
+ * the current score, after setting *carryover_p to YES.
+ */
+
+static double
+end_dashes(mll_p, syl_p, verse, place, carryover_p)
+
+struct MAINLL *mll_p; /* points to STAFF containing the syl with dash */
+struct GRPSYL *syl_p; /* this is the syllable with dash */
+int verse; /* which verse the syl_p is for */
+int place; /* a PL_* value for where the lyric is */
+int *carryover_p; /* return value, set to YES if there was a carryover */
+
+{
+ int staffno;
+ struct BAR *lastbar_p;
+
+ staffno = syl_p->staffno;
+ *carryover_p = NO;
+ lastbar_p = 0; /* will get set to something better before being used */
+ syl_p = syl_p->next;
+
+ do {
+ /* Go forward looking for another non-space syllable */
+ if (syl_p != 0) {
+ for ( ; syl_p != 0; syl_p = syl_p->next) {
+ if (syl_p->grpcont != GC_SPACE) {
+ /* found it! */
+ return(syl_p->c[AW] - Stepsize);
+ }
+ }
+ }
+
+ /* No ending syl in current measure. Try the next. */
+ for (mll_p = mll_p->next; mll_p != 0; mll_p = mll_p->next) {
+ if (mll_p->str == S_BAR) {
+ if (bar_ends_extender(mll_p->u.bar_p,
+ mll_p, staffno, verse,
+ place, 0) == YES) {
+ return(mll_p->u.bar_p->c[AW] - Stepsize);
+ }
+ lastbar_p = mll_p->u.bar_p;
+ }
+
+ else if (mll_p->str == S_FEED) {
+ /* If this is a feed at the very end of the
+ * main list, or one or more blocks follow it,
+ * this is not the kind of feed
+ * we're looking for. */
+ if (mll_p->next == 0 ||
+ mll_p->next->str == S_BLOCKHEAD) {
+ continue;
+ }
+ /* There is a carryover unless the
+ * pseudo-bar is something that would end
+ * the extender. */
+ mll_p = mll_p->next;
+ if (mll_p->str != S_CLEFSIG
+ || mll_p->u.clefsig_p->bar_p
+ == 0) {
+ if (mll_p->str == S_FEED) {
+ /* Being here means there is
+ * a bug somewhere else,
+ * because the main list rules
+ * are violated. But we can
+ * render such a bug harmless
+ * by continuing here.
+ */
+ continue;
+ }
+ pfatal("end_dashes found unexpected main list contents after feed");
+ }
+ if (bar_ends_extender(mll_p->u.clefsig_p->bar_p,
+ mll_p, staffno, verse, place, 0)
+ == NO) {
+ *carryover_p = YES;
+ }
+ return(lastbar_p->c[AW] - Stepsize);
+ }
+
+ else if (mll_p->str == S_STAFF
+ && mll_p->u.staff_p->staffno
+ == staffno) {
+ syl_p = find_verse_place(mll_p->u.staff_p,
+ verse, place);
+ break;
+ }
+ }
+ } while (mll_p != 0);
+
+ /* Fell off end of song. Use final bar */
+ return(lastbar_p->c[AW] - Stepsize);
+}
+\f
+
+/* Given a syllable ending with an underscore, and some other info,
+ * return where to end the underscore. If the underscore carries over
+ * to the following score, this will return a point near the east end of
+ * the current score, after setting *carryover_p to YES.
+ */
+
+static double
+end_underscore(mll_p, syl_p, verse, place, carryover_p)
+
+struct MAINLL *mll_p; /* points to STAFF containing the syl with underscore */
+struct GRPSYL *syl_p; /* this is the syllable with underscore */
+int verse; /* which verse the syl_p is for */
+int place; /* a PL_* value for where the lyric is */
+int *carryover_p; /* return value, set to YES if there was a carryover */
+
+{
+ struct GRPSYL *current_grp_p[MAXVOICES];/* which group we are
+ * currently dealing with on
+ * each voice */
+ RATIONAL group_time[MAXVOICES]; /* accumulated time value of
+ * groups up to the one we
+ * are currently dealing with */
+ short had_rest[MAXVOICES]; /* YES or NO */
+ RATIONAL current_time; /* how far we are in meas */
+ RATIONAL end_time; /* where next non-space
+ * syllable is for this
+ * staff/place/verse, if
+ * there is one
+ * in the current measure,
+ * otherwise the end of the
+ * current measure. */
+ struct GRPSYL *last_grp_p; /* if non-zero, this is the
+ * current candidate group
+ * with which we could
+ * potentially align the
+ * end of the underscore. */
+ double end; /* this is how far we will
+ * draw the underscore if we
+ * don't find any reason to
+ * stop it sooner. */
+ struct GRPSYL *grp_p; /* walk through GRPSYLs */
+ struct STAFF *staff_p; /* next measure's STAFF */
+ struct GRPSYL *nextsyl_p; /* syl list for same verse/place
+ * in the next measure */
+ RATIONAL grp_end_time; /* where a current group ends */
+
+ int vindex; /* voice index */
+ int v; /* voice index */
+ short found_feed; /* YES or NO */
+ int staffno;
+
+
+ *carryover_p = NO; /* assume no carryover for now */
+ staffno = mll_p->u.staff_p->staffno;
+
+ /* Back up from the syllable with underscore to count up time-wise how
+ * far into the measure it is */
+ current_time = Zero;
+ for (grp_p = syl_p->prev; grp_p != 0; grp_p = grp_p->prev) {
+ current_time = radd(current_time, grp_p->fulltime);
+ }
+
+ /* Set a default end time and place.
+ * Most likely, we will discover later we need to stop the underscore
+ * earlier than this, but if the user is using underscore in a strange
+ * way, like on a single long note rather than a melissma,
+ * we'll use this as the default place to end the underscore. */
+ end_time = default_end(mll_p, syl_p, current_time, &end);
+
+ /* We don't yet have any candidate group with which to align
+ * the ending of the underscore. */
+ last_grp_p = 0;
+
+ /* For each voice, if it exists, find the group that contains
+ * the time of the syllable with the underscore, and make that
+ * the "current group" for that voice. If the voice doesn't exist,
+ * set the current group pointer to zero. */
+ staff_p = mll_p->u.staff_p;
+ for (vindex = 0; vindex < MAXVOICES; vindex++) {
+ group_time[vindex] = Zero;
+ had_rest[vindex] = NO;
+ if (staff_p->groups_p[vindex] != 0) {
+ for (current_grp_p[vindex] = staff_p->groups_p[vindex];
+ current_grp_p[vindex] != 0;
+ current_grp_p[vindex]
+ = current_grp_p[vindex]->next) {
+ if (GE(current_time, group_time[vindex]) &&
+ LT(current_time,
+ radd(group_time[vindex],
+ current_grp_p[vindex]->fulltime))) {
+ /* This group contains the syl's time */
+
+ if (current_grp_p[vindex]->grpcont == GC_REST) {
+ had_rest[vindex] = YES;
+ }
+ break;
+ }
+ group_time[vindex] = radd(group_time[vindex],
+ current_grp_p[vindex]->fulltime);
+ }
+ if (current_grp_p[vindex] == 0) {
+ pfatal("unable to find group containing syl's time");
+ }
+ }
+ else {
+ /* voice doesn't exist in this measure */
+ current_grp_p[vindex] = 0;
+ }
+ }
+
+ for ( ; ; ) {
+ /* Most of the time, we use voice 1 to determine where to
+ * end the underscore. However, if voice 1 has spaces,
+ * we'll use voice 3 (the "middle" voice), and
+ * if that is non-existent or space, we use voice 2.
+ * If everything is space, we keep going and hope for the
+ * best. If all else fails, we would end up using the "end"
+ * value as the default.
+ *
+ * However, if this is a below or between lyric,
+ * and there exists an above lyric
+ * during the time we are dealing with,
+ * we assume voice 1 goes with the above lyric, and the
+ * below lyric probably goes with voice 2, or possibly voice 3.
+ * If both those voices exist, it's probably not possible
+ * to divine which the user wants the lyric associated with
+ * without reading their mind. But 3 voices on a vocal staff
+ * is quite unusual, especially with rests in different places,
+ * so we use voice 2 if it exists and is non-space.
+ * If that fails, we try 3, then 1, then punt.
+ * If it is a between lyric, there is a slight chance the user
+ * really wanted us to use the staff below, but we always
+ * associate "between" things with the staff above.
+ * They should use "above" on the next staff instead.
+ */
+ vindex = 0; /* use voice 1 as default */
+ if (place != PL_ABOVE) {
+ /* The lyric is below or between.
+ * Test voices 2, 3, and 1 (indexes 1, 2, 0)
+ * in that order till we find one that isn't a space,
+ * and see if there is an above lyric
+ * during its time. If so, that is the voice to use
+ * during this time to figure out
+ * where to end underscore. */
+ if (current_grp_p[1] != 0 &&
+ current_grp_p[1]->grpcont != GC_SPACE &&
+ has_above_lyr(mll_p, current_time,
+ current_grp_p[1], verse) == YES) {
+ vindex = 1;
+ }
+ else if (current_grp_p[2] != 0 &&
+ current_grp_p[2]->grpcont != GC_SPACE &&
+ has_above_lyr(mll_p, current_time,
+ current_grp_p[2], verse) == YES) {
+ vindex = 2;
+ }
+ /* Otherwise we go with the default, voice 1.
+ * We know voice 1 will always exist. */
+ }
+
+ else { /* place is above */
+ /* Note that voice 1 always exists, so
+ * so we don't need to check for null first
+ * on that voice. */
+ if (current_grp_p[0]->grpcont != GC_SPACE) {
+ vindex = 0;
+ }
+ else if (current_grp_p[2] != 0 &&
+ current_grp_p[2]->grpcont != GC_SPACE) {
+ vindex = 2;
+ }
+ else if (current_grp_p[1] != 0 &&
+ current_grp_p[1]->grpcont != GC_SPACE) {
+ vindex = 1;
+ }
+ }
+
+ /* At this point, we know which voice is most relevant for
+ * checking if it is time to end the underscore.
+ * See if the current group in that voice contains the
+ * time value of the ending syllable. */
+ if ( GE(end_time, group_time[vindex]) && LT(end_time,
+ radd(group_time[vindex],
+ current_grp_p[vindex]->fulltime)) ) {
+ /* We need to end the underscore now. */
+ return(endx(last_grp_p, end));
+ }
+
+ /* If the relevant group is a rest, need to stop here */
+ if (current_grp_p[vindex]->grpcont == GC_REST) {
+ return(endx(last_grp_p, current_grp_p[vindex]->c[AW]));
+ }
+ else if (current_grp_p[vindex]->grpcont == GC_NOTES) {
+ /* Save as last known group so far at which we
+ * could potentially end the underscore. */
+ last_grp_p = current_grp_p[vindex];
+ }
+
+ /* We're done with this group; move to next */
+ current_time = radd(current_time,
+ current_grp_p[vindex]->fulltime);
+
+ /* Catch up all the voices to the current time */
+ for (v = 0; v < MAXVOICES; v++) {
+ if (current_grp_p[v] != 0) {
+ grp_end_time = radd(group_time[v],
+ current_grp_p[v]->fulltime);
+
+ while ( LE(grp_end_time, current_time) ){
+ /* Special case. Suppose,
+ * as an example, soprano and
+ * alto share a staff and the
+ * soprano has a long note
+ * while the alto has a
+ * melissma. The underscore
+ * should then go to the
+ * last note of the melissma,
+ * even though soprano is
+ * the reference voice.
+ * However, if the alto line
+ * had had rests, it's likely
+ * it's just accompaniment,
+ * not a vocal line, or at
+ * least they should have
+ * used separate above/below
+ * lyrics.
+ * So if this group is below
+ * the reference group and
+ * hasn't had any rests and
+ * is east of our candidate
+ * last group, make it the
+ * new candidate last group. */
+ if (voice_is_above(vindex, v)
+ && place != PL_ABOVE
+ && had_rest[v] == NO
+ && last_grp_p != 0
+ && current_grp_p[v]->grpcont
+ == GC_NOTES
+ && current_grp_p[v]->c[AX]
+ > last_grp_p->c[AX]) {
+ last_grp_p = current_grp_p[v];
+ }
+
+ /* move on to next group */
+ current_grp_p[v] =
+ current_grp_p[v]->next;
+ if (current_grp_p[v] == 0) {
+ break;
+ }
+
+ group_time[v] = grp_end_time;
+ grp_end_time = radd(
+ group_time[v],
+ current_grp_p[v]->fulltime);
+ if (current_grp_p[v]->grpcont
+ == GC_REST) {
+ had_rest[v] = YES;
+ }
+ }
+ }
+ }
+
+ /* Are we now at the end of the current measure? */
+ if (current_grp_p[vindex] == 0) {
+ /* If there is a feed after this bar,
+ * we need to see if a carryover is needed.
+ * If so, we will end this underscore just before
+ * the bar, and carry it over to the next score.
+ */
+ found_feed = NO;
+ for (mll_p = mll_p->next; mll_p != 0; mll_p = mll_p->next) {
+ if (mll_p->str == S_BAR) {
+ if (bar_ends_extender(mll_p->u.bar_p, mll_p,
+ syl_p->staffno, verse,
+ place, &nextsyl_p)
+ == YES) {
+ /* It's not clear
+ * where we should stop if
+ * we can't deduce a following
+ * syllable. However,
+ * if we go to the bar line,
+ * the user can always use
+ * a <> syllable to force
+ * an earlier ending if needed,
+ * whereas if we go
+ * with the last group,
+ * there's probably no
+ * reasonable workaround
+ * if that's not what they want,
+ * so use the bar line. */
+ if (nextsyl_p == 0) {
+ return(end);
+ }
+ else if (nextsyl_p->grpcont
+ == GC_SPACE) {
+ /* "carries over" */
+ return(end);
+ }
+ else {
+ return(endx(last_grp_p, end));
+ }
+ }
+ }
+ else if (mll_p->str == S_FEED) {
+ found_feed = YES;
+ }
+ else if (mll_p->str == S_STAFF &&
+ mll_p->u.staff_p->staffno ==
+ staffno) {
+ break;
+ }
+ else if (mll_p->str == S_SSV) {
+ /* if this staff becomes invisible,
+ * end the underscore at the last
+ * group before that. */
+ struct SSV *ssv_p;
+ ssv_p = mll_p->u.ssv_p;
+ if (ssv_p->context == C_STAFF
+ && ssv_p->staffno == staffno
+ && ssv_p->used[VISIBLE] == YES
+ && ssv_p->visible == NO) {
+ return(endx(last_grp_p, end));
+ }
+ }
+ }
+ if (mll_p == 0) {
+ /* fell off end of song */
+ return(endx(last_grp_p, end));
+ }
+ staff_p = mll_p->u.staff_p;
+
+ /* See if there is a syllable at the same verse/place */
+ if ((nextsyl_p = find_verse_place(staff_p,
+ verse, place)) != 0 &&
+ nextsyl_p->grpcont != GC_SPACE) {
+ /* There is a syllable at the
+ * beginning of the next meas,
+ * so we end the underscore,
+ * unless it was just a carryover syllable
+ * that we added earlier. */
+ if (nextsyl_p->syl[2] != '_'
+ || nextsyl_p->syl[3] != '\0') {
+ return(endx(last_grp_p, end));
+ }
+ }
+ if (found_feed == YES) {
+ if (staff_p->groups_p[vindex] != 0 &&
+ staff_p->groups_p[vindex]->grpcont == GC_REST) {
+ /* next meas begins with a rest,
+ * so no need to carry over */
+ return(endx(last_grp_p, end));
+ }
+ /* We need to end the underscore on the
+ * current score, and arrange to carry it
+ * over on the next score. */
+ *carryover_p = YES;
+ return(end);
+ }
+
+
+ /* Move to next measure by initing each
+ * current_grp_p[vindex] to the first group
+ * in the next measure. */
+ for (vindex = 0; vindex < MAXVOICES; vindex++) {
+ current_grp_p[vindex] = staff_p->groups_p[vindex];
+ group_time[vindex] = Zero;
+ if (current_grp_p[vindex] != 0 &&
+ current_grp_p[vindex]->grpcont
+ == GC_REST) {
+ had_rest[vindex] = YES;
+ }
+ }
+ end_time = default_end(mll_p,
+ find_verse_place(staff_p, verse, place),
+ Zero, &end);
+ current_time = Zero;
+ }
+ }
+}
+\f
+
+/* If we found a last group where we could end a underscore,
+ * return where the east edge of its notes are,
+ * otherwise return the "end" value as the default.
+ */
+
+static double
+endx(last_grp_p, end)
+
+struct GRPSYL *last_grp_p; /* if != 0, use east edge of notes of this */
+double end; /* if all else fails, use this */
+
+{
+ int n; /* note index */
+ double edge; /* return value */
+
+
+ if (last_grp_p == 0) {
+ return(end);
+ }
+
+ if (last_grp_p->grpcont != GC_NOTES) {
+ /* This should actually never happen with the current code,
+ * but just in case, we use the east of the group */
+ return(last_grp_p->c[AE]);
+ }
+
+ /* find east edge of notes, not counting any dots or flags */
+ edge = -1000000.0; /* init to impossible value */
+ for (n = 0; n < last_grp_p->nnotes; n++) {
+ if (last_grp_p->notelist[n].c[AE] > edge) {
+ edge = last_grp_p->notelist[n].c[AE];
+ }
+ }
+ /* If the edge we calculated is east of the default end, use
+ * the default end, because that is suppose to be the farthest
+ * possible east we can be. This could happen if the user used
+ * <^....> on a lyric to force part of the lyric to encroach
+ * into the previous groups' space. In that case we need to end
+ * the underscore where the encroaching lyric begins, not where
+ * the last note group ends.
+ */
+ if (edge > end) {
+ return(end);
+ }
+ return(edge);
+}
+\f
+
+/*
+ * Return YES if there is an above lyrics during the specified time.
+ * We have to use some heuristics.
+ *
+ * If there is any non-space above lyric for the given verse
+ * at any point between the begin time
+ * and the begin time plus the fulltime of the group_p,
+ * then there is an above lyric.
+ *
+ * If there is a rest on voice 1, that implies a rest in an above lyric
+ * line.
+ *
+ * If there is lyric space for the duration in question, either
+ * explicit space, or just no above lyrics at all for the given verse
+ * in this measure, then we don't know for sure where there are no
+ * above lyrics, or there is an earlier above lyric for this verse
+ * that extends into the duration.
+ * If we find some earlier non-space above lyric
+ * and it ends with an extender (dash or underscore),
+ * we say there is an above lyric.
+ * If there is no such lyric, or the first non-space above lyric
+ * lyric we come to in backing up does not end with an extender,
+ * we say there isn't an above lyric.
+ */
+
+static int
+has_above_lyr(mll_p, begin_time, group_p, verse)
+
+struct MAINLL *mll_p; /* points to syl's STAFF */
+RATIONAL begin_time;
+struct GRPSYL *group_p; /* see if there a lyric above this group */
+int verse;
+
+{
+ struct STAFF *staff_p;
+ struct GRPSYL *grp_p;
+ RATIONAL cumm_time; /* current cummulative time */
+ RATIONAL new_cumm_time; /* cumm_time + group's fulltime */
+ RATIONAL end_time; /* begin_time + syl's fulltime */
+ int n; /* syllist index */
+ int prev_extends; /* YES/NO if prev syl has extender */
+
+
+ if (mll_p->str != S_STAFF) {
+ pfatal("has_above_lyr passed wrong type of struct");
+ }
+
+ staff_p = mll_p->u.staff_p;
+ end_time = radd(begin_time, group_p->fulltime);
+
+ /* Go through syllists for the staff */
+ prev_extends = NO;
+ for (n = 0; n < staff_p->nsyllists; n++) {
+ if (staff_p->sylplace[n] == PL_ABOVE &&
+ staff_p->syls_p[n]->vno == verse) {
+ cumm_time = Zero;
+ for (grp_p = staff_p->syls_p[n]; grp_p != 0; grp_p = grp_p->next) {
+ new_cumm_time = radd(cumm_time, grp_p->fulltime);
+
+ if ( LT(new_cumm_time, begin_time) &&
+ grp_p->grpcont != GC_SPACE) {
+ prev_extends = has_extender(grp_p->syl);
+ }
+
+ /* See if this syllable overlaps the time
+ * of the group we are checking against. */
+ else if ( (GE(begin_time, cumm_time) &&
+ LT(begin_time, new_cumm_time)) ||
+ (GE(end_time, cumm_time) &&
+ LT(end_time, new_cumm_time)) ) {
+
+ /* This is a relevant group. If it isn't
+ * a space, then we know there is
+ * indeed an above lyric. */
+ if (grp_p->grpcont != GC_SPACE) {
+ return(YES);
+ }
+ if (prev_extends == YES) {
+ /* A syllable
+ * earlier in the measure
+ * is extending into the
+ * duration, so that counts.
+ */
+ return(YES);
+ }
+ }
+ else if (GT(new_cumm_time, end_time)) {
+ /* we're past the relevant syl(s) */
+ break;
+ }
+ cumm_time = new_cumm_time;
+ }
+ /* We've dealt with the only relevant syl list
+ * in this measure. */
+ break;
+ }
+ }
+
+ /* If there is a rest on voice 1, there is an implicit above
+ * lyric (albeit a pause in the above lyrics). Or at least it hardly
+ * makes sense to use voice 1 for below/between lyrics if voice 1
+ * is a rest but there is another voice below it that isn't.
+ */
+ cumm_time = Zero;
+ for (grp_p = mll_p->u.staff_p->groups_p[0]; grp_p != 0; grp_p = grp_p->next) {
+ new_cumm_time = radd(cumm_time, grp_p->fulltime);
+ if ( (GE(begin_time, cumm_time) &&
+ LT(begin_time, new_cumm_time)) ||
+ (GE(end_time, cumm_time) &&
+ LT(end_time, new_cumm_time)) ) {
+ if (grp_p->grpcont == GC_REST) {
+ return(YES);
+ }
+ }
+ cumm_time = new_cumm_time;
+ if (GT(cumm_time, end_time)) {
+ /* past the relevant groups */
+ break;
+ }
+ }
+
+ /* If we got here, we weren't able to tell for
+ * sure if there is an above lyric, because there
+ * was either implicit or explicit space.
+ * Most likely there is no above lyric,
+ * but there is a slight possibility there is
+ * a lyric holding over into this time period
+ * via a melisma or tied notes from a previous measure.
+ * So we back up looking for such a lyric. If we find an above lyric
+ * that ends with an extender (underscore or dash),
+ * we declare that there is an above lyric.
+ * If we find one without an extender or back up
+ * all the way to the beginning of the song without
+ * finding any above lyric, there is no above lyric here.
+ * But we give up after 20 measures, figuring it's
+ * really unlikely for any melisma or tie to last
+ * that long, especially since any scorefeeds
+ * would cause a syllable to get added. The exact
+ * value of 20 is arbitrary; it just seems like plenty.
+ *
+ * prevgrpsyl doesn't work on syls, just groups,
+ * but by giving it staff_p->groups_p[0] (we
+ * know voice 1 will always exist), it will give
+ * us the mll_p for the staff we need.
+ */
+ for (n = 0; n < 20; n++) {
+ struct GRPSYL *last_non_space_p;
+
+ if (prevgrpsyl(mll_p->u.staff_p->groups_p[0],
+ &mll_p) == 0) {
+ /* Got to beginning of song */
+ return(NO);
+ }
+
+ grp_p = find_verse_place(mll_p->u.staff_p, verse, PL_ABOVE);
+
+ if (grp_p == 0) {
+ /* No relevant lyrics in this meas */
+ continue;
+ }
+
+ last_non_space_p = 0;
+ for ( ; grp_p != 0; grp_p = grp_p->next) {
+ if (grp_p->grpcont != GC_SPACE) {
+ last_non_space_p = grp_p;
+ }
+ }
+ if (last_non_space_p != 0) {
+ /* Found a preceeding syllable */
+ return(has_extender(last_non_space_p->syl));
+ }
+ }
+ /* We've backed up far enough that the chances of there actually being
+ * an above lyrics are very, very slim. */
+ return(NO);
+}
+\f
+
+/* Returns YES if voice with index v1 is "above" voice v2; else NO */
+
+static int
+voice_is_above(v1, v2)
+
+int v1;
+int v2;
+
+{
+ /* Voice number is one more than its index, so convert index to
+ * number so it's easier to think about */
+ v1++;
+ v2++;
+
+ /* Voice 1 is above voice 2 and 3 */
+ if (v1 == 1) {
+ return(YES);
+ }
+
+ /* Voice 3 is the "middle" voice and thus "above" voice 2 */
+ if (v1 == 3 && v2 == 2) {
+ return(YES);
+ }
+
+ return(NO);
+}
+\f
+
+/* Given a STAFF, return the first GRPSYL in the syllable list for the given
+ * verse and place, if one exists. Otherwise return 0.
+ */
+
+static struct GRPSYL *
+find_verse_place(staff_p, verse, place)
+
+struct STAFF *staff_p;
+int verse;
+int place;
+
+{
+ int n;
+
+ for (n = 0; n < staff_p->nsyllists; n++) {
+ if (staff_p->sylplace[n] == place &&
+ staff_p->syls_p[n]->vno == verse) {
+ return(staff_p->syls_p[n]);
+ }
+ }
+ return(0);
+}
+\f
+
+/* Given a syl and related info, return the default time and place at which to
+ * end an underscore from that syl, for this measure. If there is a
+ * non-space syl later in the measure, this will be right before that syl,
+ * otherwise right before the bar line.
+ */
+
+static RATIONAL
+default_end(mll_p, syl_p, start_time, end_p)
+
+struct MAINLL *mll_p; /* the STAFF pointing to the syl */
+struct GRPSYL *syl_p; /* start looking from the syl */
+RATIONAL start_time; /* syl is already this far into measure */
+double *end_p; /* X value at which to end underscore is
+ * returned via this pointer */
+
+{
+ struct GRPSYL *grp_p;
+ RATIONAL end_time; /* return value */
+
+ if (syl_p == 0) {
+ /* No syllable for current verse/place in current measure.
+ * Time signature may not be up to date, so add up the
+ * time of voice 1, which we know exists.
+ */
+ end_time = start_time;
+ for (grp_p = mll_p->u.staff_p->groups_p[0]; grp_p != 0;
+ grp_p = grp_p->next) {
+ end_time = radd(end_time, grp_p->fulltime);
+ }
+ }
+ else {
+ /* Go forward in the syl list, finding where the next non-space
+ * syllable is, if there is one in the current measure,
+ * otherwise find the end of the measure.
+ * Save the time and location of this.
+ */
+ end_time = radd(start_time, syl_p->fulltime);
+ for (grp_p = syl_p->next; grp_p != 0; grp_p = grp_p->next) {
+ if (grp_p->grpcont == GC_SPACE) {
+ /* Underscore continues through "space" syls */
+ end_time = radd(end_time, grp_p->fulltime);
+ continue;
+ }
+ else {
+ /* We have found the syllable
+ * at which the underscore
+ * from the previous syllable ends */
+ break;
+ }
+ }
+ }
+
+ /* If a next syl was found, set end to near its west.
+ * Most likely, we will discover later we need to stop the underscore
+ * earlier than this, but if the user is using underscore in a strange
+ * way, like on a single long note rather than a melissma,
+ * we'll use this as the default place to end the underscore.*/
+ if (grp_p != 0) {
+ *end_p = grp_p->c[AW] - Stepsize;
+ }
+ else {
+ /* The ending syllable (if any) is not in the current measure.
+ * So for now we set the end to near the west of the bar line.
+ * Note that end_time will have added up to
+ * the full measure duration in this case.
+ */
+ for ( ; mll_p != 0; mll_p = mll_p->next) {
+ if (mll_p->str == S_BAR) {
+ *end_p = mll_p->u.bar_p->c[AW] - Stepsize;
+ break;
+ }
+ }
+ if (mll_p == 0) {
+ pfatal("underscore: failed to find next bar");
+ }
+ }
+ return(end_time);
+}
+\f
+
+/* Given a bar, see if it is a bar that might force stopping an extender,
+ * and return YES, if so. If nextsyl_p_p is non-null, it also attempts
+ * to fill that in with a pointer to the next "logical" syllable.
+ * (Usually the next syllable, but at the end of a repeat it would
+ * be the first syllable in the repeated section).
+ * If it can't figure out the correct syllable, it fills in null.
+ */
+
+static int
+bar_ends_extender(bar_p, mll_p, staffno, verse, place, nextsyl_p_p)
+
+struct BAR *bar_p;
+struct MAINLL *mll_p; /* points to a BAR or CLEFSIG*/
+int staffno;
+int verse;
+int place;
+struct GRPSYL **nextsyl_p_p; /* If this is non-zero, and we can deduce
+ * the next "logical" syl, the pointed to value
+ * will be updated to point to that next syl,
+ * else will be zero. */
+
+{
+ int bartype;
+
+ bartype = bar_p->bartype;
+ if (bartype == RESTART) {
+ /* We shouldn't continue an extender over a restart.
+ * The "next" logical measure is probably the
+ * target of a D.S. or a D.C.
+ * But we don't attempt to parse
+ * STUFF strings to know such things.
+ * So we say the extender ends here,
+ * but we don't know what the "next" measure is.
+ */
+ if (nextsyl_p_p != 0) {
+ *nextsyl_p_p = 0;
+ }
+ return(YES);
+ }
+
+ if (bartype == REPEATEND || bartype == REPEATBOTH) {
+ if (nextsyl_p_p == 0) {
+ return(YES);
+ }
+
+ /* This ends the extender. The next logical measure
+ * is at the beginning of the repeat. */
+ for (mll_p = mll_p->prev; mll_p != 0; mll_p = mll_p->prev) {
+ if (mll_p->str == S_BAR &&
+ (mll_p->u.bar_p->bartype
+ == REPEATSTART ||
+ mll_p->u.bar_p->bartype
+ == REPEATBOTH)) {
+ mll_p = mll_p->next;
+ break;
+ }
+ }
+ if (mll_p == 0) {
+ /* repeatstart is implicit at beginning of song */
+ mll_p = Mainllhc_p;
+ }
+ for ( ; mll_p != 0; mll_p = mll_p->next) {
+ if (mll_p->str == S_BAR) {
+ /* staff doesn't exist in this measure */
+ *nextsyl_p_p = 0;
+ return(YES);
+ }
+ if (mll_p->str == S_STAFF && mll_p->u.staff_p->staffno
+ == staffno) {
+ *nextsyl_p_p = find_verse_place(
+ mll_p->u.staff_p, verse, place);
+ return(YES);
+ }
+ }
+ }
+
+ if (mll_p->u.bar_p->endingloc == STARTITEM) {
+ /* If this is the start of a second or subsequent ending,
+ * this ends the extender. This is the case if the previous
+ * bar was a STARTITEM on INITEM. But apparently there
+ * isn't a repeat ending here, or we would have hit the
+ * bartype check for that. So it is too hard to try to deduce
+ * the next logical syllable. */
+ for (mll_p = mll_p->prev; mll_p != 0; mll_p = mll_p->prev) {
+ if (mll_p->str == S_BAR) {
+ if (mll_p->u.bar_p->endingloc == STARTITEM ||
+ mll_p->u.bar_p->endingloc
+ == INITEM) {
+ if (nextsyl_p_p != 0) {
+ *nextsyl_p_p = 0;
+ }
+ return(YES);
+ }
+ break;
+ }
+ }
+ }
+
+ return(NO);
+}
+\f
+
+/* Actually print an extender (dash or underscore) */
+
+static void
+pr_extender(ch, start, end, y, font, size)
+
+int ch; /* dash or underscore */
+double start; /* where to start printing */
+double end; /* where to end printing */
+double y; /* y coordinate */
+int font; /* font to use for dash */
+int size; /* size to use for dash */
+
+{
+ if (ch == '-') {
+ double dashwidth;
+ char dashstring[4];
+
+ dashwidth = width(font, size, '-');
+
+ /* generate the internal string format of a dash */
+ /* can't use dash_string function here since that also
+ * deals with ~ which is okay for stuff but not lyrics */
+ dashstring[0] = (char) font;
+ dashstring[1] = (char) size;
+ dashstring[2] = '-';
+ dashstring[3] = '\0';
+
+ if ( (end - start) < (15.0 * dashwidth) ) {
+ /* not much space, so find midpoint of
+ * available distance and put dash there */
+ pr_string(start + ((end - start) / 2.0)
+ - (dashwidth / 2.0),
+ y, dashstring, J_LEFT,
+ (char *) 0, -1);
+ }
+ else {
+ int numdashes; /* how many dashes to print */
+ double spacebetween; /* between dashes */
+
+ /* Lots of space, so will need to print multiple dashes.
+ * Figure out how to spread out */
+ numdashes = (int) ((end - start) / (8.0 * dashwidth));
+ spacebetween = ((end - start) - (dashwidth * numdashes))
+ / numdashes;
+
+ for ( ; numdashes > 0; numdashes--) {
+ pr_string(start +
+ (numdashes - 0.5) * spacebetween
+ + ((numdashes - 1.0) * dashwidth),
+ y, dashstring, J_LEFT,
+ (char *) 0, -1);
+ }
+ }
+ }
+ else {
+ /* if long enough to bother drawing underscore, draw it */
+ if (end - start > Stepsize) {
+ /* Note: line width probably really ought to
+ * be scaled based on the lyric size, but unless
+ * somebody uses really huge or really tiny lyrics,
+ * a normal line width looks good enough,
+ * so we just go with that.
+ */
+ do_linetype(L_NORMAL);
+ draw_line(start, y, end, y);
+ }
+ }
+}
+\f
+
+/* Return YES if last character of syllable is an underscore or dash,
+ * NO if it isn't.
+ */
+
+int
+has_extender(syl)
+
+char *syl; /* the syllable to check */
+
+{
+ switch (last_char(syl)) {
+
+ case '_':
+ case '-':
+ return(YES);
+
+ default:
+ return(NO);
+ }
+}
+\f
+
+/* Return last character in a string.
+ * If last character is a music character,
+ * or the string is null, return null.
+ */
+
+int
+last_char(str)
+
+char *str; /* return last character in this string */
+
+{
+ int font, size;
+ int ch; /* current character in string */
+ int last_font = FONT_UNKNOWN; /* font of last character */
+ int last_ch = '\0';
+
+
+ if (str == (char *) 0) {
+ return('\0');
+ }
+
+ font = str[0];
+ size = str[1];
+
+ /* keep track of each character. When we hit
+ * end of string, return the last character we saw */
+ for ( str += 2; (ch = next_str_char(&str, &font, &size)) != 0; ) {
+ last_font = font;
+ last_ch = ch;
+ }
+ /* music characters don't count */
+ if (IS_MUSIC_FONT(last_font)) {
+ return('\0');
+ }
+ return (last_ch & 0xff);
+}
+\f
+
+/* See if an underscore or dash will need to be carried to the following score.
+ * If so, add an appropriate "syllable" at the beginning of that score */
+
+void
+cont_extender(mll_p, sylplace, verseno)
+
+struct MAINLL *mll_p; /* the syllable is hanging off of this STAFF */
+int sylplace; /* PL_ABOVE, etc */
+int verseno; /* verse number */
+
+{
+ struct GRPSYL *syl_p; /* walk through GRPSYL list */
+ struct GRPSYL *last_non_space_p;
+ int last_ch; /* last character of syllable */
+ int font; /* of syllable */
+ int size; /* of syllable */
+
+
+ if (mll_p->str != S_STAFF) {
+ pfatal("cont_extender called with wrong argument");
+ }
+
+ /* Find the actual syl grpsyl that is the last on the score */
+ syl_p = find_verse_place(mll_p->u.staff_p, verseno, sylplace);
+
+ if (syl_p == 0) {
+ pfatal("cont_extender called without any syllable");
+ }
+
+ /* Find the final non-space syllable in the list */
+ last_non_space_p = 0;
+ for ( ; syl_p != 0; syl_p = syl_p->next) {
+ if (syl_p->grpcont != GC_SPACE) {
+ last_non_space_p = syl_p;
+ }
+ }
+
+ if (last_non_space_p == 0) {
+ pfatal("cont_extender couldn't find non-space syllable");
+ }
+
+ last_ch = last_char(last_non_space_p->syl);
+ if (last_ch != '-' && last_ch != '_') {
+ pfatal("cont_extender called on syl without extender");
+ }
+
+ /* See if will carry over */
+ if (spread_extender(last_non_space_p, mll_p, verseno, sylplace, NO)
+ == YES) {
+
+ /* determine proper font/size of
+ * carried over dash/underscore
+ * based on font/size at end of syllable */
+ end_fontsize(last_non_space_p->syl, &font, &size);
+
+ /* insert the syllable on next score */
+ insert_carryover_syllable(mll_p,
+ last_non_space_p->staffno, sylplace,
+ verseno,
+ (last_ch == '-' ? "-" : "_"),
+ font, size);
+ }
+}
+\f
+
+/* A dash or underscore needs to be carried over to the following score.
+ * Search forward for the appropriate STAFF. If there is already a lyric
+ * there for the sylplace and verseno, if its first syllable is a space,
+ * change it to a dash or underscore as appropriate.
+ * If there is no lyric in that measure for the sylplace and verseno,
+ * insert a measure long syllable of the appropriate type.
+ * If there is no STAFF of the proper number after a FEED, assume we are
+ * at the end of the piece or of visibility of the staff, and do nothing.
+ * If there is already a syllable, leave it as is.
+ */
+
+
+static void
+insert_carryover_syllable(mll_p, staffno, sylplace, verseno, dash_or_underscore,
+ font, size)
+
+struct MAINLL *mll_p; /* points to staff info */
+int staffno; /* staff number */
+int sylplace; /* PL_ABOVE, etc */
+int verseno; /* verse number */
+char *dash_or_underscore; /* "-" or "_" */
+int font; /* font and size to use for dash or underscore */
+int size;
+
+{
+ struct STAFF *staff_p; /* add syllable to this staff */
+ struct CHORD *chord_p; /* chord syllables goes with */
+ int v; /* verse index */
+ float begin_x; /* where to start carryover syllable */
+
+
+ /* search forward for FEED */
+ for ( ; mll_p != (struct MAINLL *) 0; mll_p = mll_p->next) {
+ if (IS_CLEFSIG_FEED(mll_p)) {
+ break;
+ }
+ }
+
+ if (mll_p == (struct MAINLL *) 0) {
+ return;
+ }
+
+ /* The AE coordinates of syllable groups
+ * have already been set, but we need to have
+ * this one set for the underscore/dash syllable being added. So deduce
+ * where it should be using the pseudo-bar */
+ if ((mll_p = mll_p->next) == (struct MAINLL *) 0) {
+ return;
+ }
+ if (mll_p->str == S_CLEFSIG) {
+ begin_x = mll_p->u.clefsig_p->bar_p->c[AE] + STDPAD;
+ }
+ else {
+ /* setting begin_x is just to shut up compilers that erroneously
+ * think it could be used without being set. */
+ begin_x = 0.0;
+ pfatal("no clefsig after feed");
+ }
+
+ /* silence compilers that think chord_p might not be set */
+ chord_p = (struct CHORD *) 0;
+
+ /* search forward for STAFF of interest, and save CHORD info */
+ for ( mll_p = mll_p->next; mll_p != (struct MAINLL *) 0;
+ mll_p = mll_p->next) {
+
+ if (mll_p->str == S_CHHEAD) {
+ chord_p = mll_p->u.chhead_p->ch_p;
+ }
+ else if (mll_p->str == S_STAFF) {
+ if (mll_p->u.staff_p->staffno == staffno) {
+ break;
+ }
+ }
+ }
+
+ /* see if has syllable of specified place and verse */
+ if (mll_p != (struct MAINLL *) 0) {
+
+ staff_p = mll_p->u.staff_p;
+ for (v = 0; v < staff_p->nsyllists; v++) {
+
+ if (staff_p->sylplace[v] == sylplace &&
+ staff_p->syls_p[v]->vno == verseno) {
+
+ /* are lyrics in this measure. See if first
+ * syllable is a space. If so, replace with
+ * a dash. Otherwise we are done */
+ if (staff_p->syls_p[v]->syl == (char *) 0) {
+ staff_p->syls_p[v]->syl =
+ copy_string(dash_or_underscore,
+ font, size);
+ /* no longer a "space" syllable */
+ staff_p->syls_p[v]->grpcont = GC_NOTES;
+ }
+ return;
+ }
+ }
+
+ /* no lyrics in first measure on next score for this
+ * verse/place. Need to insert one */
+ add_syllable(staff_p, sylplace, verseno,
+ dash_or_underscore, font, size,
+ begin_x, chord_p);
+ }
+}
+\f
+
+/* Add a dash or underscore syllable to list of lyrics. Need to alloc new
+ * space for the sylplace and syls_p arrays, copy the existing data into
+ * them, adding the new syllable at the proper place (sorted by verseno),
+ * then free the old arrays */
+
+static void
+add_syllable(staff_p, sylplace, verseno, dash_or_underscore, font, size,
+ begin_x, chord_p)
+
+struct STAFF *staff_p; /* add syllable to this staff */
+int sylplace; /* PL_ABOVE, etc */
+int verseno;
+char *dash_or_underscore; /* "-" or "_" */
+int font;
+int size;
+double begin_x; /* where syllable is to start */
+struct CHORD *chord_p; /* what chord to attach to */
+
+{
+ short *new_sylplace; /* new, expanded sylplace array */
+ struct GRPSYL **new_syls_p; /* new, expanded syls_p array */
+ int v; /* verse index */
+ int insert_index; /* where to put in new arrays */
+ int inserted; /* 0 if haven't found where to insert
+ * yet, 1 if we have. This is then the
+ * difference between the index of the
+ * original arrays and where the copy
+ * goes in the new arrays. Since it's
+ * used in array subscript calculation
+ * we can't use YES and NO here */
+
+
+ /* alloc arrays that are one larger than the current arrays */
+ MALLOCA(short, new_sylplace, staff_p->nsyllists + 1);
+ MALLOCA(struct GRPSYL *, new_syls_p, staff_p->nsyllists + 1);
+
+ /* now copy and insert */
+ insert_index = staff_p->nsyllists;
+ for (inserted = v = 0; v < staff_p->nsyllists; v++) {
+ if (insert_index > v && staff_p->syls_p[v]->vno > verseno) {
+ /* insert here */
+ insert_index = v;
+ inserted = 1;
+ }
+
+ new_sylplace[v + inserted] = staff_p->sylplace[v];
+ new_syls_p[v + inserted] = staff_p->syls_p[v];
+ }
+
+ /* alloc and fill in the new GRPSYL */
+ new_sylplace[insert_index] = (short) sylplace;
+ new_syls_p[insert_index] = newGRPSYL(GS_SYLLABLE);
+ new_syls_p[insert_index]->syl = copy_string(dash_or_underscore,
+ font, size);
+ new_syls_p[insert_index]->inputlineno = -1;
+ new_syls_p[insert_index]->basictime = -1;
+ new_syls_p[insert_index]->is_meas = YES;
+ new_syls_p[insert_index]->fulltime = Score.time;
+ new_syls_p[insert_index]->staffno = staff_p->staffno;
+ new_syls_p[insert_index]->vno = (short) verseno;
+ /* X coords of normal syllables already set, so have to set for
+ * this special syllable here */
+ new_syls_p[insert_index]->c[AE] = begin_x
+ + strwidth(new_syls_p[insert_index]->syl);
+ new_syls_p[insert_index]->c[AW] = begin_x;
+ new_syls_p[insert_index]->c[AX] = begin_x;
+
+ /* now have one one list of syllables */
+ (staff_p->nsyllists)++;
+
+ /* free old arrays if non-null */
+ if (staff_p->sylplace != (short *) 0) {
+ FREE(staff_p->sylplace);
+ }
+ if (staff_p->syls_p != (struct GRPSYL **) 0) {
+ FREE(staff_p->syls_p);
+ }
+
+ /* now link up the new arrays */
+ staff_p->sylplace = new_sylplace;
+ staff_p->syls_p = new_syls_p;
+
+ /* add to appropriate chord */
+ stitch_syl_into_chord(chord_p, new_syls_p[insert_index]);
+}
+\f
+
+/* Given a syllable and chord to attach it to, attach it */
+/* Strictly speaking, this function probably isn't necessary, since I think
+ * all use of the CHORD struct has already been done before this function is
+ * called, but it's probably good to do anyway on general principles, in case
+ * some day the CHORDs are looked at later */
+
+static void
+stitch_syl_into_chord(chord_p, syl_gs_p)
+
+struct CHORD *chord_p; /* add to this chord */
+struct GRPSYL *syl_gs_p; /* add this syllable */
+
+{
+ struct GRPSYL *gs_p; /* walk through chord */
+
+
+ /* go down chord list */
+ for (gs_p = chord_p->gs_p; gs_p->gs_p != (struct GRPSYL *) 0;
+ gs_p = gs_p->gs_p) {
+
+ /* if next grpsyl in chord has staffno < staffno of syl to add,
+ * keep going */
+ if (gs_p->gs_p->staffno < syl_gs_p->staffno) {
+ continue;
+ }
+
+ /* if next grpsyl in chord had staffno > staffno of syl to add,
+ * put it here */
+ if (gs_p->gs_p->staffno > syl_gs_p->staffno) {
+ /* found where to insert */
+ break;
+ }
+
+ /* If here, must be same staffno.
+ * Keep going until find syllable with larger vno. */
+ if (gs_p->gs_p->grpsyl == GS_GROUP) {
+ continue;
+ }
+
+ if (gs_p->gs_p->vno > syl_gs_p->vno) {
+ /* found where to insert */
+ break;
+ }
+ }
+
+ /* insert syllable */
+ syl_gs_p->gs_p = gs_p->gs_p;
+ gs_p->gs_p = syl_gs_p;
+}
~mdw / mup / blobdiff