Merge branch 'arkkra' into shiny

[mup] / mup / mup / setgrps.c

/* Copyright (c) 1995, 1997, 1998, 1999, 2000, 2001, 2004, 2005, 2006
 * by Arkkra Enterprises */
/* All rights reserved */
/*
 * Name:	setgrps.c
 *
 * Description:	This file contains functions for setting the relative
 *		horizontal coordinates of all groups that contain notes
 *		(grpcont == GC_NOTES) and of all objects in these groups.
 *		It also sets relative vertical coordinates for the dots
 *		after notes.
 */

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

struct NOTEPTRS {
	struct NOTE *top_p;	/* point at a note in top group */
	struct NOTE *bot_p;	/* point at same note in bottom group*/
	float wid;		/* width of the note head */
};

static struct GRPSYL *procallvoices P((struct MAINLL *mll_p,
		struct GRPSYL *gs_p));
static void proc1or2voices P((struct MAINLL *mll_p, struct STAFF *staff_p,
		struct GRPSYL *gs1_p, struct GRPSYL *gs2_p));
static int compat P((struct NOTEPTRS noteptrs[], struct GRPSYL *gs1_p,
		struct GRPSYL *gs2_p));
static int can_overlap P((struct GRPSYL *gs1_p, struct GRPSYL *gs2_p));
static void procsome P((struct NOTEPTRS noteptrs[], struct MAINLL *mll_p,
		struct STAFF *staff_p, struct GRPSYL *gs1_p,
		struct GRPSYL *gs2_p));
static void procgrace P((struct NOTEPTRS noteptrs[], struct MAINLL *mll_p,
		struct STAFF *staff_p, struct GRPSYL *gsnorm_p));
static void procbunch P((struct NOTEPTRS noteptrs[], struct MAINLL *mll_p,
		struct STAFF *staff_p, struct GRPSYL *gs1_p,
		struct GRPSYL *gs2_p));
static void doacc P((struct NOTEPTRS noteptrs[], double halfwide,
		double halfhigh, int collinear));
static int nextacc P((struct NOTEPTRS noteptrs[], int found));
static void dodot P((struct STAFF *staff_p, struct GRPSYL *gs1_p,
		struct GRPSYL *gs2_p, double halfwide, int collinear));
static void dogrpdot P((struct STAFF *staff_p, struct GRPSYL *gs_p,
		struct GRPSYL *ogs_p, double halfwide, int uppermost,
		int lowermost, int push));
static void westwith P((struct GRPSYL *gs_p));
static void eastwith P((struct GRPSYL *gs_p));
static void csbstempad P((struct MAINLL *mll_p, struct GRPSYL *gs_p));
static void proctab P((struct MAINLL *mll_p, struct STAFF *staff_p,
		struct GRPSYL *gs1_p));
static void noterparen P((struct NOTEPTRS noteptrs[], struct GRPSYL *gs1_p,
		struct GRPSYL *gs2_p, double halfwide, double halfhigh,
		int collinear));
\f
/*
 * Name:        setgrps()
 *
 * Abstract:	Find first group on each staff & call procallvoices to process.
 *
 * Returns:     void
 *
 * Description: This function goes through the chord lists, and for each chord,
 *		the list of GRPSYLs hanging off it.  It finds the first group
 *		on each staff, and calls procallvoices() to set the relative
 *		horizontal coordinates of all the note groups on that staff.
 */

void
setgrps()

{
	struct CHORD *ch_p;		/* point at a chord */
	struct GRPSYL *gs1_p;		/* point at a group */
	struct MAINLL *mainll_p;	/* point at items in main linked list*/
	struct MAINLL *mstaff_p;	/* for looking for staff */


	debug(16, "setgrps");
	initstructs();		/* clean out old SSV info */

	/*
	 * Loop down the main linked list looking for each chord list
	 * headcell.
	 */
	for (mainll_p = Mainllhc_p; mainll_p != 0; mainll_p = mainll_p->next) {

		/* keep SSVs up to date */
		if (mainll_p->str == S_SSV)
			asgnssv(mainll_p->u.ssv_p);

		if (mainll_p->str != S_CHHEAD)
			continue;	/* skip everything but chord HC */

		/*
		 * Loop through each chord in this list.
		 */
		for (ch_p = mainll_p->u.chhead_p->ch_p; ch_p != 0;
					ch_p = ch_p->ch_p) {
			/*
			 * Loop through the linked list of GRPSYLs hanging off
			 * this chord.  Skip the syllables; just deal with the
			 * groups.  Upon finding the first group on a staff
			 * (which could be for any of the voices, since not all
			 * might be present in this chord), call procallvoices
			 * to process all the note groups.
			 */
			gs1_p = ch_p->gs_p;
			for (;;) {
				/* find first group on a staff */
				while (gs1_p != 0 &&
						gs1_p->grpsyl == GS_SYLLABLE)
					gs1_p = gs1_p->gs_p;
				if (gs1_p == 0)
					break;

				/* find the staff's MLL structure */
				mstaff_p = chmgrp2staffm(mainll_p, gs1_p);

				/* set gs1_p to after this staff's groups */
				gs1_p = procallvoices(mstaff_p, gs1_p);
			}
		}
	}
}
\f
/*
 * Name:        procallvoices()
 *
 * Abstract:    Process the groups for all the voices on one staff in a chord.
 *
 * Returns:     pointer to the first GRPSYL after these groups, 0 if none
 *
 * Description: This function is given the GRPSYL for the first (topmost) voice
 *		that is on this staff in this chord.  It finds what other
 *		GRPSYLs exist.  For each of them that is for notes (not rests
 *		or spaces), it calls proc1or2voices() to process them together
 *		and/or separately, as needed.  This file generally deals only
 *		with notes, not rests or spaces.  But this function also deals
 *		with rests to the following extent:  For both notes and rests,
 *		there are situations where voice 3 should "stand in" for voice 1
 *		or voice 2.  This function makes those decisions, and sets pvno.
 */

static struct GRPSYL *
procallvoices(mll_p, gs_p)

struct MAINLL *mll_p;		/* the MLL item the group is connected to */
struct GRPSYL *gs_p;		/* point at first voice on this staff */

{
	struct STAFF *staff_p;		/* point at staff */
	struct GRPSYL *g_p[MAXVOICES];	/* point at note groups */
	struct GRPSYL *last_p;		/* point at last note group */
	struct GRPSYL *g2_p[MAXVOICES];	/* point at note and rest groups */
	struct GRPSYL *gs1_p;		/* remember first group */
	struct GRPSYL *gs2_p;		/* another GRPSYL pointer */
	int numnonspace;		/* number of nonspace GRPSYLs */
	int numgrps;			/* how many note groups are here */
	int n;				/* loop variable, voices processed */


	staff_p = mll_p->u.staff_p;
	numgrps = 0;			/* no groups found yet */
	last_p = 0;			/* no note groups yet */
	gs1_p = gs_p;			/* remember first group */

	/* find all groups in this chord on this staff; remember note groups */
	while (gs_p != 0 && gs_p->staffno == staff_p->staffno &&
			    gs_p->grpsyl == GS_GROUP) {
		gs_p->pvno = gs_p->vno;	/* init pseudo voice no. to voice no.*/
		if (gs_p->grpcont == GC_NOTES) {
			g_p[numgrps++] = gs_p;
			last_p = gs_p;
		}
		gs_p = gs_p->gs_p;
	}

	/*
	 * Before continuing on to process note groups, change voice 3's pvno
	 * when appropriate.  First find all nonspace groups.
	 */
	numnonspace = 0;		/* no nonspace groups found yet */
	gs2_p = gs1_p;

	/* find all nonspace groups in this chord on this staff */
	while (gs2_p != 0 && gs2_p->staffno == staff_p->staffno &&
			    gs2_p->grpsyl == GS_GROUP) {
		if (gs2_p->grpcont != GC_SPACE) {
			g2_p[numnonspace++] = gs2_p;
		} else {
			/*
			 * This is a convenient, though somewhat inappropriate,
			 * place to process grace groups that precede a space
			 * group.  Ones that precede notes groups will be
			 * processed in the normal flow, called from procsome.
			 * They are not allowed before rest groups.
			 */
			struct NOTEPTRS noteptrs[MAXHAND + 1];
			procgrace(noteptrs, mll_p, staff_p, gs2_p);
		}
		gs2_p = gs2_p->gs_p;
	}

	/*
	 * If the only nonspace voices are 1 and 3, or 2 and 3, and at least
	 * one of them is a rest and this is not a tab staff and "ho" was not
	 * used for either . . .
	 */
	if (numnonspace == 2 && g2_p[1]->vno == 3 &&
	   (g2_p[0]->grpcont == GC_REST || g2_p[1]->grpcont == GC_REST) &&
	   ! is_tab_staff(staff_p->staffno) && g2_p[0]->ho_usage == HO_NONE &&
	   g2_p[1]->ho_usage == HO_NONE) {
		/*
		 * If v1 is either a rest or stem-up notes and v3 is a rest or
		 * stem-down notes, let v3 stand in for v2.
		 */
		if (g2_p[0]->vno == 1 && (g2_p[0]->grpcont == GC_NOTES &&
		    g2_p[0]->stemdir == UP || g2_p[0]->grpcont == GC_REST) &&
		    (g2_p[1]->grpcont == GC_NOTES && g2_p[1]->stemdir == DOWN ||
		    g2_p[1]->grpcont == GC_REST)) {
			g2_p[1]->pvno = 2;
		}
		/*
		 * If v2 is either a rest or stem-down notes and v3 is a rest or
		 * stem-up notes, let v3 stand in for v1.
		 */
		if (g2_p[0]->vno == 2 && (g2_p[0]->grpcont == GC_NOTES &&
		    g2_p[0]->stemdir == DOWN || g2_p[0]->grpcont == GC_REST) &&
		    (g2_p[1]->grpcont == GC_NOTES && g2_p[1]->stemdir == UP ||
		    g2_p[1]->grpcont == GC_REST)) {
			g2_p[1]->pvno = 1;
		}
	}

	/* if there were no note groups on this staff, nothing more to do */
	if (numgrps == 0)
		return (gs_p);

	n = 0;		/* number of voices processed so far */

	/*
	 * If voices 1 and 2 exist and are notes and do not have user specified
	 * horizontal offsets and this is not a tab staff, handle them together.
	 * If both voices 1 and 2 have a group here, they will be the first two
	 * found.  Tab staffs should be handled separately because their voices
	 * never conflict with each other (because of chktabcollision() in
	 * in setnotes.c).  Before checking the offsets, verify that they are
	 * legal and fix if not.
	 */
	if (numgrps >= 2 && g_p[0]->vno == 1 && g_p[1]->vno == 2 &&
			! is_tab_staff(staff_p->staffno)) {

		vfyoffset(g_p);		/* verify and fix */

		if (g_p[0]->ho_usage == HO_NONE && g_p[1]->ho_usage == HO_NONE){
			proc1or2voices(mll_p, staff_p, g_p[0], g_p[1]);
			n = 2;		/* processed 2 voices */
		}
	}

	/*
	 * Else, if v1 and v3, or v2 and v3, are notes, and only those two
	 * exist, and they do not have user specified horizontal offsets and
	 * this is not a tab staff, and v3's stem dir is compatible, let v3
	 * "stand in" for v1 or v2, as the case may be.  Handle the two voices
	 * together.
	 */
	else if (numgrps == 2 && numnonspace == 2 &&
			! is_tab_staff(staff_p->staffno) && g_p[0]->ho_usage ==
			HO_NONE && g_p[1]->ho_usage == HO_NONE) {

		if (g_p[0]->vno == 1 && g_p[0]->stemdir == UP &&
		    g_p[1]->vno == 3 && g_p[1]->stemdir == DOWN) {

			g_p[1]->pvno = 2;
			proc1or2voices(mll_p, staff_p, g_p[0], g_p[1]);
			n = 2;		/* processed 2 voices */

		} else if (g_p[0]->vno == 2 && g_p[0]->stemdir == DOWN &&
			   g_p[1]->vno == 3 && g_p[1]->stemdir == UP) {

			g_p[1]->pvno = 1;
			proc1or2voices(mll_p, staff_p, g_p[1], g_p[0]);
			n = 2;		/* processed 2 voices */
		}
	}

	/* process any remaining voices individually */
	for ( ; n < numgrps; n++) {
		proc1or2voices(mll_p, staff_p, g_p[n], (struct GRPSYL *)0);
	}

	/* return the first GRPSYL after the groups we processed */
	return (gs_p);
}
\f
/*
 * Name:        proc1or2voices()
 *
 * Abstract:    Process a single voice, or voices 1 and 2 together.
 *
 * Returns:     void
 *
 * Description: This function is given pointers to one or two groups on a
 *		staff.  If it's just one (the second one is a null pointer),
 *		that group is to be handled alone.  If it is two, they are
 *		voices 1 and 2, since voice 3 is always handled separately.
 *		(Except that voice 3 can sometimes "stand in" for v1 or v2.)
 *		In any case, these are always note groups, not rest or space.
 *
 *		The function sets up an array (noteptrs) to point at each
 *		note in the group(s), figuring out whether the groups overlap
 *		and, if so, if they are compatible (see below for definition).
 *		It calls procsome() to set relative horizontal coordinates for
 *		some notes, which is done either separately for each group or
 *		both at once, depending on the situation.
 */

static void
proc1or2voices(mll_p, staff_p, gs1_p, gs2_p)

struct MAINLL *mll_p;		/* the MLL item the group is connected to */
struct STAFF *staff_p;			/* the staff the groups are on */
register struct GRPSYL *gs1_p, *gs2_p;	/* point at groups in this hand */

