Import upstream version 5.3.

[mup] / mup / mup / roll.c

/* Copyright (c) 1995, 1996, 1997, 1998, 2000, 2002, 2004 by Arkkra Enterprises */
/* All rights reserved */

/* functions to deal with rolls. This includes both parse phase and print
 * phase code for rolls. */

#include "defines.h"
#include "structs.h"
#include "globals.h"



/* each "roll" input statement can have multiple beat offsets to specify
 * more than one roll. This is a linked list struct to hold these offsets */
struct ROLLOFFSET {
	float			offset;	/* beat offset where roll is */
	struct ROLLOFFSET	*next;	/* linked list */
};


/* struct to hold all needed info about a roll input statement */
struct ROLLINFO {
	short	topstaff;	/* roll goes from here */
	short	topvoice;
	short	botstaff;	/* roll ends here */
	short	botvoice;
	short	rolldir;	/* UP, DOWN, or UNKNOWN. UNKNOWN really means
				 * UP but with no arrow drawn (the default) */
	short	error;		/* YES if got bad value for some parameter */
	int	lineno;		/* input line number where defined */
	char 	*inputfile;	/* input file where defined */
	struct ROLLOFFSET *offsets_p;	/* list of beat offsets */
	struct ROLLINFO	*next;	/* linked list */
};

static struct ROLLINFO	*Roll_list_p;	/* rolls defined in current measure */
		/* rolls are linked to the head of this list, so this pointer
		 * will point to the roll currently being defined */


/* static functions declarations */
static void do_a_roll P((struct ROLLINFO *roll_p, struct MAINLL *mll_p));
static void roll P((struct MAINLL * mll_p, struct ROLLINFO *roll_p, 
		struct ROLLOFFSET * offset_p));
static void set_roll P((struct GRPSYL *gs_p, int item,
		struct ROLLINFO *roll_p));
static void draw_roll P((double x, double y1, double y2, int rolldir));

\f

/* allocate struct for info about roll, and add to list */

void
newROLLINFO()

{
	struct ROLLINFO *roll_p;	/* newly allocated roll info */


	MALLOC(ROLLINFO, roll_p, 1);

	roll_p->offsets_p = (struct ROLLOFFSET *) 0;
	/* assume direction will be up, but with no direction arrow */
	roll_p->rolldir = UNKNOWN;
	/* incomplete info so far, so mark as in error */
	roll_p->error = YES;

	/* link onto head of list */
	roll_p->next = Roll_list_p;
	Roll_list_p = roll_p;

	roll_p->lineno = yylineno;
	roll_p->inputfile = Curr_filename;
}
\f

/* alter the roll direction (default is UNKNOWN) */

void
setrolldir(int dir)

{
	Roll_list_p->rolldir = dir;
}
\f

/* set roll parameters. Any parameter that is -1 should be left as is.
 * Others should be error checked, and if okay, filled in */
/* Must be called once to fill in the top staff and voice. At that point,
 * the bottom staff and voice are assummed to be the same as the top.
 * If they aren't, this function should be called again
 * with the bottom parameters set
 * to a non-negative number and the top parameters set to -1 */

void
rollparam(topstaff, topvoice, botstaff, botvoice)

int topstaff;		/* top of roll is here */
int topvoice;
int botstaff;		/* bottom of roll is here */
int botvoice;

{
	/* we now have enough info to check, so assume it's okay, then check */
	Roll_list_p->error = NO;

	/* for each value, if being set, error check and save away if okay.
	 * If no good, set error flag */
	if (topstaff >= 0) {
		if (rangecheck(topstaff, 1, Score.staffs, "staff number")
								== NO) {
			Roll_list_p->error = YES;
		}
		Roll_list_p->topstaff = Roll_list_p->botstaff
							= (short) topstaff;
	}

	if (topvoice >= 0) {
		if (rangecheck(topvoice, MINVOICES, NORMVOICES, "roll voice number")
							== NO) {
			Roll_list_p->error = YES;
		}
		Roll_list_p->topvoice = Roll_list_p->botvoice
							= (short) topvoice;
	}

	if (botstaff >= 0) {
		if (rangecheck(botstaff, 1, Score.staffs, "ending staff number")
							== NO) {
			Roll_list_p->error = YES;
		}
		Roll_list_p->botstaff = (short) botstaff;
	}

	if (botvoice >= 0) {
		if (rangecheck(botvoice, MINVOICES, NORMVOICES,
					"ending voice number") == NO) {
			Roll_list_p->error = YES;
		}
		Roll_list_p->botvoice = (short) botvoice;
	}

	if (Roll_list_p->topstaff > Roll_list_p->botstaff ||
			(Roll_list_p->topstaff == Roll_list_p->botstaff
			&& Roll_list_p->topvoice > Roll_list_p->botvoice)) {
		yyerror("end of roll must be below beginning of roll");
		Roll_list_p->error = YES;
	}
}
\f

