--- /dev/null
+
+/* Copyright (c) 1995, 1997, 1999, 2000, 2001, 2002, 2003, 2005 by Arkkra Enterprises */
+/* All rights reserved */
+
+/* functions to deal with brace/bracket lists, to make sure they don't
+ * overlap, and then to place the labels to minimize the space they use. */
+
+#include "defines.h"
+#include "structs.h"
+#include "globals.h"
+
+/* padding between labels in inches. **** eventually should adjust padding
+ * based on size??? ***/
+#define LABELPAD 0.125
+
+/* information to be able to determine overlaps in the brace/bracket lists */
+static struct BRAC_INFO {
+ struct STAFFSET *staffset_p; /* bracelist or bracklist item */
+ int bractype; /* BRACELIST or BRACKLIST */
+ struct BRAC_INFO *nested_p; /* pointer to another brace/bracket
+ * item, which has its top on the
+ * same staff, and presumably
+ * is nested inside this one */
+ struct BRAC_INFO *nested_by_p; /* if this one is nested, pointer
+ * to what it is nested by, else NULL */
+ short nestlevel; /* how many levels deep */
+ short topvisstaff; /* top visible staff in range */
+ short botvisstaff; /* bottom visible staff in range */
+} *Brac_info_p [MAXSTAFFS + 1];
+
+
+/* information about a label, either for a staff or group. */
+struct LABELINFO {
+ char *label; /* text of the label */
+ float width; /* strwidth(label) */
+ float west; /* relative distance of left edge of label
+ * from the line between the labels and the
+ * braces/brackets. This will be negative */
+ int is_staff_label; /* YES for staff label, NO for group */
+ struct LABELINFO *next;/* linked list of labels at same y location */
+};
+
+/* information about all the labels that end up being printed left of a
+ * specific staff or between that staff and the one below it. */
+struct LABELLIST {
+ short staffno; /* which staff */
+ struct LABELINFO *label_p; /* list of labels to be printed to
+ * the left of this staff */
+ struct LABELINFO *btwnlabel_p; /* list of labels to be printed
+ * between this staff and the one
+ * below this staff */
+ short pad; /* how many levels of labels
+ * have been put on this staff, either
+ * on the staff itself or on one or
+ * more other staffs that are
+ * grouped with this one */
+};
+static struct LABELLIST Labellist[MAXSTAFFS + 1];
+
+static short Numvis; /* how many staffs currently visible */
+static short Maxlevels; /* maximum number of nesting levels */
+static float Nested_brace_adjust = 0.0; /* brace outside a bracket needs
+ * some extra space to look good. */
+
+
+/* static functions */
+static void free_brac_info P((struct BRAC_INFO *brac_info_p));
+static void set_brac_info P((struct STAFFSET *staffset_p, int bractype));
+static int check_brac_overlap P((struct BRAC_INFO *brac_info_p));
+static void setnestlevel P((struct BRAC_INFO *brac_p,
+ struct BRAC_INFO *nested_by_p));
+static void place_labels P((struct MAINLL *mll_p,
+ struct MAINLL *prev_feed_mll_p));
+static void init_labellist P((void));
+static void free_label P((struct LABELINFO *label_p));
+static struct LABELINFO *newlabelinfo P((char *label, int is_staff_label));
+static void grouplabel P((struct BRAC_INFO *brac_p, int do_nested,
+ struct MAINLL *mll_p, struct MAINLL *prev_feed_mll_p));
+static double west_adjust P((struct MAINLL *mll_p,
+ struct MAINLL *prev_feed_mll_p));
+static struct MAINLL *find_prev_feed_mll_p P((struct MAINLL *mll_p));
+static char * label4staff P((struct MAINLL *mll_p, int s,
+ struct MAINLL *prev_feed_mll_p));
+static char * label4group P((struct MAINLL *mll_p, struct BRAC_INFO *brac_p,
+ struct MAINLL *prev_feed_mll_p));
+static double dflt_label_width P((struct MAINLL *mll_p,
+ struct MAINLL *prev_feed_mll_p));
+
+\f
+
+/* check for overlap between brace and bracket lists. Return YES if okay, NO
+ * if there is something illegal */
+
+int
+brac_check (bracelist_p, nbrace, bracklist_p, nbrack)
+
+struct STAFFSET *bracelist_p;
+int nbrace; /* how many items in bracelist_p */
+struct STAFFSET *bracklist_p;
+int nbrack; /* how many items in bracklist_p */
+
+{
+ register int s; /* staff index into Brac_info_p */
+ register int n; /* index into staffset */
+ int retval = 0; /* return from check_brac_overlap() */
+ static int first_time = YES; /* flag for if first time this function
+ * has been called */
+
+
+ debug(4, "brac_check");
+
+ /* initialize table */
+ for (s = 1; s <= Score.staffs; s++) {
+ if (first_time == NO) {
+ /* only try to free if we know item has been properly
+ * initialized, in case this is ever run on some system
+ * that doesn't initialize pointer arrays to null ptrs */
+ free_brac_info(Brac_info_p[s]);
+ }
+ Brac_info_p[s] = (struct BRAC_INFO *) 0;
+ }
+ first_time = NO;
+ Maxlevels = 0;
+
+ /* Go through each list, attaching each to table slot of its top staff.
+ */
+ for (n = 0; n < nbrace; n++) {
+ set_brac_info( &(bracelist_p[n]), BRACELIST);
+ }
+ for (n = 0; n < nbrack; n++) {
+ set_brac_info( &(bracklist_p[n]), BRACKLIST);
+ }
+
+ /* now check each staff for possible overlap */
+ for (s = 1; s <= Score.staffs; s++) {
+ if (Brac_info_p[s] == (struct BRAC_INFO *) 0) {
+ /* no braces or brackets, so can't be any overlap */
+ continue;
+ }
+
+ retval += check_brac_overlap (Brac_info_p[s]);
+ }
+
+ return(retval == 0 ? YES : NO);
+}
+\f
+
+/* recursively free a linked list of BRAC_INFO structs */
+
+static void
+free_brac_info(brac_info_p)
+
+struct BRAC_INFO *brac_info_p; /* the list to free */
+
+{
+ if (brac_info_p == (struct BRAC_INFO *) 0) {
+ return;
+ }
+
+ free_brac_info(brac_info_p->nested_p);
+ FREE(brac_info_p);
+}
+\f
+
+/* save information about a brace/bracket STAFFSET and link onto list for its
+ * top staff */
+
+static void
+set_brac_info (staffset_p, bractype)
+
+struct STAFFSET *staffset_p; /* staffs to group together */
+int bractype; /* BRACELIST or BRACKLIST */
+
+{
+ struct BRAC_INFO *new_p; /* info to be saved */
+ int s; /* staff num of top staff of staffset */
+
+
+ /* record information */
+ MALLOC(BRAC_INFO, new_p, 1);
+ new_p->staffset_p = staffset_p;
+ new_p->bractype = bractype;
+ new_p->nested_by_p = (struct BRAC_INFO *) 0;
+ new_p->nestlevel = 0;
+
+ /* link into list off of table */
+ s = staffset_p->topstaff;
+ new_p->nested_p = Brac_info_p[s];
+ Brac_info_p[s] = new_p;
+}
+\f
+
+/* check the brace/bracket information for one staff for overlap. Return
+ * number of errors found */
+
+static int
+check_brac_overlap (brac_info_p)
+
+struct BRAC_INFO *brac_info_p;
+
+{
+ register int s;
+
+
+ if (brac_info_p == (struct BRAC_INFO *) 0) {
+ /* end recursion */
+ return(0);
+ }
+
+ /* if no nesting, don't need to do those checks */
+ if (brac_info_p->nested_p != (struct BRAC_INFO *) 0) {
+
+ /* braces can't have anything nested inside them */
+ if (brac_info_p->bractype == BRACELIST) {
+ yyerror("nesting inside a brace not allowed");
+ return(1);
+ }
+
+ /* brace on top of bracket needs extra space */
+ if (brac_info_p->nested_p->bractype == BRACELIST) {
+ Nested_brace_adjust = STEPSIZE;
+ }
+
+ /* check that nested range is a proper subset */
+ if (brac_info_p->nested_p->staffset_p->botstaff
+ >= brac_info_p->staffset_p->botstaff) {
+ yyerror("nested brackets must be subsets of other brackets");
+ return(1);
+ }
+
+ setnestlevel(brac_info_p->nested_p, brac_info_p);
+ }
+
+ /* see if this one overlaps with groups
+ * defined previously */
+ for (s = brac_info_p->staffset_p->topstaff + 1;
+ s <= brac_info_p->staffset_p->botstaff; s++) {
+
+ if (Brac_info_p[s] == (struct BRAC_INFO *) 0) {
+ continue;
+ }
+
+ /* if brace is being nested by something else,
+ * overlap is illegal */
+ if (brac_info_p->bractype == BRACELIST) {
+ yyerror("brace overlap not allowed");
+ return(1);
+ }
+
+ /* if bottom of this staffset is greater than bottom of the one
+ * we are checking, there is illegal overlap */
+ if (Brac_info_p[s]->staffset_p->botstaff
+ > brac_info_p->staffset_p->botstaff) {
+ yyerror("overlapping brackets are not nested");
+ return(1);
+ }
+
+ /* remember who nests this one */
+ setnestlevel(Brac_info_p[s], brac_info_p);
+ }
+
+ /* recurse */
+ return (check_brac_overlap (brac_info_p->nested_p));
+}
+\f
+
+/* when one bracket is nested inside another, record that fact */
+
+static void
+setnestlevel(brac_p, nested_by_p)
+
+struct BRAC_INFO *brac_p; /* set nesting here */
+struct BRAC_INFO *nested_by_p; /* brac_p is nested by this one */
+
+{
+ brac_p->nested_by_p = nested_by_p;
+ brac_p->nestlevel = nested_by_p->nestlevel + 1;
+
+ /* keep track of deepest nesting level */
+ if (brac_p->nestlevel > Maxlevels) {
+ Maxlevels = brac_p->nestlevel;
+ }
+}
+\f
+
+/*
+ * for each label
+ * find which staff the label should go on based on visible
+ *
+ * Determine placement of staff labels, then nested, then outer.
+ */
+
+static void
+place_labels(mll_p, prev_feed_mll_p)
+
+struct MAINLL *mll_p; /* current place in main list, used to determine
+ * whether to use label or label2. */
+struct MAINLL *prev_feed_mll_p; /* actual or proposed location of prev FEED */
+
+{
+ int s; /* index through staffs */
+ int count; /* how many labels */
+ char *label; /* the label being processed */
+ struct LABELINFO *lab_p;/* info about label */
+
+
+ init_labellist();
+ lab_p = (struct LABELINFO *) 0;
+
+ /* put the staff labels on the label list. While we're at it, count
+ * up the number of staffs that are currently visible */
+ for (count = Numvis = 0, s = 1; s <= Score.staffs; s++) {
+ if (svpath(s, VISIBLE)->visible == NO) {
+ continue;
+ }
+
+ /* use label or label2 as appropriate */
+ if ((label = label4staff(mll_p, s, prev_feed_mll_p)) != 0) {
+ lab_p = newlabelinfo(label, YES);
+ }
+
+ /* if there was a label, save info about it */
+ if (lab_p != (struct LABELINFO *) 0) {
+
+ /* staff labels always go as far east as possible */
+ /* Adjust by staffscale, but get from SSV, since
+ * Stepsize won't be up to date. */
+ lab_p->west = (-(lab_p->width) - STEPSIZE)
+ * svpath(s, STAFFSCALE)->staffscale;
+
+ /* link onto list */
+ lab_p->next = Labellist[Numvis].label_p;
+ Labellist[Numvis].label_p = lab_p;
+
+ /* count up number of staff labels */
+ count++;
+
+ /* re-init for next trip through loop */
+ lab_p = (struct LABELINFO *) 0;
+ }
+
+ Labellist[Numvis].staffno = (short) s;
+
+ /* we now know there is one more staff visible */
+ Numvis++;
+ }
+
+ /* if there were any labels, mark all staffs as needing padding
+ * before placing another label. If there were no staff labels,
+ * group labels will go as far east as possible, otherwise the
+ * group labels will be leftward a bit. */
+ if (count > 0) {
+ for (s = 0; s < Numvis; s++) {
+ (Labellist[s].pad)++;
+ }
+ }
+
+ /* do all nested group labels */
+ for (s = 1; s <= Score.staffs; s++) {
+ grouplabel(Brac_info_p[s], YES, mll_p, prev_feed_mll_p);
+ }
+
+ /* do all non-nested group labels */
+ for (s = 1; s <= Score.staffs; s++) {
+ grouplabel(Brac_info_p[s], NO, mll_p, prev_feed_mll_p);
+ }
+}
+\f
+
+/* initialize label list. Free any information currently in the list and
+ * mark everything as empty */
+
+static void
+init_labellist()
+
+{
+ register int s; /* index through label list */
+
+
+ for (s = 0; s <= Numvis; s++) {
+ free_label(Labellist[s].label_p);
+ free_label(Labellist[s].btwnlabel_p);
+ Labellist[s].label_p = Labellist[s].btwnlabel_p
+ = (struct LABELINFO *) 0;
+ Labellist[s].pad = 0;
+ }
+ Numvis = 0;
+}
+\f
+
+/* recursively free linked list of LABELINFO structs */
+
+static void
+free_label(label_p)
+
+struct LABELINFO *label_p; /* free this list */
+
+{
+ if (label_p == (struct LABELINFO *) 0) {
+ return;
+ }
+
+ free_label(label_p->next);
+ FREE(label_p);
+}
+\f
+
+/* allocate a new LABELINFO struct and fill in the label and width. Initialize
+ * west to zero */
+
+static struct LABELINFO *
+newlabelinfo(label, is_staff_label)
+
+char *label; /* text of the label */
+int is_staff_label; /* YES or NO */
+
+{
+ struct LABELINFO *new_p; /* newly allocate place to save info */
+
+
+ MALLOC(LABELINFO, new_p, 1);
+ new_p->label = label;
+ new_p->west = 0.0;
+ new_p->width = strwidth(label);
+ new_p->is_staff_label = is_staff_label;
+ new_p->next = (struct LABELINFO *) 0;
+ return(new_p);
+}
+\f
+
+/* do placement of group labels */
+
+static void
+grouplabel(brac_p, do_nested, mll_p, prev_feed_mll_p)
+
+struct BRAC_INFO *brac_p; /* info about group of staffs to do */
+int do_nested; /* if YES, process nested staff group. If NO,
+ * process non-nested */
+struct MAINLL *mll_p; /* used to decide if to use label or label2 */
+struct MAINLL *prev_feed_mll_p; /* actual or proposed previous FEED */
+
+{
+ struct STAFFSET *staffset_p; /* staffs/label in group */
+ char *label; /* label for group */
+ int index; /* into Labellist */
+ int topindex, botindex; /* index into Labellist of where
+ * group range top & bottom visible
+ * staffs are */
+ int labindex; /* index into Labellist of staff where
+ * label should go */
+ struct LABELINFO *lab_p; /* information about group label */
+ struct LABELINFO **lab_p_p; /* where to insert label info */
+
+
+ if (brac_p == (struct BRAC_INFO *) 0) {
+ /* end recursion */
+ return;
+ }
+
+ if (do_nested == YES) {
+ /* recurse */
+ grouplabel(brac_p->nested_p, do_nested, mll_p, prev_feed_mll_p);
+ if (brac_p->nested_by_p == (struct BRAC_INFO *) 0) {
+ return;
+ }
+ }
+ else if (brac_p->nested_by_p != (struct BRAC_INFO *) 0) {
+ return;
+ }
+
+ /* we'll probably need the staffset info a lot, so get pointer to it */
+ staffset_p = brac_p->staffset_p;
+
+ /* Find index in Labellist of top
+ * and bottom visible staffs of the range */
+ for (topindex = botindex = -1, index = 0; index < Numvis; index++) {
+ if (topindex == -1 && staffset_p->topstaff
+ <= Labellist[index].staffno) {
+ topindex = index;
+ }
+ if (staffset_p->botstaff >= Labellist[index].staffno) {
+ botindex = index;
+ }
+ }
+
+ /* see if there were some visible staffs in this group */
+ if (topindex != -1 && botindex != -1 && botindex >= topindex) {
+
+ brac_p->topvisstaff = Labellist[topindex].staffno;
+ brac_p->botvisstaff = Labellist[botindex].staffno;
+
+ /* figure out which label to use, if any */
+ if ((label = label4group(mll_p, brac_p, prev_feed_mll_p))
+ == (char *) 0) {
+ return;
+ }
+
+ /* find index in list of visible staffs where label should
+ * go. If even number of visible staffs in range, label
+ * goes between two staffs */
+ labindex = (topindex + botindex) / 2;
+ if ((botindex - topindex) & 1) {
+ lab_p_p = &(Labellist[labindex].btwnlabel_p);
+ }
+ else {
+ lab_p_p = &(Labellist[labindex].label_p);
+ }
+
+ lab_p = newlabelinfo(label, NO);
+
+ /* put as far east as possible */
+ lab_p->west = - (lab_p->width);
+
+ lab_p->west -= Labellist[labindex].pad * LABELPAD;
+
+ /* link onto list */
+ lab_p->next = *lab_p_p;
+ *lab_p_p = lab_p;
+
+ /* add padding to all visible staffs in the group range */
+ for ( ; topindex <= botindex; topindex++) {
+ Labellist[topindex].pad++;
+ }
+ }
+ else {
+ /* all staffs in group are invisible */
+ brac_p->topvisstaff = 0;
+ }
+}
+\f
+
+/* determine total width of labels. This is how much to add to
+ * relative west to get absolute location from left margin */
+
+static double
+west_adjust(mll_p, prev_feed_mll_p)
+
+struct MAINLL *mll_p; /* actual or proposed FEED location,
+ * used to decide if to use label or label2 */
+struct MAINLL *prev_feed_mll_p; /* actual or proposed location of preceeding
+ * FEED, used for label/label2 decision */
+
+{
+ register int s; /* index */
+ double minwest = 0.0; /* farthest west distance */
+
+
+ /* find westernmost label */
+ for (s = 0; s < Numvis; s++) {
+ if (Labellist[s].label_p != (struct LABELINFO *) 0) {
+ if (Labellist[s].label_p->west < minwest) {
+ minwest = Labellist[s].label_p->west;
+ }
+ }
+ if (Labellist[s].btwnlabel_p != (struct LABELINFO *) 0) {
+ if (Labellist[s].btwnlabel_p->west < minwest) {
+ minwest = Labellist[s].btwnlabel_p->west;
+ }
+ }
+ }
+
+ /* check for need to use default label on first score.
+ * If default label is needed, it creates an indent. */
+ if (minwest == 0.0) {
+ return(dflt_label_width(mll_p, prev_feed_mll_p));
+ }
+
+ return( - minwest);
+}
+\f
+
+/* return width of braces/brackets and their labels */
+
+double
+width_left_of_score(mll_p)
+
+struct MAINLL *mll_p; /* FEED, used to decide if to use label or label2 */
+
+{
+ return(pwidth_left_of_score(mll_p, find_prev_feed_mll_p(mll_p)));
+}
+
+double
+pwidth_left_of_score(mll_p, prev_feed_mll_p)
+
+struct MAINLL *mll_p; /* actual or proposed location of current FEED,
+ * used to decide if to use label or label2 */
+struct MAINLL *prev_feed_mll_p; /* actual or proposed location of prev FEED */
+
+{
+ double westadj;
+ int n; /* index through brac*lists */
+ int s; /* staff index */
+ int hasbracs; /* YES if there are visible brackets/braces */
+
+
+ if (brac_check(Score.bracelist, Score.nbrace, Score.bracklist,
+ Score.nbrack) == NO) {
+ /* we should have exited before */
+ pfatal("illegal brace/bracket ranges");
+ }
+ /* call functions to determine the placement of all labels and
+ * save that information in the Labellist, then determine how
+ * wide the labels plus braces and brackets are */
+ place_labels(mll_p, prev_feed_mll_p);
+ westadj = west_adjust(mll_p, prev_feed_mll_p);
+
+ /* total is space for the labels (the westadj),
+ * the braces/brackets themselves (based on Maxlevels),
+ * and 2 stepsizes of padding to left of score before brace/brack,
+ * plus special adjustment for brace on top of bracket, if any */
+ /* See if there are any visible brackets/braces.
+ * If so, we'll need to allow space for them, otherwise not. */
+ hasbracs = NO;
+ for (n = 0; n < Score.nbrace && hasbracs == NO; n++) {
+ for (s = Score.bracelist[n].topstaff;
+ s <= Score.bracelist[n].botstaff; s++){
+ if (svpath(s, VISIBLE)->visible == YES) {
+ hasbracs = YES;
+ break;
+ }
+ }
+ }
+ for (n = 0; n < Score.nbrack && hasbracs == NO; n++) {
+ for (s = Score.bracklist[n].topstaff;
+ s <= Score.bracklist[n].botstaff; s++){
+ if (svpath(s, VISIBLE)->visible == YES) {
+ hasbracs = YES;
+ break;
+ }
+ }
+ }
+
+ if (hasbracs == YES) {
+ return(westadj + ((Maxlevels + 2) * 2.0 * STDPAD)
+ + (2.0 * STEPSIZE) + Nested_brace_adjust);
+ }
+ else {
+ return(westadj);
+ }
+}
+\f
+
+/* print braces/brackets and their labels, Return YES if there were braces or
+ * brackets, NO if not. */
+
+int
+pr_brac(is_restart, x_offset, mll_p)
+
+int is_restart; /* YES if being called due to restart */
+double x_offset; /* where to print, if is_restart == YES */
+struct MAINLL *mll_p; /* for FEED for possible margin override, and to
+ * decide if to use label or label2 */
+
+{
+ register int li; /* index into Labellist */
+ register int s; /* staff index */
+ struct LABELINFO *lab_p; /* info about a label */
+ struct LABELINFO *l_p; /* for finding y adjust for overlaps */
+ double y_adjust; /* for overlapping labels */
+ struct BRAC_INFO *brac_p; /* info about brace or bracket */
+ double adj; /* how much to adjust relative west */
+ double x, y, y1;
+ int eff_stafflines; /* how many stafflines there effectively
+ * are, counting the extra space around
+ * staffs with a very small number
+ * of stafflines */
+ double tab_adjust; /* to adjust for TABRATIO */
+ double eff_stepsize; /* STEPSIZE adjusted for staffscale */
+ char *label;
+ int printed_brac = NO; /* if printed any braces/brackets */
+ struct MAINLL *prev_feed_mll_p; /* previous FEED */
+
+
+ debug(512, "pr_brac");
+
+ /* figure out where to place everything */
+ (void) brac_check(Score.bracelist, Score.nbrace, Score.bracklist,
+ Score.nbrack);
+ prev_feed_mll_p = find_prev_feed_mll_p(mll_p);
+ place_labels(mll_p, prev_feed_mll_p);
+ if (is_restart == NO) {
+ adj = west_adjust(mll_p, prev_feed_mll_p)
+ + eff_leftmargin(mll_p);
+
+ /* print labels on visible staffs */
+ for (li = 0; li < Numvis; li++) {
+
+ /* print labels to go by this staff */
+ for (lab_p = Labellist[li].label_p;
+ lab_p != (struct LABELINFO *) 0;
+ lab_p = lab_p->next) {
+ if (lab_p->is_staff_label == YES) {
+ /* Have to adjust by staffscale.
+ * We can't change the label
+ * in the SSV itself because that
+ * would cause problems, so make a copy
+ * and adjust that, then free it
+ * when we are done with it.
+ * Have to get size out of SSV,
+ * because Staffscale won't be
+ * up to date. */
+ MALLOCA(char, label, strlen(lab_p->label) + 1);
+ memcpy(label, lab_p->label,
+ strlen(lab_p->label) + 1);
+ resize_string(label,
+ svpath(Labellist[li].staffno,
+ STAFFSCALE)->staffscale,
+ (char *) 0, -1);
+ }
+ else {
+ label = lab_p->label;
+ }
+
+ x = lab_p->west + adj;
+ /* Move above any other inner labels.
+ * The very inner-most stays centered on the
+ * staff, so ones above that have to be adjusted
+ * by its ascent. This label itself has to
+ * have enough room for half its height,
+ * since it was originally centered,
+ * for any between there, we need to skip
+ * past their entire height.
+ */
+ for (y_adjust = 0.0, l_p = lab_p->next;
+ l_p != 0; l_p = l_p->next) {
+ if (l_p->next == 0) {
+ y_adjust += strascent(
+ l_p->label) + STDPAD;
+ }
+ else {
+ y_adjust += strheight(
+ l_p->label) + STDPAD;
+ }
+ }
+ if (lab_p->next != 0) {
+ y_adjust += strheight(lab_p->label)
+ / 2.0 + STDPAD;
+ }
+ y = Staffs_y[ Labellist[li].staffno ]
+ + (strheight(label) / 2.0)
+ - strascent(label)
+ + y_adjust;
+ pr_string(x, y, label, J_CENTER, (char *) 0, -1);
+ if (lab_p->is_staff_label == YES) {
+ FREE(label);
+ }
+ }
+
+ /* do labels that fall between staffs */
+ for (lab_p = Labellist[li].btwnlabel_p;
+ lab_p != (struct LABELINFO *) 0;
+ lab_p = lab_p->next) {
+ label = lab_p->label;
+ x = lab_p->west + adj;
+ /* y is the midpoint between the staffs,
+ * adjusted by the height/ascent of the label,
+ * and for any other labels. */
+ for (y_adjust = 0.0, l_p = lab_p->next;
+ l_p != 0; l_p = l_p->next) {
+ if (l_p->next == 0) {
+ y_adjust += strascent(
+ l_p->label) + STDPAD;
+ }
+ else {
+ y_adjust += strheight(
+ l_p->label) + STDPAD;
+ }
+ }
+ if (lab_p->next != 0) {
+ y_adjust += strheight(lab_p->label)
+ / 2.0 + STDPAD;
+ }
+ y = (Staffs_y[ Labellist[li].staffno ] +
+ Staffs_y[ Labellist[li+1].staffno ])/2.0
+ + (strheight(label) / 2.0)
+ - strascent(label) + y_adjust;
+ pr_string(x, y, label, J_CENTER, (char *) 0, -1);
+ }
+ }
+ }
+ else {
+ adj = - (Maxlevels * 2.0 * STDPAD);
+ }
+
+ /* print the braces and brackets themselves */
+ for (s = 1; s <= Score.staffs; s++) {
+ for (brac_p = Brac_info_p[s]; brac_p != (struct BRAC_INFO *) 0;
+ brac_p = brac_p->nested_p) {
+ x = x_offset + adj + (Maxlevels - brac_p->nestlevel + 1)
+ * (2.0 * STDPAD) + (2.0 * STEPSIZE)
+ + Nested_brace_adjust;
+ if (brac_p->bractype == BRACELIST) {
+ if (brac_p->nested_by_p == 0) {
+ x += (0.5 * STEPSIZE);
+ }
+ else {
+ x -= (0.5 * STEPSIZE);
+ }
+ }
+ if (brac_p->topvisstaff > 0) {
+ /* figure out y (the top). Start at the y
+ * of the top staff, then adjust as needed. */
+ y = Staffs_y [brac_p->topvisstaff];
+
+ /* figure out how tall the staff is effectively.
+ * Staffs with only a few stafflines are
+ * effectively taller than the number of
+ * stafflines. */
+ if ((eff_stafflines = svpath(
+ brac_p->topvisstaff, STAFFLINES) ->stafflines) < 3) {
+ eff_stafflines = 3;
+ }
+ /* stepsizes are taller on tab staffs */
+ tab_adjust = (is_tab_staff(brac_p->topvisstaff)
+ ? TABRATIO : 1.0);
+
+ /* adjust for height of staff */
+ eff_stepsize = svpath(brac_p->topvisstaff,
+ STAFFSCALE)->staffscale
+ * STEPSIZE;
+ y += (eff_stafflines - 1) * eff_stepsize
+ * tab_adjust;
+
+ /* nested brackets should be a little shorter
+ * vertically to fit inside their parent.
+ * But beyond about 4 levels, if there is
+ * only a single staff, things look
+ * pretty bad, so limit to 4. */
+ y -= (eff_stepsize * (brac_p->nestlevel < 5
+ ? brac_p->nestlevel : 4));
+
+ /* brackets are 1 stepsize taller than braces */
+ if (brac_p->bractype == BRACKLIST) {
+ y += eff_stepsize;
+ }
+
+ /* now calculate y1 (the bottom) by similar
+ * means */
+ y1 = Staffs_y [brac_p->botvisstaff];
+
+ /* figure out how tall the staff is effectively.
+ * Staffs with only a few stafflines are
+ * effectively taller than the number of
+ * stafflines. */
+ if ((eff_stafflines = svpath(
+ brac_p->botvisstaff, STAFFLINES) ->stafflines) < 3) {
+ eff_stafflines = 3;
+ }
+ /* stepsizes are taller on tab staffs */
+ tab_adjust = (is_tab_staff(brac_p->botvisstaff)
+ ? TABRATIO : 1.0);
+
+ /* adjust for height of staff */
+ eff_stepsize = svpath(brac_p->botvisstaff,
+ STAFFSCALE)->staffscale
+ * STEPSIZE;
+ y1 -= (eff_stafflines - 1) * eff_stepsize
+ * tab_adjust;
+
+ /* nested brackets should be a little shorter
+ * vertically to fit inside their parent.
+ * But beyond about 4 levels, if there is
+ * only a single staff, things look
+ * pretty bad, so limit to 4. */
+ y1 += (eff_stepsize * (brac_p->nestlevel < 5
+ ? brac_p->nestlevel : 4));
+
+ /* brackets are 1 stepsize taller than braces */
+ if (brac_p->bractype == BRACKLIST) {
+ y1 -= eff_stepsize;
+ }
+
+ /* now do the actual printing */
+ do_pr_brac(x, y, y1, brac_p->bractype);
+ printed_brac = YES;
+ }
+ }
+ }
+
+ return(printed_brac);
+}
+\f
+
+/* Given one MAINLL pointing to a FEED, find the previous one.
+ * Many functions in this file need the previous feed. At abshorz time,
+ * there may not be an actual FEED yet, it might just be proposed,
+ * so functions at that time need to provide that proposed FEED place.
+ * Once all the FEEDs are determined, we can use this function to
+ * find the previous one.
+ */
+
+static struct MAINLL *
+find_prev_feed_mll_p(mll_p)
+
+struct MAINLL *mll_p;
+
+{
+ for (mll_p = mll_p->prev; mll_p != 0; mll_p = mll_p->prev) {
+ if (IS_CLEFSIG_FEED(mll_p)) {
+ break;
+ }
+ }
+ return(mll_p);
+}
+\f
+
+/* Determine which label to use for a given staff.
+ * Goes backwards from mll_p, finding if label has been changed more recently
+ * than the previous feed. If so, use that label, else use label2.
+ */
+
+static char *
+label4staff(mll_p, s, prev_feed_mll_p)
+
+struct MAINLL *mll_p; /* should point to an actual or proposed FEED location */
+int s;
+struct MAINLL *prev_feed_mll_p; /* should point to an actual or proposed FEED location */
+
+{
+ for (mll_p = mll_p->prev; mll_p != 0; mll_p = mll_p->prev) {
+ if (mll_p == prev_feed_mll_p) {
+ break;
+ }
+ if (mll_p->str == S_SSV) {
+ struct SSV *ssv_p = mll_p->u.ssv_p;
+
+ /* If user changed label for this staff in staff
+ * context more recently that the previous feed,
+ * then that's the label we need. */
+ if (ssv_p->context == C_STAFF && ssv_p->staffno == s
+ && ssv_p->used[LABEL] == YES) {
+ return(ssv_p->label);
+ }
+
+ /* If user changed the score-wide label
+ * more recently than the previous feed,
+ * but there isn't any label set in staff context for
+ * this staff to override the score level label,
+ * then the score level label is the one we need. */
+ if (ssv_p->context == C_SCORE &&
+ ssv_p->used[LABEL] == YES &&
+ Staff[s-1].used[LABEL] == NO) {
+ return(ssv_p->label);
+ }
+ }
+ }
+ if (mll_p != 0) {
+ /* Hit another feed before any relevent label changes,
+ * so we need to use label2 */
+ return(svpath(s, LABEL2)->label2);
+ }
+ /* Ran off the top of the song. Use label */
+ return(svpath(s, LABEL)->label);
+}
+\f
+
+/* Given information about a set of grouped staffs,
+ * return the appropriate label to use: label or label2.
+ */
+
+static char *
+label4group(mll_p, brac_p, prev_feed_mll_p)
+
+struct MAINLL *mll_p;
+struct BRAC_INFO *brac_p;
+struct MAINLL *prev_feed_mll_p;
+
+{
+ for (mll_p = mll_p->prev; mll_p != 0; mll_p = mll_p->prev) {
+ if (mll_p == prev_feed_mll_p) {
+ /* Hasn't changed since previous feed, so label2 */
+ return(brac_p->staffset_p->label2);
+ }
+ if (mll_p->str == S_SSV && mll_p->u.ssv_p->context == C_SCORE &&
+ mll_p->u.ssv_p->used[brac_p->bractype] == YES) {
+ /* found SSV where brace/bracket was changed */
+ break;
+ }
+ }
+ /* Either changed since previous feed or is the first feed in song,
+ * so use label. */
+ return(brac_p->staffset_p->label);
+}
+\f
+
+/* Return width of default label if the default label is needed (for
+ * indent of first score. Returns 0.0 if default label should not be used.
+ */
+
+static double
+dflt_label_width(mll_p, prev_feed_mll_p)
+
+struct MAINLL *mll_p; /* points to FEED or proposed place
+ * where current FEED will be */
+struct MAINLL *prev_feed_mll_p; /* points to previous FEED, or proposed
+ * place where prev FEED will be */
+
+{
+ char dfltlabel[16];
+
+
+ for (mll_p = mll_p->prev; mll_p != 0; mll_p = mll_p->prev) {
+ if (mll_p == prev_feed_mll_p) {
+ /* not the first; so don't use default for first */
+ return(0.0);
+ }
+
+ if (mll_p->str == S_SSV && mll_p->u.ssv_p->context == C_SCORE &&
+ mll_p->u.ssv_p->used[LABEL] == YES) {
+ /* explicit label for first, so don't use default */
+ return(0.0);
+ }
+ }
+ (void) sprintf(dfltlabel, "%c%c ", FONT_TR, DFLT_SIZE);
+ return(strwidth(dfltlabel));
+}
~mdw / mup / blobdiff