{
	/*
	 * Each structure in this array points at a note.  Notes from gs1_p
	 * are pointed at by top_p, and, when both groups exist, notes
	 * from gs2_p are pointed at by bot_p.  If there's no overlap
	 * between the groups, there won't be any here either.  But if
	 * the groups "share" notes, the shared notes will be pointed
	 * at by both.  If the groups are "incompatible" (must be
	 * drawn shifted horizontally to avoid interference), they will
	 * be done separately and use this array separately, one at a time.
	 * And in that case, notes from both gs1_p and gs2_p will use top_p,
	 * in turn.
	 */
	struct NOTEPTRS noteptrs[MAXHAND + 1];

	float offset;		/* how far to offset incompatible groups */
	int num1;		/* number of notes in top group */
	int n;			/* loop variable */
	int incompat;		/* are groups incompatible (special case) */


	/*
	 * For mrpt, we have nothing to do except set the horizontal group
	 * coordinates.  If the first group is a measure repeat, so is the
	 * second one, if it exists at all.  We set a very small width, as a
	 * placeholder, because if other staffs have normal notes, we don't
	 * want the first chord to be abnormally wide because of the mrpt
	 * symbol.  (It will be centered in the measure.)  If all the staffs
	 * have mrpt, abshorz.c will ensure that enough space is left for
	 * these symbols.
	 */
	if (is_mrpt(gs1_p)) {
		gs1_p->c[RX] = 0;
		gs1_p->c[RE] = TEMPMRPTWIDTH / 2.0;
		gs1_p->c[RW] = -TEMPMRPTWIDTH / 2.0;

		if (gs2_p != 0) {
			gs2_p->c[RX] = 0;
			gs2_p->c[RE] = TEMPMRPTWIDTH / 2.0;
			gs2_p->c[RW] = -TEMPMRPTWIDTH / 2.0;
		}
		return;
	}

	/* clear out the array */
	for (n = 0; n < NUMELEM(noteptrs); n++) {
		noteptrs[n].top_p = 0;
		noteptrs[n].bot_p = 0;
		noteptrs[n].wid = 0.0;
	}

	num1 = gs1_p->nnotes;

	/* set all the "top" group pointers */
	for (n = 0; n < num1; n++)
		noteptrs[n].top_p = &gs1_p->notelist[n];

	/* if there is no "bottom" group, process the first bunch and quit */
	if (gs2_p == 0) {
		procsome(noteptrs, mll_p, staff_p, gs1_p, (struct GRPSYL *)0);

		/* if group is rolled, allow room for the roll */
		if (gs1_p->roll != NOITEM)
			gs1_p->c[RW] -= ROLLPADDING;
		return;
	}

	/*
	 * If the lowest note of the top group is higher than the highest
	 * note of the bottom group, point at all the bottom notes,
	 * process both, and quit.  Exception:  if the inner notes of the
	 * two groups are on neighboring steps, and the top note of the
	 * bottom group is on a line and has a dot, and the top group has
	 * no dots, the groups are to be regarded as if overlapping and
	 * incompatible.  This is because there is no decent way to place
	 * the dots in this case otherwise.  But if, in this neighboring note
	 * situation, there are no problems with dots, the groups can still be
	 * handled together here; their stems will be made collinear.  When
	 * the notes are two or more steps apart, there's no problem at all,
	 * and the groups' X coordinates will line up and equal the chord's.
	 * Another exception ("else if") is that when the stem of either group
	 * has been forced the "wrong way" by the user, we require more
	 * vertical space between the groups.  Since we don't know the stem
	 * lengths yet, we can't do the full job, though.  The user may have to
	 * use "len" or "ho" to avoid a collision.
	 */
	incompat = NO;
	if (noteptrs[num1-1].top_p->stepsup > gs2_p->notelist[0].stepsup) {
		if (noteptrs[num1-1].top_p->stepsup ==
				gs2_p->notelist[0].stepsup + 1 &&
				gs2_p->notelist[0].stepsup % 2 == 0 &&
				gs2_p->dots == 0 &&
				gs1_p->dots > 0) {
			incompat = YES;
		} else if ((gs1_p->stemdir == DOWN || gs2_p->stemdir == UP) &&
				noteptrs[num1-1].top_p->stepsup <
				gs2_p->notelist[0].stepsup + 3) {
			incompat = YES;
		} else {
			for (n = 0; n < gs2_p->nnotes; n++)
				noteptrs[num1+n].bot_p = &gs2_p->notelist[n];
			procsome(noteptrs, mll_p, staff_p, gs1_p, gs2_p);

			/* if a group is rolled, allow room for the roll */
			if (gs1_p->roll != NOITEM)
				gs1_p->c[RW] -= ROLLPADDING;
			if (gs2_p->roll != NOITEM)
				gs2_p->c[RW] -= ROLLPADDING;
			return;
		}
	}

	/*
	 * There is overlap between the two groups.  See if they are
	 * compatible (also fills in group 2 in noteptrs).  If so,
	 * process the groups together, and return.
	 */
	if (incompat == NO && compat(noteptrs, gs1_p, gs2_p) == YES) {
		procsome(noteptrs, mll_p, staff_p, gs1_p, gs2_p);

		/* if a group is rolled, allow room for the roll */
		if (gs1_p->roll != NOITEM)
			gs1_p->c[RW] -= ROLLPADDING;
		if (gs2_p->roll != NOITEM)
			gs2_p->c[RW] -= ROLLPADDING;
		return;
	}

	/*
	 * The fact that we are here means the two groups are not compatible,
	 * meaning they overlap but can't share note heads.  Clear the array
	 * of any notes from the second group, in case compat() put some there.
	 */
	for (n = 0; n < NUMELEM(noteptrs); n++)
		noteptrs[n].bot_p = 0;

	/*
	 * It is possible that the groups can at least be given collinear
	 * stems.  For this to be allowed, it must be that the bottom note of
	 * the top group is on the same step as the top note of the bottom
	 * group.  The top group's note can't have dots, the bottom group's
	 * can't have accidentals or a roll, and neither can have parentheses,
	 * because they couldn't be drawn decently.  Neither note can have
	 * another note on a neighboring step.
	 */
	if (noteptrs[num1-1].top_p->stepsup == gs2_p->notelist[0].stepsup &&

			gs1_p->dots == 0 &&

			gs2_p->notelist[0].accidental == '\0' &&

			gs2_p->roll == NOITEM &&

			noteptrs[num1-1].top_p->note_has_paren == NO &&
			gs2_p->notelist[0].note_has_paren == NO &&

			(num1 == 1 || noteptrs[num1-2].top_p->stepsup
				> noteptrs[num1-1].top_p->stepsup + 1) &&

			(gs2_p->nnotes == 1 || gs2_p->notelist[0].stepsup
				> gs2_p->notelist[1].stepsup + 1) ) {
		/*
		 * Since we are not sharing noteheads, the notes of the bottom
		 * group must be put after the notes of the top group in the
		 * noteptrs table.  Then process them together.
		 */
		for (n = 0; n < gs2_p->nnotes; n++)
			noteptrs[num1+n].bot_p = &gs2_p->notelist[n];
		procsome(noteptrs, mll_p, staff_p, gs1_p, gs2_p);

		/* if top group is rolled, allow room for the roll */
		if (gs1_p->roll != NOITEM)
			gs1_p->c[RW] -= ROLLPADDING;
		return;
	}

	/*
	 * At this point we know we have to handle the groups separately, and
	 * then place them.  Process the top group now.
	 */
	procsome(noteptrs, mll_p, staff_p, gs1_p, (struct GRPSYL *)0);

	/*
	 * Clear the top group out of the array, and fill it with just the
	 * bottom group, to process them.  But mark them as if "top", to
	 * simplify procsome().
	 */
	for (n = 0; n < NUMELEM(noteptrs); n++)
		noteptrs[n].top_p = 0;

	/* set all the "top" group pointers even though this is group 2 */
	for (n = 0; n < gs2_p->nnotes; n++)
		noteptrs[n].top_p = &gs2_p->notelist[n];

	procsome(noteptrs, mll_p, staff_p, gs2_p, (struct GRPSYL *)0);

	/*
	 * Now that we've figured out all the relative horizontal coords for
	 * the two groups (and everything in them) separately, we need to
	 * decide how to offset them so they don't overlap.  We'll offset
	 * each the same distance, one right and one left, and apply that
	 * offset to every horizontal coord of the groups.
	 */
	/*
	 * If the groups can be placed so that their rectangles overlap, do it.
	 * Else if one of the groups is to be rolled and the other is not, the
	 * one to be rolled must be put on the left.  Otherwise, find which
	 * direction gives minimal offset, but bias the results (0.1) to favor
	 * putting the top group towards the left, so that the stems will be
	 * closer to lining up.  Set "offset" to the offset to be applied to
	 * group 1.  Group 2's will be -offset.
	 */
	if (can_overlap(gs1_p, gs2_p) == YES) {
		/* top group goes on right; top's offset > 0 */
		if (allsmall(gs1_p, gs1_p) == allsmall(gs2_p, gs2_p)) {
			offset = 0.50 * STEPSIZE;
		} else {
			offset = 0.75 * STEPSIZE;
		}
		if (gs2_p->roll != NOITEM)
			gs2_p->c[RW] -= ROLLPADDING;
	} else if (gs1_p->roll != NOITEM && gs2_p->roll == NOITEM) {
		/* only top group is rolled; it goes on left; its offset < 0 */
		offset = ( gs2_p->c[RW] - gs1_p->c[RE] ) / 2;
		gs1_p->c[RW] -= ROLLPADDING;
	} else if (gs1_p->roll == NOITEM && gs2_p->roll != NOITEM) {
		/* only bottom is rolled; top goes on right; top's offset > 0 */
		offset = ( gs2_p->c[RE] - gs1_p->c[RW] ) / 2;
		gs2_p->c[RW] -= ROLLPADDING;
	} else {
		/* either both are rolled or neither is; use other criterion */
		if (gs1_p->c[RE] - gs2_p->c[RW] <
					gs2_p->c[RE] - gs1_p->c[RW] + 0.1) {
			/* top group goes on left; its offset is negative */
			offset = ( gs2_p->c[RW] - gs1_p->c[RE] ) / 2;
			if (gs1_p->roll != NOITEM)
				gs1_p->c[RW] -= ROLLPADDING;
		} else {
			/* top group goes on right; its offset is positive */
			offset = ( gs2_p->c[RE] - gs1_p->c[RW] ) / 2;
			if (gs2_p->roll != NOITEM)
				gs2_p->c[RW] -= ROLLPADDING;
		}
	}

	/* apply offset to the groups and any preceding grace groups */
	shiftgs(gs1_p, offset);
	shiftgs(gs2_p, -offset);
}
\f
/*
 * Name:        compat()
 *
 * Abstract:    Determine whether two groups in a hand are "compatible".
 *
 * Returns:     YES or NO
 *
 * Description: This function is given pointers to the two groups in a hand,
 *		in a situation where they overlap.  The noteptrs array has
 *		just the top group filled in at this point.  The function
 *		figures out whether the two groups are compatible (see block
 *		comment below), or whether they must be drawn separately and
 *		offset horizontally.  While doing this, it fills in the bottom
 *		group part of noteptrs.  If it returns YES, this has been
 *		completed.  If it returns NO, this may be partially done,
 *		and the caller should clear out the partially complete bot_p
 *		part of noteptrs.
 */

static int
compat(noteptrs, gs1_p, gs2_p)

struct NOTEPTRS noteptrs[];		/* array of ptrs to notes to process */
register struct GRPSYL *gs1_p, *gs2_p;	/* point at groups in this hand */