/* allocate space for offset information, fill it in, and link onto current
 * roll information struct */

void
rolloffset(offset)

double offset;		/* count offset where roll is to go */

{
	struct ROLLOFFSET *offset_p;	/* where to save offset info */


	/* error check */
	if (offset > Score.timenum + 1) {
		yyerror("roll offset beyond end of measure");
		Roll_list_p->error = YES;
		return;
	}

	/* allocate */
	MALLOC(ROLLOFFSET, offset_p, 1);

	/* fill in */
	offset_p->offset = offset;

	/* link to list */
	offset_p->next = Roll_list_p->offsets_p;
	Roll_list_p->offsets_p = offset_p;
}
\f

/* at end of bar, do each roll. For each roll, find closest group of
 * top and bottom voice of roll. If they aren't at precisely the same
 * fulltime into the measure, error. Otherwise, mark these groups STARTITEM and
 * ENDITEM for roll, unless they are the same, in which case LONEITEM.
 * Also find any intervening groups that are also at the same fulltime.
 * Mark them INITEM. Finally, free the roll information. */

void
do_rolls(mll_p)

struct MAINLL *mll_p;	/* MAINLL of BAR */

{
	debug(4, "do_rolls lineno=%d", mll_p->inputlineno);

	do_a_roll(Roll_list_p, mll_p);
	Roll_list_p = (struct ROLLINFO *) 0;
}
\f

/* recursively go down list of rolls, and mark the relevant GRPSYLs */

static void
do_a_roll(roll_p, mll_p)

struct ROLLINFO *roll_p;	/* current roll */
struct MAINLL *mll_p;		/* look from here to find appropriate staff */

{
	if (roll_p == (struct ROLLINFO *) 0) {
		/* end recursion */
		return;
	}

	/* recurse */
	do_a_roll(roll_p->next, mll_p);

	/* if error in early checking, ignore this one */
	if (roll_p->error == NO) {
	
		/* find the relevant STAFF */
		for (   ; mll_p != (struct MAINLL *) 0; mll_p = mll_p->prev) {
			if (mll_p->str == S_STAFF) {
				if (mll_p->u.staff_p->staffno ==
							roll_p->topstaff) {
					break;
				}
			}
		}

		if (mll_p == (struct MAINLL *) 0) {
			pfatal("couldn't find staff information for roll");
		}

		/* mark the GRPSYLs */
		roll(mll_p, roll_p, roll_p->offsets_p);
	}

	/* this one has been handled */
	FREE(roll_p);
}
\f

/* for a specific roll on a specific chord, fill in the roll parameters for
 * all affected, visible groups */

static void
roll(mll_p, roll_p, offset_p)

struct MAINLL *mll_p;		/* STAFF of top of roll */
struct ROLLINFO *roll_p;	/* info about the roll */
struct ROLLOFFSET *offset_p;	/* count offset at which to place roll */

{
	RATIONAL timeoffset;	/* time into measure of group getting rolled */
	RATIONAL time1offset;	/* timeoffset of group in top voice of roll */
	struct GRPSYL *gs_p;
	struct GRPSYL *roll_grp_p;	/* group having roll */
	struct GRPSYL *lastvisgrp_p;	/* most recent grp with roll that is
					 * on a visible staff */
	int rollstate;			/* STARTITEM, etc */
	int staffno;
	int voice;
	double top_staffscale;	/* staffscale of staff at top of roll */


	/* recurse */
	if (offset_p == (struct ROLLOFFSET *) 0) {
		return;
	}
	roll(mll_p, roll_p, offset_p->next);


	/* find relevant group */
	gs_p = mll_p->u.staff_p->groups_p [ roll_p->topvoice - 1 ];
	roll_grp_p = closestgroup(offset_p->offset, gs_p, Score.timeden);

