--- /dev/null
+/* Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ * 2006 by Arkkra Enterprises */
+/* All rights reserved */
+/*
+ * Name: ssv.c
+ *
+ * Description: This file defines the instances of score, staff, and voice
+ * structures that are used for viewpathing. It also contains
+ * functions for accessing them.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "defines.h"
+#include "rational.h"
+#include "structs.h"
+#include "globals.h"
+
+/* define the default order of stacking for marks */
+static char Defmarkorder[] = {
+ 1, /* MK_MUSSYM */
+ 2, /* MK_OCTAVE */
+ 3, /* MK_DYN */
+ 3, /* MK_OTHERTEXT */
+ 3, /* MK_CHORD */
+ 4, /* MK_LYRICS */
+ 5, /* MK_ENDING */
+ 6, /* MK_REHEARSAL */
+ 7, /* MK_PEDAL */
+};
+
+/* default timesig of 4/4 */
+static char Dflt_timerep[] = { 4, TSR_SLASH, 4, TSR_END };
+
+static void freestaffset P((int num, struct STAFFSET *ss_p));
+static void asgnstaffset P((int num, struct STAFFSET **new_p_p,
+ struct STAFFSET *old_p));
+static void setorder P((int place, struct SSV *i_p, struct SSV *f_p));
+\f
+/*
+ * Name: initstructs()
+ *
+ * Abstract: Init the fixed instances of the SSV structures.
+ *
+ * Returns: void
+ *
+ * Description: This function initializes all the fixed structures Score,
+ * Staff[s], and Voice[s][v]. This needs to be done before
+ * scanning through the main linked list of user input
+ * structures.
+ */
+
+void
+initstructs()
+
+{
+ int s; /* staff number */
+ int v; /* voice number */
+ int n; /* another loop variable */
+ int p; /* place (PL_*) */
+ int m; /* mark (MK_*) */
+ int hs; /* head shape number */
+
+
+ /*
+ * Call zapssv() to release any malloc'ed memory, if any of the
+ * structures have been used before, and mark all fields unused.
+ */
+ zapssv(&Score);
+
+ for (s = 0; s < MAXSTAFFS; s++) {
+ zapssv(&Staff[s]);
+ for (v = 0; v < MAXVOICES; v++)
+ zapssv(&Voice[s][v]);
+ }
+
+ /*
+ * Fill the Score structure with the proper default values, and
+ * mark all its fields as used.
+ */
+ /* score context */
+ Score.scale_factor = DEFSCALE;
+ Score.units = INCHES;
+ Score.pageheight = DEFPAGEHEIGHT;
+ Score.pagewidth = DEFPAGEWIDTH;
+ Score.panelsperpage = DEFPANELSPERPAGE;
+ Score.topmargin = DEFVMARGIN;
+ Score.botmargin = DEFVMARGIN;
+ Score.leftmargin = DEFHMARGIN;
+ Score.rightmargin = DEFHMARGIN;
+ Score.restcombine = NORESTCOMBINE;
+ Score.firstpage = NOFIRSTPAGE;
+ Score.staffs = DEFSTAFFS;
+ Score.minscsep = DEFMINSCSEP;
+ Score.maxscsep = DEFMAXSCSEP;
+ Score.minscpad = DEFMINSCPAD;
+ Score.maxscpad = DEFMAXSCPAD;
+ Score.nbrace = 0;
+ Score.nbrack = 0;
+ Score.nbarst = 0;
+ Score.timerep = Dflt_timerep;
+ Score.timenum = 4;
+ Score.timeden = 4;
+ Score.time.n = 1;
+ Score.time.d = 1;
+ Score.division = DEFDIVISION;
+ Score.endingstyle = ENDING_TOP;
+ Score.gridsatend = NO;
+ Score.measnum = NO;
+ Score.measnumfamily = BASE_TIMES;
+ Score.measnumfont = FONT_TR;
+ Score.measnumsize = MNUM_SIZE;
+ Score.packfact = DFLTPACKFACT;
+ Score.packexp = DFLTPACKEXP;
+ Score.warn = YES;
+
+ /* score and staff context */
+ Score.staffscale = DEFSTFSCALE;
+ Score.visible = YES;
+ Score.hidesilent = NO;
+ Score.stafflines = 5;
+ Score.strinfo = 0;
+ Score.printclef = SS_NORMAL;
+ Score.gridswhereused = NO;
+ Score.gridscale = DEFGRIDSCALE;
+ Score.gridfret = DEFGRIDFRET;
+ Score.numbermrpt = YES;
+ Score.printmultnum = YES;
+ Score.restsymmult = NO;
+ Score.vscheme = V_1;
+ for (v = 0; v < MAXVOICES; v++) {
+ Score.vcombine[v] = 0;
+ }
+ Score.vcombinequal = VC_NOOVERLAP;
+ Score.sharps = DEFSHARPS;
+ Score.is_minor = NO;
+ Score.cancelkey = NO;
+ Score.inttype = PERFECT;
+ Score.intnum = 1;
+ Score.addinttype = PERFECT;
+ Score.addintnum = 1;
+ Score.clef = TREBLE;
+ Score.rehstyle = RS_BOXED;
+ Score.fontfamily = BASE_TIMES;
+ Score.font = FONT_TR;
+ Score.size = DFLT_SIZE;
+ Score.lyricsfamily = BASE_TIMES;
+ Score.lyricsfont = FONT_TR;
+ Score.lyricssize = DFLT_SIZE;
+ Score.lyricsalign = DEFLYRICSALIGN;
+ Score.sylposition = DEFSYLPOSITION;
+ Score.minstsep = DEFMINSTSEP;
+ Score.staffpad = DEFSTPAD;
+ for (p = 0; p < NUM_PLACE; p++) {
+ for (m = 0; m < NUM_MARK; m++) {
+ Score.markorder[p][m] = Defmarkorder[m];
+ }
+ }
+ Score.pedstyle = P_LINE;
+ Score.chorddist = DEFCHORDDIST;
+ Score.dist = DEFDIST;
+ Score.dyndist = DEFDYNDIST;
+ Score.label = 0;
+ Score.label2 = 0;
+
+ /* score, staff, and voice context */
+ Score.nbeam = 0;
+ Score.nsubbeam = 0;
+ Score.beamfact = DEFBEAMFACT;
+ Score.beammax = DEFBEAMMAX;
+ Score.pad = DEFPAD;
+ Score.stemlen = DEFSTEMLEN;
+ Score.stemshorten = DEFSTEMSHORTEN;
+ Score.defoct = DEFOCTAVE;
+ Score.timeunit.n = 1;
+ Score.timeunit.d = 4;
+ Score.timelist_p = 0;
+ Score.swingunit = Zero;
+ Score.release = DEFRELEASE;
+ Score.ontheline = YES;
+ Score.tabwhitebox = NO;
+ hs = get_shape_num("norm");
+ for (n = 0; n < 7; n++) {
+ Score.noteheads[n] = hs;
+ }
+
+ for (n = 0; n < NUMFLDS; n++) {
+ Score.used[n] = YES; /* all items will be set in Score */
+ }
+}
+\f
+/*
+ * Name: zapssv()
+ *
+ * Abstract: Init a fixed instance of the SSV structure to empty.
+ *
+ * Returns: void
+ *
+ * Description: This function initializes a fixed SSV structure to say that
+ * all fields are unused.
+ */
+
+void
+zapssv(s_p)
+
+struct SSV *s_p; /* pointer to the structure to be zapped */
+
+{
+ int n; /* loop variable */
+
+
+ /*
+ * If the structure has been used before, we first have to free any
+ * memory that was malloc'ed. It's okay to check "used" the first
+ * time, because global variables are set to 0 by the compiler;
+ * thus, used[X] == NO.
+ */
+ if (s_p->used[BRACELIST] == YES) {
+ freestaffset(s_p->nbrace, s_p->bracelist);
+ s_p->bracelist = 0;
+ }
+ if (s_p->used[BRACKLIST] == YES) {
+ freestaffset(s_p->nbrack, s_p->bracklist);
+ s_p->bracklist = 0;
+ }
+ if (s_p->used[BARSTLIST] == YES && s_p->barstlist != 0) {
+ FREE(s_p->barstlist);
+ s_p->barstlist = 0;
+ }
+ if (s_p->used[LABEL] == YES && s_p->label != 0) {
+ FREE(s_p->label);
+ s_p->label = 0;
+ }
+ if (s_p->used[LABEL2] == YES && s_p->label2 != 0) {
+ FREE(s_p->label2);
+ s_p->label2 = 0;
+ }
+ if (s_p->used[BEAMSTLIST] == YES && s_p->beamstlist != 0) {
+ FREE(s_p->beamstlist);
+ s_p->beamstlist = 0;
+ }
+
+ /*
+ * Mark all fields unused.
+ */
+ for (n = 0; n < NUMFLDS; n++) {
+ s_p->used[n] = NO;
+ }
+}
+\f
+/*
+ * Name: freestaffset()
+ *
+ * Abstract: Free all malloc'ed memory associated with a staffset list.
+ *
+ * Returns: void
+ *
+ * Description: This function frees staffset structures, along with their
+ * labels if they exist.
+ */
+
+static void
+freestaffset(num, ss_p)
+
+int num; /* how many staffsets are in list? */
+struct STAFFSET *ss_p; /* pointer to first staffset */
+
+{
+ int n; /* loop variable */
+
+
+ if (ss_p == 0) /* if there is no list, just return */
+ return;
+
+ /* for each staffset in the list, free labels if present */
+ for (n = 0; n < num; n++) {
+ if (ss_p[n].label != 0) { /* if label, free it */
+ FREE(ss_p[n].label);
+ ss_p[n].label = 0;
+ }
+ if (ss_p[n].label2 != 0) { /* if label2, free it */
+ FREE(ss_p[n].label2);
+ ss_p[n].label2 = 0;
+ }
+ }
+
+ FREE(ss_p); /* free the staffset list itself */
+}
+\f
+/*
+ * Name: asgnstaffset()
+ *
+ * Abstract: Set up a staffset list in another SSV structure.
+ *
+ * Returns: void
+ *
+ * Description: This function sets up a new staffset list identical to
+ * another one, including the labels if they exist.
+ */
+
+static void
+asgnstaffset(num, new_p_p, old_p)
+
+int num; /* how many staffsets are in list? */
+struct STAFFSET **new_p_p; /* ptr to ptr to first staffset of new list */
+struct STAFFSET *old_p; /* pointer to first staffset of old list */
+
+{
+ int n; /* loop variable */
+
+
+ if (num == 0) /* if there's no old list, nothing to do */
+ return;
+
+ /*
+ * Allocate the new list and point at it.
+ */
+ MALLOC(STAFFSET, *new_p_p, num);
+
+ /*
+ * Loop through the old list. Wherever there is a label, allocate
+ * one for the new list. When there isn't, set that pointer to null.
+ */
+ for (n = 0; n < num; n++) {
+ (*new_p_p)[n].topstaff = old_p[n].topstaff;
+ (*new_p_p)[n].botstaff = old_p[n].botstaff;
+
+ if (old_p[n].label != 0) {
+ MALLOCA(char, (*new_p_p)[n].label,
+ strlen(old_p[n].label) + 1);
+ (void)strcpy((*new_p_p)[n].label, old_p[n].label);
+ } else {
+ (*new_p_p)[n].label = 0;
+ }
+
+ if (old_p[n].label2 != 0) {
+ MALLOCA(char, (*new_p_p)[n].label2,
+ strlen(old_p[n].label2) + 1);
+ (void)strcpy((*new_p_p)[n].label2, old_p[n].label2);
+ } else {
+ (*new_p_p)[n].label2 = 0;
+ }
+ }
+}
+\f
+/*
+ * Name: svpath()
+ *
+ * Abstract: Find a field for a staff, using the viewpath.
+ *
+ * Returns: pointer to structure containing correct field value
+ *
+ * Description: This function, given a staff number and a field number, looks
+ * down the viewpath to find the first structure where the field
+ * is set. It returns a pointer to that structure. (However, see
+ * below for a special kluge for the "visible" field.)
+ * Note: 0 is allowed for the staff number, and that means use
+ * the Score value.
+ */
+
+struct SSV *
+svpath(s, field)
+
+int s; /* staff number, 1 to MAXSTAFFS; or 0, meaning score */
+int field; /* the defined symbol for the field desired */
+
+{
+ static struct SSV phony; /* phony SSV; see below */
+
+
+ if (s == 0)
+ return (&Score);
+
+ /*
+ * For the "visible" field, special kluges are needed, for two reasons.
+ * One is that there is a command line option (-s) that overrides the
+ * visibility requests in the Mup input file. The other is that, even
+ * though it is a score/staff/voice parameter, it is easier to manage
+ * visibility at the staff level than at the voice level. Otherwise,
+ * to know if a staff should be drawn, we would have to check vscheme
+ * and the visibility state of each voice.
+ *
+ * The design is as follows: in mkchords.c, if a voice is to be
+ * invisible, a measure space is put in place of its original GRPSYL
+ * list. Users can use svpath() to check if a staff is visible
+ * instead of having to call vvpath() for its voice(s). The field
+ * staff_p->visible is set by calling here, so that will also be
+ * consistent.
+ *
+ * If the -s option was used on the command line, only staffs/voices
+ * listed there are ever allowed to be visible. So although SSVs are
+ * set as for other score/staff/voice parameters, the results from
+ * svpath() also consider what the -s option said. In vvpath() this
+ * is also done.
+ */
+ if (field == VISIBLE) {
+ int num_voices; /* how many voices on this staff */
+
+ /*
+ * In case we are going to return the phony SSV, load the
+ * hidesilent field into it. Both visible and hidesilent are
+ * controlled by VISIBLE, but hidesilent is not to be affected
+ * by the kluges needed for "visible".
+ */
+ /* if the field is set in the staff structure, use that */
+ if (Staff[s-1].used[VISIBLE] == YES) {
+ phony.hidesilent = Staff[s-1].hidesilent;
+ } else {
+ /* use the score structure; it's always set there */
+ phony.hidesilent = Score.hidesilent;
+ }
+
+ /* always return NO if the command line says staff invisible */
+ if (Staff_vis[s] == NO) {
+ /* return phony SSV with NO, ignore real SSV */
+ phony.visible = NO;
+ return (&phony);
+ }
+
+ num_voices = vscheme_voices(svpath(s, VSCHEME)->vscheme);
+
+ /*
+ * If a voice that the command line is allowing to be visible
+ * was requested via an SSV to be visible, we must let the
+ * staff be visible.
+ */
+ if ((Voice_vis[s][1] == YES &&
+ Voice[s-1][0].used[VISIBLE] == YES &&
+ Voice[s-1][0].visible == YES) ||
+
+ (num_voices >= 2 &&
+ Voice_vis[s][2] == YES &&
+ Voice[s-1][1].used[VISIBLE] == YES &&
+ Voice[s-1][1].visible == YES) ||
+
+ (num_voices >= 3 &&
+ Voice_vis[s][3] == YES &&
+ Voice[s-1][2].used[VISIBLE] == YES &&
+ Voice[s-1][2].visible == YES)) {
+
+ /* return phony SSV with YES, ignore real SSV */
+ phony.visible = YES;
+ return (&phony);
+ }
+
+ /*
+ * If, for each voice that exists, either the command line is
+ * forcing it to be invisible or else it was requested via an
+ * SSV to be invisible, then the staff must be invisible.
+ */
+ if ((Voice_vis[s][1] == NO ||
+ Voice[s-1][0].used[VISIBLE] == YES &&
+ Voice[s-1][0].visible == NO) &&
+
+ (num_voices < 2 ||
+ (Voice_vis[s][2] == NO ||
+ Voice[s-1][1].used[VISIBLE] == YES &&
+ Voice[s-1][1].visible == NO)) &&
+
+ (num_voices < 3 ||
+ (Voice_vis[s][3] == NO ||
+ Voice[s-1][2].used[VISIBLE] == YES &&
+ Voice[s-1][2].visible == NO))) {
+
+ /* return phony SSV with NO, ignore real SSV */
+ phony.visible = NO;
+ return (&phony);
+ }
+
+ /*
+ * The command line and the voice(s) aren't forcing the issue.
+ * So fall through to determine the staff's visibility the
+ * normal way.
+ */
+ }
+
+ /* if the field is set in the staff structure, use that */
+ if (Staff[s-1].used[field] == YES)
+ return (&Staff[s-1]);
+
+ /* else use the score structure; it's always set there */
+ return (&Score);
+}
+\f
+/*
+ * Name: vvpath()
+ *
+ * Abstract: Find a field for a voice, using the viewpath.
+ *
+ * Returns: pointer to structure containing correct field value
+ *
+ * Description: This function, given a staff number, voice number on that
+ * staff, and a field number, looks down the viewpath to find
+ * the first structure where the field is set. It returns a
+ * pointer to that structure. (However, see below for a special
+ * kluge for the "visible" field.)
+ * Note: 0 is allowed for the voice number, and that means use
+ * the staff's value. If staff is 0, the Score is used,
+ * regardless of the voice number.
+ */
+
+struct SSV *
+vvpath(s, v, field)
+
+int s; /* staff number, 1 to MAXSTAFFS; or 0, meaning score */
+int v; /* voice number, 1 to MAXVOICES; or 0, meaning staff */
+int field; /* the defined symbol for the field desired */
+
+{
+ static struct SSV phony; /* phony SSV; see below */
+
+
+ if (s == 0 || v == 0)
+ return (svpath(s, field));
+
+ /*
+ * See the comment in svpath() regarding the "visible" field. There's
+ * probably no need to call vvpath() for "visible" after mkchords.c has
+ * run, since voices that are to be invisible are changed to measure
+ * spaces there. But in mkchords.c itself, and earlier, there is
+ * sometimes a need.
+ *
+ * For the "visible" field, first check the command line to see if this
+ * voice or its staff must always be invisible. If so, return a phony
+ * SSV that says that. Otherwise fall through to handle the normal way.
+ */
+ if (field == VISIBLE && (Staff_vis[s] == NO || Voice_vis[s][v] == NO)) {
+ /*
+ * Since we are going to force visible to NO, it's irrelevant
+ * what hidesilent is, so don't bother setting it, unlike what
+ * we had to do in svpath().
+ */
+ phony.visible = NO;
+ return (&phony);
+ }
+
+ /* if the field is set in the voice structure, use that */
+ if (Voice[s-1][v-1].used[field] == YES)
+ return (&Voice[s-1][v-1]);
+
+ /* else if the field is set in the staff structure, use that */
+ if (Staff[s-1].used[field] == YES)
+ return (&Staff[s-1]);
+
+ /* else use the score structure; it's always set there */
+ return (&Score);
+}
+\f
+/*
+ * Name: asgnssv()
+ *
+ * Abstract: Assign fields from an input SSV to a fixed one.
+ *
+ * Returns: void
+ *
+ * Description: This function is passed an input SSV structure (from an input
+ * context). For each field where "used" is YES in the input SSV,
+ * it copies it to the appropriate fixed SSV and sets its "used"
+ * flag to YES. For each field where "used" is UNSET in the input
+ * SSV, it sets "used" to NO in the appropriate fixed SSV.
+ * In some cases, there are side effects, where it also
+ * alters a lower level structure. E.g., changing the number of
+ * voices of a staff inits its voice structures. In the case
+ * of stafflines, setting a staff to be a tablature staff
+ * automatically automatically forces some other fields to be set
+ * not only in the given staff, but also in the preceding tabnote
+ * staff. Note also that the Score "used" flags are already
+ * always set and don't need to be set here. And Score fields can
+ * never be unset.
+ */
+
+void
+asgnssv(i_p)
+
+struct SSV *i_p; /* input SSV structure to be copied from */
+
+{
+ struct SSV *f_p; /* ptr to fixed SSV structure to copy into */
+ int s, v; /* used for looping through staffs & voices */
+ int start, stop; /* loop limits */
+ int n; /* another loop variable */
+
+
+ f_p = 0; /* to prevent "uninitialized variable" warnings */
+
+ /*
+ * Using the selector fields in the input structure, set a pointer to
+ * the fixed structure that is to be populated.
+ */
+ switch (i_p->context) {
+ case C_SCORE:
+ f_p = &Score;
+ break;
+ case C_STAFF:
+ /* silently ignore bogus staff no.; it is caught elsewhere */
+ if (i_p->staffno < 1 || i_p->staffno > MAXSTAFFS) {
+ return;
+ }
+ f_p = &Staff[ i_p->staffno - 1 ];
+ break;
+ case C_VOICE:
+ /* silently ignore bogus staff/voice; it is caught elsewhere */
+ if (i_p->staffno < 1 || i_p->staffno > MAXSTAFFS ||
+ i_p->voiceno < 1 || i_p->voiceno > MAXVOICES) {
+ return;
+ }
+ f_p = &Voice[ i_p->staffno - 1 ][ i_p->voiceno - 1 ];
+ break;
+ }
+
+ /*
+ * ========== ITEMS FOR SCORE CONTEXT ONLY ===========
+ * There's no need to set f_p->used[] = YES here; since this is the
+ * score, those bits are already always YES.
+ */
+ if (i_p->used[SCALE_FACTOR] == YES) {
+ f_p->scale_factor = i_p->scale_factor;
+ }
+
+ if (i_p->used[UNITS] == YES) {
+ f_p->units = i_p->units;
+ }
+
+ /*
+ * PAGEHEIGHT, PAGEHEIGHT, and PANELSPERPAGE interact, because when the
+ * user sets PAGE*, they are referring to the paper, but internally we
+ * want page* to refer to one "panel" of music, which is a 90 degree
+ * rotated half of the sheet of paper when panelsperpage is 2.
+ */
+ if (i_p->used[PAGEHEIGHT] == YES) {
+ if (f_p->panelsperpage == 1) {
+ f_p->pageheight = i_p->pageheight;
+ } else {
+ f_p->pagewidth = i_p->pageheight / 2.0;
+ }
+ }
+
+ if (i_p->used[PAGEWIDTH] == YES) {
+ if (f_p->panelsperpage == 1) {
+ f_p->pagewidth = i_p->pagewidth;
+ } else {
+ f_p->pageheight = i_p->pagewidth;
+ }
+ }
+
+ if (i_p->used[PANELSPERPAGE] == YES) {
+ /* depending on how this is changing, flip height and width */
+ float oldwidth;
+ if (f_p->panelsperpage == 1 && i_p->panelsperpage == 2) {
+ oldwidth = f_p->pagewidth;
+ f_p->pagewidth = f_p->pageheight / 2.0;
+ f_p->pageheight = oldwidth;
+ } else if (f_p->panelsperpage == 2 && i_p->panelsperpage == 1) {
+ oldwidth = f_p->pagewidth;
+ f_p->pagewidth = f_p->pageheight;
+ f_p->pageheight = oldwidth * 2.0;
+ }
+ f_p->panelsperpage = i_p->panelsperpage;
+ }
+
+ if (i_p->used[TOPMARGIN] == YES) {
+ f_p->topmargin = i_p->topmargin;
+ }
+
+ if (i_p->used[BOTMARGIN] == YES) {
+ f_p->botmargin = i_p->botmargin;
+ }
+
+ if (i_p->used[LEFTMARGIN] == YES) {
+ f_p->leftmargin = i_p->leftmargin;
+ }
+
+ if (i_p->used[RIGHTMARGIN] == YES) {
+ f_p->rightmargin = i_p->rightmargin;
+ }
+
+ if (i_p->used[RESTCOMBINE] == YES) {
+ f_p->restcombine = i_p->restcombine;
+ }
+
+ if (i_p->used[FIRSTPAGE] == YES) {
+ f_p->firstpage = i_p->firstpage;
+ }
+
+ if (i_p->used[NUMSTAFF] == YES) {
+ f_p->staffs = i_p->staffs;
+
+ /* this destroys all staff and voice info */
+ for (s = 0; s < MAXSTAFFS; s++) {
+ zapssv(&Staff[s]);
+ for (v = 0; v < MAXVOICES; v++)
+ zapssv(&Voice[s][v]);
+ }
+ }
+
+ if (i_p->used[MINSCSEP] == YES) {
+ f_p->minscsep = i_p->minscsep;
+ }
+
+ if (i_p->used[MAXSCSEP] == YES) {
+ f_p->maxscsep = i_p->maxscsep;
+ }
+
+ if (i_p->used[MINSCPAD] == YES) {
+ f_p->minscpad = i_p->minscpad;
+ }
+
+ if (i_p->used[MAXSCPAD] == YES) {
+ f_p->maxscpad = i_p->maxscpad;
+ }
+
+ if (i_p->used[BRACELIST] == YES) {
+ /* if it was already used, free old list if present */
+ if (f_p->used[BRACELIST] == YES) {
+ freestaffset(f_p->nbrace, f_p->bracelist);
+ f_p->bracelist = 0;
+ }
+
+ /* set up new list */
+ f_p->nbrace = i_p->nbrace;
+ asgnstaffset(f_p->nbrace, &f_p->bracelist, i_p->bracelist);
+ }
+
+ if (i_p->used[BRACKLIST] == YES) {
+ /* if it was already used, free old list if present */
+ if (f_p->used[BRACKLIST] == YES) {
+ freestaffset(f_p->nbrack, f_p->bracklist);
+ f_p->bracklist = 0;
+ }
+
+ /* set up new list */
+ f_p->nbrack = i_p->nbrack;
+ asgnstaffset(f_p->nbrack, &f_p->bracklist, i_p->bracklist);
+ }
+
+ if (i_p->used[BARSTLIST] == YES) {
+ /* if it was already used, free old list if present */
+ if (f_p->used[BARSTLIST] == YES && f_p->nbarst != 0)
+ FREE(f_p->barstlist);
+
+ /* set up new list */
+ f_p->nbarst = i_p->nbarst;
+ /* the +1 is to guard against allocating 0 */
+ MALLOC(TOP_BOT, f_p->barstlist, f_p->nbarst + 1);
+ for (n = 0; n < f_p->nbarst; n++) {
+ f_p->barstlist[n] = i_p->barstlist[n];
+ }
+ }
+
+ if (i_p->used[TIME] == YES) {
+ f_p->timenum = i_p->timenum;
+ f_p->timeden = i_p->timeden;
+ f_p->timevis = i_p->timevis;
+ f_p->timerep = i_p->timerep;
+ f_p->time = i_p->time;
+
+ /*
+ * Changing the time sig forces a change in default time unit.
+ * Set it to one "beat" for the score, and unset it for all
+ * staffs and voices.
+ */
+ f_p->timeunit.n = 1;
+ f_p->timeunit.d = f_p->timeden;
+ f_p->timelist_p = 0;
+ for (s = 0; s < MAXSTAFFS; s++) {
+ Staff[s].used[TIMEUNIT] = NO;
+ for (v = 0; v < MAXVOICES; v++)
+ Voice[s][v].used[TIMEUNIT] = NO;
+ }
+
+ /*
+ * Changing the time also destroys all beamstyle lists.
+ * However, the special empty beamstyle list that was set up
+ * for a tablature staff must be retained, so that it will
+ * continue to override any score beamstyle list that may be
+ * set up later on.
+ */
+ if (Score.used[BEAMSTLIST] == YES) {
+ if (Score.nbeam != 0) {
+ FREE(Score.beamstlist);
+ Score.beamstlist = 0;
+ Score.nbeam = 0;
+ FREE(Score.subbeamstlist);
+ Score.subbeamstlist = 0;
+ Score.nsubbeam = 0;
+ }
+ }
+ for (s = 0; s < MAXSTAFFS; s++) {
+ if (Staff[s].used[BEAMSTLIST] == YES &&
+ Staff[s].strinfo == 0) { /* not tablature */
+ if (Staff[s].nbeam != 0) {
+ FREE(Staff[s].beamstlist);
+ Staff[s].beamstlist = 0;
+ Staff[s].nbeam = 0;
+ FREE(Staff[s].subbeamstlist);
+ Staff[s].subbeamstlist = 0;
+ Staff[s].nsubbeam = 0;
+ }
+ Staff[s].used[BEAMSTLIST] = NO;
+ }
+ for (v = 0; v < MAXVOICES; v++) {
+ if (Voice[s][v].used[BEAMSTLIST] == YES) {
+ if (Voice[s][v].nbeam != 0) {
+ FREE(Voice[s][v].beamstlist);
+ Voice[s][v].beamstlist = 0;
+ Voice[s][v].nbeam = 0;
+ FREE(Voice[s][v].subbeamstlist);
+ Voice[s][v].subbeamstlist = 0;
+ Voice[s][v].nsubbeam = 0;
+ }
+ Voice[s][v].used[BEAMSTLIST] = NO;
+ }
+ }
+ }
+ }
+
+ if (i_p->used[DIVISION] == YES) {
+ f_p->division = i_p->division;
+ }
+
+ if (i_p->used[ENDINGSTYLE] == YES) {
+ f_p->endingstyle = i_p->endingstyle;
+ }
+
+ if (i_p->used[GRIDSATEND] == YES) {
+ f_p->gridsatend = i_p->gridsatend;
+ }
+
+ if (i_p->used[MEASNUM] == YES) {
+ f_p->measnum = i_p->measnum;
+ }
+
+ if (i_p->used[MEASNUMFAMILY] == YES) {
+ f_p->measnumfamily = i_p->measnumfamily;
+ }
+
+ if (i_p->used[MEASNUMFONT] == YES) {
+ f_p->measnumfont = i_p->measnumfont;
+ }
+
+ if (i_p->used[MEASNUMSIZE] == YES) {
+ f_p->measnumsize = i_p->measnumsize;
+ }
+
+ if (i_p->used[PACKFACT] == YES) {
+ f_p->packfact = i_p->packfact;
+ }
+
+ if (i_p->used[PACKEXP] == YES) {
+ f_p->packexp = i_p->packexp;
+ }
+
+ if (i_p->used[WARN] == YES) {
+ f_p->warn = i_p->warn;
+ }
+
+ /*
+ * ========== ITEMS FOR SCORE AND STAFF CONTEXT ===========
+ */
+ /*
+ * Most parameters involve just a single field, and have no side
+ * effects. For this, we can use the following switch statement to
+ * do the work, for parameters that can exist on staff or voice.
+ * (Score-only ones don't need it, since that can't be unset.)
+ */
+#define SETPARM(name, NAME) \
+ switch (i_p->used[NAME]) { \
+ case YES: \
+ f_p->name = i_p->name; \
+ f_p->used[NAME] = YES; \
+ break; \
+ case UNSET: \
+ f_p->used[NAME] = NO; \
+ break; \
+ /* default is NO; do nothing */ \
+ }
+
+ SETPARM(staffscale, STAFFSCALE)
+
+ switch (i_p->used[STAFFLINES]) {
+ case YES: {
+ struct SSV *tabnote_p; /* ptr to tabnote fixed SSV */
+ f_p->stafflines = i_p->stafflines;
+
+ if (i_p->strinfo != 0) { /* tablature */
+ struct SSV *voice_p; /* ptr to a voice's fixed SSV*/
+
+ /*
+ * This is a tablature staff. Set printclef to normal
+ * (even though tab isn't particularly "normal").
+ * Point f_p->strinfo at the same array that
+ * i_p->strinfo points at.
+ */
+ f_p->printclef = SS_NORMAL;
+ f_p->strinfo = i_p->strinfo;
+
+ /*
+ * Force some other score/staff items to fixed values
+ * for tab. The parser blocks the user from setting
+ * these. We need to set them here in the staff SSV to
+ * override whatever may be in the score SSV. This
+ * will make it possible to avoid special checks for
+ * tablature in many places; the right values will be
+ * set for this staff. Also force score/staff/voice
+ * items here.
+ */
+ f_p->sharps = 0;
+ f_p->is_minor = NO;
+ f_p->used[SHARPS] = YES;
+
+ f_p->inttype = PERFECT;
+ f_p->intnum = 1;
+ f_p->used[TRANSPOSITION] = YES;
+
+ f_p->addinttype = PERFECT;
+ f_p->addintnum = 1;
+ f_p->used[ADDTRANSPOSITION] = YES;
+
+ f_p->clef = TABCLEF;
+ f_p->used[CLEF] = YES;
+
+ if (f_p->used[BEAMSTLIST] == YES && f_p->nbeam != 0) {
+ /* if already used, free old list if present */
+ FREE(f_p->beamstlist);
+ FREE(f_p->subbeamstlist);
+ }
+ f_p->nbeam = 0;
+ f_p->beamstlist = 0;
+ f_p->nsubbeam = 0;
+ f_p->subbeamstlist = 0;
+ f_p->used[BEAMSTLIST] = YES;
+
+ f_p->defoct = 4;
+ f_p->used[DEFOCT] = YES;
+
+ /* blow away the following in tab staff's voices */
+ for (v = 0; v < MAXVOICES; v++) {
+ voice_p = &Voice[ i_p->staffno - 1][ v ];
+
+ if (voice_p->used[BEAMSTLIST] == YES) {
+ if (voice_p->nbeam != 0) {
+ FREE(f_p->beamstlist);
+ FREE(f_p->subbeamstlist);
+ }
+ voice_p->used[BEAMSTLIST] = NO;
+ }
+ voice_p->used[DEFOCT] = NO;
+ }
+
+ /*
+ * Force fields on the tabnote staff above this tab
+ * staff.
+ */
+ tabnote_p = &Staff[ i_p->staffno - 2 ];
+
+ /*
+ * The parse phase wouldn't let this be another tab
+ * staff, so we don't need to check for that. But it
+ * might be a 1-line staff. If so, override it to 5
+ * line. If this parameter wasn't set, force printclef
+ * to normal, but if it was, keep the old value. (We
+ * might as well allow 5n and 5 drum as well as 5,
+ * though that would be a weird usage.)
+ */
+ tabnote_p->stafflines = 5;
+ if (tabnote_p->used[STAFFLINES] == NO)
+ tabnote_p->printclef = SS_NORMAL;
+ tabnote_p->used[STAFFLINES] = YES;
+
+ } else { /* not tablature */
+ /*
+ * If this staff used to be tablature, we need to unset
+ * some "used" fields that were forced.
+ */
+ if (f_p->strinfo != 0) {
+ f_p->used[SHARPS] = NO;
+ f_p->used[TRANSPOSITION] = NO;
+ f_p->used[ADDTRANSPOSITION] = NO;
+ f_p->used[CLEF] = NO;
+ f_p->used[BEAMSTLIST] = NO;
+ f_p->used[DEFOCT] = NO;
+ tabnote_p = &Staff[ i_p->staffno - 2 ];
+
+ /* make it non-tablature */
+ f_p->strinfo = 0;
+ }
+
+ f_p->printclef = i_p->printclef;
+ }
+ f_p->used[STAFFLINES] = YES;
+ } break;
+ case UNSET:
+ f_p->used[STAFFLINES] = NO;
+ break;
+ }
+
+ SETPARM(gridswhereused, GRIDSWHEREUSED)
+
+ SETPARM(gridscale, GRIDSCALE)
+
+ SETPARM(gridfret, GRIDFRET)
+
+ SETPARM(numbermrpt, NUMBERMRPT)
+
+ SETPARM(printmultnum, PRINTMULTNUM)
+
+ SETPARM(restsymmult, RESTSYMMULT)
+
+ switch (i_p->used[VSCHEME]) {
+ case YES:
+ /*
+ * If the vscheme change changes the *number* of voices, we
+ * have to wipe out the voice information, but otherwise not.
+ */
+ if (i_p->context == C_SCORE) {
+ start = 0; /* if score, do test for */
+ stop = MAXSTAFFS - 1; /* all staffs */
+ } else { /* C_STAFF */
+ start = stop = i_p->staffno - 1; /* do just this one */
+ }
+
+ /* for each staff affected by this change . . . */
+ for (n = start; n <= stop; n++) {
+ int oldvoices, newvoices; /* how many before & after */
+
+ oldvoices = vscheme_voices(svpath(n + 1,
+ VSCHEME)->vscheme);
+ newvoices = vscheme_voices(i_p->vscheme);
+
+ if (oldvoices != newvoices) {
+
+ for (v = 0; v < MAXVOICES; v++)
+ zapssv(&Voice[n][v]);
+ }
+ }
+
+ f_p->vscheme = i_p->vscheme;
+ f_p->used[VSCHEME] = YES;
+ break;
+ case UNSET:
+ f_p->used[VSCHEME] = NO;
+ break;
+ }
+
+ switch (i_p->used[VCOMBINE]) {
+ case YES:
+ for (v = 0; v < MAXVOICES; v++) {
+ f_p->vcombine[v] = i_p->vcombine[v];
+ }
+ f_p->vcombinequal = i_p->vcombinequal;
+ f_p->used[VCOMBINE] = YES;
+ break;
+ case UNSET:
+ f_p->used[VCOMBINE] = NO;
+ break;
+ }
+
+ switch (i_p->used[SHARPS]) {
+ case YES:
+ f_p->sharps = i_p->sharps;
+ f_p->is_minor = i_p->is_minor;
+ f_p->used[SHARPS] = YES;
+ break;
+ case UNSET:
+ f_p->used[SHARPS] = NO;
+ break;
+ }
+
+ SETPARM(cancelkey, CANCELKEY)
+
+ switch (i_p->used[TRANSPOSITION]) {
+ case YES:
+ f_p->inttype = i_p->inttype;
+ f_p->intnum = i_p->intnum;
+ f_p->used[TRANSPOSITION] = YES;
+ break;
+ case UNSET:
+ f_p->used[TRANSPOSITION] = NO;
+ break;
+ }
+
+ switch (i_p->used[ADDTRANSPOSITION]) {
+ case YES:
+ f_p->addinttype = i_p->addinttype;
+ f_p->addintnum = i_p->addintnum;
+ f_p->used[ADDTRANSPOSITION] = YES;
+ break;
+ case UNSET:
+ f_p->used[ADDTRANSPOSITION] = NO;
+ break;
+ }
+
+ switch (i_p->used[CLEF]) {
+ case YES:
+ f_p->clef = i_p->clef;
+ f_p->used[CLEF] = YES;
+
+ /*
+ * Reset the default octave so that the middle line of the
+ * staff lies within it. If the user also set octave in
+ * this context, this will get changed again later in this
+ * function.
+ */
+ if (f_p->clef > ALTO) /* lower than alto */
+ f_p->defoct = 3;
+ else if (f_p->clef < TREBLE) /* higher than treble */
+ f_p->defoct = 5;
+ else
+ f_p->defoct = 4;
+ f_p->used[DEFOCT] = YES;
+ break;
+ case UNSET:
+ f_p->used[DEFOCT] = NO;
+ break;
+ }
+
+ SETPARM(rehstyle, REHSTYLE)
+
+ SETPARM(fontfamily, FONTFAMILY)
+
+ SETPARM(font, FONT)
+
+ SETPARM(size, SIZE)
+
+ SETPARM(lyricsfamily, LYRICSFAMILY)
+
+ SETPARM(lyricsfont, LYRICSFONT)
+
+ SETPARM(lyricssize, LYRICSSIZE)
+
+ SETPARM(lyricsalign, LYRICSALIGN)
+
+ SETPARM(sylposition, SYLPOSITION)
+
+ SETPARM(minstsep, MINSTSEP)
+
+ SETPARM(staffpad, STAFFPAD)
+
+ switch (i_p->used[ABOVEORDER]) {
+ case YES:
+ setorder(PL_ABOVE, i_p, f_p);
+ f_p->used[ABOVEORDER] = YES;
+ break;
+ case UNSET:
+ f_p->used[ABOVEORDER] = NO;
+ break;
+ }
+
+ switch (i_p->used[BELOWORDER]) {
+ case YES:
+ setorder(PL_BELOW, i_p, f_p);
+ f_p->used[BELOWORDER] = YES;
+ break;
+ case UNSET:
+ f_p->used[BELOWORDER] = NO;
+ break;
+ }
+
+ switch (i_p->used[BETWEENORDER]) {
+ case YES:
+ setorder(PL_BETWEEN, i_p, f_p);
+ f_p->used[BETWEENORDER] = YES;
+ break;
+ case UNSET:
+ f_p->used[BETWEENORDER] = NO;
+ break;
+ }
+
+ SETPARM(pedstyle, PEDSTYLE)
+
+ SETPARM(chorddist, CHORDDIST)
+
+ SETPARM(dist, DIST)
+
+ SETPARM(dyndist, DYNDIST)
+
+ switch (i_p->used[LABEL]) {
+ case YES:
+ /* if it was already used, free old label */
+ if (f_p->used[LABEL] == YES && f_p->label != 0) {
+ FREE(f_p->label);
+ f_p->label = 0;
+ }
+
+ /* set up new label */
+ MALLOCA(char, f_p->label, strlen(i_p->label) + 1);
+ (void)strcpy(f_p->label, i_p->label);
+
+ f_p->used[LABEL] = YES;
+ break;
+ case UNSET:
+ /* if it was already used, free old label */
+ if (f_p->used[LABEL] == YES && f_p->label != 0) {
+ FREE(f_p->label);
+ f_p->label = 0;
+ }
+ f_p->used[LABEL] = NO;
+ break;
+ }
+
+ switch (i_p->used[LABEL2]) {
+ case YES:
+ /* if it was already used, free old label2 */
+ if (f_p->used[LABEL2] == YES && f_p->label2 != 0) {
+ FREE(f_p->label2);
+ f_p->label2 = 0;
+ }
+
+ /* set up new label */
+ MALLOCA(char, f_p->label2, strlen(i_p->label2) + 1);
+ (void)strcpy(f_p->label2, i_p->label2);
+
+ f_p->used[LABEL2] = YES;
+ break;
+ case UNSET:
+ /* if it was already used, free old label2 */
+ if (f_p->used[LABEL2] == YES && f_p->label2 != 0) {
+ FREE(f_p->label2);
+ f_p->label2 = 0;
+ }
+ f_p->used[LABEL2] = NO;
+ break;
+ }
+
+ /*
+ * ========== ITEMS FOR SCORE, STAFF, AND VOICE CONTEXT ===========
+ */
+ switch (i_p->used[VISIBLE]) {
+ case YES:
+ f_p->visible = i_p->visible;
+ f_p->hidesilent = i_p->hidesilent;
+ f_p->used[VISIBLE] = YES;
+ break;
+ case UNSET:
+ f_p->used[VISIBLE] = NO;
+ }
+
+ switch (i_p->used[BEAMSTLIST]) {
+ case YES:
+ /* if it was already used, free old list if present */
+ if (f_p->used[BEAMSTLIST] == YES && f_p->nbeam != 0) {
+ FREE(f_p->beamstlist);
+ FREE(f_p->subbeamstlist);
+ f_p->beamstlist = 0;
+ f_p->subbeamstlist = 0;
+ }
+
+ /* set up new list */
+ f_p->nbeam = i_p->nbeam;
+ f_p->beamrests = i_p->beamrests;
+ f_p->beamspaces = i_p->beamspaces;
+ f_p->nsubbeam = i_p->nsubbeam;
+ /* the +1 is to guard against allocating 0 */
+ MALLOCA(RATIONAL, f_p->beamstlist, f_p->nbeam + 1);
+ MALLOCA(RATIONAL, f_p->subbeamstlist, f_p->nsubbeam + 1);
+ for (n = 0; n < f_p->nbeam; n++) {
+ f_p->beamstlist[n] = i_p->beamstlist[n];
+ }
+ for (n = 0; n < f_p->nsubbeam; n++) {
+ f_p->subbeamstlist[n] = i_p->subbeamstlist[n];
+ }
+
+ f_p->used[BEAMSTLIST] = YES;
+ break;
+ case UNSET:
+ /* if it was already used, free old list if present */
+ if (f_p->used[BEAMSTLIST] == YES && f_p->nbeam != 0) {
+ FREE(f_p->beamstlist);
+ FREE(f_p->subbeamstlist);
+ f_p->beamstlist = 0;
+ f_p->subbeamstlist = 0;
+ }
+ f_p->used[BEAMSTLIST] = NO;
+ break;
+ }
+
+ switch (i_p->used[BEAMSLOPE]) {
+ case YES:
+ f_p->beamfact = i_p->beamfact;
+ f_p->beammax = i_p->beammax;
+ f_p->used[BEAMSLOPE] = YES;
+ break;
+ case UNSET:
+ f_p->used[BEAMSLOPE] = NO;
+ break;
+ }
+
+ SETPARM(pad, PAD)
+
+ SETPARM(stemlen, STEMLEN)
+
+ SETPARM(stemshorten, STEMSHORTEN)
+
+ SETPARM(defoct, DEFOCT)
+
+ switch (i_p->used[TIMEUNIT]) {
+ case YES:
+ f_p->timeunit = i_p->timeunit;
+ f_p->timelist_p = i_p->timelist_p;
+ f_p->used[TIMEUNIT] = YES;
+ break;
+ case UNSET:
+ f_p->used[TIMEUNIT] = NO;
+ }
+
+ SETPARM(swingunit, SWINGUNIT)
+
+ SETPARM(release, RELEASE)
+
+ SETPARM(ontheline, ONTHELINE)
+
+ SETPARM(tabwhitebox, TABWHITEBOX)
+
+ switch (i_p->used[NOTEHEADS]) {
+ case YES:
+ for (n = 0; n < 7; n++) {
+ f_p->noteheads[n] = i_p->noteheads[n];
+ }
+ f_p->used[NOTEHEADS] = YES;
+ break;
+ case UNSET:
+ f_p->used[NOTEHEADS] = NO;
+ break;
+ }
+}
+\f
+/*
+ * Name: setssvstate()
+ *
+ * Abstract: Set the static SSVs to the state for a given place in the MML.
+ *
+ * Returns: void
+ *
+ * Description: This function, given any structure from the main linked list,
+ * initializes the static SSVs, and then runs through the MLL up
+ * to just before that point, assigning SSVs. It assigns not only
+ * the SSVs in the MLL, but also the timed SSVs hanging off
+ * barlines. You can pass a null pointer, and then it will go
+ * through the whole MLL.
+ */
+
+void
+setssvstate(mainll_p)
+
+struct MAINLL *mainll_p; /* place in the MLL to stop */
+
+{
+ struct MAINLL *mll_p; /* for looping through MLL */
+ struct TIMEDSSV *tssv_p; /* for looping through TIMEDSSV lists*/
+
+
+ initstructs();
+ for (mll_p = Mainllhc_p; mll_p != 0 && mll_p != mainll_p;
+ mll_p = mll_p->next) {
+ switch (mll_p->str) {
+ case S_SSV:
+ /* assign this normal input SSV */
+ asgnssv(mll_p->u.ssv_p);
+ break;
+ case S_BAR:
+ /* assign each timed SSV, if any */
+ for (tssv_p = mll_p->u.bar_p->timedssv_p; tssv_p != 0;
+ tssv_p = tssv_p->next) {
+ asgnssv(&tssv_p->ssv);
+ }
+ break;
+ }
+ }
+}
+\f
+/*
+ * Name: setorder()
+ *
+ * Abstract: Assign an "order" field from an input SSV to a fixed one.
+ *
+ * Returns: void
+ *
+ * Description: This function is called by asgnssv() to assign to the
+ * appropriate part of the markorder array, based on above, below,
+ * or between.
+ */
+
+static void
+setorder(place, i_p, f_p)
+
+int place; /* PL_* */
+struct SSV *i_p; /* input SSV structure to be copied from */
+struct SSV *f_p; /* ptr to fixed SSV structure to copy into */
+
+{
+ int m; /* mark (MK_*) */
+ int stk; /* stacking order */
+
+
+ /*
+ * First assign all the marks' stacking orders as given. Keep track of
+ * the highest stacking order number found.
+ */
+ stk = 0;
+ for (m = 0; m < NUM_MARK; m++) {
+ f_p->markorder[place][m] = i_p->markorder[place][m];
+
+ if (f_p->markorder[place][m] > stk)
+ stk = f_p->markorder[place][m];
+ }
+
+ /*
+ * For every mark type that the user didn't list, the stacking order is
+ * now 0. Set all these to default settings, higher than all the ones
+ * the user listed, but in the same order as Defmarkorder. They will
+ * all be separate numbers, none set equal, unlike Defmarkorder, where
+ * some are equal.
+ */
+ for (m = 0; m < NUM_MARK; m++) {
+ if (f_p->markorder[place][m] == 0) {
+ f_p->markorder[place][m] = ++stk;
+ }
+ }
+}
~mdw / mup / blobdiff