{
	int num1;		/* number of notes in top group */
	register int n, k;	/* loop variables */


	num1 = gs1_p->nnotes;

	/*
	 * There is overlap between the two groups.  Try to match the bottom
	 * N notes of the top group with the top N notes of the bottom group.
	 * If all N are "compatible", we can "share" these notes.  For two
	 * groups to be compatible, they must meet the following conditions:
	 *	1) both basic time values must be half notes, or both must be
	 *	   shorter than half notes
	 *	2) both have no dots or the same number of dots
	 *	3) the bottom N notes of the top group are the same letters
	 *	   and octaves as the top N notes of the bottom group
	 * 	4) no two of these N notes can be on neighboring letters
	 * 	5) for each of the N pairs, the two notes have no accidental
	 *	   or the same accidental
	 *	6) for each of the N pairs, the two notes must have the same
	 *	   size and headshape
	 */
	/* check rule 1 */
	if (gs1_p->basictime < 2  || gs2_p->basictime < 2)
		return (NO);
	if (gs1_p->basictime == 2 && gs2_p->basictime != 2)
		return (NO);
	if (gs1_p->basictime != 2 && gs2_p->basictime == 2)
		return (NO);

	/* check rule 2 */
	if (gs1_p->dots != gs2_p->dots)
		return (NO);

	/* check rules 3, 4, 5, and 6 together */
	/* see if any note in the top group matches the top note in the other*/
	for (n = 0; n < num1; n++) {
		if (noteptrs[n].top_p->stepsup == gs2_p->notelist[0].stepsup)
			break;
	}
	if (n == num1)
		return (NO);		/* didn't find any match */

	/* starting with this note, verify that it and the rest match */
	for (k = 0; n < num1; k++, n++) {
		if (k >= gs2_p->nnotes)	/* not enough notes in group 2? */
			return (NO);
		if (gs2_p->notelist[k].stepsup != noteptrs[n].top_p->stepsup)
			return (NO);
		if (k > 0 &&
		gs2_p->notelist[k-1].stepsup - 1 == gs2_p->notelist[k].stepsup)
			return (NO);
		if (gs2_p->notelist[k].accidental != noteptrs[n].top_p->accidental)
			return (NO);
		if (gs2_p->notelist[k].notesize != noteptrs[n].top_p->notesize)
			return (NO);
		if (gs2_p->notelist[k].headshape != noteptrs[n].top_p->headshape)
			return (NO);

		/* this note matches; set up noteptrs */
		noteptrs[n].bot_p = &gs2_p->notelist[k];
	}

	/*
	 * The fact that we made it to here means all the overlapping notes
	 * matched.  So fill the rest of group 2's note pointers.
	 */
	for ( ; k < gs2_p->nnotes; k++, n++)
		noteptrs[n].bot_p = &gs2_p->notelist[k];
	/*
	 * It is possible that, although the overlapping notes' headshapes
	 * match, some of the characters are mirrors of each other due to the
	 * opposite stem dir.  In these cases, group 2 rules.  So overwrite the
	 * notes in group 1.  If the lowest note in group 1 has to be changed,
	 * that could affect the RS of group 1, so change that too.
	 * Also, while doing this, if any of these notes or their accs have
	 * parens in one group but not the other, erase those parens.
	 */
	n -= k;
	for (k = 0; n < num1; k++, n++) {
		gs1_p->notelist[n].headchar = gs2_p->notelist[k].headchar;
		gs1_p->notelist[n].headfont = gs2_p->notelist[k].headfont;
		gs1_p->notelist[n].c[RN] = gs2_p->notelist[k].c[RN];
		gs1_p->notelist[n].c[RS] = gs2_p->notelist[k].c[RS];

		if (gs1_p->notelist[n].note_has_paren !=
		    gs2_p->notelist[k].note_has_paren) {
			gs1_p->notelist[n].note_has_paren = NO;
			gs2_p->notelist[k].note_has_paren = NO;
		}
		if (gs1_p->notelist[n].acc_has_paren !=
		    gs2_p->notelist[k].acc_has_paren) {
			gs1_p->notelist[n].acc_has_paren = NO;
			gs2_p->notelist[k].acc_has_paren = NO;
		}
	}
	gs1_p->c[RS] = gs2_p->notelist[k - 1].c[RS];

	return (YES);
}
\f
/*
 * Name:        can_overlap()
 *
 * Abstract:    Decides whether incompatible groups' rectangles can overlap.
 *
 * Returns:     YES or NO
 *
 * Description: This function is given two incompatible groups in a hand.  It
 *		decides whether they can be placed such that their rectangles
 *		overlap.  This arrangement is where the first group is to the
 *		right of the second group, and the stems are about 3 stepsizes
 *		apart.  The noteheads must be separated enough vertically so
 *		that they don't collide, and various other things must also be
 *		true for this to work.
 */

static int
can_overlap(gs1_p, gs2_p)

struct GRPSYL *gs1_p, *gs2_p;	/* point at group(s) in this hand */

{
	int notedist;		/* steps between two notes (absolute value) */
	int n, k;		/* loop counters */


	/*
	 * First, ensure that no note heads would collide.  We don't yet know
	 * whether any will be on the "wrong" side of their stem.  This is not
	 * too common and would rarely help things, so for now we assume the
	 * worst case, which is that all are on the "correct" side and thus
	 * have the potential of colliding with the other group's notes.
	 */
	for (n = 0; n < gs1_p->nnotes; n++) {
		for (k = 0; k < gs2_p->nnotes; k++) {
			notedist = abs(gs1_p->notelist[n].stepsup -
				       gs2_p->notelist[k].stepsup);

			/* never allow closer than 2 steps */
			if (notedist < 2)
				return (NO);

			/* if either is double whole, don't allow less than 3 */
			if ((gs1_p->basictime == 0 || gs2_p->basictime == 0) &&
					notedist < 3)
				return (NO);
		}
	}

	/* neither group can have slashes */
	if (gs1_p->slash_alt > 0 || gs2_p->slash_alt > 0)
		return (NO);

	/* the first group can't have accidentals */
	for (n = 0; n < gs1_p->nnotes; n++) {
		if (gs1_p->notelist[n].accidental != '\0')
			return (NO);
	}

	/* the first group can't any preceding grace groups */
	if (gs1_p->prev != 0 && gs1_p->prev->grpvalue == GV_ZERO)
		return (NO);

	/* the first group can't have a roll unless the second group has one */
	if (gs1_p->roll != NOITEM && gs2_p->roll == NOITEM)
		return (NO);

	/* the second group can't have any dots */
	if (gs2_p->dots > 0)
		return (NO);

	/* the second group can't have any flags */
	if (gs2_p->basictime >= 8 && gs2_p->beamloc == NOITEM)
		return (NO);

	/* neither group can have a stem forced the "wrong" way */
	if (gs1_p->stemdir == DOWN || gs2_p->stemdir == UP)
		return (NO);

	/*
	 * At this point we know we can overlap.
	 */
	return (YES);
}
\f
/*
 * Name:        procsome()
 *
 * Abstract:    Sets coords for group(s) and their associated grace groups.
 *
 * Returns:     void
 *
 * Description: This function calls procbunch() to set the horizontal coords
 *		for the given group(s) and their notes, etc.  Then it calls
 *		procgrace() to deal with any grace groups preceding these
 *		group(s) and adjust the main group(s)' west coordinates to.
 *		contain the grace groups.
 */

static void
procsome(noteptrs, mll_p, staff_p, gs1_p, gs2_p)

struct NOTEPTRS noteptrs[];	/* array of ptrs to notes to process */
struct MAINLL *mll_p;		/* the MLL item the group is connected to */
struct STAFF *staff_p;		/* the staff the groups are connected to */
struct GRPSYL *gs1_p, *gs2_p;	/* point at group(s) in this hand */

{
	/* process the normal group(s) */
	procbunch(noteptrs, mll_p, staff_p, gs1_p, gs2_p);

	/* process any grace groups preceding first normal group */
	procgrace(noteptrs, mll_p, staff_p, gs1_p);

	/* process any grace groups preceding second normal group, if exists */
	if (gs2_p != 0)
		procgrace(noteptrs, mll_p, staff_p, gs2_p);
}
\f
/*
 * Name:        procgrace()
 *
 * Abstract:    Sets coords for grace groups and adjusts normal group's west.
 *
 * Returns:     void
 *
 * Description: This function loops leftward from the given normal group,
 *		calling procbunch() for each grace group, and adjusting the
 *		normal group's west coordinate accordingly.
 */

static void
procgrace(noteptrs, mll_p, staff_p, gsnorm_p)

struct NOTEPTRS noteptrs[];	/* array of ptrs to notes to process */
struct MAINLL *mll_p;		/* the MLL item the group is connected to */
struct STAFF *staff_p;		/* the staff the groups are connected to */
struct GRPSYL *gsnorm_p;	/* point at the normal group to start from */

{
	struct GRPSYL *gs_p;	/* point at a grace group */
	struct GRPSYL *right_p;	/* point at the group to the right of this */
	int n;			/* loop variable */


	/*
	 * Loop through any grace groups preceding the normal group, working
	 * right to left.  Call procbunch() for each.  Upon return, set
	 * the grace group's x,e,w relative to the normal group's x, and
	 * alter the west coordinate of the normal group to include them.
	 */
	right_p = gsnorm_p;
	for (gs_p = gsnorm_p->prev; gs_p != 0 && gs_p->grpvalue == GV_ZERO;
				gs_p = gs_p->prev) {
		/* clear noteptrs, and resetup for this grace group */
		/* note:  grace groups are always notes, not rests or spaces */
		for (n = 0; n < MAXHAND + 1; n++) {
			noteptrs[n].top_p = 0;
			noteptrs[n].bot_p = 0;
		}
		/* set all the "top" group pointers */
		for (n = 0; n < gs_p->nnotes; n++)
			noteptrs[n].top_p = &gs_p->notelist[n];

		procbunch(noteptrs, mll_p, staff_p, gs_p, (struct GRPSYL *)0);

		gs_p->c[RX] = right_p->c[RW] - gs_p->c[RE];
		gs_p->c[RW] += gs_p->c[RX];
		gs_p->c[RE] += gs_p->c[RX];

		gsnorm_p->c[RW] = gs_p->c[RW];
		right_p = gs_p;
	}
}
\f
/*
 * Name:        procbunch()
 *
 * Abstract:    Sets relative horizontal coords of note heads, accs, & dots.
 *
 * Returns:     void
 *
 * Description: This function figures out which note heads in the given
 *		group(s) need to be put on the "wrong" side of the stem to
 *		avoid overlapping.  Then it sets all note heads' horizontal
 *		coords.  It calls doacc() to find and store the positions
 *		for the accidentals, dodot() for the dots.  It sets RW and
 *		RE for the group(s), also taking flags into consideration.
 */

/*
 * This macro checks the n'th structure in noteptrs.  If the top group has
 * a note there, it returns a pointer to that note, else it returns the
 * bottom pointer, which may or may not be 0.
 */
#define	GETPTR(n)	(noteptrs[n].top_p != 0 ?		\
			noteptrs[n].top_p : noteptrs[n].bot_p)

static void
procbunch(noteptrs, mll_p, staff_p, gs1_p, gs2_p)

struct NOTEPTRS noteptrs[];	/* array of ptrs to notes to process */
struct MAINLL *mll_p;		/* the MLL item the group is connected to */
struct STAFF *staff_p;		/* the staff the groups are connected to */
struct GRPSYL *gs1_p, *gs2_p;	/* point at group(s) in this hand */

{
	int normhead[MAXHAND + 1];	/* position of note heads */
	float gwide;			/* width of any note in these groups */
	float nwide;			/* width of a particular note */
	float maxwide;			/* max of gwide for the two groups */
	float ghigh;			/* height of any note in these groups*/
	float nhigh;			/* height of a particular note */
	float g1wide, g2wide;		/* gwide for the two groups */
	float maxhigh;			/* max of ghigh for the two groups */
	float flagwidth;		/* width of a flag */
	float rh;			/* relative horizontal of a note */
	int collinear;			/* are the 2 groups' stems collinear? */
	register int k, n;		/* loop variables */
	int size;


	/*
	 * If this is a tablature staff, call a special function to handle it,
	 * and return.  Voices on tab staffs are handled one at a time, so
	 * gs2_p will never be used for them.
	 */
	if (is_tab_staff(staff_p->staffno)) {
		proctab(mll_p, staff_p, gs1_p);
		return;
	}

	collinear = NO;			/* assume not collinear stems */

	/*
	 * "Normal" position of a note head means to the left of the stem
	 * for an upward stem, and right for downward.  When two notes in a
	 * group are on neighboring letters, one of the note heads has to be
	 * in "abnormal" position so that they don't collide.  Shared
	 * note heads must always be in normal position.  (The fact
	 * that no two of them can be on neighboring letters is enforced
	 * when checking for compatibility of groups.)
	 */
	/*
	 * See if there are any shared notes first.
	 */
	for (n = 0; noteptrs[n].top_p != 0; n++) {
		if (noteptrs[n].bot_p != 0)
			break;		/* found a shared note */
	}

	if (noteptrs[n].top_p != 0) {
		/*
		 * There are shared notes, and n indexes to the first one
		 * (starting from the top).  Set this first one to normal.
		 * First work upwards from there, reversing normality
		 * whenever there are neighboring notes, setting back to
		 * normal otherwise.  Then work downwards from there, doing
		 * the same.
		 */
		normhead[n] = YES;
		for (k = n - 1 ; k >= 0; k--) {
			if (noteptrs[k+1].top_p->stepsup ==
			    noteptrs[ k ].top_p->stepsup - 1)
				normhead[k] = ! normhead[k+1];
			else
				normhead[k] = YES;
		}
		for (k = n + 1 ; noteptrs[k].bot_p != 0; k++) {
			if (noteptrs[k-1].bot_p->stepsup ==
			    noteptrs[ k ].bot_p->stepsup + 1)
				normhead[k] = ! normhead[k-1];
			else
				normhead[k] = YES;
		}
	} else {
		/*
		 * There are no shared notes.  It may even be that there's only
		 * one group.  In each group, the note that's opposite the stem
		 * must be normal, and then we go down the list of other notes
		 * in the group, reversing normality whenever there are
		 * neighboring notes, and setting back to normal otherwise.
		 * There's a special concern if the bottom note of the top
		 * group is on the neighboring letter to the top note of the
		 * bottom group, or if it is on the same letter.  In that case,
		 * we want to offset the groups slightly, such that their stems
		 * are collinear, so set that flag.
		 */
		/* the first group's stem could go either way */
		if (gs1_p->stemdir == UP) {
			normhead[n-1] = YES;	/* bottom note normal */
			for (k = n - 2; k >= 0; k--) {
				if (noteptrs[k+1].top_p->stepsup ==
				    noteptrs[ k ].top_p->stepsup - 1)
					normhead[k] = ! normhead[k+1];
				else
					normhead[k] = YES;
			}
		} else {	/* stemdir == DOWN */
			normhead[0] = YES;	/* top note normal */
			for (k = 1; k < n; k++) {
				if (noteptrs[k-1].top_p->stepsup ==
				    noteptrs[ k ].top_p->stepsup + 1)
					normhead[k] = ! normhead[k-1];
				else
					normhead[k] = YES;
			}
		}

		/* the second group's stem (if it exists) must go down */
		if (gs2_p != 0) {
			normhead[n] = YES;	/* top note normal */
			for (k = n + 1; noteptrs[k].bot_p != 0; k++) {
				if (noteptrs[k-1].bot_p->stepsup ==
				    noteptrs[ k ].bot_p->stepsup + 1)
					normhead[k] = ! normhead[k-1];
				else
					normhead[k] = YES;
			}

			collinear = (noteptrs[n-1].top_p->stepsup <=
				     noteptrs[ n ].bot_p->stepsup + 1);
		}
	}