	if (roll_grp_p->roll != NOITEM) {
		l_yyerror(roll_p->inputfile, roll_p->lineno,
					"overlapping rolls not allowed");
		FREE(offset_p);
		return;
	}

	/* a lot of the time, the top and bottom staff/voice of roll will
	 * be the same, meaning we have a LONEITEM. This is the easy case
	 * so handle that. */
	if (roll_p->topstaff == roll_p->botstaff
				&& roll_p->topvoice == roll_p->botvoice) {
		if (svpath(roll_p->topstaff, VISIBLE)->visible == YES) {
			set_roll(roll_grp_p, LONEITEM, roll_p);
		}
		FREE(offset_p);
		return;
	}

	/* we must have a roll that encompasses more than one voice */
	lastvisgrp_p = (struct GRPSYL *) 0;

	/* find group's actual RATIONAL time offset into the measure */
	for (time1offset = Zero; gs_p != roll_grp_p; gs_p = gs_p->next) {
		time1offset = radd(time1offset, gs_p->fulltime);
	}

	/* if the top voice is visible, mark it as the top of the roll.
	 * If not, make a note that we don't have a real top yet */
	if (svpath(roll_p->topstaff, VISIBLE)->visible == YES) {
		if (is_tab_staff(roll_grp_p->staffno) == YES) {
			l_yyerror(roll_p->inputfile, roll_p->lineno,
				"roll spanning multiple voices cannot include tab staff");
			return;
		}
		set_roll(roll_grp_p, STARTITEM, roll_p);
		rollstate = INITEM;
		lastvisgrp_p = roll_grp_p;
	}
	else {
		rollstate = STARTITEM;
	}

	staffno = roll_p->topstaff;
	voice = roll_p->topvoice;
	top_staffscale = svpath(staffno, STAFFSCALE)->staffscale;

	/* find all groups down to ending of roll */
	for ( ; ; ) {

		/* move to next voice, which may be on next staff */
		if (++voice > MAXVOICES) {
			++staffno;
			voice = 1;
			mll_p = mll_p->next;
			if (mll_p->str != S_STAFF ||
					mll_p->u.staff_p->staffno != staffno) {
				pfatal("main list messed up while doing rolls");
			}
		}

		/* if no more voices on staff, no reason to check more */
		if (voice > vscheme_voices(svpath(staffno, VSCHEME)->vscheme))  {
			continue;
		}

		/* find relevant group */
		gs_p = mll_p->u.staff_p->groups_p[ voice - 1];
		roll_grp_p = closestgroup(offset_p->offset, gs_p, Score.timeden);

		if (is_tab_staff(roll_grp_p->staffno) == YES) {
			l_yyerror(roll_p->inputfile, roll_p->lineno,
				"roll spanning multiple voices cannot include tab staff");
			return;
		}

		if (svpath(roll_grp_p->staffno, STAFFSCALE)->staffscale !=
							top_staffscale) {
			l_yyerror(roll_p->inputfile, roll_p->lineno,
				"roll cannot span staffs with differing staffscale values");
			return;
		}

		if (roll_grp_p == (struct GRPSYL *) 0) {
			l_yyerror(roll_p->inputfile, roll_p->lineno,
					"no chord associated with roll");
			return;
		}

		/* find group's actual RATIONAL time offset into the measure */
		for (timeoffset = Zero; gs_p != roll_grp_p; gs_p = gs_p->next) {
			timeoffset = radd(timeoffset, gs_p->fulltime);
		}

		/* if this group's RATIONAL time isn't the same as
		 * the top group's, it doesn't get included in the roll */
		if (EQ(timeoffset, time1offset)) {
			/* need roll on this group */
			if (roll_grp_p->grpcont == GC_NOTES) {
				set_roll(roll_grp_p, rollstate, roll_p);
				rollstate = INITEM;
				if (svpath(staffno, VISIBLE)->visible == YES) {
					lastvisgrp_p = roll_grp_p;
				}
			}
		}

		/* check if at bottom of roll */
		if (staffno == roll_p->botstaff && voice == roll_p->botvoice) {
			if (NE(timeoffset, time1offset)) {
				l_yyerror(roll_p->inputfile, roll_p->lineno,
					"groups on top and bottom of roll are in different chords");
			}
			else if (svpath(staffno, VISIBLE)->visible == NO) {
				/* bottom staff of roll is invisible */
				if (lastvisgrp_p == (struct GRPSYL *) 0) {
					/* no visible staffs in roll */
					break;
				}

				/* change last visible staff included in the
				 * roll, to be the end of the roll, or
				 * set to LONEITEM if only visible */
				if (lastvisgrp_p->roll == STARTITEM) {
					lastvisgrp_p->roll = LONEITEM;
				}
				else {
					lastvisgrp_p->roll = ENDITEM;
				}
			}

			else if (lastvisgrp_p->roll == STARTITEM) {
				/* all but the last were invisible */
				roll_grp_p->roll = LONEITEM;
			}
			else {
				roll_grp_p->roll = ENDITEM;
			}
			break;
		}
	}