	/*
	 * Set gwide and ghigh to be the biggest values of any note in the top
	 * group, also storing the width of each note for later use.
	 */
	gwide = ghigh = 0.0;
	for (n = 0; noteptrs[n].top_p != 0; n++) {
		size = noteptrs[n].top_p->notesize == GS_NORMAL ?
				DFLT_SIZE : SMALLSIZE;
		nwide = width(noteptrs[n].top_p->headfont, size,
				noteptrs[n].top_p->headchar);
		noteptrs[n].wid = nwide;
		if (nwide > gwide) {
			gwide = nwide;
		}
		nhigh = height(noteptrs[n].top_p->headfont, size,
				noteptrs[n].top_p->headchar);
		if (nhigh > ghigh) {
			ghigh = nhigh;
		}
	}

	/* remember these values, for comparing to the other group (if any) */
	maxwide = g1wide = gwide;	/* widest group so far */
	maxhigh = ghigh;		/* highest group so far */

	if (gs1_p->basictime <= 1) {
		gs1_p->stemx = 0.0;	/* center the imaginary stem */
	} else {
		gs1_p->stemx = gs1_p->stemdir == UP ? gwide / 2 : -gwide / 2;
	}

	for (n = 0; noteptrs[n].top_p != 0; n++) {
		nwide = noteptrs[n].wid;

		if (normhead[n] == YES) {
			/*
			 * The note head is in normal position, so usually its
			 * relative x coord is 0, and west and east are half a
			 * width off.  But if the note is smaller than the
			 * group's max, and there is a stem, and the note is
			 * not shared by the other group, the note needs to
			 * be off center so that it touches the stem.
			 */
			if (nwide != gwide && gs1_p->basictime >= 2 &&
					noteptrs[n].bot_p == 0) {
				if (gs1_p->stemdir == UP) {
					noteptrs[n].top_p->c[RE] = gwide / 2;
					noteptrs[n].top_p->c[RX] =
							gwide / 2 - nwide / 2;
					noteptrs[n].top_p->c[RW] =
							gwide / 2 - nwide;
				} else {	/* DOWN */
					noteptrs[n].top_p->c[RW] = -gwide / 2;
					noteptrs[n].top_p->c[RX] =
							-gwide / 2 + nwide / 2;
					noteptrs[n].top_p->c[RE] =
							-gwide / 2 + nwide;
				}
			} else {
				noteptrs[n].top_p->c[RX] = 0;
				noteptrs[n].top_p->c[RW] = -nwide / 2;
				noteptrs[n].top_p->c[RE] = nwide / 2;
			}
		} else {
			/*
			 * The note head is in abnormal position.  Its relative
			 * x coord, and west and east, depend on which way the
			 * stem is going.  Smaller than normal notes need to
			 * be placed differently regardless of whether stemed.
			 * In all case, adjust by W_NORMAL*POINT, the width of
			 * the stem, so that the note overlays the stem.
			 */
			if (nwide != gwide) {
				if (gs1_p->stemdir == UP) {
					noteptrs[n].top_p->c[RW] =
						gwide / 2 - W_NORMAL * POINT;
					noteptrs[n].top_p->c[RX] =
						gwide / 2 + nwide / 2
						- W_NORMAL * POINT;
					noteptrs[n].top_p->c[RE] =
						gwide / 2 + nwide
						- W_NORMAL * POINT;
				} else {	/* DOWN */
					noteptrs[n].top_p->c[RE] =
						W_NORMAL * POINT - gwide / 2;
					noteptrs[n].top_p->c[RX] =
						W_NORMAL * POINT
						- gwide / 2 - nwide /2;
					noteptrs[n].top_p->c[RW] =
						W_NORMAL * POINT
						- gwide / 2 - nwide;
				}
			} else {
				if (gs1_p->stemdir == UP) {
					noteptrs[n].top_p->c[RX] =
						nwide - W_NORMAL * POINT;
					noteptrs[n].top_p->c[RW] =
						nwide * 0.5 - W_NORMAL * POINT;
					noteptrs[n].top_p->c[RE] =
						nwide * 1.5 - W_NORMAL * POINT;
				} else {	/* DOWN */
					noteptrs[n].top_p->c[RX] =
						W_NORMAL * POINT - nwide;
					noteptrs[n].top_p->c[RW] =
						W_NORMAL * POINT - nwide * 1.5;
					noteptrs[n].top_p->c[RE] =
						W_NORMAL * POINT - nwide * 0.5;
				}
			}
		}
	}

	/*
	 * If there is a bottom group, get note head character width for
	 * it, find where in noteptrs that group starts, then loop through
	 * it, setting coords.  While doing this, set the group's
	 * horizontal coords.
	 */
	g2wide = 0.0;	/* to avoid useless 'used before set' warning */
	if (gs2_p != 0) {
		/* skip by notes that are only in the top group */
		for (n = 0; noteptrs[n].bot_p == 0; n++)
			;
		/*
		 * Set gwide and ghigh to be the biggest values of any note in
		 * the bottom group, also storing the width of each note for
		 * later use.  If the note is shared between groups, the width
		 * has already been stored in noteptrs[].wid, so we don't have
		 * to recalculate it.
		 */
		gwide = ghigh = 0.0;
		for ( ; noteptrs[n].bot_p != 0; n++) {
			size = noteptrs[n].bot_p->notesize == GS_NORMAL ?
					DFLT_SIZE : SMALLSIZE;
			if (noteptrs[n].wid == 0.0) {
				nwide = width(noteptrs[n].bot_p->headfont, size,
						noteptrs[n].bot_p->headchar);
				noteptrs[n].wid = nwide;
			} else {
				nwide = noteptrs[n].wid;
			}
			if (nwide > gwide) {
				gwide = nwide;
			}
			nhigh = height(noteptrs[n].bot_p->headfont, size,
					noteptrs[n].bot_p->headchar);
			if (nhigh > ghigh) {
				ghigh = nhigh;
			}
		}
		g2wide = gwide;
		if (gs2_p->basictime <= 1) {
			gs2_p->stemx = 0.0;	/* center the imaginary stem */
		} else {
			gs2_p->stemx = gs2_p->stemdir == UP ? gwide / 2
							   : -gwide / 2;
		}

		/* if groups have different note head sizes, adjust maxes */
		if (gwide > maxwide)
			maxwide = gwide;
		if (ghigh > maxhigh)
			maxhigh = ghigh;

		for (n = 0; noteptrs[n].bot_p == 0; n++)
			;
		for ( ; noteptrs[n].bot_p != 0; n++) {
			nwide = noteptrs[n].wid;

			if (normhead[n] == YES) {
				/*
				 * The note head is in normal position, so its
				 * relative x coord is 0, and west and east are
				 * half a width off.  But if the note is smaller
				 * than the widest note in the group and there
				 * is a stem, and the note is not shared by the
				 * other group, the note needs to be off center
			 	 * so that it touches the stem.
				 */
				if (nwide != gwide && gs2_p->basictime >= 2 &&
						noteptrs[n].top_p == 0) {
					noteptrs[n].bot_p->c[RW] = -gwide / 2;
					noteptrs[n].bot_p->c[RX] =
							-gwide / 2 + nwide / 2;
					noteptrs[n].bot_p->c[RE] =
							-gwide / 2 + nwide;
				} else {
					noteptrs[n].bot_p->c[RX] = 0;
					noteptrs[n].bot_p->c[RW] = -nwide * 0.5;
					noteptrs[n].bot_p->c[RE] = nwide * 0.5;
				}
			} else {
				/*
				 * The note head is in abnormal position.  Its
				 * relative x coord, and west and east, depend
				 * on which way the stem is going, but the
				 * stem must always be down in group 2.  Smaller
			 	 * than normal notes need to be placed
				 * differently regardless of whether stemed.
				 */
				if (nwide != gwide) {
					noteptrs[n].bot_p->c[RE] =
						W_NORMAL * POINT - gwide / 2;
					noteptrs[n].bot_p->c[RX] =
						W_NORMAL * POINT
						- gwide / 2 - nwide /2;
					noteptrs[n].bot_p->c[RW] =
						W_NORMAL * POINT
						- gwide / 2 - nwide;
				} else {
					noteptrs[n].bot_p->c[RX] =
						W_NORMAL * POINT - nwide;
					noteptrs[n].bot_p->c[RW] =
						W_NORMAL * POINT - nwide * 1.5;
					noteptrs[n].bot_p->c[RE] =
						W_NORMAL * POINT - nwide * 0.5;
				}
			}
		}
	}

	/* find position of accidentals */
	doacc(noteptrs, maxwide / 2, maxhigh / 2, collinear);

	/* find position of dots after notes */
	dodot(staff_p, gs1_p, gs2_p, maxwide / 2, collinear);

	/* find position of right parentheses around notes */
	noterparen(noteptrs, gs1_p, gs2_p, maxwide/2, maxhigh/2, collinear);

	/*
	 * Set RX for the group(s) to 0 for now if stems are offset (the
	 * normal case), or to the appropriate value if stems are collinear.
	 * If we only have one group it will thus be set to 0 now, though
	 * later, if there's an incompatible group next to it, this coord
	 * and all others will be adjusted.
	 */
	if (collinear) {
		gs1_p->c[RX] = (W_NORMAL * POINT - maxwide) / 2;
		gs2_p->c[RX] = (maxwide - W_NORMAL * POINT) / 2;
	} else {
		gs1_p->c[RX] = 0;
		if (gs2_p != 0)
			gs2_p->c[RX] = 0;
	}

	/*
	 * Set the western boundaries for the group(s).
	 */
	/*
	 * Init the group's RW to 0.  Then loop through the notes, finding the
	 * westernmost thing associated with a note, and leaving the group's RW
	 * set to that.
	 */
	gs1_p->c[RW] = 0;
	for (k = 0; k < gs1_p->nnotes; k++) {
		rh = notehorz(gs1_p, &gs1_p->notelist[k], RW);
		if (rh < gs1_p->c[RW])
			gs1_p->c[RW] = rh;
	}
	/*
	 * If the stem is down on a half note or shorter that is to have
	 * slashes through its stem, make sure there is room for the slashes.
	 */
	if (gs1_p->slash_alt > 0 && gs1_p->stemdir == DOWN &&
			gs1_p->basictime >= 2) {
		gwide = g1wide;
		/* if position of stem minus slash room < current west . . . */
		if (-gwide / 2 - SLASHPAD < gs1_p->c[RW])
			gs1_p->c[RW] = -gwide / 2 - SLASHPAD;
	}
	westwith(gs1_p);		/* expand RW for "with" list if needbe*/
	gs1_p->c[RW] -= gs1_p->padding;	/* add user requested padding */

	/* add the pad parameter that user wants for this voice */
	gs1_p->c[RW] -= vvpath(gs1_p->staffno, gs1_p->vno, PAD)->pad;

	csbstempad(mll_p, gs1_p);	/* cross staff beaming may need space */
	gs1_p->c[RW] += gs1_p->c[RX];	/* shift by RX, in case RX isn't 0 */

	/*
	 * If group 2 exists, do the same for it.  However, in the slash
	 * section, we know the stem must be down, so no need to check that.
	 */
	if (gs2_p != 0) {
		gs2_p->c[RW] = 0;
		for (k = 0; k < gs2_p->nnotes; k++) {
			rh = notehorz(gs2_p, &gs2_p->notelist[k], RW);
			if (rh < gs2_p->c[RW])
				gs2_p->c[RW] = rh;
		}
		if (gs2_p->slash_alt > 0 && gs2_p->basictime >= 2) {
			gwide = g2wide;
			/* if pos of stem minus slash room < current west . .*/
			if (-gwide / 2 - SLASHPAD < gs2_p->c[RW])
				gs2_p->c[RW] = -gwide / 2 - SLASHPAD;
		}
		westwith(gs2_p);
		gs2_p->c[RW] -= gs2_p->padding;
		gs2_p->c[RW] -= vvpath(gs2_p->staffno, gs2_p->vno, PAD)->pad;
		csbstempad(mll_p, gs2_p);
		gs2_p->c[RW] += gs2_p->c[RX];
	}

	/*
	 * Set the eastern boundaries for the group(s).
	 */
	/*
	 * Init the group's RE to 0.  Then loop through the notes, finding the
	 * easternmost thing associated with a note, and leaving the group's RE
	 * set to that.
	 */
	gs1_p->c[RE] = 0;
	for (k = 0; k < gs1_p->nnotes; k++) {
		rh = notehorz(gs1_p, &gs1_p->notelist[k], RE);
		if (rh > gs1_p->c[RE])
			gs1_p->c[RE] = rh;
	}
	/*
	 * Add in any padding needed for ties, slurs, and bends.  Also add room
	 * for alternations if there are any.
	 */
	gs1_p->c[RE] += tieslurpad(staff_p, gs1_p);
	if (gs1_p->slash_alt < 0 && gs1_p->beamloc == STARTITEM)
		gs1_p->c[RE] += ALTPAD;
	/*
	 * If the stem is up and a flag is needed, and the east boundary
	 * doesn't yet contain it, adjust the east boundary so the flag will
	 * fit.
	 */
	if (gs1_p->stemdir == UP && gs1_p->basictime >= 8 &&
				gs1_p->beamloc == NOITEM) {
		flagwidth = width(FONT_MUSIC, gs1_p->grpsize == GS_NORMAL ?
			DFLT_SIZE : SMALLSIZE, C_UPFLAG);
		if (gs1_p->notelist[0].c[RE] + flagwidth > gs1_p->c[RE])
			gs1_p->c[RE] = gs1_p->notelist[0].c[RE] + flagwidth;
	}
	/*
	 * If the stem is up on a half note or shorter that is to have slashes
	 * through its stem, make sure there's room for the slashes.
	 */
	if (gs1_p->slash_alt > 0 && gs1_p->stemdir == UP &&
			gs1_p->basictime >= 2) {
		gwide = g1wide;
		/* if position of stem plus slash room > current east . . . */
		if (gwide / 2 + SLASHPAD > gs1_p->c[RE])
			gs1_p->c[RE] = gwide / 2 + SLASHPAD;
	}
	/*
	 * Expand RE some more if need be to accommodate the "with" list.  Then
	 * shift it over by RX, in case RX isn't 0.
	 */
	eastwith(gs1_p);
	gs1_p->c[RE] += gs1_p->c[RX];

	/*
	 * If group 2 exists, do the same for it.  However, the stem is always
	 * down, so any flags will always already fit.  For the same reason,
	 * slashes don't need to be considered.
	 */
	if (gs2_p != 0) {
		gs2_p->c[RE] = 0;
		for (k = 0; k < gs2_p->nnotes; k++) {
			rh = notehorz(gs2_p, &gs2_p->notelist[k], RE);
			if (rh > gs2_p->c[RE])
				gs2_p->c[RE] = rh;
		}
		gs2_p->c[RE] += tieslurpad(staff_p, gs2_p);
		if (gs2_p->slash_alt < 0 && gs2_p->beamloc == STARTITEM)
			gs2_p->c[RE] += ALTPAD;
		eastwith(gs2_p);
		gs2_p->c[RE] += gs2_p->c[RX];
	}
}
\f
/*
 * Name:        doacc()
 *
 * Abstract:    Finds horizontal position for each accidental in group(s).
 *
 * Returns:     void
 *
 * Description: This function loops through all the accidentals belonging
 *		to notes in the group(s) it is given.  It figures out where
 *		to place them horizontally to avoid overlap, and stores the
 *		relative west coord of each in NOTE.waccr.  For each group,
 *		it uses the appropriate size of accidentals (based on normal
 *		versus cue/grace), and places them appropriately, considering
 *		also the size of the notes.  However, if there are two groups,
 *		the note head sizes could be different.  The halfwide and
 *		halfhigh passed in are supposed to be the right size for the
 *		bigger of the two sizes, and accidentals will not be packed
 *		as tightly against the other notes.  This doesn't hurt, and
 *		isn't worth the trouble to do it "right".
 *
 *		This function takes into account parentheses around accidentals.
 *		Its algorithm treats them as part of the accidental.  Also, when
 *		there are parentheses around the note, it handles the left
 *		parentheses the same way:  if there is also an accidental, it
 *		treats it as part of it; otherwise the paren is handled like an
 *		accidental itself.
 */

/* this fudge factor prevents roundoff error from causing overlap */
#define	FUDGE		(.01)

/* when CSS applies to a note or acc, move it by this much */
#define CSS_OFF		(CSS_STEPS * STEPSIZE)

static void
doacc(noteptrs, halfwide, halfhigh, collinear)

struct NOTEPTRS noteptrs[];	/* array of ptrs to notes to process */
double halfwide;		/* half of max of width & height of (notes */
double halfhigh;		/*  in group 1, notes in group 2) */
int collinear;			/* are stems collinear? */

{
	/*
	 * Each structure in this table represents either a note head that
	 * is farther left than normal, or an accidental.  A note head
	 * could be too far left for one of two reasons: either it was
	 * forced to be on the left ("wrong") side of a stem that points
	 * down, or it is a normal note in the top group when the stems are
	 * collinear.  In the collinear case, to make this function easier,
	 * we start out regarding the bottom group as being normal, and
	 * the top group as being shifted left one note head, and we figure
	 * everything relative to the bottom group.  But at the end we adjust
	 * waccr so that every accidental is relative to its own group, like
	 * it's supposed to be.
	 *
	 * The coordinates define the rectangle that surrounds the note or acc,
	 * including standard padding, even on note heads, which don't
	 * normally have padding.  First the notes are put into this table;
	 * then the accidentals, one at a time, making sure they don't
	 * overlap things already in the table.
	 * To see if the accidental being added overlaps, first its north
	 * and south are tested.  All previous rectangles that are "out of
	 * its way" vertically are marked not "relevant"; the others are
	 * marked "relevant".  As positions are tried, right to left, positions
	 * that fail to avoid overlap are marked "tried".
	 *
	 * After the correct position is found for an accidental, there is a
	 * special case for flats and double flats to take advantage of their
	 * shape and let them pack tighter.
	 */
	struct {
		float n, s, e, w;	/* boundaries of a rectangle */
		short relevant;		/* is rectangle relevant? */
		short tried;		/* have we tried this one yet? */
	} rectab[2 * MAXHAND + 1];	/* enough for all notes & accidentals*/

	struct NOTE *note_p;		/* point at a note */
	int reclim;			/* index after last rectangle in tab */
	float north, south, east, west;	/* relative coords of new accidental */
	float accasc, accdesc;		/* ascent & descent of accidental */
	float accwidth;			/* width of new accidental */
	float parenwidth;		/* width of note's left parenthesis */
	float parenv;			/* half the vertical size of paren */
	float totwidth;			/* width of acc plus paren */
	int overlap;			/* does our acc overlap existing ones*/
	int try;			/* which element of rectab to try */
	int found;			/* accs/parens found so far */
	int k, j;			/* loop variables */
	int size;
	float horfn, verfn;		/* horz & vert flat/nat notch sizes */
	float savehorfn;		/* save original horfn */


	reclim = 0;			/* table initially empty */

	/*
	 * Loop through noteptrs, finding all notes that are left of normal
	 * position, entering them in rectab.  Include padding around them.
	 * First loop through all notes, finding ones that are on the left
	 * side of a down stem; then, if stems are collinear, loop through
	 * the top group, finding all normal notes.
	 */
	for (k = 0; (note_p = GETPTR(k)) != 0; k++) {
		if (note_p->c[RX] < 0) {
			rectab[reclim].n = note_p->c[RY] + halfhigh + STDPAD;
			rectab[reclim].s = note_p->c[RY] - halfhigh - STDPAD;
			rectab[reclim].e = note_p->c[RE] + STDPAD;
			rectab[reclim].w = note_p->c[RW] - STDPAD;
			if (note_p->stepsup >= CSS_STEPS / 2) {
				rectab[reclim].n += CSS_OFF;
				rectab[reclim].s += CSS_OFF;
			} else if (note_p->stepsup <= -CSS_STEPS / 2) {
				rectab[reclim].n -= CSS_OFF;
				rectab[reclim].s -= CSS_OFF;
			}
			reclim++;
		}
	}
	if (collinear) {
		for (k = 0; (note_p = noteptrs[k].top_p) != 0; k++) {
			if (note_p->c[RX] == 0) {
				rectab[reclim].n = note_p->c[RY] + halfhigh
						+ STDPAD;
				rectab[reclim].s = note_p->c[RY] - halfhigh
						- STDPAD;
				rectab[reclim].e = W_NORMAL * POINT
						- halfwide + STDPAD;
				rectab[reclim].w = W_NORMAL * POINT
						- 3 * halfwide - STDPAD;
				if (note_p->stepsup >= CSS_STEPS / 2) {
					rectab[reclim].n += CSS_OFF;
					rectab[reclim].s += CSS_OFF;
				} else if (note_p->stepsup <= -CSS_STEPS / 2) {
					rectab[reclim].n -= CSS_OFF;
					rectab[reclim].s -= CSS_OFF;
				}
				reclim++;
			}
		}
	}

	/* prevent false "may be used before set" lint warning */
	verfn = savehorfn = 0.0;

	/*
	 * Loop through all notes, find the ones with accs or parens.  Find
	 * where the accs and parens will fit, storing that info in waccr, and
	 * adding them to rectab.  Call a function so that we loop in the
	 * proper order.
	 */
	for (found = 0, k = nextacc(noteptrs, found);  k != -1;
				found++, k = nextacc(noteptrs, found)) {
		note_p = GETPTR(k);
		/* get dimensions of accidental if there is one */
		if (note_p->accidental != '\0') {
			accdimen(note_p, &accasc, &accdesc, &accwidth);
		} else {
			accwidth = accasc = accdesc = 0.0;
		}
		/* get dimensions of note's left paren, if there is one */
		if (note_p->note_has_paren == YES) {
			size = (note_p->notesize == GS_NORMAL ?
					DFLT_SIZE : SMALLSIZE);
			parenwidth = width(FONT_TR, size, '(');
			parenv = height(FONT_TR, size, '(') / 2.0;
		} else {
			parenwidth = parenv = 0.0;
		}
		/* set the north, south, and width of what we have found */
		north = note_p->c[RY] + MAX(accasc, parenv);
		south = note_p->c[RY] - MAX(accdesc, parenv);
		if (note_p->stepsup >= CSS_STEPS / 2) {
			north += CSS_OFF;
			south += CSS_OFF;
		} else if (note_p->stepsup <= -CSS_STEPS / 2) {
			north -= CSS_OFF;
			south -= CSS_OFF;
		}
		totwidth = accwidth + parenwidth;

		/*
		 * For each rectangle in rectab, decide whether (based on
		 * its vertical coords) it could possibly overlap with our
		 * new accidental.  If it's totally above or below ours, it
		 * can't.  We allow a slight overlap (FUDGE) so that round
		 * off errors don't stop us from packing things as tightly
		 * as possible.
		 */
		for (j = 0; j < reclim; j++) {
			if (rectab[j].s + FUDGE > north ||
			    rectab[j].n < south + FUDGE)
				rectab[j].relevant = NO;
			else
				rectab[j].relevant = YES;
		}

		/*
		 * Mark that none of the relevant rectangles' boundaries have
		 * been tried yet for positioning our acc.
		 */
		for (j = 0; j < reclim; j++) {
			if (rectab[j].relevant == YES)
				rectab[j].tried = NO;
		}

		/*
		 * Set up first trial position for this acc., just to the
		 * left of normal notes, allowing padding.
		 */
		east = - halfwide - STDPAD;
		west = east - totwidth;

		/*
		 * Keep trying positions for this acc, working right to
		 * left.  When we find one that doesn't overlap an existing
		 * rectangle, break.  This has to succeed at some point,
		 * at the leftmost rectangle position if not earlier.
		 */
		for (;;) {
			overlap = NO;
			for (j = 0; j < reclim; j++) {
				/* ignore ones too far north or south */
				if (rectab[j].relevant == NO)
					continue;

				/* if all west or east, okay; else overlap */
				if (rectab[j].w + FUDGE <= east &&
				    rectab[j].e >= west + FUDGE) {
					overlap = YES;
					break;
				}
			}

			/* if no rectangle overlapped, we found a valid place*/
			if (overlap == NO)
				break;

			/*
			 * Something overlapped, so we have to try again.
			 * Find the eastermost relevant west rectangle boundary
			 * that hasn't been tried already, to use as the next
			 * trial position for our acc's east.
			 */
			try = -1;
			for (j = 0; j < reclim; j++) {
				/* ignore ones too far north or south */
				if (rectab[j].relevant == NO ||
				    rectab[j].tried == YES)
					continue;

				/*
				 * If this is the first relevant one we haven't
				 * tried, or if this is farther east than the
				 * easternmost so far, save it as being the
				 * new easternmost so far.
				 */
				if (try == -1 || rectab[j].w > rectab[try].w)
					try = j;
			}

			if (try == -1)
				pfatal("bug in doacc()");

			/*
			 * Mark this one as having been tried (for next time
			 * around, if necessary).  Set new trial values for
			 * east and west of our acc.
			 */
			rectab[try].tried = YES;
			east = rectab[try].w;
			west = east - totwidth;

		} /* end of while loop trying positions for this acc */

		/*
		 * We found the correct position for the new acc.  However, for
		 * flats, double flats & nats, we would like a notch to be taken
		 * out of the upper right corner of their rectangle, in effect,
		 * since there's nothing there but white space.  This can only
		 * be done if the acc is not already right next to the group.
		 */
		if (note_p->accidental == '&' || note_p->accidental == 'B' ||
					note_p->accidental == 'n') {
			/* get notch size; if paren, add width to horz */
			if (note_p->accidental == 'n') {
				horfn = 1.4 * STEPSIZE;	/* horizontal notch */
				verfn = 1.6 * STEPSIZE;	/* vertical notch */
			} else {
				horfn = 1.5 * STEPSIZE;	/* horizontal notch */
				verfn = 2.8 * STEPSIZE;	/* vertical notch */
			}
			if (note_p->notesize == GS_SMALL) {
				horfn *= SM_FACTOR;
				verfn *= SM_FACTOR;
			}
			if (note_p->acc_has_paren) {
				size = (note_p->notesize == GS_NORMAL ?
						DFLT_SIZE : SMALLSIZE);
				horfn += width(FONT_TR, size, ')');
			}
			savehorfn = horfn;	/* may need it later */
			/*
			 * If notch width is bigger than the max possible dist
			 * we could move the acc (we would overwrite the note),
			 * reduce it to be the space available.
			 */
			if (horfn > - east - halfwide - STDPAD)
				horfn = - east - halfwide - STDPAD;

			/* only attempt the shift if > 0 width available */
			if (horfn > 0.0) {
				/*
				 * The useable notch size is horfn by verfn.
				 * We'd like to move the acc to the right by
				 * horfn.  We can only do this if the space is
				 * unoccupied that is immediately to the right
				 * of the acc, of width = horfn and height =
				 * (height of acc) - verfn.  (If only part of
				 * that space is available, we won't bother
				 * trying to use it.)  So check whether any
				 * existing rectangle overlaps that space.
				 */
				overlap = NO;
				for (j = 0; j < reclim; j++) {
					if (rectab[j].s + FUDGE <= north - verfn &&
					    rectab[j].n - FUDGE >= south &&
					    rectab[j].w + FUDGE <= east + horfn &&
					    rectab[j].e - FUDGE >= east) {
						overlap = YES;
						break;
					}
				}
				/*
				 * If the space is free, move the acc to the
				 * right by HORFN.
				 */
				if (overlap == NO) {
					west += horfn;
					east += horfn;
				} else {
					/*
					 * All right, let's try again with 1/2
					 * of the previous horfn.
					 */
					horfn /= 2.0;
					overlap = NO;
					for (j = 0; j < reclim; j++) {
						if (rectab[j].s + FUDGE <= north - verfn &&
						    rectab[j].n - FUDGE >= south &&
						    rectab[j].w + FUDGE <= east + horfn &&
						    rectab[j].e - FUDGE >= east) {
							overlap = YES;
							break;
						}
					}
					if (overlap == NO) {
						west += horfn;
						east += horfn;
					}
				}
			}
		}

		/*
		 * We have the final position for the new acc.  Enter it into
		 * rectab.  But for naturals, we don't want to reserve the
		 * lower left corner, where there is nothing but white space;
		 * so in that case, put two overlapping entries in rectab to
		 * account for the rest of the space.  Naturals are symmetrical,
		 * so we can use the same horfn and verfn as were calculated
		 * above for the upper right corner.
		 */
		if (note_p->accidental == 'n') {
			/* upper part of natural */
			rectab[reclim].n = north;
			rectab[reclim].s = south + verfn;
			rectab[reclim].e = east;
			rectab[reclim].w = west;
			reclim++;

			/* right hand part of natural */
			rectab[reclim].n = north;
			rectab[reclim].s = south;
			rectab[reclim].e = east;
			rectab[reclim].w = west + savehorfn;
		} else {
			/* some other accidental; reserve the whole rectangle*/
			rectab[reclim].n = north;
			rectab[reclim].s = south;
			rectab[reclim].e = east;
			rectab[reclim].w = west;
		}
		reclim++;

		/*
		 * Store the acc's west in waccr in the NOTE structure for
		 * whichever groups have this note.  Store wlparen when there
		 * is a left paren on the note.
		 */
		if (noteptrs[k].top_p != 0) {
			if (note_p->note_has_paren == YES)
				noteptrs[k].top_p->wlparen = west;
			if (note_p->accidental != '\0')
				noteptrs[k].top_p->waccr = west + parenwidth;
		}
		if (noteptrs[k].bot_p != 0) {
			if (note_p->note_has_paren == YES)
				noteptrs[k].bot_p->wlparen = west;
			if (note_p->accidental != '\0')
				noteptrs[k].bot_p->waccr = west + parenwidth;
		}

	} /* end of loop for each accidental */

	/*
	 * Finally, if the stems were collinear, we have to adjust waccr for
	 * all the notes of the top group, so that it's relative to the top
	 * group instead of the bottom group.
	 */
	if (collinear) {
		for (k = 0; noteptrs[k].top_p != 0; k++) {
			if (noteptrs[k].top_p->note_has_paren == YES)
				noteptrs[k].top_p->wlparen += 2 * halfwide
					 	- W_NORMAL * POINT;
			if (noteptrs[k].top_p->accidental != '\0')
				noteptrs[k].top_p->waccr += 2 * halfwide
					 	- W_NORMAL * POINT;
		}
	}
}
\f
/*
 * Name:	nextacc()
 *
 * Abstract:	Find the next note that has an accidental to be processed.
 *
 * Returns:	Index to the NOTE, or -1 if no more.
 *
 * Description:	This function is called by doacc(), to return in the correct
 *		order the notes that have accidentals to be processed.
 *		(Actually, a note is to be processed not only if it has an
 *		accidental, but also if it has parentheses.)  The first time in
 *		here, count is 0, and it looks for the first eligible note (top
 *		down).  The next time, count is 1, and it looks for the bottom-
 *		most eligible note.  After that, it goes through the inner
 *		notes, top down.  In the great majority of cases, this will
 *		result in the most desirable packing of accidentals.
 */