	/* this one has been handled */
	FREE(offset_p);
}
\f

/* do final checking and actually fill in roll parameters in grpsyl */

static void
set_roll(gs_p, item, roll_p)

struct GRPSYL *gs_p;		/* which GRPSYL to mark */
int item;			/* LONEITEM, STARTITEM, etc */
struct ROLLINFO *roll_p;	/* info about roll associated with group */

{
	if (gs_p->grpcont != GC_NOTES) {
		switch (item) {
		case STARTITEM:
			l_yyerror(roll_p->inputfile, roll_p->lineno,
				"top visible chord of roll must not be rest or space");
			return;
		case ENDITEM:
			l_yyerror(roll_p->inputfile, roll_p->lineno,
				"bottom visible chord of roll must not be rest or space");
			return;
		case LONEITEM:
			l_yyerror(roll_p->inputfile, roll_p->lineno,
				"rolled chord must not be rest or space");
			return;
		}
	}

	/* fill in values */
	gs_p->roll = (short) item;
	gs_p->rolldir = roll_p->rolldir;
}
\f

/* print a roll */

void
print_roll(gs_p)

struct GRPSYL *gs_p;	/* GRPSYL that might have a roll on it */

{
	struct GRPSYL *botgs_p;		/* bottom group of roll */
	struct GRPSYL *prevgs_p;	/* chord above current chord */
	float north;
	float south;
	float westmost;			/* if voices overlap, the west of
					 * different groups in the chord may
					 * be different, so have to find
					 * whichever is farther west */

	switch (gs_p->roll) {

	case  LONEITEM:
		draw_roll(gs_p->c[AW] + ROLLPADDING * Staffscale / 2.0,
				gs_p->notelist[0].c[AN],
				gs_p->notelist[ gs_p->nnotes - 1].c[AS],
				gs_p->rolldir);
		return;

	case STARTITEM:
		/* normally, the north of the roll is the north of the top
		 * group. However, there is one special case. If the roll
		 * starts on voice 1 and goes through voice 2 on that staff,
		 * and the top note on voice 2 is higher than the top note
		 * on voice 1, need to start roll at the top note of voice 2 */
		north = gs_p->notelist[0].c[AN];
		if (gs_p->vno == 1 && gs_p->gs_p != (struct GRPSYL *) 0 &&
					gs_p->gs_p->staffno == gs_p->staffno &&
					gs_p->gs_p->grpsyl == GS_GROUP &&
					gs_p->gs_p->grpcont == GC_NOTES) {
			if (gs_p->gs_p->notelist[0].c[AN] >
						gs_p->notelist[0].c[AN]) {
				north = gs_p->gs_p->notelist[0].c[AN];
			}
		}
		
		westmost = gs_p->c[AW];

		/* find the bottom group of the roll */
		prevgs_p = gs_p;
		for (botgs_p = gs_p->gs_p; botgs_p != (struct GRPSYL *) 0;
						botgs_p = botgs_p->gs_p) {

			if (botgs_p->grpsyl != GS_SYLLABLE &&
						botgs_p->c[AW] < westmost) {
				westmost = botgs_p->c[AW];
			}

			if (botgs_p->roll == ENDITEM) {

				/* normally, the end of the roll is the bottom
				 * note of the ending group. However, there is
				 * one special case. If the roll ends on voice
				 * 2, and the bottom note of voice 1 is lower
				 * than the bottom note of voice 1, the south
				 * of the roll is the bottom of voice 1 */
				south = botgs_p->notelist
						[ botgs_p->nnotes - 1].c[AS];

				if (botgs_p->vno == 2 && prevgs_p->staffno
						== botgs_p->staffno &&
						prevgs_p->grpsyl == GS_GROUP) {

					if (prevgs_p->nnotes > 0 &&
							prevgs_p->notelist[prevgs_p->nnotes-1].c[AS]
							< botgs_p->notelist
							[botgs_p->nnotes - 1]
							.c[AS]) {

						south = prevgs_p->notelist
							[prevgs_p->nnotes - 1]
							.c[AS];
					}
				}

				draw_roll(westmost +
					ROLLPADDING * Staffscale / 2.0,
					north, south, gs_p->rolldir);
				return;
			}
			prevgs_p = botgs_p;
		}
		pfatal("failed to find end of multi-voice roll");
		break;

	default:
		/* nothing to do */
		break;
	}
}
\f