static int
nextacc(noteptrs, found)

struct NOTEPTRS noteptrs[];	/* array of ptrs to notes to process */
int found;			/* no. of accidentals found already */

{
	struct NOTE *note_p;	/* point at a note */
	static int previdx;	/* idx to note chosen the last time in here */
	static int lastidx;	/* idx to the bottommost note chosen */
	int n;			/* loop counter */


	/*
	 * If this is the first call for this group(s), find the topmost
	 * eligible note.
	 */
	if (found == 0) {
		for (n = 0; (note_p = GETPTR(n)) != 0; n++) {
			if (note_p->accidental != '\0' ||
					note_p->note_has_paren == YES) {
				previdx = n;	/* remember it for next time */
				return (n);
			}
		}
		return (-1);	/* no notes have acc or parens */
	}

	/*
	 * If this is the second call, find the bottom of the list, then look
	 * backwards for the last eligible note.  Stop before finding the first
	 * note again.
	 */
	if (found == 1) {
		/* find the slot beyond the last note */
		for (n = 0; (note_p = GETPTR(n)) != 0; n++) {
			;
		}
		/* search from last note going backwards */
		for (n-- ; n > previdx; n--) {
			note_p = GETPTR(n);
			if (note_p->accidental != '\0' ||
					note_p->note_has_paren == YES) {
				lastidx = n;	/* remember it for next time */
				return (n);
			}
		}
		return (-1);	/* only 1 note has acc or parens */
	}

	/*
	 * Third or later call:  Scan inner notes top to bottom.
	 */
	for (n = previdx + 1; n < lastidx; n++) {
		note_p = GETPTR(n);
		if (note_p->accidental != '\0' ||
				note_p->note_has_paren == YES) {
			previdx = n;
			return (n);
		}
	}
	return (-1);		/* all eligible notes were already found */
}
\f
/*
 * Name:        dodot()
 *
 * Abstract:    Finds horizontal and vertical positions of dots.
 *
 * Returns:     void
 *
 * Description: This function figures out the limitations on where dots
 *		can be put, for each group, and calls dogrpdot() for each
 *		group that has dots, to figure their positions.
 */

static void
dodot(staff_p, gs1_p, gs2_p, halfwide, collinear)

struct STAFF *staff_p;		/* the staff the groups are connected to */
register struct GRPSYL *gs1_p, *gs2_p;	/* point at group(s) in this hand */
double halfwide;			/* half of max of width of notes */
int collinear;				/* are stems collinear? */

{
	/* the highest and lowest values of steps above the middle staff */
	/* line that a dot is allowed to be for the given group */
	int uppermost, lowermost;

	int lowtopidx;		/* index to lowest note of top group */
	int push;		/* steps to protruding note */
	register int k;		/* loop variable */


	lowtopidx = gs1_p->nnotes - 1;	/* for convenience */

	/*
	 * For each group that needs dots, set the outer limits of where
	 * they are allowed.  If the other group doesn't need dots, we
	 * have to be careful to keep them out of its way.  Otherwise,
	 * don't worry about that; let them fall on top of each other if
	 * that would happen.
	 */

	/*
	 * If the first group needs dots, find out how high and low they are
	 * allowed to be.  Also find out if nearby notes in the other group
	 * could be in the way of dots.  Call dogrpdot() with this info to
	 * find their positions.
	 */
	if (gs1_p->dots > 0) {
		/* upper limit is always as described above */
		uppermost = gs1_p->notelist[0].stepsup;
		if (uppermost % 2 == 0)		/* line note */
			uppermost++;

		/* set lower limit as if no other group */
		lowermost = gs1_p->notelist[lowtopidx].stepsup;
		if (lowermost % 2 == 0)		/* line note */
			lowermost--;

		/* but adjust if the other group exists & would interfere */
		if (gs2_p != 0 && gs2_p->dots == 0 || collinear) {
			if (lowermost <= gs2_p->notelist[0].stepsup)
				lowermost += 2;
		}

		/*
		 * If the stems are collinear, bottom group notes that are
		 * in normal position for that group protrude to the right
		 * relative to the top group.  From top down, search for notes
		 * in the bottom group that are like this.  Set push to the
		 * first one.  If none are found, let push be 1000 to be out of
		 * the way.  In setting horizontal dot positions, dogrpdot()
		 * needs to know this.
		 */
		push = 1000;
		if ( gs2_p != 0 && collinear ) {
			for (k = 0; k < gs2_p->nnotes; k++) {
				if (gs2_p->notelist[k].c[RX] == 0) {
					push = gs2_p->notelist[k].stepsup;
					break;
				}
			}
		}

		/* do top group's dots */
		dogrpdot(staff_p, gs1_p, (struct GRPSYL *)0, halfwide,
				uppermost, lowermost, push);
	}

	/*
	 * If the second group exists and needs dots, find out how high and
	 * low they are allowed to be, and find their positions.
	 */
	if (gs2_p != 0 && gs2_p->dots > 0) {
		/* set upper limit as if no other group */
		uppermost = gs2_p->notelist[0].stepsup;
		if (uppermost % 2 == 0)		/* line note */
			uppermost++;

		/* but adjust if the other group would interfere */
		if (gs1_p->dots == 0 || collinear) {
			if (uppermost >= gs1_p->notelist[lowtopidx].stepsup)
				uppermost -= 2;
		}

		/* lower limit is always as described above */
		lowermost = gs2_p->notelist[ gs2_p->nnotes - 1 ].stepsup;
		if (lowermost % 2 == 0)		/* line note */
			lowermost--;

		/*
		 * Unless the stems are collinear, in which case no problem,
		 * from bottom up, search for notes in the top group that
		 * protrude towards the right.  Set push to the first one.
		 * If none are found, let push be 1000 to be out of the way.
		 * In setting horizontal dot positions, dogrpdot() needs to
		 * know this.
		 */
		push = 1000;
		if ( ! collinear ) {
			for (k = lowtopidx; k >= 0; k--) {
				if (gs1_p->notelist[k].c[RX] > 0) {
					push = gs1_p->notelist[k].stepsup;
					break;
				}
			}
		}

		/* do bottom group's dots */
		dogrpdot(staff_p, gs2_p, gs1_p, halfwide, uppermost, lowermost,
				push);
	}
}
\f
/*
 * Name:        dogrpdot()
 *
 * Abstract:    Finds horizontal and vertical positions of dots for one group.
 *
 * Returns:     void
 *
 * Description: This function loops through all the notes belonging to the
 *		given group, setting the coords of the dots relative to it.
 */

/* recover dotsteps from ydotr, avoiding roundoff error */
#define	DOTSTEPS(ydotr)	(				\
	ydotr > 0.0 ?					\
		(int)((ydotr + 0.001) / STEPSIZE)	\
	:						\
		-(int)((-ydotr + 0.001) / STEPSIZE)	\
)

static void
dogrpdot(staff_p, gs_p, ogs_p, halfwide, uppermost, lowermost, push)

struct STAFF *staff_p;		/* the staff the groups are connected to */
register struct GRPSYL *gs_p;	/* point at group */
struct GRPSYL *ogs_p;		/* if we're doing group 1 and 2 together, and
				 * gs_p is group 2, ogs_p is group 1, else 0 */
double halfwide;		/* half of max of width of notes */
int uppermost;			/* highest step where a dot is permitted */
int lowermost;			/* lowest step where a dot is permitted */
int push;			/* avoid protruding note at this position */

{
	float dotwidth;		/* width of a dot (includes padding) */
	int normhorz;		/* use normal horizontal dot position? */
	int notesteps;		/* steps note is above center line of staff */
	int dotsteps;		/* steps dot is above center line of staff */
	register int n, k;	/* loop variables */


	/* until proven otherwise, assume normal horizontal dot position */
	normhorz = YES;

	/*
	 * The rules for vertical positioning of dots are as follows.
	 * For space notes, dots will be put in the same space.  For line
	 * notes we'd like them to be in the space directly above, except for
	 * voice 2 in vscheme=2o,3o or 2f,3f when voice 1 is not space, in
	 * which case we'd like them to be in the space below.  But if notes in
	 * a group are jammed onto neighboring steps, we may need to put some
	 * line note dots on the space below regardless; and we may
	 * even have to let some dots land on top of each other.  But in
	 * any case, never exceed the uppermost/lowermost bounds, which
	 * would interfere with the other group.
	 *
	 * The rules for horizontal positioning of dots are as follows.
	 * If the note on the dot's space, or either neighboring line,
	 * is in abnormal position to the right, the dot must be put
	 * farther right than normal.  The parameter "push" is the nearest
	 * note from the other group that protrudes this way.  And the dots
	 * of all the notes have to line up, so if any one has this problem,
	 * they must all be moved.
	 */

	/*
	 * Loop through all notes in the group, setting dot positions.  At
	 * the top of the loop, "dotsteps" is the previous dot, but by the
	 * end it gets set to the current dot.
	 */
	dotsteps = uppermost + 2;	/* pretend previous dot was here */

	for (n = 0; n < gs_p->nnotes; n++) {

		notesteps = gs_p->notelist[n].stepsup;

		if (notesteps % 2 == 0) {
			/*
			 * This note is on a line.  If the dot cannot be put
			 * above the line, or if doing that would overlay the
			 * previous dot and we are allowed to put it below
			 * the line, then put it below the line.  Else, put
			 * it above the line.  Notice that we're putting the
			 * dot in the space above if at all possible; later on,
			 * we'll make adjustments for voice 2 if appropriate.
			 */
			if (notesteps + 1 > uppermost ||
			   (notesteps + 1 == dotsteps &&
			    notesteps - 1 >= lowermost)) {
				dotsteps = notesteps - 1;
			} else {
				dotsteps = notesteps + 1;
			}
		} else {
			/*
			 * This note is on a space.  The dot must be put in
			 * this same space, regardless of anything else.
			 */
			dotsteps = notesteps;
		}

		/* set relative y coord based on step position */
		gs_p->notelist[n].ydotr = dotsteps * STEPSIZE;

		/*
		 * Now see if this dot forces abnormal positioning.  "Push" may
		 * indicate a protruding note in the other group.  If this
		 * note is within 1 step of our dot, use abnormal positioning
		 * for the dot.  Else if the stem is down, all dots can be
		 * normal.  Else, we have to search for protruding notes to
		 * see where the dot can be.
		 */
		if (normhorz == YES) {
			if (abs(dotsteps - push) <= 1) {
				normhorz = NO;
			} else if (gs_p->stemdir == UP) {
				for (k = 0; k < gs_p->nnotes; k++) {
					notesteps = gs_p->notelist[k].stepsup;

					if (gs_p->notelist[k].c[RE] >halfwide &&
					    notesteps <= dotsteps + 1 &&
					    notesteps >= dotsteps - 1) {

						normhorz = NO;
						break;
					}
				}
			}
		}
	}

	/*
	 * Set horizontal dot positions, relative to the group.  STDPAD is
	 * needed because notehead characters don't include padding.  The
	 * abnormal case adds in one more notehead width, minus the width
	 * of the stem.  Since the dots for all notes line up vertically,
	 * xdotr is in GRPSYL instead of in each NOTE.
	 */
	dotwidth = width(FONT_MUSIC, DFLT_SIZE, C_DOT);
	gs_p->xdotr = halfwide + STDPAD + dotwidth / 2;
	if (normhorz == NO) {
		gs_p->xdotr += 2 * halfwide - W_NORMAL * POINT;
	}

	/*
	 * If this is voice 2, we may need to adjust the vertical position of
	 * nonshared line notes.  The same should happen if this is voice 3
	 * "standing in" for voice 2.
	 */
	if (gs_p->pvno == 2) {
		int trymove;		/* try to move dots? */
		int vscheme;		/* voice scheme */
		RATIONAL vtime;		/* time so far in this measure */
		int prevdotsteps;	/* Y distance of prev note's dot */
		struct GRPSYL *pgs_p;	/* point along GRPSYL list */
		int onotesteps;		/* lowest note of voice 1 */

		trymove = NO;		/* first assume leave them alone */
		vscheme = svpath(gs_p->staffno, VSCHEME)->vscheme;
		if (vscheme == V_2OPSTEM || vscheme == V_3OPSTEM) {
			/* always try to move if 2o or 3o */
			trymove = YES;
		} else {
			/* 2f or 3f; move iff voice 1 is not all spaces here */
			vtime = Zero;	/* add up time of preceding groups */
			for (pgs_p = gs_p->prev; pgs_p != 0;
					pgs_p = pgs_p->prev) {
				vtime = radd(vtime, pgs_p->fulltime);
			}
			if ( ! hasspace(staff_p->groups_p[0], vtime,
					radd(vtime, gs_p->fulltime))) {
				/* not all space during duration of our group*/
				trymove = YES;
			}
		}

		if (trymove == YES) {
			/*
			 * We need to try to move the dots of line notes from
			 * the space above them to the space below them.  We
			 * will work from bottom to top.  Initially, pretend
			 * that the previous note is way low out of the way.
			 * If a voice 1 group was being handled along with our
			 * group, find the stepsup of its lowest note.
			 */
			prevdotsteps = -1000;
			if (ogs_p != 0) {
				onotesteps = ogs_p->notelist[
						ogs_p->nnotes - 1].stepsup;
			} else {
				onotesteps = 0;	/* for lint; set before used */
			}
			for (n = gs_p->nnotes - 1; n >= 0; n--) {
				notesteps = gs_p->notelist[n].stepsup;
				/*
				 * We want to stop if we run into notes shared
				 * by group 1 if it exists.  ( > is defensive).
				 */
				if (ogs_p != 0 && notesteps >= onotesteps)
					break;
				/*
				 * Recover our dotsteps from our dots coord
				 * calculated earlier in this function.  Then,
				 * consider moving our dot only if we are a
				 * line note and our dot is currently in the
				 * space above.  (It could already be below,
				 * do to tightly packed notes.)
				 */
				dotsteps = DOTSTEPS(gs_p->notelist[n].ydotr);
				if (notesteps % 2 == 0 &&
						dotsteps == notesteps + 1) {
					/*
					 * If the previous (lower) note is at
					 * least 2 steps away, we can certainly
					 * move our dot.  But also move it if
					 * we are the top note of group 2, and
					 * group 1 exists and has a note 2 steps
					 * away, and they don't have a dot at
					 * the same horz position; because our
					 * dot would be confusing if above.  If
					 * it make our dot land on top of the
					 * previous note's dot, tough.
					 */
					if (prevdotsteps < notesteps - 1 ||
					    n == 0 && ogs_p != 0 &&
					    notesteps + 2 == onotesteps &&
					    ogs_p->xdotr != gs_p->xdotr) {

						dotsteps -= 2;
						gs_p->notelist[n].ydotr -=
							2.0 * STEPSIZE;
					}
				}
				prevdotsteps = dotsteps;
			}
		}
	}
}
\f
/*
 * Name:        westwith()
 *
 * Abstract:    Adjust west coord of a group to allow for its "with" lists.
 *
 * Returns:     void
 *
 * Description: This function is given a GRPSYL whose relative horizontal
 *		coords are set, relative to the center of the group, except
 *		that "with" lists have not yet been considered.  It alters
 *		gs_p->c[RW] if need be so that the group's rectangle includes
 *		all "with" lists.
 */

static void
westwith(gs_p)

struct GRPSYL *gs_p;		/* point at this group */

{
	int n;			/* loop through the "with" list items */
	int font, size;		/* of the chars in the "with" list item */
	int first_char;		/* first char of string to print */
	char *str_p;		/* point into the item */
	float x_offset;		/* half the width of the first char in item */


	for (n = 0; n < gs_p->nwith; n++) {
		/* should center first character on x */
		font = gs_p->withlist[n][0];
		size = gs_p->withlist[n][1];
		str_p = gs_p->withlist[n] + 2;
		first_char = next_str_char(&str_p, &font, &size);
		x_offset = width(font, size, first_char) / 2.0;
		if (-x_offset < gs_p->c[RW])
			gs_p->c[RW] = -x_offset;
	}
}
\f
/*
 * Name:        eastwith()
 *
 * Abstract:    Adjust east coord of a group to allow for its "with" lists.
 *
 * Returns:     void
 *
 * Description: This function is given a GRPSYL whose relative horizontal
 *		coords are set, relative to the center of the group, except
 *		that "with" lists have not yet been considered.  It alters
 *		gs_p->c[RE] if need be so that the group's rectangle includes
 *		all "with" lists.
 */

static void
eastwith(gs_p)

struct GRPSYL *gs_p;		/* point at this group */

{
	int n;			/* loop through the "with" list items */
	int font, size;		/* of the chars in the "with" list item */
	int first_char;		/* first char of string to print */
	char *str_p;		/* point into the item */
	float x_offset;		/* half the width of the first char in item */


	for (n = 0; n < gs_p->nwith; n++) {
		/* should center first character on x */
		font = gs_p->withlist[n][0];
		size = gs_p->withlist[n][1];
		str_p = gs_p->withlist[n] + 2;
		first_char = next_str_char(&str_p, &font, &size);
		x_offset = strwidth(gs_p->withlist[n]) -
				width(font, size, first_char) / 2.0;
		if (x_offset > gs_p->c[RE])
			gs_p->c[RE] = x_offset;
	}
}
\f
/*
 * Name:        csbstempad()
 *
 * Abstract:    Pad a group's RW for cross staff beaming if need be.
 *
 * Returns:     void
 *
 * Description: In cross staff beamed groups, where the beams are between the
 *		staffs, and a note on the bottom staff is followed by a note on
 *		the top staff, and the first note has no dots or anything else
 *		that would force more space after it, and the top note has no
 *		accidentals, graces, or anything that would force more space
 *		before it, the stems of the two groups can be very close
 *		together, too close.  This function checks for that case, and
 *		when found, adds padding to the left of the top group.
 */

static void
csbstempad(mll_p, gs_p)

struct MAINLL *mll_p;		/* the MLL item the group is connected to */
struct GRPSYL *gs_p;		/* point at the top staff's group */

{
	struct GRPSYL *gs2_p;		/* point at various GRPSYLs */
	struct CHORD *ch_p, *pch_p;	/* our chord and preceding chord */
	struct MAINLL *m2_p;		/* loop through MLL */
	int k;				/* loop through notelist */
	int found;			/* have we found our group? */


	/* if this group is not a candidate for this, return */
	if (gs_p->beamto != CS_BELOW)	/* must be CSB beamed with below */
		return;
	if (gs_p->stemdir == UP)	/* stem must be down */
		return;
	if (gs_p->beamloc == STARTITEM)	/* must not be first item in CSB */
		return;
	if (gs_p->prev == 0)		/* (defensive) */
		return;
	if (gs_p->prev->grpcont != GC_SPACE)	/* prev must be a space */
		return;

	/*
	 * The notes should all have the same RW (even cues) unless a note is
	 * on the "wrong" side of the stem, because they are all supposed to
	 * touch the stem.  In the latter case, there's already enough space in
	 * the group to the left of the stem, so return.
	 */
	for (k = 1; k < gs_p->nnotes; k++) {
		if (ABSDIFF(gs_p->notelist[k].c[RW], gs_p->notelist[0].c[RW])
				> FUDGE)
			return;
	}

	/*
	 * If there's anything to the left of the notes' RWs (the stem
	 * position), it should be enough space, so return.
	 */
	if (gs_p->c[RW] < gs_p->notelist[0].c[RW] - STDPAD - FUDGE)
		return;

	/* find the chord headcell for this measure */
	for (m2_p = mll_p->prev; m2_p->str != S_CHHEAD; m2_p = m2_p->prev)
		;
	/*
	 * Loop through the chords.  For each chord, loop through all its
	 * groups, trying to find our group.  It should be found.  At the point
	 * it is found, pch_p will point to the chord preceding the one that
	 * contains our group.
	 */
	found = NO;
	pch_p = 0;	/* to avoid useless 'used before set' warning */
	for (ch_p = m2_p->u.chhead_p->ch_p; ch_p != 0;
				pch_p = ch_p, ch_p = ch_p->ch_p) {
		for (gs2_p = ch_p->gs_p; gs2_p != 0; gs2_p = gs2_p->gs_p) {
			if (gs2_p == gs_p) {
				found = YES;
				break;
			}
		}
		if (found == YES)
			break;
	}
	if (found == NO)	/* defensive; this should never happen */
		return;

	/* find next visible staff after our staff */
	for (m2_p = mll_p->next; m2_p->str == S_STAFF &&
			m2_p->u.staff_p->visible == NO; m2_p = m2_p->next)
		;
	if (m2_p->str != S_STAFF)	/* defensive; should not happen */
		return;

	/*
	 * Loop down the preceding chord, looking for a group that is on the
	 * next visible staff after our staff and is CSB'ed to the staff above.
	 */
	for (gs2_p = pch_p->gs_p; gs2_p != 0; gs2_p = gs2_p->gs_p) {

		if (gs2_p->staffno == m2_p->u.staff_p->staffno &&
				gs2_p->beamto == CS_ABOVE) {
			/*
			 * We found such a group; it must be the only one.
			 * Check that it meets the conditions.
			 */
			if (gs2_p->stemdir == DOWN)
				return;
			/*
			 * The notes need to all have the same RE, analogous to
			 * the earlier check on gs_p's RW.
			 */
			for (k = 1; k < gs2_p->nnotes; k++) {
				if (ABSDIFF(gs2_p->notelist[k].c[RE], gs2_p->
						notelist[0].c[RE]) > FUDGE)
					return;
			}
			/*
			 * If there's anything to the right of the notes' REs,
			 * there's already enough space.
			 */
			if (gs2_p->c[RE] > gs2_p->notelist[0].c[RE] +
					STDPAD + FUDGE)
				return;

			/*
			 * FINALLY!  We have established the need for more
			 * space.  Append it to our group's RW.
			 */
			gs_p->c[RW] -= STEPSIZE;
			return;
		}
	}

	/* didn't find one; shouldn't happen, but just return */
}
\f
/*
 * Name:        proctab()
 *
 * Abstract:    Sets relative horizontal coords of fret numbers.
 *
 * Returns:     void
 *
 * Description: This function sets all the horizontal coords of "notes" on a
 *		tablature staff, which are actually fret numbers.  It sets RW
 *		and RE for the group, too.  They also take bends into account.
 */

static void
proctab(mll_p, staff_p, gs_p)

struct MAINLL *mll_p;		/* the MLL item the group is connected to */
struct STAFF *staff_p;		/* the staff the group is connected to */
struct GRPSYL *gs_p;		/* point at this group */

{
	int n;			/* loop through the "notes" in the group */
	float halfwide;		/* half the width of a fret or bend number */
	float maxhalffret;	/* half the max width of a fret number */
	float maxhalfbend;	/* half the max width of a bend number */
	float maxbend;		/* width of a bend number that sticks right */
	struct GRPSYL *prevgs_p;/* point at previous group */
	int center;		/* should bend string be centered? */
	int k;			/* loop variable */


	maxhalffret = 0.0;
	maxhalfbend = 0.0;
	maxbend = 0.0;