/* Actually draw a roll at the given x from y1 to y2. If rolldir is DOWN,
 * draw an arrow at the bottom; if it is UP draw an arrow at the top;
 * if UNKNOWN don't draw any arrow. */

static void
draw_roll(x, y1, y2, rolldir)

double x;		/* horizontal location of roll */
double y1;		/* vertical location */
double y2;
int rolldir;		/* UP, DOWN, or UNKNOWN (i.e., UP but no arrow) */

{
	/* draw the roll itself */
	draw_wavy(x, y1, x, y2);

	/* If arrow was requested, draw it */
	if (rolldir != UNKNOWN) {
		float len;

		/* draw arrow at bottom */
		len = ROLLPADDING * Staffscale / 2.0 - Stdpad;
		do_linetype(L_NORMAL);
		if (rolldir == DOWN) {
			draw_line(x, y2 - Stepsize, x - (0.8 * len), y2 + len);
			draw_line(x, y2 - Stepsize, x + (0.8 * len), y2 + len);
		}
		else {
			draw_line(x, y1 + Stepsize, x - (0.8 * len), y1 - len);
			draw_line(x, y1 + Stepsize, x + (0.8 * len), y1 - len);
		}
	}
}
\f

/* return YES if given group is the top group that gets a roll drawn by it,
 * NO if not. This is called from the print phase */

int
gets_roll(gs_p, staff_p, v)

struct GRPSYL *gs_p;		/* check if this group gets a roll */
struct STAFF *staff_p;	/* it's connected to this staff */
int v;			/* and is in this voice */

{
	float width1, width2;		/* widest note heads in each group */
	float maxwide;			/* widest notehead */
	struct GRPSYL *othergs_p;	/* group in other voice */


	if (gs_p->roll != STARTITEM && gs_p->roll != LONEITEM) {
		return(NO);
	}

	/* check for strange case where we don't print a roll because groups
	 * are incompatible (had to be moved horizontally because they
	 * overlapped), and both have rolls. If the group's RX is greater
	 * than (maxwide - W_NORMAL * POINT) / 2 where
	 * maxwide is the maximum of width of the note head characters
	 * the two groups, then don't print the roll. */
	if (svpath(staff_p->staffno, VSCHEME)->vscheme == V_1) {
		/* strange case only happens with 2 voices */
		return(YES);
	}
	else {
		/* find width of widest note of this group */
		width1 = widest_head(gs_p) * Staffscale;

		/* find other group. If this is first voice,
		 * just look down the chord link */
		if (v == 0) {
			othergs_p = gs_p->gs_p;
		}
		else {
			/* follow groups until we find the one linked to this
			 * one */
			for (othergs_p = staff_p->groups_p[0];
					othergs_p != (struct GRPSYL *) 0;
					othergs_p = othergs_p->next) {
				if (othergs_p->gs_p == gs_p) {
					break;
				}
			}
		}

		if (othergs_p != (struct GRPSYL *) 0 &&
				othergs_p->grpcont == GC_NOTES) {

			/* find width of widest note of the other group */
			width2 = widest_head(othergs_p) * Staffscale;

			maxwide = MAX(width1, width2);

			if (gs_p->c[RX] > ((maxwide - W_NORMAL * POINT) / 2.0)){
				/* we hit the strange case */
				return(NO);
			}
		}
	}
	return(YES);
}