	prevgs_p = prevgrpsyl(gs_p, &mll_p);	/* in case we need it */

	/* loop though all frets and bends in this group */
	for (n = 0; n < gs_p->nnotes; n++) {
		/*
		 * If there is a fret, find half the width of that number.  It
		 * should be centered on the center of the group.  Keep track
		 * of the maximum width so far.  Allow 1.5*STDPAD on each side
		 * of the fret number, since we don't ever want the numbers so
		 * close that they look like one number.
		 */
		if (gs_p->notelist[n].FRETNO != NOFRET) {
			halfwide = strwidth(fret_string(&gs_p->notelist[n],
					gs_p)) / 2.0;
			gs_p->notelist[n].c[RX] = 0.0;
			gs_p->notelist[n].c[RE] = halfwide;
			gs_p->notelist[n].c[RW] = -halfwide;
			maxhalffret = MAX(halfwide + 1.5*STDPAD, maxhalffret);
		}

		/*
		 * If there is a bend, figure out if it's the normal situation
		 * (centered on the group's X) or the the case where its left
		 * edge should be at the group's X (the case of a continuation
		 * bend where the previous group's bend was higher).  In the
		 * latter case, the string had to be shifted to avoid colliding
		 * with the arrow coming down from the previous group.
		 */
		if (HASREALBEND(gs_p->notelist[n])) {
			center = YES;	/* first assume normal */

			/* search previous group, if any, for a bend */
			if (prevgs_p != 0) {
				for (k = 0; k < prevgs_p->nnotes; k++) {
					if (HASREALBEND(prevgs_p->notelist[k]))
						break;
				}
				/*
				 * If previous group had a bend and its
				 * distance was higher than the current group,
				 * we have the special case.
				 */
				if (k < prevgs_p->nnotes &&
				    GT( ratbend(&prevgs_p->notelist[k]),
				    ratbend(&gs_p->notelist[n]) ) ) {
					center = NO;
				}
			}
			if (center == YES) {
				/*
				 * Normal case of a bend string: centered at
				 * group's X.  Maintain maxhalfbend as the
				 * the widest so far.
				 */
				halfwide = strwidth(bend_string(
						&gs_p->notelist[n])) / 2.0;
				maxhalfbend = MAX(halfwide, maxhalfbend);
			} else {
				/*
				 * A bend string that has its left edge at the
				 * group's X.  There can only be one such,
				 * since multiple continuation bends are not
				 * allowed (other than releases).
				 */
				maxbend = strwidth(bend_string(
						&gs_p->notelist[n]));
			}
		}
	}

	/*
	 * Set the group's relative horizontal coordinates.  On the east, add
	 * extra room if there are ties or slurs.  On the west, add any user
	 * requested padding.  Also adjust for "with" lists.  They can extend
	 * into tie/slur padding, but not into user requested padding.
	 */
	gs_p->c[RX] = 0.0;

	gs_p->c[RW] = -MAX(maxhalffret, maxhalfbend);
	westwith(gs_p);
	gs_p->c[RW] -= gs_p->padding;
	gs_p->c[RW] -= vvpath(gs_p->staffno, gs_p->vno, PAD)->pad;

	maxhalffret += tieslurpad(staff_p, gs_p);
	gs_p->c[RE] = MAX(MAX(maxhalffret, maxhalfbend), maxbend);
	eastwith(gs_p);
}
\f
/*
 * Name:        noterparen()
 *
 * Abstract:    Finds horizontal position notes' right parentheses.
 *
 * Returns:     void
 *
 * Description: If any of the notes in the given group(s) are to have
 *		parentheses around them, this function finds the horizontal
 *		positions of the right parentheses.  The left ones were done
 *		in doacc() along with accidentals.  For each group, it uses
 *		the appropriate size of parentheses (based on normal versus
 *		cue/grace), and places them appropriately, considering also
 *		the size of the notes.  However, if there are two groups,
 *		the note head sizes could be different.  The halfwide and
 *		halfhigh passed in are supposed to be the right size for the
 *		bigger of the two sizes, and accidentals will not be packed
 *		as tightly against the other notes.  This doesn't hurt, and
 *		isn't worth the trouble to do it "right".
 */

static void
noterparen(noteptrs, gs1_p, gs2_p, halfwide, halfhigh, collinear)

struct NOTEPTRS noteptrs[];	/* array of ptrs to notes to process */
struct GRPSYL *gs1_p, *gs2_p;	/* point at group(s) in this hand */
double halfwide;		/* half of max of width & height of (notes */
double halfhigh;		/*  in group 1, notes in group 2) */
int collinear;			/* are stems collinear? */

{
	/*
	 * Each structure in this table represents either a note head that is
	 * farther right than normal, note dot(s), or right paren.  A note head
	 * could be too far right for one of two reasons: either it was
	 * forced to be on the right ("wrong") side of a stem that points
	 * up, or it is a normal note in the bottom group when the stems are
	 * collinear.  In the collinear case, to make this function easier,
	 * we start out regarding the top group as being normal, and
	 * the bottom group as being shifted right one note head, and we figure
	 * everything relative to the top group.  But at the end we adjust
	 * so that every parenthesis is relative to its own group, like
	 * it's supposed to be.
	 *
	 * The coordinates define the rectangle that surrounds the note, dot(s),
	 * or paren, including standard padding, even on note heads, which don't
	 * normally have padding.  First the notes and dots are put into this
	 * table, just one rectangle for a sequence of dots; then the right
	 * parens one at a time, making sure they don't overlap things already
	 * in the table.
	 *
	 * To see if the parenthesis being added overlaps, first its north
	 * and south are tested.  All previous rectangles that are "out of
	 * its way" vertically are marked not "relevant"; the others are
	 * marked "relevant".  As positions are tried, left to right, positions
	 * that fail to avoid overlap are marked "tried".
	 */
	struct {
		float n, s, e, w;	/* boundaries of a rectangle */
		short relevant;		/* is rectangle relevant? */
		short tried;		/* have we tried this one yet? */
	} rectab[2 * MAXHAND + 1];	/* enough for all notes & accidentals*/

	struct NOTE *note_p;		/* point at a note */
	int reclim;			/* index after last rectangle in tab */
	int parensexist;		/* does any note have parens? */
	float north, south, east, west;	/* relative coords of new accidental */
	float parenwidth;		/* width of note's left parenthesis */
	float parenv;			/* half the vertical size of paren */
	float dotoff;			/* additional offset caused by dots */
	float dotoff1, dotoff2;		/* same, for groups 1 and 2 */
	int overlap;			/* does our acc overlap existing ones*/
	int try;			/* which element of rectab to try */
	int k, j;			/* loop variables */
	int size;


	/*
	 * If no notes have parentheses, we can get out because there is
	 * nothing to do.
	 */
	parensexist = NO;		/* init to no parens */
	for (k = 0; (note_p = GETPTR(k)) != 0; k++) {
		if (note_p->note_has_paren == YES)
			parensexist = YES;
	}
	if (parensexist == NO)
		return;

	reclim = 0;			/* table initially empty */

	/* set up dot offsets for both groups, zero if no dots */
	dotoff1 = gs1_p->dots * (width(FONT_MUSIC,DFLT_SIZE,C_DOT) + 2*STDPAD);
	dotoff2 = 0.0;		/* prevent useless 'used before set' warning */
	if (gs2_p != 0) {
		dotoff2 = gs2_p->dots * (width(FONT_MUSIC, DFLT_SIZE, C_DOT) +
				2 * STDPAD);
	}

	/*
	 * Loop through noteptrs, loading rectab with all the things that are
	 * already present that are to the right of the baseline.
	 */
	for (k = 0; (note_p = GETPTR(k)) != 0; k++) {
		/*
		 * If note exists in top group, use its dot offset, else use
		 * bottom's.  If it's in both, the results would be the same.
		 */
		if (noteptrs[k].top_p != 0)
			dotoff = dotoff1;
		else
			dotoff = dotoff2;

		/* if note is right of normal position, put it in the table */
		if (note_p->c[RX] > 0) {
			rectab[reclim].n = note_p->c[RY] + halfhigh + STDPAD;
			rectab[reclim].s = note_p->c[RY] - halfhigh - STDPAD;
			rectab[reclim].e = note_p->c[RE] + STDPAD;
			rectab[reclim].w = note_p->c[RW] - STDPAD;
			reclim++;
		}

		/* if collinear, bottom group's notes go into table if normal */
		if (collinear && noteptrs[k].bot_p != 0) {
			if (note_p->c[RX] == 0) {
				rectab[reclim].n = note_p->c[RY] + halfhigh
						+ STDPAD;
				rectab[reclim].s = note_p->c[RY] - halfhigh
						- STDPAD;
				rectab[reclim].e = W_NORMAL * POINT
						+ 3 * halfwide + STDPAD;
				rectab[reclim].w = W_NORMAL * POINT
						+ halfwide - STDPAD;
				reclim++;
			}
		}

		/* if this group has dots, do rectangle for dots */
		if (dotoff > 0) {
			rectab[reclim].n = note_p->ydotr + STDPAD;
			rectab[reclim].s = note_p->ydotr - STDPAD;
			if (noteptrs[k].top_p != 0)
				rectab[reclim].e = gs1_p->xdotr + dotoff;
			else
				rectab[reclim].e = gs2_p->xdotr + dotoff;
			rectab[reclim].w = 0;
			reclim++;
		}
	}

	/*
	 * Loop through all parentheses, finding where they will fit, storing
	 * that info in erparen, and adding them to rectab.
	 */
	for (k = 0; (note_p = GETPTR(k)) != 0; k++) {

		/* if no parens around the note, skip the note */
		if (note_p->note_has_paren == NO)
			continue;

		/* get dimensions of note's right paren */
		size = (note_p->notesize == GS_NORMAL ? DFLT_SIZE : SMALLSIZE);
		parenwidth = width(FONT_TR, size, ')');
		parenv = height(FONT_TR, size, ')') / 2.0;

		/* set the north and south of the paren */
		north = note_p->c[RY] + parenv;
		south = note_p->c[RY] - parenv;

		/*
		 * For each rectangle in rectab, decide whether (based on
		 * its vertical coords) it could possibly overlap with our
		 * new paren.  If it's totally above or below ours, it
		 * can't.  We allow a slight overlap (FUDGE) so that round
		 * off errors don't stop us from packing things as tightly
		 * as possible.
		 */
		for (j = 0; j < reclim; j++) {
			if (rectab[j].s + FUDGE > north ||
			    rectab[j].n < south + FUDGE)
				rectab[j].relevant = NO;
			else
				rectab[j].relevant = YES;
		}

		/*
		 * Mark that none of the relevant rectangles' boundaries have
		 * been tried yet for positioning our paren.
		 */
		for (j = 0; j < reclim; j++) {
			if (rectab[j].relevant == YES)
				rectab[j].tried = NO;
		}

		/*
		 * Set up first trial position for this paren, just to the
		 * right of normal notes, allowing padding.
		 */
		west = halfwide + STDPAD;
		east = west + parenwidth;

		/*
		 * Keep trying positions for this paren, working left to
		 * right.  When we find one that doesn't overlap an existing
		 * rectangle, break.  This has to succeed at some point,
		 * at the rightmost rectangle position if not earlier.
		 */
		for (;;) {
			overlap = NO;
			for (j = 0; j < reclim; j++) {
				/* ignore ones too far north or south */
				if (rectab[j].relevant == NO)
					continue;

				/* if all west or east, okay; else overlap */
				if (rectab[j].w + FUDGE <= east &&
				    rectab[j].e >= west + FUDGE) {
					overlap = YES;
					break;
				}
			}

			/* if no rectangle overlapped, we found a valid place*/
			if (overlap == NO)
				break;

			/*
			 * Something overlapped, so we have to try again.
			 * Find the westermost relevant east rectangle boundary
			 * that hasn't been tried already, to use as the next
			 * trial position for our paren's west.
			 */
			try = -1;
			for (j = 0; j < reclim; j++) {
				/* ignore ones too far north or south */
				if (rectab[j].relevant == NO ||
				    rectab[j].tried == YES)
					continue;

				/*
				 * If this is the first relevant one we haven't
				 * tried, or if this is farther west than the
				 * westernmost so far, save it as being the
				 * new westernmost so far.
				 */
				if (try == -1 || rectab[j].e < rectab[try].e)
					try = j;
			}

			if (try == -1)
				pfatal("bug in noterparen()");

			/*
			 * Mark this one as having been tried (for next time
			 * around, if necessary).  Set new trial values for
			 * east and west of our paren.
			 */
			rectab[try].tried = YES;
			west = rectab[try].e;
			east = west + parenwidth;

		} /* end of while loop trying positions for this acc */

		/*
		 * We have the final position for the new paren.  Enter it into
		 * rectab.  Store its east in erparen in the NOTE structure for
		 * whichever groups have this note.
		 */
		rectab[reclim].n = north;
		rectab[reclim].s = south;
		rectab[reclim].e = east;
		rectab[reclim].w = west;
		reclim++;
		if (noteptrs[k].top_p != 0) {
			noteptrs[k].top_p->erparen = east;
		}
		if (noteptrs[k].bot_p != 0) {
			noteptrs[k].bot_p->erparen = east;
		}

	} /* end of loop for each accidental */

	/*
	 * Finally, if the stems were collinear, we have to adjust erparen for
	 * all the notes of the bottom group, so that it's relative to the
	 * bottom group instead of the top group.
	 */
	if (collinear) {
		for (k = 0; (note_p = GETPTR(k)) != 0; k++) {
			if (noteptrs[k].bot_p != 0) {
				noteptrs[k].bot_p->erparen -= 2 * halfwide
						- W_NORMAL * POINT;
			}
		}
	}
}