1 /* Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
2 * 2005, 2006 by Arkkra Enterprises */
3 /* All rights reserved */
7 * Description: This file contains functions for setting all absolute
8 * vertical coordinates.
16 * Define the maximum number of scores that could ever fit on a page, when all
17 * staffs and scores are packed as tightly as possible. The 8 * STEPSIZE is
18 * the height of the five lines of a staff, and the other factor in the
19 * denominator is the minimum distance between staffs or scores, whichever is
20 * smaller. If a staff has less than 5 lines, it is still given as much space
21 * as a 5 line staff, so that's why we can use 8 * STEPSIZE here as the
22 * smallest possible staff size.
24 #define MAXSCORES ( (int)(PGHEIGHT / \
25 (MINSTFSCALE * STEPSIZE * (8 + MIN(MINMINSTSEP, MINMINSCSEP)))) + 1 )
27 #define FUDGE 0.001 /* fudge factor for round off error */
29 /* determine what clef, if any, will be printed on a staff */
30 #define CLEF2PRINT(staffno) \
31 (svpath(staffno, STAFFLINES)->printclef == SS_NORMAL ? \
32 svpath(staffno, CLEF)->clef : NOCLEF)
34 /* define amount of horz and vert padding between at-end grids */
35 #define HPADGRID (2.0 * STEPSIZE)
36 #define VPADGRID (2.0 * STEPSIZE)
38 /* maximum length of a chord name that we care about for sorting purposes */
39 #define MAXCHNAME (100)
41 static void relscore
P((struct MAINLL
*mllfeed_p
));
42 static void relstaff
P((struct MAINLL
*feed_p
, int s1
, int s2
, double botoff
,
44 static void posscores
P((void));
45 static void abspage
P((struct MAINLL
*page_p
, float cursep
[], float maxsep
[],
46 float curpad
[], float maxpad
[], int totscores
,
47 double remheight
, double y_start
));
48 static void absstaff
P((struct FEED
*feed_p
, struct STAFF
*staff_p
));
49 static double grids_atend
P((double vertavail
, int firstpage
,
50 struct FEED
*mfeed_p
, struct FEED
*gfeed_p
));
51 static int compgrids
P((const void *g1_p_p
, const void *g2_p_p
));
52 static void proc_css
P((void));
53 static void one_css
P((struct STAFF
*ts_p
, struct STAFF
*os_p
,
54 struct GRPSYL
*tg_p
, RATIONAL time
));
55 static void horzavoid
P((void));
56 static void avoidone
P((struct MAINLL
*mainll_p
, struct GRPSYL
*cssg_p
,
58 static void set_csb_stems
P((void));
59 static void onecsb
P((struct GRPSYL
*gs1_p
, struct GRPSYL
*gs2_p
));
60 static int calcline
P((struct GRPSYL
*start1_p
, struct GRPSYL
*end1_p
,
61 struct GRPSYL
*start2_p
, struct GRPSYL
*end2_p
,
62 struct GRPSYL
*first_p
, struct GRPSYL
*last_p
,
63 int topdir
, int botdir
,
64 float *b0_p
, float *b1_p
));
65 static void samedir
P((struct GRPSYL
*first_p
, struct GRPSYL
*last_p
,
66 struct GRPSYL
*start1_p
, struct GRPSYL
*start2_p
,
67 struct GRPSYL
*end1_p
, float *b0_p
, float *b1_p
,
68 double deflen
, int one_end_forced
, int slope_forced
,
69 double forced_slope
));
70 static void oppodir
P((struct GRPSYL
*first_p
, struct GRPSYL
*last_p
,
71 struct GRPSYL
*start1_p
, struct GRPSYL
*start2_p
,
72 float *b0_p
, float *b1_p
, double deflen
, int one_end_forced
,
73 int slope_forced
, double forced_slope
));
74 static struct GRPSYL
*nextcsb
P((struct GRPSYL
*gs_p
));
75 static struct GRPSYL
*nxtbmnote
P((struct GRPSYL
*gs_p
, struct GRPSYL
*first_p
,
76 struct GRPSYL
*endnext_p
));
81 * Abstract: Set all absolute vertical coordinates.
85 * Description: This function sets all absolute vertical coordinates. First it
86 * calls relscore() for each score, to position the staffs in that
87 * score relative to the score. Then it calls posscores() to
88 * decide how many scores to put on each page, and set all the
89 * absolute coordinates. Finally it completes the work for
90 * cross staff stemming (CSS) and cross staff beaming (CSB).
97 struct MAINLL
*mainll_p
; /* point along main linked list */
100 debug(16, "absvert");
102 * Find each section of the main linked list, delimited by FEEDs. For
103 * each such section, call relscore() to fix the score internally
104 * (relative to itself, all staffs and between stuff). Keep SSVs
105 * up to date so that we always know what the user requested
108 initstructs(); /* clean out old SSV info */
110 for (mainll_p
= Mainllhc_p
; mainll_p
!= 0; mainll_p
= mainll_p
->next
) {
111 switch (mainll_p
->str
) {
113 asgnssv(mainll_p
->u
.ssv_p
);
123 * Position the scores on the pages, setting all absolute vertical
129 * Process groups that have cross staff stemming, if there were any.
131 if (CSSused
== YES
) {
136 * Set stem lengths for groups involved in cross staff beaming, if
139 if (CSBused
== YES
) {
147 * Abstract: Set certain relative coords to be relative to score.
151 * Description: This function loops through the part of the main linked list
152 * for this score. It adjusts the relative vertical coords of
153 * STAFFs, and also of GRPSYLs (syllables) and STUFFs of the
154 * things that are "between" staffs. In the end, the STAFFs will
155 * be relative to the score (FEED), and the between things will
156 * be relative to the staff above them. Yes, I suppose this
157 * belongs in relvert.c, but relvert.c has enough work to do.
163 struct MAINLL
*mllfeed_p
; /* FEED at start of this score */
166 struct MAINLL
*mainll_p
;/* point along main linked list */
167 struct STAFF
*cstaff_p
; /* point at current staff */
168 struct STAFF
*pstaff_p
; /* point at previous staff */
169 struct FEED
*feed_p
; /* point at FEED structure itself */
170 float cstaffoffset
; /* current staff offset from score */
171 float staffdist
; /* dist between prev & cur staff inner lines*/
172 float halfnonbetween
; /* (staffdist - heightbetween) / 2 */
173 float betweendist
; /* from prev staff center line to base line */
174 float prevhalf
; /* half the height of previous staff */
175 float curhalf
; /* half the height of current staff */
176 float limit
; /* smallest dist allowed between inner lines */
177 float needed
; /* dist between inner lines to avoid collis */
178 int prevclef
; /* clef on the previous staff */
179 float prevscale
; /* staffscale of the previous staff */
180 float spad
; /* staffpad (inches) below previous staff */
181 float clefroom
; /* room for clefs and/or measure numbers */
182 static int first
= YES
; /* is this the first score in the song? */
185 debug(32, "relscore file=%s line=%d", mllfeed_p
->inputfile
,
186 mllfeed_p
->inputlineno
);
187 feed_p
= mllfeed_p
->u
.feed_p
;
190 * If this score is actually a block, all we have to do is set the
191 * relative vertical coords of the FEED. We set RY to be the center.
193 if (mllfeed_p
->next
!= 0 && mllfeed_p
->next
->str
== S_BLOCKHEAD
) {
194 feed_p
->c
[RN
] = mllfeed_p
->next
->u
.blockhead_p
->height
/ 2.0;
195 feed_p
->c
[RY
] = 0; /* RY is always 0 */
196 feed_p
->c
[RS
] = -feed_p
->c
[RN
];
197 feed_p
->lastdist
= 0.0;
202 * Find the first STAFF in this score (will be in first measure).
204 for (mainll_p
= mllfeed_p
->next
; mainll_p
!= 0 &&
205 mainll_p
->str
!= S_FEED
&& mainll_p
->str
!= S_STAFF
;
206 mainll_p
= mainll_p
->next
)
208 if (mainll_p
== 0 || mainll_p
->str
!= S_STAFF
)
209 return; /* ignore items when there's a feed at end of song */
211 /* init variables for main loop */
212 cstaffoffset
= 0; /* top staff Y == score Y */
213 pstaff_p
= 0; /* there is no previous staff */
216 spad
= 0.0; /* keep lint happy; will be set before used */
219 * Loop through all STAFF structures in the first measure of this
220 * score. Skip invisible ones. cstaff_p always points at the staff
221 * we are working on, and pstaff_p always points to the previous
222 * visible staff (so is 0 while we are working on the first visible
223 * staff of the score). For each visible staff except the first, we
224 * figure out how far down it should be from the one above it, and
225 * set its relative vertical coords relative to the score. Also, we
226 * figure out where to put the things that are "between" this staff
227 * and the one above, and set them relative to the above staff.
229 for ( ; mainll_p
->str
== S_STAFF
; mainll_p
= mainll_p
->next
) {
231 cstaff_p
= mainll_p
->u
.staff_p
;
234 * If this staff is invisible, ignore it completely.
236 if (cstaff_p
->visible
== NO
)
240 * If it's the first visible staff, there are no coords to set,
241 * since its offset is 0 and the "between" objects below it
242 * will be handled by the next loop. Also set first and last
243 * visible staff numbers in the FEED in this loop, and the
244 * relative vertical coords of the score.
247 /* set first visible staff number */
248 feed_p
->firstvis
= cstaff_p
->staffno
;
250 /* feed's RN is same as first visible staff's RN */
251 feed_p
->c
[RN
] = cstaff_p
->c
[RN
];
252 feed_p
->c
[RY
] = 0; /* RY is always 0 */
254 /* these next 3 will be changed later if more staffs */
255 feed_p
->c
[RS
] = cstaff_p
->c
[RS
];
256 feed_p
->lastvis
= cstaff_p
->staffno
;
257 feed_p
->lastdist
= cstaff_p
->c
[RY
] - cstaff_p
->c
[RS
] -
258 staffvertspace(cstaff_p
->staffno
) / 2.0;
260 pstaff_p
= cstaff_p
; /* previous visible staff */
261 prevclef
= CLEF2PRINT(pstaff_p
->staffno
);
262 prevscale
= svpath(pstaff_p
->staffno
, STAFFSCALE
)->
264 spad
= svpath(pstaff_p
->staffno
, STAFFPAD
)->staffpad
265 * STEPSIZE
* prevscale
;
266 continue; /* no coords to set */
269 /* set half the height of the previous and current staffs */
270 prevhalf
= staffvertspace(pstaff_p
->staffno
) / 2.0;
271 curhalf
= staffvertspace(cstaff_p
->staffno
) / 2.0;
274 * The space needed between the bottom line of the previous
275 * staff and the top line of the current staff to avoid
276 * collisions is how far up from the current staff things
277 * stick, plus how far down from the previous staff things
278 * stick, plus the height of anything "between" the two.
279 * To this we add spad for extra padding (overlap if negative).
281 needed
= (cstaff_p
->c
[RN
] - curhalf
) +
282 ((pstaff_p
->c
[RY
] - pstaff_p
->c
[RS
]) - prevhalf
) +
283 pstaff_p
->heightbetween
+ spad
;
285 * Set the distance between those two lines to be what the
286 * user requested, or what was calculated above as "needed",
287 * whichever is greater. Set halfnonbetween to be half of
288 * this result, minus half the height of the "between" items.
290 /* never closer than this */
291 limit
= svpath(pstaff_p
->staffno
,MINSTSEP
)->minstsep
* STEPSIZE
;
292 clefroom
= clefspace(prevclef
, prevscale
,
293 CLEF2PRINT(cstaff_p
->staffno
),
294 svpath(cstaff_p
->staffno
, STAFFSCALE
)->staffscale
,
295 Score
.measnum
== YES
&& has_ending(cstaff_p
->staffno
)
297 limit
= MAX(limit
, clefroom
);
299 staffdist
= MAX(limit
, needed
); /* between prev & current */
302 * Find half the room between the inner staff lines that is not
303 * going to be used by the "between" items. But pretend that
304 * the "between" items are bigger by "spad" than they really
305 * are, so that half of staffpad will go on each side of them.
307 halfnonbetween
= (staffdist
- (pstaff_p
->heightbetween
+ spad
))
310 /* set cstaffoffset for relative to score */
311 cstaffoffset
-= (prevhalf
+ staffdist
+ curhalf
);
314 * The "between" items are currently placed relative to a base
315 * line that they were piled onto. We would like to center
316 * them between the staffs, but if one staff sticks out more
317 * than the other, it may not be possible. Center as close as
318 * possible. betweendist is how far the base line is from the
319 * center line of the previous staff.
321 if ((pstaff_p
->c
[RY
] - pstaff_p
->c
[RS
]) - prevhalf
>
324 * The top staff sticks down far enough that we have
325 * to put the "between" items below center. Jam them
326 * against the top staff.
328 betweendist
= (pstaff_p
->c
[RY
] - pstaff_p
->c
[RS
]) +
329 pstaff_p
->heightbetween
+ spad
;
330 } else if (cstaff_p
->c
[RN
] - curhalf
> halfnonbetween
) {
332 * The bottom staff sticks up far enough that we have
333 * to put the "between" items above center. Jam them
334 * against the bottom staff.
336 betweendist
= (prevhalf
+ staffdist
+ curhalf
) -
340 * There is room to center the between items.
342 betweendist
= prevhalf
+ staffdist
- halfnonbetween
;
345 /* change baseline of padding to actual baseline */
346 betweendist
-= spad
/ 2.0;
349 * For all STAFF structures of these staff numbers in this
350 * score, change relative coords as described below.
352 relstaff(mllfeed_p
, pstaff_p
->staffno
, cstaff_p
->staffno
,
353 cstaffoffset
, betweendist
);
355 /* last loop iteration leaves right value in these variables */
356 feed_p
->lastvis
= cstaff_p
->staffno
;
357 feed_p
->c
[RS
] = cstaff_p
->c
[RS
];
358 feed_p
->lastdist
= cstaff_p
->c
[RY
] - cstaff_p
->c
[RS
] - curhalf
;
361 prevclef
= CLEF2PRINT(pstaff_p
->staffno
);
362 prevscale
= svpath(pstaff_p
->staffno
, STAFFSCALE
)->staffscale
;
363 spad
= svpath(pstaff_p
->staffno
, STAFFPAD
)->staffpad
364 * STEPSIZE
* prevscale
;
367 first
= NO
; /* next score will not be the first */
373 * Abstract: Set certain relative coords to be relative to score.
377 * Description: This function is given two staff structures for consecutive
378 * visible staffs. For all STAFF structures of these staff
379 * numbers in this score, set the bottom staff's coords relative
380 * to the score, and set the "between" items' coords (for what's
381 * between top and bottom staff) relative to the top staff.
385 relstaff(feed_p
, s1
, s2
, botoff
, betweendist
)
387 struct MAINLL
*feed_p
; /* pointer to FEED for this score */
388 int s1
; /* number of top staff */
389 int s2
; /* number of bottom staff */
390 double botoff
; /* center line of bottom, relative to score */
391 double betweendist
; /* center line of top to base line of between*/
394 struct MAINLL
*mainll_p
;/* point along main linked list */
395 struct STAFF
*staff_p
; /* pointer to a staff */
396 struct GRPSYL
*syl_p
; /* pointer to a syllable */
397 struct STUFF
*stuff_p
; /* pointer to stuff to draw */
398 int n
; /* loop variable */
401 debug(32, "relstaff file=%s line=%d s1=%d s2=%d botoff=%f betweendist=%f",
402 feed_p
->inputfile
, feed_p
->inputlineno
, s1
, s2
,
403 (float)botoff
, (float)betweendist
);
405 * Loop through the section of the main linked list for this score,
406 * looking for every STAFF for one of the two given staffs.
408 for (mainll_p
= feed_p
->next
; mainll_p
!= 0 && mainll_p
->str
!= S_FEED
;
409 mainll_p
= mainll_p
->next
) {
411 if (mainll_p
->str
== S_STAFF
&&
412 mainll_p
->u
.staff_p
->staffno
== s1
) {
414 staff_p
= mainll_p
->u
.staff_p
;
417 * Subtract betweendist from all relative coords of
418 * "between" items hanging off this staff, to make them
419 * relative to this staff instead of the base line.
421 for (n
= 0; n
< staff_p
->nsyllists
; n
++) {
422 if (staff_p
->sylplace
[n
] == PL_BETWEEN
) {
423 for (syl_p
= staff_p
->syls_p
[n
];
425 syl_p
= syl_p
->next
) {
426 syl_p
->c
[RN
] -= betweendist
;
427 syl_p
->c
[RY
] -= betweendist
;
428 syl_p
->c
[RS
] -= betweendist
;
432 for (stuff_p
= staff_p
->stuff_p
; stuff_p
!= 0;
433 stuff_p
= stuff_p
->next
) {
434 if (stuff_p
->place
== PL_BETWEEN
) {
435 stuff_p
->c
[RN
] -= betweendist
;
436 stuff_p
->c
[RY
] -= betweendist
;
437 stuff_p
->c
[RS
] -= betweendist
;
442 if (mainll_p
->str
== S_STAFF
&&
443 mainll_p
->u
.staff_p
->staffno
== s2
) {
445 staff_p
= mainll_p
->u
.staff_p
;
448 * Make this staff relative to the score instead of
449 * relative to its own center line.
451 staff_p
->c
[RN
] += botoff
;
452 staff_p
->c
[RY
] = botoff
;
453 staff_p
->c
[RS
] += botoff
;
461 * Abstract: Place which scores on which pages, and set all vertical coords.
465 * Description: This function decides how many scores are going to fit on each
466 * page, based on how big they are and how much minimum space the
467 * user wants put between them. It calls abspage() for each page
468 * to do final positioning and coordinate setting.
475 struct MAINLL
*mainll_p
;/* point along main LL */
476 struct TIMEDSSV
*tssv_p
;/* point along timed SSV lists */
477 struct MAINLL
*page_p
; /* point at first FEED of a page */
478 struct MAINLL
*ppage_p
; /* point at first FEED of previous page */
479 struct MAINLL
*gridpage_p
; /* point at FEED for grids-at-end */
480 struct MAINLL
*origpage_p
; /* remember original page_p */
481 struct FEED
*cfeed_p
; /* point at current scorefeed */
482 struct FEED
*pfeed_p
; /* point at previous scorefeed */
483 float availheight
; /* available height on page (middle window) */
484 float remheight
; /* remaining height on page */
485 float y_start
; /* where y begins (at top of _win) */
486 float limit
; /* smallest distance allowed between scores */
487 int prevclef
; /* clef on last visible staff of prev score */
488 float clefroom
; /* room for clefs and/or measure numbers */
489 float excess
; /* extra room needed for top score */
490 float abovetopline
; /* dist from top line of score to top of score*/
491 float ink
; /* distance ink extends between inner lines */
492 float padding
; /* space between farthest extents */
493 float scoreheight
; /* height of current score */
494 float topheight
, botheight
; /* height of a "top" or "bot" block */
495 int aftertitle
; /* is this the page after a title page? */
496 int firstpage
; /* are we working on the first page? */
497 int totscores
; /* number of scores on a page */
499 /* the following are all in inches, unlike scorepad/scoresep parms */
500 float curminpad
; /* current minscpad */
501 float curmaxpad
; /* current maxscpad */
502 float *curpad
; /* malloc: pad above each score */
503 float *maxpad
; /* malloc: maxscpad above each score */
504 float curminsep
; /* current minscsep */
505 float curmaxsep
; /* current maxscsep */
506 float *cursep
; /* malloc: sep above each score */
507 float *maxsep
; /* malloc: maxscsep above each score */
509 int is_block
; /* is there a block after this FEED? */
510 struct BLOCKHEAD
*rememtop2_p
, *remembot2_p
; /* remember most current*/
511 struct BLOCKHEAD
*head_p
; /* point at Header or Header2 */
512 struct BLOCKHEAD
*foot_p
; /* point at Footer or Footer2 */
515 debug(16, "posscores");
517 * In each of these arrays, array[idx] refers to distance below score
518 * number idx on a page, numbering the scores from 1 to N. For sep,
519 * only indices 1 through N-1 are used. For pad, indices 0 through N
520 * are used, where 0 means above the first score and N below the last.
521 * The "sep" arrays are for distances between the outermost staff lines
522 * of neighboring scores. The "pad" arrays are for distances between
523 * the outermost thing sticking out of those scores. The "above"
524 * arrays are for distance currently allocated. The "max" arrays are
525 * for the max limits we impose (when we can).
527 MALLOCA(float, cursep
, MAXSCORES
);
528 MALLOCA(float, curpad
, MAXSCORES
+ 1);
529 MALLOCA(float, maxsep
, MAXSCORES
);
530 MALLOCA(float, maxpad
, MAXSCORES
+ 1);
532 initstructs(); /* init SSVs */
534 /* the following need to be initialized for the coming loop */
535 curminsep
= Score
.minscsep
* STEPSIZE
;
536 curminpad
= Score
.minscpad
* STEPSIZE
;
537 curmaxsep
= Score
.maxscsep
* STEPSIZE
;
538 curmaxpad
= Score
.maxscpad
* STEPSIZE
;
541 mainll_p
= Mainllhc_p
;
542 rememtop2_p
= remembot2_p
= 0;
544 /* the following don't really need to be initialized; we're doing it */
545 /* just to prevent useless 'used before set' warnings */
556 * Loop through the main linked list, looking at each feed. Assuming
557 * the scores are packed as tightly as allowed, see how many will fit
558 * on each page. Whenever a page fills up, call abspage() to
559 * distribute the extra white space as well as possible and set all
560 * the absolute vertical coords for that page. At the end, call it
561 * again for the last page.
563 while (mainll_p
!= 0) {
564 switch (mainll_p
->str
) {
566 break; /* go handle this score */
568 /* apply, and reset vars in case some changed */
569 asgnssv(mainll_p
->u
.ssv_p
);
570 curminsep
= Score
.minscsep
* STEPSIZE
;
571 curmaxsep
= Score
.maxscsep
* STEPSIZE
;
572 curminpad
= Score
.minscpad
* STEPSIZE
;
573 curmaxpad
= Score
.maxscpad
* STEPSIZE
;
574 mainll_p
= mainll_p
->next
;
577 /* apply timed SSVs; they won't affect the above
578 * variables, but they could affect clef, which we
580 for (tssv_p
= mainll_p
->u
.bar_p
->timedssv_p
;
581 tssv_p
!= 0; tssv_p
= tssv_p
->next
) {
582 asgnssv(&tssv_p
->ssv
);
584 mainll_p
= mainll_p
->next
;
587 mainll_p
= mainll_p
->next
;
591 /* if there is nothing after this FEED, break out */
592 if (mainll_p
->next
== 0) {
596 cfeed_p
= mainll_p
->u
.feed_p
; /* set convenient pointer */
599 * If firstpage is set, normally there would be no pagefeed,
600 * because the first FEED on that page is marked as a pagefeed
601 * only if the user requested it. If they did, that means
602 * there was a title page with no music on it. We need to
603 * remember this fact, so that we know to use header2/footer2
604 * instead of header/footer. Only the title page would use
607 aftertitle
= firstpage
== YES
&& cfeed_p
->pagefeed
== YES
;
609 /* see if there is a block after this feed */
610 is_block
= mainll_p
->next
!= 0 &&
611 mainll_p
->next
->str
== S_BLOCKHEAD
;
613 scoreheight
= cfeed_p
->c
[RN
] - cfeed_p
->c
[RS
];
617 * We are at the top of a page. Point at the header
618 * and footer that apply. Note that if the header or
619 * footer is unused, its height will be 0.
621 if (firstpage
== YES
&& aftertitle
== NO
) {
629 /* if not the first page, set pagefeed */
630 if (firstpage
== NO
) {
631 cfeed_p
->pagefeed
= YES
;
634 /* remember most recent settings of top2 and bot2 */
635 if (cfeed_p
->top2_p
!= 0) {
636 rememtop2_p
= cfeed_p
->top2_p
;
638 if (cfeed_p
->bot2_p
!= 0) {
639 remembot2_p
= cfeed_p
->bot2_p
;
643 * Decide what is to be printed at the top and
644 * bottom (inside the header(2)/footer(2) if any).
645 * On the first page and at every pagefeed where top_p
646 * is set, that is to be used, so leave it alone.
647 * Otherwise use the most recent top2_p setting, so
648 * save the value into top_p. Later in this function,
649 * and also in the print phase, top_p is used, not
650 * top2_p, with exception of grids-at-end pages.
652 if (firstpage
== NO
&& cfeed_p
->top_p
== 0) {
653 cfeed_p
->top_p
= rememtop2_p
;
655 /* analogous for bottom */
656 if (firstpage
== NO
&& cfeed_p
->bot_p
== 0) {
657 cfeed_p
->bot_p
= remembot2_p
;
660 /* set height of "top" & "bot" if they exist, else 0 */
661 topheight
= cfeed_p
->top_p
!= 0 ?
662 cfeed_p
->top_p
->height
: 0.0;
663 botheight
= cfeed_p
->bot_p
!= 0 ?
664 cfeed_p
->bot_p
->height
: 0.0;
667 * Remove these items' size from the space available
668 * for music, and set music's starting point.
670 availheight
= PGHEIGHT
- EFF_TOPMARGIN
- EFF_BOTMARGIN
671 - head_p
->height
- foot_p
->height
672 - topheight
- botheight
;
674 y_start
= PGHEIGHT
- EFF_TOPMARGIN
675 - head_p
->height
- topheight
;
678 * If a header or top exists on this page, we need to
679 * have pad below it. Since we're initially packing as
680 * tightly as possible, assume the minimum. Reduce the
681 * available room by that amount. Analogous for
684 if (head_p
->height
+ topheight
> 0.0) {
685 availheight
-= curminpad
;
687 if (foot_p
->height
+ botheight
> 0.0) {
688 availheight
-= curminpad
;
691 /* increase score's RN and scoreheight if need be */
694 * Blocks have no clef or measure number, but
695 * clefspace() still will return a little
696 * something for padding, so add that in.
698 excess
= clefspace(NOCLEF
, 1.0, NOCLEF
, 1.0,NO
);
699 cfeed_p
->c
[RN
] += excess
;
700 scoreheight
+= excess
;
703 * If clef (and measure number if that is to be
704 * printed) stick up higher than anything else,
705 * adjust the size of the score to allow for it.
707 clefroom
= clefspace(NOCLEF
, 1.0,
708 CLEF2PRINT(cfeed_p
->firstvis
), 1.0,
709 Score
.measnum
== YES
&&firstpage
== NO
);
710 abovetopline
= cfeed_p
->c
[RN
] -
711 staffvertspace(cfeed_p
->firstvis
) / 2.0;
712 excess
= clefroom
- abovetopline
;
714 cfeed_p
->c
[RN
] += excess
;
715 scoreheight
+= excess
;
719 if (scoreheight
> availheight
) {
720 if (Score
.units
== INCHES
) {
721 ufatal("score is too high (%.2f inches) to fit on one page (limit %.2f)",
722 scoreheight
* Score
.scale_factor
,
723 availheight
* Score
.scale_factor
);
725 ufatal("score is too high (%.2f cm) to fit on one page (limit %.2f)",
726 scoreheight
* Score
.scale_factor
*
727 CMPERINCH
, availheight
*
728 Score
.scale_factor
* CMPERINCH
);
733 * Set pad above the top score. If there is a header
734 * or top, use the values from scorepad. If not, force
735 * both to 0, so that none will be allowed.
737 if (head_p
->height
+ topheight
> 0.0) {
738 curpad
[0] = curminpad
;
739 maxpad
[0] = curmaxpad
;
745 remheight
= availheight
- scoreheight
;
750 mainll_p
= mainll_p
->next
;
755 prevclef
= CLEF2PRINT(pfeed_p
->lastvis
);
760 * This will be the second or later score on this page,
761 * if it fits, and the user did not request a manual
762 * pagefeed. Figure out what the minimum padding can
763 * be between this score and the previous. "ink" is
764 * the distance things on the bottom visible staff of
765 * the previous score extend from its bottom line down,
766 * plus the distance things on the top visible staff of
767 * the current score extend from its top line up.
768 * curminpad is the minimum white space the user wants
769 * to allow between scores.
772 ink
= pfeed_p
->lastdist
;
773 clefroom
= clefspace(prevclef
, 1.0, NOCLEF
,
776 ink
= pfeed_p
->lastdist
+ (cfeed_p
->c
[RN
] -
777 staffvertspace(cfeed_p
->firstvis
)/2.0);
778 clefroom
= clefspace(prevclef
, 1.0,
779 CLEF2PRINT(cfeed_p
->firstvis
), 1.0,
782 limit
= MAX(curminsep
, clefroom
);
783 if (ink
< limit
- curminpad
) {
784 padding
= limit
- ink
;
789 if (padding
+ scoreheight
<= remheight
&&
790 cfeed_p
->pagefeed
== NO
) {
791 /* this score fits on this page */
792 remheight
-= padding
+ scoreheight
;
793 cursep
[totscores
] = ink
+ padding
;
794 maxsep
[totscores
] = curmaxsep
;
795 curpad
[totscores
] = padding
;
796 maxpad
[totscores
] = curmaxpad
;
799 mainll_p
= mainll_p
->next
;
803 prevclef
= CLEF2PRINT(pfeed_p
->lastvis
);
805 /* the score does not fit */
807 * Set pad below the bottom score. If there is
808 * a footer or bottom, use the values from
809 * scorepad. If not, force both to 0, so that
810 * none will be allowed.
812 if (foot_p
->height
+ botheight
> 0.0) {
813 curpad
[totscores
] = curminpad
;
814 maxpad
[totscores
] = curmaxpad
;
816 curpad
[totscores
] = 0.0;
817 maxpad
[totscores
] = 0.0;
820 abspage(page_p
, cursep
, maxsep
, curpad
,
828 /* in case it changes, remember the original page_p */
831 /* find out what is after the last FEED */
832 if (page_p
->next
!= 0 && (page_p
->next
->str
== S_CLEFSIG
||
833 page_p
->next
->str
== S_BLOCKHEAD
)) {
835 * The last top-of-page feed has music/block(s) after it. Let
836 * page_p continue to point at it, and for now let gridpage_p
842 * The last top-of-page feed is after all music/blocks. Point
843 * page_p at the previous one, and use this one for gridpage_p.
850 * Before distributing the scores on the last page, if there are chord
851 * grids to be printed at the end, find whether they fit on this page
852 * (their height doesn't exceed remheight minus white). If so, the
853 * subroutine places them at the bottom and returns their height. If
854 * they don't fit, it returns zero and puts them on a separate page.
856 if (Atend_info
.grids_used
> 0) {
860 * In case grids need to go on later page(s), we need to make
861 * sure there is a FEED at the end of the MLL. Its top_p and
862 * bot_p will be used on the first grid page, and top2_p and
863 * bot2_p will be used on later pages.
865 if (gridpage_p
== 0) {
866 /* find last thing in MLL that's not LINE/CURVE/PRHEAD*/
867 for (mainll_p
= Mainlltc_p
;
868 mainll_p
->str
== S_LINE
||
869 mainll_p
->str
== S_CURVE
||
870 mainll_p
->str
== S_PRHEAD
;
871 mainll_p
= mainll_p
->prev
)
873 if (mainll_p
->str
== S_FEED
) {
874 /* FEED, so reuse for gridpage FEED */
875 /* (it wasn't a top-of-page FEED before) */
876 gridpage_p
= mainll_p
;
878 /* alloc new FEED to be used for grid pages */
879 gridpage_p
= newMAINLLstruct(S_FEED
, -1);
880 insertMAINLL(gridpage_p
, Mainlltc_p
);
884 * Both the first and later grid pages should use what
885 * is currently remembered for top2 and bot2.
887 gridpage_p
->u
.feed_p
->top_p
=
888 gridpage_p
->u
.feed_p
->top2_p
= rememtop2_p
;
889 gridpage_p
->u
.feed_p
->bot_p
=
890 gridpage_p
->u
.feed_p
->bot2_p
= remembot2_p
;
892 /* set pointers that are not already set */
893 if (gridpage_p
->u
.feed_p
->top2_p
== 0) {
894 gridpage_p
->u
.feed_p
->top2_p
= rememtop2_p
;
896 if (gridpage_p
->u
.feed_p
->top_p
== 0) {
897 gridpage_p
->u
.feed_p
->top_p
=
898 gridpage_p
->u
.feed_p
->top2_p
;
900 if (gridpage_p
->u
.feed_p
->bot2_p
== 0) {
901 gridpage_p
->u
.feed_p
->bot2_p
= remembot2_p
;
903 if (gridpage_p
->u
.feed_p
->bot_p
== 0) {
904 gridpage_p
->u
.feed_p
->bot_p
=
905 gridpage_p
->u
.feed_p
->bot2_p
;
910 * (remheight - curminpad) is how much space is available on the
911 * last page for grids. firstpage is needed to know whether
912 * to use Header or Header2 (etc.) in calculations. The next
913 * two parms are needed for finding the correct top and bottom
914 * sizes for the last music page, and any grid-only pages.
916 gridheight
= grids_atend(remheight
- curminpad
, firstpage
,
917 page_p
->u
.feed_p
, gridpage_p
->u
.feed_p
);
919 if (gridheight
> 0.0) {
920 /* reduce remaining height by grids and curminpad */
921 remheight
-= gridheight
+ curminpad
;
926 * Set pad below the bottom score. If there is a footer
927 * or bottom, use the values from scorepad. If not, force
928 * both to 0, so that none will be allowed.
930 if (foot_p
->height
+ botheight
> 0.0) {
931 curpad
[totscores
] = curminpad
;
932 maxpad
[totscores
] = curmaxpad
;
934 curpad
[totscores
] = 0.0;
935 maxpad
[totscores
] = 0.0;
938 abspage(origpage_p
, cursep
, maxsep
, curpad
, maxpad
, totscores
,
950 * Abstract: Set all absolute vertical coordinates on a page.
954 * Description: This function positions the scores on this page as well as
955 * possible, and then sets all the absolute vertical coordinates
956 * for the scores and everything in them.
960 abspage(page_p
, cursep
, maxsep
, curpad
, maxpad
, totscores
, remheight
,
963 struct MAINLL
*page_p
; /* point at first FEED for this page */
964 float cursep
[]; /* this score's top line to above score's bottom line */
965 float maxsep
[]; /* the max we'd like to expand cursep to */
966 float curpad
[]; /* white pad between this score and above score */
967 float maxpad
[]; /* the max we'd like to expand curpad to */
968 int totscores
; /* number of scores on this page */
969 double remheight
; /* extra vertical space available, to be distributed */
970 double y_start
; /* Y coord of top of first score (before padding) */
973 struct MAINLL
*mainll_p
;/* point along main LL */
974 struct FEED
*feed_p
; /* point at a score feed on this page */
975 struct CHORD
*ch_p
; /* point at a chord on this page */
976 struct STAFF
*staff_p
; /* point at a staff on this page */
977 float min
; /* smallest number in curpad or cursep */
978 float min2
; /* second smallest number in curpad or sep */
979 float share
; /* space to add to the min numbers each loop */
980 int mins
; /* how many numbers are tied for min */
981 int n
; /* loop variable */
982 int *is_min
; /* pointer to array malloc'ed below */
983 int *hit_max
; /* pointer to array malloc'ed below */
984 int allmax
; /* have all scores used the max sep allowed? */
987 debug(32,"abspage file=%s line=%d totscores=%d remheight=%f y_start=%f",
988 page_p
->inputfile
, page_p
->inputlineno
, totscores
,
989 (float)remheight
, (float)y_start
);
991 * Array to hold which of the distances in curpad or cursep are
994 MALLOCA(int, is_min
, MAXSCORES
+ 1);
996 * Malloc an array to hold YES or NO as to whether this score's
997 * curpad or cursep has reached the maximum allowed.
999 MALLOCA(int, hit_max
, MAXSCORES
+ 1);
1002 * The current values in curpad[] and cursep[] are for the case of
1003 * the scores being packed as tightly as the stuff sticking out of them
1004 * and the user's specification of minscpad and minscsep allow.
1005 * maxpad[] and maxsep[] have the values of maxscpad and maxscsep
1006 * above each. Now we need to spread the score out, distributing
1007 * remheight appropriately.
1010 * First, "smooth out" curpad[], so that the numbers in it will be as
1011 * equal as possible, subject to maxpad[], but ignoring maxsep[].
1013 while (remheight
> FUDGE
) {
1015 * For each score, remember in hit_max whether its curpad
1016 * meets or exceeds the max pad allowed. The fudge factor is
1017 * so we'll pretend we made it, even if there is roundoff
1018 * error. If all scores' curpads have reached that, we're
1019 * done, so break out.
1022 for (n
= 0; n
<= totscores
; n
++) {
1023 if (curpad
[n
] >= maxpad
[n
] - FUDGE
) {
1030 if (allmax
== YES
) {
1035 * Find the smallest curpad among scores that haven't hit
1039 for (n
= 0; n
<= totscores
; n
++) {
1040 if (hit_max
[n
] == NO
&& curpad
[n
] < min
)
1044 mins
= 0; /* number of curpads tied for min */
1045 min2
= 1000; /* second smallest curpad value */
1048 * In this loop, mark which of the curpads are tied for the
1049 * "min" value, and count how many are tied (mins). Also, find
1050 * the second smallest value (min2). All this is done only for
1051 * scores that haven't hit their max.
1053 for (n
= 0; n
<= totscores
; n
++) {
1054 if (hit_max
[n
] == NO
) {
1055 if (curpad
[n
] == min
) {
1060 if (curpad
[n
] < min2
) {
1068 * Don't let min2 exceed the maxpad of any eligible score.
1069 * That way, when we spread the scores out to min2, we won't be
1070 * spreading any of them beyond where they are allowed to go.
1071 * In the next loop, ones that have reached their limit will
1072 * get hit_max[] == YES, while other scores can continue to be
1075 for (n
= 0; n
<= totscores
; n
++) {
1076 if (hit_max
[n
] == NO
&& min2
> maxpad
[n
]) {
1082 * We're going to add to all those minimum curpads, either
1083 * using up all of remheight, or bringing them up equal to
1084 * min2, whichever is lower. We add the same amount to the
1085 * curseps, since they change by the same amount as we move
1088 share
= remheight
/ mins
;
1089 if (share
> min2
- min
) {
1092 for (n
= 0; n
<= totscores
; n
++) {
1093 if (hit_max
[n
] == NO
&& is_min
[n
] == YES
) {
1099 /* decrement remheight by the amount we just used */
1100 remheight
-= mins
* share
;
1104 * "Smooth out" cursep[], so that the numbers in it will be as
1105 * equal as possible, subject to maxsep[], but ignoring maxpad[].
1106 * If there is only one score, the first "for" loop won't execute, and
1109 while (remheight
> FUDGE
) {
1111 * For each score, remember in hit_max whether its cursep
1112 * meets or exceeds the max sep allowed. The fudge factor is
1113 * so we'll pretend we made it, even if there is roundoff
1114 * error. If all scores' curseps have reached that, we're
1115 * done, so break out.
1118 for (n
= 1; n
< totscores
; n
++) {
1119 if (cursep
[n
] >= maxsep
[n
] - FUDGE
) {
1126 if (allmax
== YES
) {
1131 * Find the smallest cursep among scores that haven't hit
1135 for (n
= 1; n
< totscores
; n
++) {
1136 if (hit_max
[n
] == NO
&& cursep
[n
] < min
)
1140 mins
= 0; /* number of curseps tied for min */
1141 min2
= 1000; /* second smallest cursep value */
1144 * In this loop, mark which of the curseps are tied for the
1145 * "min" value, and count how many are tied (mins). Also, find
1146 * the second smallest value (min2). All this is done only for
1147 * scores that haven't hit their max.
1149 for (n
= 1; n
< totscores
; n
++) {
1150 if (hit_max
[n
] == NO
) {
1151 if (cursep
[n
] == min
) {
1156 if (cursep
[n
] < min2
) {
1164 * Don't let min2 exceed the maxsep of any eligible score.
1165 * That way, when we spread the scores out to min2, we won't be
1166 * spreading any of them beyond where they are allowed to go.
1167 * In the next loop, ones that have reached their limit will
1168 * get hit_max[] == YES, while other scores can continue to be
1171 for (n
= 1; n
< totscores
; n
++) {
1172 if (hit_max
[n
] == NO
&& min2
> maxsep
[n
]) {
1178 * We're going to add to all those minimum curseps, either
1179 * using up all of remheight, or bringing them up equal to
1180 * min2, whichever is lower.
1182 share
= remheight
/ mins
;
1183 if (share
> min2
- min
) {
1186 for (n
= 1; n
< totscores
; n
++) {
1187 if (hit_max
[n
] == NO
&& is_min
[n
] == YES
) {
1192 /* decrement remheight by the amount we just used */
1193 remheight
-= mins
* share
;
1196 /* move to top of first score */
1197 y_start
-= curpad
[0];
1199 feed_p
= 0; /* flag that we haven't seen the first FEED yet */
1202 * Loop through the main linked list for this page, setting all
1203 * absolute vertical coordinates.
1205 for (mainll_p
= page_p
, n
= 0; mainll_p
!= 0 && ! (n
== totscores
&&
1206 mainll_p
->str
== S_FEED
); mainll_p
= mainll_p
->next
) {
1208 switch (mainll_p
->str
) {
1210 /* by end of page, SSVs will be up to date for there */
1211 asgnssv(mainll_p
->u
.ssv_p
);
1216 * If this is the first FEED on the page, and what
1217 * follows is music (not a block), move to the top line
1218 * of the first score.
1220 if (feed_p
== 0 && IS_CLEFSIG_FEED(mainll_p
)) {
1221 y_start
= y_start
- page_p
->u
.feed_p
->c
[RN
] +
1222 staffvertspace(page_p
->u
.feed_p
->firstvis
)/2.0;
1226 * Set the score's absolute coordinates. The feed_p
1227 * pointer will be used by other cases in later loops.
1229 feed_p
= mainll_p
->u
.feed_p
;
1231 /* if next is 0, this is a trailing feed, and it */
1232 /* really has no meaningful coords */
1233 if (mainll_p
->next
== 0)
1236 if (mainll_p
->next
->str
== S_BLOCKHEAD
) {
1237 /* move from top of block to middle of block */
1238 y_start
-= feed_p
->c
[RN
];
1240 /* move from top line of score to middle of
1242 y_start
-= staffvertspace(feed_p
->firstvis
)/2.0;
1245 feed_p
->c
[AN
] = y_start
+ feed_p
->c
[RN
];
1246 feed_p
->c
[AY
] = y_start
;
1247 feed_p
->c
[AS
] = y_start
+ feed_p
->c
[RS
];
1249 /* unless last score, set up y_start for next one */
1250 if (n
< totscores
- 1) {
1251 /* top line of next score */
1252 y_start
= y_start
+ feed_p
->c
[RS
] +
1253 feed_p
->lastdist
- cursep
[n
+ 1];
1261 * Set each chord's absolute coordinates the same as
1262 * the feed. These are pretty arbitrary, since they
1263 * are using only for drawing boxes with the MUP_BB
1264 * environment variable.
1266 for (ch_p
= mainll_p
->u
.chhead_p
->ch_p
; ch_p
!= 0;
1267 ch_p
= ch_p
->ch_p
) {
1268 ch_p
->c
[AN
] = feed_p
->c
[AN
];
1269 ch_p
->c
[AY
] = feed_p
->c
[AY
];
1270 ch_p
->c
[AS
] = feed_p
->c
[AS
];
1276 * Set absolute N, Y, and S for the bar line. Y can be
1277 * copied from the score's Y; they are both the center
1278 * line of the top visible staff. But the score's N
1279 * S can stick out, based on the groups present,
1280 * whereas the bar line's N is the top line of the top
1281 * staff, and its S is the bottom line of the bottom
1284 mainll_p
->u
.bar_p
->c
[AN
] = feed_p
->c
[AY
] +
1285 halfstaffhi(feed_p
->firstvis
);
1286 mainll_p
->u
.bar_p
->c
[AY
] = feed_p
->c
[AY
];
1287 mainll_p
->u
.bar_p
->c
[AS
] = feed_p
->c
[AS
] +
1293 * If the clefsig doesn't contain a pseudo bar, just
1294 * break. But otherwise, set this bar's coords just
1295 * like a normal bar.
1297 if (mainll_p
->u
.clefsig_p
->bar_p
== 0)
1299 mainll_p
->u
.clefsig_p
->bar_p
->c
[AN
] = feed_p
->c
[AY
] +
1300 halfstaffhi(feed_p
->firstvis
);
1301 mainll_p
->u
.clefsig_p
->bar_p
->c
[AY
] = feed_p
->c
[AY
];
1302 mainll_p
->u
.clefsig_p
->bar_p
->c
[AS
] = feed_p
->c
[AS
] +
1303 feed_p
->lastdist
- halfstaffhi(feed_p
->lastvis
);
1307 /* if visible, set all abs vertical coords on staff */
1308 staff_p
= mainll_p
->u
.staff_p
;
1309 if (staff_p
->visible
== YES
)
1310 absstaff(feed_p
, staff_p
);
1323 * Abstract: Set all absolute vertical coordinates for a STAFF structure.
1327 * Description: This function sets all the absolute vertical coords for a
1328 * STAFF structure; those of the staff itself, and those of
1329 * everything hanging off it.
1333 absstaff(feed_p
, staff_p
)
1335 struct FEED
*feed_p
; /* FEED for the score we're on */
1336 struct STAFF
*staff_p
; /* the staff to be set */
1339 struct GRPSYL
*gs_p
; /* point at a group of syllable */
1340 struct STUFF
*stuff_p
; /* point at a STUFF structure */
1341 struct CRVLIST
*pp_p
; /* point at a coord for phrase point */
1342 int v
; /* index to voices or verses */
1343 int n
; /* loop variable */
1346 debug(32, "absstaff file=%s line=%d", staff_p
->groups_p
[0]->inputfile
,
1347 staff_p
->groups_p
[0]->inputlineno
);
1348 /* set the staff's own coords */
1349 staff_p
->c
[AN
] = feed_p
->c
[AY
] + staff_p
->c
[RN
];
1350 staff_p
->c
[AY
] = feed_p
->c
[AY
] + staff_p
->c
[RY
];
1351 staff_p
->c
[AS
] = feed_p
->c
[AY
] + staff_p
->c
[RS
];
1353 /* do the voice(s) */
1354 for (v
= 0; v
< MAXVOICES
; v
++) {
1355 for (gs_p
= staff_p
->groups_p
[v
]; gs_p
!= 0; gs_p
= gs_p
->next
){
1356 gs_p
->c
[AY
] = staff_p
->c
[AY
] + gs_p
->c
[RY
];
1357 gs_p
->c
[AN
] = staff_p
->c
[AY
] + gs_p
->c
[RN
];
1358 gs_p
->c
[AS
] = staff_p
->c
[AY
] + gs_p
->c
[RS
];
1360 /* if it's a group with notes, do the notes too */
1361 if (gs_p
->grpcont
== GC_NOTES
) {
1362 for (n
= 0; n
< gs_p
->nnotes
; n
++) {
1363 gs_p
->notelist
[n
].c
[AY
] = staff_p
->c
[AY
]
1364 + gs_p
->notelist
[n
].c
[RY
];
1365 gs_p
->notelist
[n
].c
[AN
] = staff_p
->c
[AY
]
1366 + gs_p
->notelist
[n
].c
[RN
];
1367 gs_p
->notelist
[n
].c
[AS
] = staff_p
->c
[AY
]
1368 + gs_p
->notelist
[n
].c
[RS
];
1374 /* do the verse(s) */
1375 for (v
= 0; v
< staff_p
->nsyllists
; v
++) {
1376 for (gs_p
= staff_p
->syls_p
[v
]; gs_p
!= 0; gs_p
= gs_p
->next
){
1377 gs_p
->c
[AY
] = staff_p
->c
[AY
] + gs_p
->c
[RY
];
1378 gs_p
->c
[AN
] = staff_p
->c
[AY
] + gs_p
->c
[RN
];
1379 gs_p
->c
[AS
] = staff_p
->c
[AY
] + gs_p
->c
[RS
];
1384 for (stuff_p
= staff_p
->stuff_p
; stuff_p
!= 0; stuff_p
= stuff_p
->next
){
1385 stuff_p
->c
[AY
] = staff_p
->c
[AY
] + stuff_p
->c
[RY
];
1386 stuff_p
->c
[AN
] = staff_p
->c
[AY
] + stuff_p
->c
[RN
];
1387 stuff_p
->c
[AS
] = staff_p
->c
[AY
] + stuff_p
->c
[RS
];
1389 /* if it's a phrase/tie/slur, do the phrase points too */
1390 if (stuff_p
->stuff_type
== ST_PHRASE
||
1391 stuff_p
->stuff_type
== ST_TIESLUR
||
1392 stuff_p
->stuff_type
== ST_TABSLUR
||
1393 stuff_p
->stuff_type
== ST_BEND
) {
1394 for (pp_p
= stuff_p
->crvlist_p
; pp_p
!= 0;
1396 pp_p
->y
+= staff_p
->c
[AY
];
1402 * Name: grids_atend()
1404 * Abstract: Determine placement of chord grids to be printed at the end.
1406 * Returns: height of all the grids printed on this page
1408 * Description: This function determines the placement of chord grids that are
1409 * to be printed at the end of the song, and sets up the data in
1410 * Atend_info accordingly.
1414 grids_atend(vertavail
, firstpage
, mfeed_p
, gfeed_p
)
1416 double vertavail
; /* space available for grids and spreading out scores*/
1417 int firstpage
; /* is this first page (there's only 1 page of music)?*/
1418 struct FEED
*mfeed_p
; /* FEED at start of last music page */
1419 struct FEED
*gfeed_p
; /* FEED applying to grid-only pages (may be same) */
1422 struct GRID
*grid_p
; /* point at a grid */
1423 int ngrids
; /* no. of grids used */
1424 float north
, south
, east
, west
; /* coords for one grid */
1425 float farnorth
, farsouth
, fareast
, farwest
; /* farthest for any grid */
1426 float hstrwid
; /* half the width of chord string */
1427 float havail
; /* horizonal space available */
1428 int inrow
; /* no. of grids in one row */
1429 int nrows
; /* no. of rows of grids */
1430 float totalheight
; /* of all the rows */
1431 float white
; /* scorepad in inches */
1432 float upheight
; /* height of header + top */
1433 float downheight
; /* height of bottom + footer */
1436 debug(32, "grids_atend vertavail=%f", (float)vertavail
);
1438 /* malloc array of pointers to the grids that were used */
1439 MALLOCA(struct GRID
*, Atend_info
.grid_p
, Atend_info
.grids_used
);
1442 * Set pointers to the grids that were used. While doing this, find
1443 * the farthest extent of any grid, for each of the 4 directions. The
1444 * size of the chord string must also be considered in this.
1447 farnorth
= farsouth
= fareast
= farwest
= 0.0;
1448 for (grid_p
= 0; (grid_p
= nextgrid(grid_p
)) != 0; ) {
1449 if (grid_p
->used
== NO
)
1451 Atend_info
.grid_p
[ngrids
++] = grid_p
;
1452 gridsize(grid_p
, -1, &north
, &south
, &east
, &west
);
1453 north
+= strheight(grid_p
->name
);
1454 hstrwid
= strwidth(grid_p
->name
) / 2.0;
1455 if (north
> farnorth
)
1457 if (south
< farsouth
)
1463 if (-hstrwid
< west
)
1469 /* sort the pointers by grid name */
1470 qsort((char *)Atend_info
.grid_p
, ngrids
, sizeof (struct GRID
*),
1473 /* horizontal available width to use */
1474 havail
= PGWIDTH
- eff_leftmargin((struct MAINLL
*)0)
1475 - eff_rightmargin((struct MAINLL
*)0);
1478 * Find max we could put in one row, allowing padding. Note that we do
1479 * not try to optimize the packing at all: the biggest grid coord in
1480 * any direction is what we use. The "padding" to the right of the
1481 * rightmost grid is not needed, so let it hang into the margin.
1483 inrow
= (havail
+ HPADGRID
) / (fareast
- farwest
+ HPADGRID
);
1485 ufatal("chord grid is too wide to fit on a page");
1488 /* this determines how many rows there will be; it will not change */
1489 nrows
= (ngrids
+ inrow
- 1) / inrow
;
1492 * It could be that the last row would be far from full. So attempt to
1493 * spread the grids more equally between rows.
1495 while (nrows
> 1 && inrow
> 1) {
1496 inrow
--; /* try one less grid per row */
1497 if ((ngrids
+ inrow
- 1) / inrow
> nrows
) {
1498 /* whoops, no. of rows increased, so undo last decr. */
1504 Atend_info
.grids_per_row
= inrow
;
1506 /* spread them out appropriately */
1507 Atend_info
.horz_sep
= havail
/ (nrows
== 1 ? ngrids
: inrow
);
1510 * Normally, the first grid's X is as far from the left margin as the
1511 * last (on that line) grid's X is from the right margin. But if any
1512 * grids have "N fr", fareast may be bigger than -farwest. So move
1513 * everything to the left by half the difference.
1515 Atend_info
.firstgrid_x
= eff_leftmargin((struct MAINLL
*)0) +
1516 Atend_info
.horz_sep
/ 2.0 - (fareast
+ farwest
) / 2.0;
1519 * Base the vertical separation on the maximum case plus padding. Of
1520 * course, no padding is needed below the bottom row, so subtract it.
1522 Atend_info
.vert_sep
= farnorth
- farsouth
+ VPADGRID
;
1523 totalheight
= nrows
* Atend_info
.vert_sep
- VPADGRID
;
1525 white
= Score
.minscpad
* STEPSIZE
;
1527 if (totalheight
<= vertavail
&& gfeed_p
->pagefeed
== NO
) {
1529 * It fits on the last page of music. Set the absolute coord
1530 * so that it rests above the footer and/or bottom block (if
1531 * any) and bottom margin.
1533 Atend_info
.firstgrid_y
= EFF_BOTMARGIN
+ totalheight
- farnorth
;
1535 downheight
= (firstpage
== YES ?
&Footer
: &Footer2
)->height
+
1536 (mfeed_p
->bot_p
!= 0 ? mfeed_p
->bot_p
->height
: 0.0);
1537 if (downheight
> 0) {
1538 Atend_info
.firstgrid_y
+= downheight
+ white
;
1541 Atend_info
.rows_per_page
= nrows
;
1543 return (totalheight
);
1547 * All grids must go on later page(s). Find how much height must be
1548 * reserved for header/top and bottom/footer on those pages. Since
1549 * this cannot be the first page, we always use Header2 and Footer2.
1551 upheight
= Header2
.height
+
1552 (gfeed_p
->top_p
!= 0 ? gfeed_p
->top_p
->height
: 0.0);
1553 downheight
= Footer2
.height
+
1554 (gfeed_p
->bot_p
!= 0 ? gfeed_p
->bot_p
->height
: 0.0);
1556 /* make the grid page FEED a pagefeed, in case it isn't already */
1557 gfeed_p
->pagefeed
= YES
;
1560 * It will have to go on other page(s). Set the absolute coord to put
1563 Atend_info
.separate_page
= YES
;
1564 Atend_info
.firstgrid_y
= PGHEIGHT
- EFF_TOPMARGIN
-
1565 upheight
- farnorth
;
1567 Atend_info
.firstgrid_y
-= white
;
1570 /* reset vertavail to the amount of space on a whole page */
1571 vertavail
= PGHEIGHT
- EFF_TOPMARGIN
- EFF_BOTMARGIN
;
1573 vertavail
-= upheight
+ white
;
1575 vertavail
-= downheight
+ white
;
1577 /* find number of rows per page; must be at least 1 */
1578 Atend_info
.rows_per_page
= (vertavail
+ VPADGRID
) / Atend_info
.vert_sep
;
1579 if (Atend_info
.rows_per_page
== 0)
1580 ufatal("chords grids are too high to fit on a page");
1583 * If there is at least 1 full page, spread the rows out evenly. The
1584 * same spacing will be used on later pages, even though the last page
1585 * may not be full. That's okay.
1587 if (nrows
>= Atend_info
.rows_per_page
) {
1588 Atend_info
.vert_sep
= (vertavail
+ VPADGRID
) /
1589 Atend_info
.rows_per_page
;
1592 return (0.0); /* nothing goes on the last page of music */
1598 * Abstract: Compare grid names; used by qsort.
1600 * Returns: negative or positive
1602 * Description: This function returns its result based on whether the grid
1603 * pointed to by g1_p should precede or follow g2_p. It uses
1604 * their names in alphabetical order, basically, but it also
1605 * understands accidentals. They will never be equal because the
1606 * grids are all unique.
1610 compgrids(g1_p_p
, g2_p_p
)
1613 const void *g1_p_p
; /* the two grid pointers to compare */
1616 char *g1_p_p
; /* the two grid pointers to compare */
1621 char *name
[2]; /* pointers into first and second names */
1622 char *asc_ptr
; /* point at the first name in ASCII */
1623 char chbuff
[MAXCHNAME
]; /* hold the ASCII name of the first chord */
1624 int accnum
[2]; /* accidental number, -2 to 2 (&& to x) */
1625 int ridx
[2]; /* index to rest of string */
1626 int k
; /* loop variable */
1630 * Translate the chords names to the way the user entered them (as
1631 * closely as possible). Since ascii_str() overwrites the same static
1632 * area each time, we have to copy the first name to our own buffer.
1633 * Rather than wasting time using malloc(), just put it in a fixed
1634 * buffer. If someone has an absurd name longer than MAXCHNAME, just
1637 asc_ptr
= ascii_str((*(struct GRID
**)g1_p_p
)->name
, YES
, NO
, TM_CHORD
);
1638 if ((int)strlen(asc_ptr
) < MAXCHNAME
) {
1639 (void)strcpy(chbuff
, asc_ptr
);
1641 (void)strncpy(chbuff
, asc_ptr
, MAXCHNAME
- 1);
1642 chbuff
[MAXCHNAME
- 1] = '\0';
1645 name
[1] = ascii_str((*(struct GRID
**)g2_p_p
)->name
, YES
, NO
, TM_CHORD
);
1648 * If chord letters differ, return based on that. For bizarre cases
1649 * like letters not A through G, or null string, que sera sera.
1651 if (name
[0][0] != name
[1][0])
1652 return (name
[0][0] - name
[1][0]);
1655 * The first chars (presumably chord letters) were the same. They
1656 * can't be \0 because then the whole strings would be equal (null
1657 * string) but we know chord names are unique. For each name, set a
1658 * number for its accidental, and index to what follows, if anything.
1660 for (k
= 0; k
< 2; k
++) {
1661 switch (name
[k
][1]) {
1663 if (name
[k
][2] == '&') {
1664 accnum
[k
] = -2; /* double flat */
1667 accnum
[k
] = -1; /* flat */
1672 accnum
[k
] = 1; /* sharp */
1676 accnum
[k
] = 2; /* double sharp */
1680 accnum
[k
] = 0; /* no acc is like a natural */
1686 /* if accidentals differ, that rules */
1687 if (accnum
[0] != accnum
[1])
1688 return (accnum
[0] - accnum
[1]);
1690 /* else the rest of it decides */
1691 return (strcmp(&name
[0][ridx
[0]], &name
[1][ridx
[1]]));
1697 * Abstract: Process groups involved with cross staff stemming.
1701 * Description: This function does all the remaining work necessary for groups
1702 * involved in cross staff stemming.
1709 struct MAINLL
*mainll_p
; /* point along main LL */
1710 struct MAINLL
*prevvis_p
; /* previous visible staff */
1711 struct MAINLL
*nextvis_p
; /* next visible staff */
1712 struct TIMEDSSV
*tssv_p
; /* point along a timed SSV list */
1713 struct STAFF
*thisstaff_p
; /* point at a staff */
1714 struct GRPSYL
*thisg_p
; /* point at a group */
1715 struct STUFF
*stuff_p
; /* point at a stuff structure */
1716 struct CRVLIST
*pp_p
; /* point at a coord for phrase point */
1717 RATIONAL vtime
; /* start time of groups */
1718 int vidx
; /* voice index */
1721 debug(16, "proc_css");
1722 initstructs(); /* clean out old SSV info */
1725 * Loop through the whole MLL, looking for visible staffs, and keeping
1726 * SSVs up to date (including midmeasure SSVs, since CSS notes are
1727 * affected by clef changes).
1730 for (mainll_p
= Mainllhc_p
; mainll_p
!= 0; mainll_p
= mainll_p
->next
) {
1732 switch (mainll_p
->str
) {
1734 thisstaff_p
= mainll_p
->u
.staff_p
;
1735 /* if staff is invisible, skip it */
1736 if (thisstaff_p
->visible
== NO
) {
1739 break; /* go handle this visible staff */
1741 /* assign normal SSV */
1742 asgnssv(mainll_p
->u
.ssv_p
);
1745 /* assign preceding measure's timed SSVs */
1746 for (tssv_p
= mainll_p
->u
.bar_p
->timedssv_p
;
1748 tssv_p
= tssv_p
->next
) {
1749 asgnssv(&tssv_p
->ssv
);
1753 /* set prev to null in preparation for next measure */
1758 /* look for next visible staff, skipping invisible */
1759 for (nextvis_p
= mainll_p
->next
; nextvis_p
!= 0 &&
1760 nextvis_p
->str
== S_STAFF
&&
1761 nextvis_p
->u
.staff_p
->visible
== NO
;
1762 nextvis_p
= nextvis_p
->next
) {
1765 /* if no more visible staffs in score, set next to null */
1766 if (nextvis_p
!= 0 && nextvis_p
->str
!= S_STAFF
) {
1771 * thisstaff_p is a visible staff, and prevvis_p and nextvis_p
1772 * are the MLL structs for the previous and next visible staffs,
1773 * if they exist. Loop through the voices on the this staff.
1775 for (vidx
= 0; vidx
< MAXVOICES
; vidx
++) {
1777 * Loop through the groups of this voice, keeping track
1778 * of the elapsed time, looking for groups that have
1779 * CSS, and calling one_css() for them.
1782 for (thisg_p
= thisstaff_p
->groups_p
[vidx
]; thisg_p
!=0;
1783 vtime
= radd(vtime
, thisg_p
->fulltime
),
1784 thisg_p
= thisg_p
->next
) {
1786 switch (thisg_p
->stemto
) {
1790 if (prevvis_p
== 0) {
1791 l_ufatal(mainll_p
->inputfile
,
1792 mainll_p
->inputlineno
,
1793 "cannot cross staff stem 'with above' from top visible staff");
1795 one_css(thisstaff_p
,
1796 prevvis_p
->u
.staff_p
,
1800 if (nextvis_p
== 0) {
1801 l_ufatal(mainll_p
->inputfile
,
1802 mainll_p
->inputlineno
,
1803 "cannot cross staff stem 'with below' from bottom visible staff");
1805 one_css(thisstaff_p
,
1806 nextvis_p
->u
.staff_p
,
1813 prevvis_p
= mainll_p
;
1817 * Now we have to call beamstem() again, to do the work that it
1818 * couldn't do before on groups affected by CSS.
1824 * Do "horizontal avoidance": moving CSS groups sideways if necessary
1825 * because they would collide with groups on the other staff.
1830 * Back in relvert.c, we skipped placing tie/slur/bend/phrases whose
1831 * endpoint groups were affected by CSS. Now that we know where the
1832 * final group boundaries are, we set up the coords for these items.
1833 * tieslur_points and phrase_points destroy groups' AN and AS, and
1834 * depends on them starting out as zero. So zero them now and restore
1835 * them later. Because these items can cross bar lines, we need
1836 * to zap all of these coords in this first loop, and have a separate
1837 * loop to do the main work (and restore the groups' coords).
1839 for (mainll_p
= Mainllhc_p
; mainll_p
!= 0; mainll_p
= mainll_p
->next
) {
1840 if (mainll_p
->str
!= S_STAFF
) {
1843 thisstaff_p
= mainll_p
->u
.staff_p
;
1845 for (vidx
= 0; vidx
< MAXVOICES
; vidx
++) {
1846 for (thisg_p
= thisstaff_p
->groups_p
[vidx
];
1847 thisg_p
!= 0; thisg_p
= thisg_p
->next
) {
1848 thisg_p
->c
[AN
] = 0.0;
1849 thisg_p
->c
[AS
] = 0.0;
1854 for (mainll_p
= Mainllhc_p
; mainll_p
!= 0; mainll_p
= mainll_p
->next
) {
1855 if (mainll_p
->str
!= S_STAFF
) {
1858 thisstaff_p
= mainll_p
->u
.staff_p
;
1861 * Find and handle every tie/slur/bend/phrase starting in this
1864 for (stuff_p
= thisstaff_p
->stuff_p
;
1865 stuff_p
!= 0; stuff_p
= stuff_p
->next
) {
1866 switch (stuff_p
->stuff_type
) {
1868 if (css_affects_phrase(stuff_p
,
1870 phrase_points(mainll_p
, stuff_p
);
1872 stuff_p
->c
[AY
] = thisstaff_p
->c
[AY
]
1874 stuff_p
->c
[AN
] = thisstaff_p
->c
[AY
]
1876 stuff_p
->c
[AS
] = thisstaff_p
->c
[AY
]
1879 /* do the phrase points too */
1880 for (pp_p
= stuff_p
->crvlist_p
;
1881 pp_p
!= 0; pp_p
= pp_p
->next
) {
1883 pp_p
->y
+= thisstaff_p
->c
[AY
];
1889 if (css_affects_tieslurbend(stuff_p
,
1891 if (stuff_p
->stuff_type
== ST_TIESLUR
) {
1892 tieslur_points(mainll_p
, stuff_p
);
1894 bend_points(mainll_p
, stuff_p
);
1897 stuff_p
->c
[AY
] = thisstaff_p
->c
[AY
]
1899 stuff_p
->c
[AN
] = thisstaff_p
->c
[AY
]
1901 stuff_p
->c
[AS
] = thisstaff_p
->c
[AY
]
1904 /* do the tie/slur/bend points too */
1905 for (pp_p
= stuff_p
->crvlist_p
;
1906 pp_p
!= 0; pp_p
= pp_p
->next
) {
1908 pp_p
->y
+= thisstaff_p
->c
[AY
];
1916 * phrase_points destroys groups' AN and AS. And some code in
1917 * the second pass of beamstem.c doesn't set the absolute
1918 * coords of groups. So go through now and set the absolute
1919 * coords of all groups.
1921 for (vidx
= 0; vidx
< MAXVOICES
; vidx
++) {
1922 for (thisg_p
= thisstaff_p
->groups_p
[vidx
];
1923 thisg_p
!= 0; thisg_p
= thisg_p
->next
) {
1924 thisg_p
->c
[AN
] = thisstaff_p
->c
[AY
]
1926 thisg_p
->c
[AY
] = thisstaff_p
->c
[AY
]
1928 thisg_p
->c
[AS
] = thisstaff_p
->c
[AY
]
1938 * Abstract: Process one group involved with cross staff stemming.
1942 * Description: This function processes one CSS group. It moves the CSS notes
1943 * in the group to fall into the correct place on the other staff.
1944 * When necessary, it also adjusts the group boundary.
1948 one_css(ts_p
, os_p
, tg_p
, time
)
1950 struct STAFF
*ts_p
; /* This Staff, the normal one for the grpsyl */
1951 struct STAFF
*os_p
; /* Other Staff that the grpsyl has notes on */
1952 struct GRPSYL
*tg_p
; /* This Grpsyl */
1953 RATIONAL time
; /* time offset of this grpsyl */
1956 struct GRPSYL
*og_p
; /* Other Grpsyl (some grpsyl on other staff) */
1957 int foundclef
; /* found a clef change on other staff? */
1958 RATIONAL cleftime
; /* time at which the last clef change happens*/
1959 RATIONAL tt
; /* temporary time variable */
1960 float offset
; /* distance from old note position to new */
1961 int upfromc4
; /* steps up from middle C */
1962 int clef
; /* clef in force on other staff */
1963 int vidx
; /* voice index */
1964 int n
; /* loop variable */
1968 * Set globals like Staffscale according our staff. The parse phase
1969 * ensures that the two staffs have the same staffscale.
1971 set_staffscale(ts_p
->staffno
);
1974 * We need to find out what clef is in force on the other staff. We
1975 * start with the current value; but it may change midmeasure. We
1976 * can't just use the timed SSVs, because there are weird cases
1977 * where the clef got put farther to the right (because the clef was
1978 * changed before rests or spaces). So we have to search all the
1979 * voices for clefs. We look for the rightmost clef that does not
1980 * exceed the given time value.
1982 /* find clef in force on other staff at start of this measure */
1983 clef
= svpath(os_p
->staffno
, CLEF
)->clef
;
1986 for (vidx
= 0; vidx
< MAXVOICES
; vidx
++) {
1988 for (og_p
= os_p
->groups_p
[vidx
]; og_p
!= 0 && LE(tt
, time
);
1989 og_p
= og_p
->next
) {
1990 /* if group has a clef, and either it's the first group
1991 * found to have one or it's later than the latest such
1992 * group found so far . . . */
1993 if (og_p
->clef
!= NOCLEF
&&
1994 (foundclef
== NO
|| GT(tt
, cleftime
))) {
1996 clef
= og_p
->clef
; /* remember this clef*/
1997 cleftime
= tt
; /* and when it was */
1999 tt
= radd(tt
, og_p
->fulltime
);
2004 * Everything that has to move will move by the same offset. Calculate
2005 * it, using the first CSS note. First find its stepsup on the new
2006 * staff, like setnotes.c does for the normal staff. Subtract new
2007 * minus old vertical positions.
2010 upfromc4
= (tg_p
->notelist
[n
].octave
- 4) * 7 +
2011 Letshift
[ tg_p
->notelist
[n
].letter
- 'a' ];
2012 tg_p
->notelist
[n
].stepsup
= upfromc4
+ clef
- ALTO
;
2013 offset
= (os_p
->c
[AY
] + tg_p
->notelist
[n
].stepsup
* Stepsize
) -
2014 tg_p
->notelist
[n
].c
[AY
];
2016 /* move all the CSS notes and their dots */
2017 for ( ; n
<= LCNI(tg_p
); n
++) {
2018 upfromc4
= (tg_p
->notelist
[n
].octave
- 4) * 7 +
2019 Letshift
[ tg_p
->notelist
[n
].letter
- 'a' ];
2020 tg_p
->notelist
[n
].stepsup
= upfromc4
+ clef
- ALTO
;
2021 tg_p
->notelist
[n
].c
[RN
] += offset
;
2022 tg_p
->notelist
[n
].c
[RY
] += offset
;
2023 tg_p
->notelist
[n
].c
[RS
] += offset
;
2024 tg_p
->notelist
[n
].c
[AN
] += offset
;
2025 tg_p
->notelist
[n
].c
[AY
] += offset
;
2026 tg_p
->notelist
[n
].c
[AS
] += offset
;
2027 if (tg_p
->dots
> 0) {
2028 tg_p
->notelist
[n
].ydotr
+= offset
;
2033 * If the CSS note(s) were not on the stemside, stemlen and group
2034 * boundaries were set already in beamstem.c, but we need to fix them
2035 * here to account for moving the CSS notes.
2037 if (STEMSIDE_CSS(tg_p
) == NO
) {
2038 if (tg_p
->stemlen
!= 0.0) {
2039 tg_p
->stemlen
+= fabs(offset
);
2041 if (tg_p
->stemdir
== UP
) {
2042 tg_p
->c
[RS
] = tg_p
->notelist
[tg_p
->nnotes
- 1].c
[RS
]
2044 tg_p
->c
[AS
] = tg_p
->notelist
[tg_p
->nnotes
- 1].c
[AS
]
2047 tg_p
->c
[RN
] = tg_p
->notelist
[0].c
[RN
] + Stdpad
;
2048 tg_p
->c
[AN
] = tg_p
->notelist
[0].c
[AN
] + Stdpad
;
2056 * Abstract: Move CSS groups horizontally to avoid collisions on other staff.
2060 * Description: This function goes through the MLL, and for each CSS group,
2061 * calls a function to do horizontal avoidance.
2068 struct MAINLL
*mainll_p
; /* point along main LL */
2069 struct GRPSYL
*gs_p
; /* point at a group */
2070 int vidx
; /* voice index */
2071 RATIONAL time
; /* start time of a group */
2074 for (mainll_p
= Mainllhc_p
; mainll_p
!= 0; mainll_p
= mainll_p
->next
) {
2075 if (mainll_p
->str
!= S_STAFF
) {
2079 for (vidx
= 0; vidx
< MAXVOICES
; vidx
++) {
2081 for (gs_p
= mainll_p
->u
.staff_p
->groups_p
[vidx
];
2082 gs_p
!= 0; gs_p
= gs_p
->next
) {
2083 if (gs_p
->stemto
!= CS_SAME
) {
2084 avoidone(mainll_p
, gs_p
, time
);
2086 time
= radd(time
, gs_p
->fulltime
);
2095 * Abstract: Move CSS group horizontally to avoid collisions on other staff.
2099 * Description: This function finds whether the given group collides with any
2100 * groups on the other staff. If so, it moves that group, along
2101 * with all other groups on its staff and their preceding grace
2102 * groups, to the right enough so that the group no longer
2103 * collides. But it won't move it so far that it would collide
2104 * with a later group on its own staff.
2108 avoidone(mainll_p
, cssg_p
, time
)
2110 struct MAINLL
*mainll_p
; /* the MLL for our group's staff */
2111 struct GRPSYL
*cssg_p
; /* the CSS group we are working on */
2112 RATIONAL time
; /* time offset of this group */
2115 struct MAINLL
*mll_p
; /* point along main LL */
2116 int otherstaffno
; /* staff where the CSS notes are */
2117 struct GRPSYL
*gs_p
; /* point along grpsyl lists */
2118 struct GRPSYL
*gs2_p
; /* another pointer along grpsyl lists */
2119 struct CHORD
*ch_p
; /* point at chord we're in */
2120 float movedist
; /* distance to move groups */
2121 float otherhorz
; /* east boundary of groups on other staff */
2122 float slope
; /* slope of a beam */
2123 float deltax
; /* change in X coord of stem tip */
2124 int gotone
; /* flag variable */
2125 int n
; /* loop variable */
2128 /* never move the group if the user is forcing it with "ho" */
2129 if (cssg_p
->ho_usage
!= HO_NONE
) {
2134 * Find the other staff's number.
2136 if (cssg_p
->stemto
== CS_ABOVE
) {
2137 for (mll_p
= mainll_p
->prev
; mll_p
!= 0 && mll_p
->str
== S_STAFF
2138 && mll_p
->u
.staff_p
->visible
== NO
; mll_p
= mll_p
->prev
) {
2142 for (mll_p
= mainll_p
->next
; mll_p
!= 0 && mll_p
->str
== S_STAFF
2143 && mll_p
->u
.staff_p
->visible
== NO
; mll_p
= mll_p
->next
) {
2147 if (mll_p
== 0 || mll_p
->str
!= S_STAFF
) {
2148 pfatal("missing staff in avoidone");
2150 otherstaffno
= mll_p
->u
.staff_p
->staffno
;
2153 * Find what groups, if any, the other staff has at this time value.
2154 * First we find the GPRSYL at which the search begins.
2156 if (cssg_p
->stemto
== CS_ABOVE
) {
2158 * We will start the search at this first grpsyl in the chord.
2160 ch_p
= gs2ch(mainll_p
, cssg_p
);
2164 * We will start the search at our group, or if it is grace,
2165 * the main group that follows.
2167 for (gs_p
= cssg_p
; gs_p
->grpvalue
== GV_ZERO
;
2168 gs_p
= gs_p
->next
) {
2171 ch_p
= 0; /* remember we don't know the chord */
2174 /* find the first GRPSYL, if any, on the other staff at this time */
2175 for ( ; gs_p
!= 0 && gs_p
->staffno
< otherstaffno
; gs_p
= gs_p
->gs_p
) {
2179 /* if no groups on the other staff, there is no need to move anything */
2180 if (gs_p
== 0 || gs_p
->grpsyl
== GS_SYLLABLE
||
2181 gs_p
->staffno
> otherstaffno
) {
2186 * Find the easternmost extent of any group on the other staff that
2187 * extends far enough vertically to run into our group. We don't care
2188 * about grace groups, because they are on the west side, and we are
2189 * going to move our group to the east side.
2192 otherhorz
= 0.0; /* avoid "used before set" warning */
2193 for ( ; gs_p
!= 0 && gs_p
->grpsyl
== GS_GROUP
&&
2194 gs_p
->staffno
== otherstaffno
; gs_p
= gs_p
->gs_p
) {
2195 /* spaces never interfere; mr and mrpt rarely do, and their
2196 * coords make them seem really wide, so ignore them too */
2197 if (gs_p
->grpcont
== GC_SPACE
|| gs_p
->is_meas
== YES
) {
2200 if (cssg_p
->stemto
== CS_ABOVE
&& cssg_p
->c
[AN
] <= gs_p
->c
[AS
]){
2203 if (cssg_p
->stemto
== CS_BELOW
&& cssg_p
->c
[AS
] >= gs_p
->c
[AN
]){
2206 if (gotone
== NO
|| gs_p
->c
[AE
] > otherhorz
) {
2207 otherhorz
= gs_p
->c
[AE
];
2213 * If our group doesn't reach the other staff's groups vertically,
2214 * there is no need to move anything.
2221 * Find how far we'd need to move our group to the right to be beyond
2222 * any of the other staff's groups. If somehow that is not positive,
2223 * there is no need to move.
2225 movedist
= otherhorz
- cssg_p
->c
[AW
];
2226 if (movedist
<= 0.0) {
2230 /* find the first nongrace group at this time on our staff */
2231 if (cssg_p
->vno
== 1) {
2232 for (gs_p
= cssg_p
; gs_p
->grpvalue
== GV_ZERO
;
2233 gs_p
= gs_p
->next
) {
2238 ch_p
= gs2ch(mainll_p
, cssg_p
);
2240 /* find the first GRPSYL, if any, on our staff at this time */
2241 for (gs_p
= ch_p
->gs_p
; gs_p
!= 0 && gs_p
->staffno
<
2242 cssg_p
->staffno
; gs_p
= gs_p
->gs_p
) {
2248 * For each group on this staff in this chord, and for all their
2249 * preceding grace groups, move them to the east. Adjust stem lengths
2252 for ( ; gs_p
!= 0 && gs_p
->grpsyl
== GS_GROUP
&&
2253 gs_p
->staffno
== cssg_p
->staffno
; gs_p
= gs_p
->gs_p
) {
2255 /* never move the group if the user is forcing it with "ho" */
2256 if (gs_p
->ho_usage
!= HO_NONE
) {
2261 * If the group is beamed and the beam is not horizontal, the
2262 * stem length needs to be changed so it will meet the beam.
2264 if (gs_p
->beamloc
!= NOITEM
&& gs_p
->grpcont
== GC_NOTES
) {
2266 * Find a neighboring group in the beamed set so we can
2267 * find the beam's slope. The prev group is already
2268 * corrected; our group and the next group haven't been
2269 * moved yet; so the stems of all 3 are currently
2270 * touching the beam and are valid for finding slope.
2272 if (gs_p
->beamloc
== STARTITEM
) {
2273 gs2_p
= nextsimilar(gs_p
);
2275 gs2_p
= prevsimilar(gs_p
);
2277 slope
= (find_y_stem(gs2_p
) - find_y_stem(gs_p
)) /
2278 (find_x_stem(gs2_p
) - find_x_stem(gs_p
));
2280 deltax
= slope
* movedist
;
2282 if (gs_p
->stemdir
== UP
) {
2283 gs_p
->stemlen
+= deltax
;
2284 gs_p
->c
[RN
] += deltax
;
2285 gs_p
->c
[AN
] += deltax
;
2287 gs_p
->stemlen
-= deltax
;
2288 gs_p
->c
[RS
] += deltax
;
2289 gs_p
->c
[AS
] += deltax
;
2294 * Always do our group (a nongrace group), then loop
2295 * additionally for all preceding graces.
2299 gs2_p
->c
[AW
] += movedist
;
2300 gs2_p
->c
[AX
] += movedist
;
2301 gs2_p
->c
[AE
] += movedist
;
2303 /* if it's a group with notes, do the notes too */
2304 if (gs2_p
->grpcont
== GC_NOTES
) {
2305 for (n
= 0; n
< gs2_p
->nnotes
; n
++) {
2306 gs2_p
->notelist
[n
].c
[AW
] += movedist
;
2307 gs2_p
->notelist
[n
].c
[AX
] += movedist
;
2308 gs2_p
->notelist
[n
].c
[AE
] += movedist
;
2312 gs2_p
= gs2_p
->prev
;
2313 } while (gs2_p
!= 0 && gs2_p
->grpvalue
== GV_ZERO
);
2318 * Name: set_csb_stems()
2320 * Abstract: Set stem lengths for groups involved in cross staff beaming.
2324 * Description: This function searches the MLL for cross staff beaming places.
2325 * For each one, it calls onecsb() to set the stem lengths.
2332 struct MAINLL
*mainll_p
; /* point along main LL */
2333 struct MAINLL
*mll_p
; /* point along main LL again */
2334 struct STAFF
*staff1_p
, *staff2_p
; /* point at top and bottom staffs */
2335 struct GRPSYL
*gs1_p
, *gs2_p
; /* point at top and bottom groups */
2336 int v
, bv
; /* loop thru voices, top and bottom */
2337 RATIONAL vtime1
, vtime2
; /* start time of groups */
2340 debug(16, "set_csb_stems");
2341 initstructs(); /* clean out old SSV info */
2344 * Loop through the whole MLL, looking for visible staffs that are
2345 * not the last visible staff in their score. Then find cross staff
2346 * beamings and call a function to set stem lengths.
2348 for (mainll_p
= Mainllhc_p
; mainll_p
!= 0; mainll_p
= mainll_p
->next
) {
2349 /* apply SSVs to keep staffscale up to date */
2350 if (mainll_p
->str
== S_SSV
) {
2351 asgnssv(mainll_p
->u
.ssv_p
);
2355 if (mainll_p
->str
!= S_STAFF
)
2358 /* if staff is invisible, skip it */
2359 staff1_p
= mainll_p
->u
.staff_p
;
2360 if (staff1_p
->visible
== NO
)
2363 /* look for next visible staff, skipping invisible */
2364 for (mll_p
= mainll_p
->next
; mll_p
!= 0 && mll_p
->str
==
2365 S_STAFF
&& mll_p
->u
.staff_p
->visible
== NO
;
2366 mll_p
= mll_p
->next
)
2368 /* if no more visible staffs in score, skip */
2369 if (mll_p
== 0 || mll_p
->str
!= S_STAFF
)
2372 staff2_p
= mll_p
->u
.staff_p
;
2375 * staff1_p and staff2_p are two neighboring visible staffs
2376 * (possibly with invisible ones in between). Loop through the
2377 * voices on the top staff. For ones that don't exist, their
2378 * pointers will be 0 and the inside loop will do nothing.
2380 for (v
= 0; v
< MAXVOICES
; v
++) {
2382 * Loop through the groups of this voice, keeping track
2383 * of the elapsed time, looking for the first group of
2384 * each CSB set that is joined with the staff below.
2385 * It could be any of the voices on the staff below.
2386 * The parser deals with any checks concerning voices
2387 * being in the way of each other.
2390 for (gs1_p
= staff1_p
->groups_p
[v
]; gs1_p
!= 0;
2391 vtime1
= radd(vtime1
, gs1_p
->fulltime
),
2392 gs1_p
= gs1_p
->next
) {
2394 if (gs1_p
->beamto
!= CS_BELOW
||
2395 gs1_p
->beamloc
!= STARTITEM
)
2398 for (bv
= 0; bv
< MAXVOICES
; bv
++) {
2400 for (gs2_p
= staff2_p
->groups_p
[bv
];
2402 (LT(vtime2
, vtime1
) ||
2405 gs2_p
= gs2_p
->next
) {
2406 vtime2
= radd(vtime2
,
2409 if (gs2_p
!= 0 && EQ(vtime2
, vtime1
) &&
2410 gs2_p
->beamto
== CS_ABOVE
&&
2411 gs2_p
->beamloc
== STARTITEM
) {
2413 onecsb(gs1_p
, gs2_p
);
2424 * Abstract: Set stem lengths for one instance of cross staff beaming.
2428 * Description: This function finds the stem directions on the two staffs of
2429 * a CSB and the first and last groups of it that are note groups.
2430 * If the user didn't specify the stem lengths for those outer
2431 * groups (which determines the equation of the beams), it calls a
2432 * function to decide what the equation should be; otherwise it
2433 * finds the equation in-line. Then it sets all the groups' stem
2438 * Given the STARTITEM group of a CSB (whether notes or space), return the
2439 * first CSB group that is notes. Embedded grace groups are not part of CSB.
2441 #define FIRSTCSB(gs_p) (gs_p->grpcont == GC_NOTES ? gs_p : nextcsb(gs_p))
2444 onecsb(start1_p
, start2_p
)
2446 struct GRPSYL
*start1_p
; /* first GRPSYL on top staff */
2447 struct GRPSYL
*start2_p
; /* first GRPSYL on bottom staff */
2450 struct GRPSYL
*gs_p
; /* point at a group */
2451 int topdir
, botdir
; /* stem directions of the two lists */
2452 struct GRPSYL
*end1_p
, *end2_p
; /* ending group in each list */
2453 struct GRPSYL
*first_p
, *last_p
;/* first and last note groups in CSB */
2454 float firstx
, lastx
; /* x coords of end of stems */
2455 float firsty
, lasty
; /* y coords of stems */
2456 float b0
, b1
; /* y intercept and slope of the beam */
2457 float stemshift
; /* x distance of stem from center of note */
2458 float x
; /* x coord of a stem */
2459 float outstem
; /* the part of the stemlen outside notes of group */
2460 float hi
; /* height of a "with" list item */
2461 int n
; /* loop variable */
2465 * Set globals like Staffscale for use by the rest of the file. The
2466 * parse phase ensures that the two staffs have the same staffscale.
2468 set_staffscale(start1_p
->staffno
);
2470 topdir
= botdir
= UP
; /* prevent useless 'used before set' warnings */
2473 * Find stemdir of the top groups. (They will be consistent; that was
2474 * enforced in dobunch().) Set end1_p to the last group.
2476 for (gs_p
= FIRSTCSB(start1_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
2477 if (gs_p
->grpcont
== GC_NOTES
)
2478 topdir
= gs_p
->stemdir
;
2480 for (end1_p
= start1_p
; end1_p
!= 0 && end1_p
->beamloc
!= ENDITEM
;
2481 end1_p
= nextnongrace(end1_p
))
2484 pfatal("no ENDITEM in beamed set (onecsb[1])");
2486 /* do the same for the bottom groups */
2487 for (gs_p
= FIRSTCSB(start2_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
2488 if (gs_p
->grpcont
== GC_NOTES
)
2489 botdir
= gs_p
->stemdir
;
2491 for (end2_p
= start2_p
; end2_p
!= 0 && end2_p
->beamloc
!= ENDITEM
;
2492 end2_p
= nextnongrace(end2_p
))
2495 pfatal("no ENDITEM in beamed set (onecsb[2])");
2497 if (topdir
== UP
&& botdir
== DOWN
) {
2498 l_ufatal(start2_p
->inputfile
, start2_p
->inputlineno
,
2499 "when beaming across staffs, cannot have stems up on top staff and down on bottom");
2503 * Set first_p and last_p to the first and last note groups, whichever
2504 * staff(s) they are on.
2506 first_p
= start1_p
->grpcont
== GC_NOTES ? start1_p
: start2_p
;
2507 last_p
= end1_p
->grpcont
== GC_NOTES ? end1_p
: end2_p
;
2510 * Find half the width of a note head; the stems will need to be
2511 * shifted by that amount from the center of the notes so that they
2512 * will meet the edge of the notes properly.
2514 stemshift
= getstemshift(first_p
);
2518 * The user must either specify a stem length for both first and last
2519 * groups, or neither. (The parse phase enforces that.) If neither,
2520 * call a function to determine a line for a beam. It sets b0 and b1
2523 if (IS_STEMLEN_UNKNOWN(first_p
->stemlen
) ||
2524 IS_STEMLEN_UNKNOWN(last_p
->stemlen
)) {
2526 * User did not provide both outer stem lengths. Find the best
2527 * line. But if the stemlen parm was zero, we get back "NO",
2528 * and we set all stems to zero.
2530 if (calcline(start1_p
, end1_p
, start2_p
, end2_p
, first_p
,
2531 last_p
, topdir
, botdir
, &b0
, &b1
) == NO
) {
2532 for (gs_p
= first_p
; gs_p
!= end1_p
->next
;
2533 gs_p
= nxtbmnote(gs_p
, start1_p
, end1_p
->next
)) {
2534 gs_p
->stemlen
= 0.0;
2540 * User provided outer stem lengths. If they are zero, force
2541 * all groups to zero and get out. There will be no stems and
2544 if (first_p
->stemlen
== 0.0 && last_p
->stemlen
== 0.0) {
2545 for (gs_p
= first_p
; gs_p
!= end1_p
->next
;
2546 gs_p
= nxtbmnote(gs_p
, start1_p
, end1_p
->next
)) {
2547 gs_p
->stemlen
= 0.0;
2553 * User provided outer stem lengths; calculate b0 and b1.
2554 * First get Y coords of endpoints of first and last stems.
2556 first_p
->stemlen
*= Staffscale
;
2557 last_p
->stemlen
*= Staffscale
;
2558 firsty
= first_p
->stemdir
== UP ?
2559 first_p
->notelist
[0].c
[AY
] + first_p
->stemlen
:
2560 first_p
->notelist
[ first_p
->nnotes
- 1 ].c
[AY
]
2562 lasty
= last_p
->stemdir
== UP ?
2563 last_p
->notelist
[0].c
[AY
] + last_p
->stemlen
:
2564 last_p
->notelist
[ last_p
->nnotes
- 1 ].c
[AY
]
2567 * If first and last are opposite, adjust the right end of
2570 if (first_p
->stemdir
!= last_p
->stemdir
)
2571 lasty
+= end_bm_offset(start1_p
, last_p
, 8);
2573 /* get X coords; calculate b0 and b1 */
2574 firstx
= first_p
->c
[AX
] + stemshift
*
2575 (first_p
->stemdir
== DOWN ?
-1 : 1);
2576 lastx
= last_p
->c
[AX
] + stemshift
*
2577 (last_p
->stemdir
== DOWN ?
-1 : 1);
2578 b1
= (lasty
- firsty
) / (lastx
- firstx
); /* slope */
2579 b0
= firsty
- b1
* firstx
; /* y intercept */
2584 * At this point we know the equation for the beams. Figure out and
2585 * set the correct stem lengths for all of these beamed groups.
2587 if (topdir
== botdir
) { /* all stems have the same direction */
2588 if (first_p
->stemdir
== DOWN
)
2589 stemshift
= -stemshift
;
2591 /* loop through the top staff's groups */
2592 for (gs_p
= FIRSTCSB(start1_p
); gs_p
!= 0; gs_p
=nextcsb(gs_p
)){
2593 x
= gs_p
->c
[AX
] + stemshift
;
2595 /* first set stemlen to beam's Y coord minus note's */
2596 gs_p
->stemlen
= (b0
+ b1
* x
) - BNOTE(gs_p
).c
[AY
];
2598 /* if stems are down, reverse it */
2599 if (gs_p
->stemdir
== DOWN
)
2600 gs_p
->stemlen
= -(gs_p
->stemlen
);
2602 finalstemadjust(gs_p
);
2604 /* loop through the bottom staff's groups */
2605 for (gs_p
= FIRSTCSB(start2_p
); gs_p
!= 0; gs_p
=nextcsb(gs_p
)){
2606 x
= gs_p
->c
[AX
] + stemshift
;
2608 /* first set stemlen to beam's Y coord minus note's */
2609 gs_p
->stemlen
= (b0
+ b1
* x
) - BNOTE(gs_p
).c
[AY
];
2611 /* if stems are down, reverse it */
2612 if (gs_p
->stemdir
== DOWN
)
2613 gs_p
->stemlen
= -(gs_p
->stemlen
);
2615 /* if negative (note on wrong side of beam), error */
2616 if (gs_p
->stemlen
< 0) {
2617 l_ufatal(gs_p
->inputfile
, gs_p
->inputlineno
,
2618 "stem length was forced negative");
2621 finalstemadjust(gs_p
);
2623 } else { /* topdir != botdir; some stems have different dir */
2625 struct GRPSYL
*prev_p
; /* previous CSB group */
2626 struct GRPSYL
*firstsub_p
; /* first group of a subbeam */
2627 struct GRPSYL
*lastsub_p
; /* last group of a subbeam */
2628 struct GRPSYL
*sub_p
; /* a group in a subbeam */
2629 int minbeams
; /* no. of beams all share */
2630 int beams
; /* no. of beams of a group */
2631 int slowbasic
; /* slowest basictime in CSB */
2632 int fastbasic
; /* fastest basictime in CSB */
2633 int basic
; /* a basictime value */
2634 float bhigh
; /* height of beams */
2635 float extra
; /* amount to lengthen all stems by */
2639 * Find the minimum number of beams of the groups in the CSB
2640 * set. That will be the number of beams that they all share.
2642 minbeams
= 999; /* way more than there could ever be */
2643 for (gs_p
= first_p
; gs_p
!= end1_p
->next
;
2644 gs_p
= nxtbmnote(gs_p
, start1_p
, end1_p
->next
)){
2645 beams
= drmo(gs_p
->basictime
) - 2;
2646 if (beams
< minbeams
)
2651 * Find height of all the beams: the distance between the
2652 * centers of the outer beams. This should agree with
2653 * the numbers in prntdata.c.
2655 bhigh
= (minbeams
- 1) * Staffscale
*
2656 (first_p
->grpsize
== GS_NORMAL ? FLAGSEP
: 4.0 * POINT
);
2659 * Change the y intercept such that the first stem is lengthened
2660 * by half of this height. The line is at the outer beam, from
2661 * the perspective of the first group.
2663 b0
+= first_p
->stemdir
== UP ? bhigh
/ 2.0 : -bhigh
/ 2.0;
2666 * First set stem lengths to reach the line of the main beam.
2667 * At this point, we don't yet include the distance between the
2668 * notes of multinote groups. While we're at it, find the
2669 * slowest basictime of any group in the CSB set.
2670 * Also find the fastest basictime.
2672 slowbasic
= 1024; /* faster than any could be */
2673 fastbasic
= 8; /* slowest that any could be */
2674 /* loop through the top staff's groups: all stems down */
2675 for (gs_p
= FIRSTCSB(start1_p
); gs_p
!= 0; gs_p
=nextcsb(gs_p
)){
2676 x
= gs_p
->c
[AX
] - stemshift
;
2678 /* first set stemlen to note's Y coord minus beam's */
2679 gs_p
->stemlen
= gs_p
->notelist
[ gs_p
->nnotes
- 1 ].
2680 c
[AY
] - (b0
+ b1
* x
);
2682 slowbasic
= MIN(slowbasic
, gs_p
->basictime
);
2683 fastbasic
= MAX(fastbasic
, gs_p
->basictime
);
2685 /* loop through the bottom staff's groups; all stems up */
2686 for (gs_p
= FIRSTCSB(start2_p
); gs_p
!= 0; gs_p
=nextcsb(gs_p
)){
2687 x
= gs_p
->c
[AX
] + stemshift
;
2689 /* first set stemlen to beam's Y coord minus note's */
2690 gs_p
->stemlen
= (b0
+ b1
* x
) - gs_p
->notelist
[0].c
[AY
];
2692 slowbasic
= MIN(slowbasic
, gs_p
->basictime
);
2693 fastbasic
= MAX(fastbasic
, gs_p
->basictime
);
2697 * Find the minimum number of beams (based on the slowest
2698 * basictime) and subtract 1 to find the number of additional
2699 * beams that all groups share beyond the first beam. Multiply
2700 * by the distance the centers of neighboring beams.
2702 extra
= ((drmo(slowbasic
) - 2) - 1) * Staffscale
*
2703 (first_p
->grpsize
== GS_NORMAL ? FLAGSEP
: 4.0 * POINT
);
2706 * For each group with stemdir opposite to that of the first
2707 * group, lengthen its stemlen by that amount.
2709 for (gs_p
= first_p
; gs_p
!= end1_p
->next
; gs_p
=
2710 nxtbmnote(gs_p
, start1_p
, end1_p
->next
)) {
2712 if (gs_p
->stemdir
!= first_p
->stemdir
)
2713 gs_p
->stemlen
+= extra
;
2717 * Loop for each basictime being used that is shorter than the
2718 * longest one; that is, for each level of subbeam that is
2721 for (basic
= slowbasic
* 2; basic
<= fastbasic
; basic
*= 2) {
2723 /* loop through all note groups in the CSB */
2724 for (prev_p
= 0, gs_p
= first_p
;
2725 gs_p
!= end1_p
->next
;
2726 prev_p
= gs_p
, gs_p
= nxtbmnote(gs_p
, start1_p
,
2729 * If this group has at least as fast a basic-
2730 * time as the one we're now dealing with, and
2731 * the previous group doesn't (or there is no
2732 * previous group), a new subbeam must begin
2733 * here (or it could be just a partial beam).
2734 * If not, "continue" here.
2736 if (gs_p
->basictime
< basic
|| (gs_p
!= first_p
2737 && prev_p
->basictime
>= basic
)){
2741 /* point at the start of this subbeam */
2745 * Set lastsub_p to right end of the subbeam,
2746 * the group right before the basictime becomes
2747 * slower than the level we are dealing with.
2749 for (lastsub_p
= sub_p
= firstsub_p
; sub_p
!=
2750 end1_p
->next
; sub_p
= nxtbmnote(sub_p
,
2751 start1_p
, end1_p
->next
)) {
2754 sub_p
->basictime
< basic
) {
2761 * Loop through subbeam, lengthening the stems
2762 * of all the note groups whose stem direction
2763 * is opposite to the first group's. Lengthen
2764 * them enough for one more beam.
2766 for (sub_p
= firstsub_p
; sub_p
!= end1_p
->next
;
2767 sub_p
= nxtbmnote(sub_p
, start1_p
,
2770 if (sub_p
->stemdir
!= firstsub_p
->
2773 (sub_p
->grpsize
== GS_NORMAL ?
2774 FLAGSEP
: 4.0 * POINT
) *
2778 if (sub_p
== lastsub_p
) {
2785 /* adjust all stems in the CSB */
2786 for (gs_p
= first_p
;
2787 gs_p
!= end1_p
->next
;
2788 gs_p
= nxtbmnote(gs_p
, start1_p
, end1_p
->next
)) {
2790 /* if negative (note on wrong side of beam), error */
2791 if (gs_p
->stemlen
< 0) {
2792 l_ufatal(gs_p
->inputfile
, gs_p
->inputlineno
,
2793 "stem length was forced negative");
2796 /* add distance between outer notes of group */
2797 gs_p
->stemlen
+= (gs_p
->notelist
[0].stepsup
-
2798 gs_p
->notelist
[ gs_p
->nnotes
- 1 ].stepsup
) * Stepsize
;
2804 * In beamstem.c, setgroupvert() expanded the north and south
2805 * boundaries of groups to allow for stems (except for CSB groups) and
2806 * "with" items (except for CSB where normwith was NO). The exceptions
2807 * were because in those cases we needed to know the stem lengths and
2808 * we didn't yet. Well, now we know. So do the job here.
2810 * The extension for the stem is the length of the exterior part of it
2811 * minus half the size of the stem side note (about a STEPSIZE), since
2812 * the note itself is already included in the group boundary. Each
2813 * "with" item is allowed enough space for its height, or MINWITHHEIGHT,
2814 * whichever is greater. In the print phase, items of height less than
2815 * MINWITHHEIGHT will be placed so as to avoid staff lines as much as
2818 for (gs_p
= first_p
; gs_p
!= end1_p
->next
; gs_p
= nxtbmnote(gs_p
,
2819 start1_p
, end1_p
->next
)) {
2820 outstem
= gs_p
->stemlen
2821 - (gs_p
->notelist
[0].c
[RY
]
2822 - gs_p
->notelist
[ gs_p
->nnotes
- 1 ].c
[RY
]);
2823 if (gs_p
->stemdir
== UP
)
2824 gs_p
->c
[AN
] += outstem
- Stepsize
;
2826 gs_p
->c
[AS
] -= outstem
- Stepsize
;
2828 if (gs_p
->normwith
== NO
) {
2829 for (n
= 0; n
< gs_p
->nwith
; n
++) {
2830 hi
= strheight(gs_p
->withlist
[n
]);
2831 hi
= MAX(hi
, Staffscale
* MINWITHHEIGHT
);
2832 if (gs_p
->stemdir
== UP
)
2844 * Abstract: Calculate the equation of the line for the beams of a CSB set.
2846 * Returns: YES if an equation was calculated, NO if there are no stems.
2848 * Description: This function uses linear regression to figure out where the
2849 * best place to put the beam is, for a CSB set. Then, based on
2850 * whether the stems on the two staffs have the same direction, it
2851 * calls the appropriate function to adjust the results of the
2852 * linear regression as needed.
2856 calcline(start1_p
, end1_p
, start2_p
, end2_p
, first_p
, last_p
, topdir
, botdir
,
2859 struct GRPSYL
*start1_p
; /* first group in first voice */
2860 struct GRPSYL
*start2_p
; /* first group in second voice */
2861 struct GRPSYL
*end1_p
; /* last group in first voice */
2862 struct GRPSYL
*end2_p
; /* last group in second voice */
2863 struct GRPSYL
*first_p
; /* first note group in either voice */
2864 struct GRPSYL
*last_p
; /* last note group in either voice */
2865 int topdir
, botdir
; /* stem directions of top and bottom voices */
2866 float *b0_p
, *b1_p
; /* y intercept and slope to return */
2869 float defstemsteps
; /* default stem length */
2870 int one_end_forced
; /* is stem len forced on one end only? */
2871 int slope_forced
; /* is the slope of the beam forced? */
2872 float forced_slope
; /* slope that the user forced */
2873 struct GRPSYL
*gs_p
; /* loop through the groups in the beamed set */
2874 float sx
, sy
; /* sum of x and y coords of notes */
2875 float xbar
, ybar
; /* average x and y coords of notes */
2876 float top
, bottom
; /* numerator & denominator for finding b1 */
2877 float temp
; /* scratch variable */
2878 float b0
, b1
; /* y intercept and slope */
2879 float deflen
; /* default len of a stem, based on basictime */
2880 int num
; /* number of notes */
2883 if (fabs(first_p
->beamslope
- NOBEAMANGLE
) < 0.001) {
2885 forced_slope
= 0.0; /* not used, keep lint happy */
2888 forced_slope
= tan(first_p
->beamslope
* PI
/ 180.0);
2890 one_end_forced
= IS_STEMLEN_KNOWN(first_p
->stemlen
) !=
2891 IS_STEMLEN_KNOWN(last_p
->stemlen
);
2894 * Find how long we'd like stems to be, ignoring for the moment groups
2895 * that need to be longer due to multiple beams.
2897 /* average default stems lengths of the two voices */
2898 defstemsteps
= (vvpath(start1_p
->staffno
, start1_p
->vno
, STEMLEN
)->
2900 vvpath(start2_p
->staffno
, start2_p
->vno
, STEMLEN
)->
2902 /* if this is zero, both stemlens must be zero, so no stems */
2903 if (defstemsteps
== 0.0 && ! slope_forced
&& ( ! one_end_forced
||
2904 first_p
->stemlen
== 0.0 || last_p
->stemlen
== 0.0)) {
2907 if (allsmall(start1_p
, end1_p
) == NO
||
2908 allsmall(start2_p
, end2_p
) == NO
) {
2909 /* at least one group has a normal size note */
2910 deflen
= defstemsteps
* Stepsize
;
2912 /* all groups have all small notes */
2913 deflen
= defstemsteps
* SM_STEMFACTOR
* Stepsize
;
2917 * Use linear regression to find the best-fit line through where the
2918 * ends of the stems would be if they were the standard length. In
2919 * setbeam() where a similar thing was done for non-CSB beams, we used
2920 * the centers of the notes, which was okay because at this point in
2921 * the game we're really just interested in finding the slope. But
2922 * in CSB, sometimes the stems of the two staffs go in opposite
2923 * directions, so we really need to consider the ends of the stems.
2925 * In this function, we will always be concerned with the X coord of
2926 * the group as a whole (disregarding any notes that are on the "wrong"
2927 * side of the stem) but the Y coord of the note of the group that's
2928 * nearest to the beam (thus the BNOTE macro).
2930 * First get sum of x and y coords, to find averages.
2934 for (gs_p
= FIRSTCSB(start1_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
2936 sy
+= BNOTE(gs_p
).c
[AY
] + (topdir
== UP ? deflen
: -deflen
);
2937 num
++; /* count number of notes */
2939 for (gs_p
= FIRSTCSB(start2_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
2941 sy
+= BNOTE(gs_p
).c
[AY
] + (botdir
== UP ? deflen
: -deflen
);
2942 num
++; /* count number of notes */
2948 /* accumulate numerator & denominator of regression formula for b1 */
2950 for (gs_p
= FIRSTCSB(start1_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
2951 temp
= gs_p
->c
[AX
] - xbar
;
2952 top
+= temp
* (BNOTE(gs_p
).c
[AY
] +
2953 (topdir
== UP ? deflen
: -deflen
) - ybar
);
2954 bottom
+= temp
* temp
;
2956 for (gs_p
= FIRSTCSB(start2_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
2957 temp
= gs_p
->c
[AX
] - xbar
;
2958 top
+= temp
* (BNOTE(gs_p
).c
[AY
] +
2959 (botdir
== UP ? deflen
: -deflen
) - ybar
);
2960 bottom
+= temp
* temp
;
2963 b1
= top
/ bottom
; /* slope */
2964 b0
= ybar
- b1
* xbar
; /* y intercept */
2966 /* equation of regression line: y = b0 + b1 * x */
2968 if (topdir
== botdir
) {
2969 samedir(first_p
, last_p
, start1_p
, start2_p
, end1_p
, &b0
, &b1
,
2970 deflen
, one_end_forced
, slope_forced
,
2973 oppodir(first_p
, last_p
, start1_p
, start2_p
, &b0
, &b1
, deflen
,
2974 one_end_forced
, slope_forced
, forced_slope
);
2977 /* return the calculated slope and intercept */
2987 * Abstract: Adjust b0 and b1 when stems are all the same direction.
2991 * Description: This function is used in the case that the stems on the two
2992 * staffs of the CSB have the same direction. It is given the
2993 * y intercept and slope of the beam as calculated by linear
2994 * regression. It adjusts these values if need be. The algorithm
2995 * is similar to the one in setbeam() in beamstem.c. But here we
2996 * have to deal with two linked lists of groups, and we don't have
2997 * to deal with grace notes or alternations.
3001 samedir(first_p
, last_p
, start1_p
, start2_p
, end1_p
, b0_p
, b1_p
, deflen
,
3002 one_end_forced
, slope_forced
, forced_slope
)
3004 struct GRPSYL
*first_p
, *last_p
; /* first and last note groups in CSB */
3005 struct GRPSYL
*start1_p
, *start2_p
; /* first groups of 1st & 2nd voices */
3006 struct GRPSYL
*end1_p
; /* last group of 1st voice */
3007 float *b0_p
, *b1_p
; /* y intercept and slope */
3008 double deflen
; /* default len of a stem, based on group size*/
3009 int one_end_forced
; /* is stem len forced on one end only? */
3010 int slope_forced
; /* is the slope of the beam forced? */
3011 double forced_slope
; /* slope that the user forced */
3014 struct GRPSYL
*gs_p
; /* loop through the groups in the beamed set */
3015 float firstx
, lastx
; /* x coord of first & last note (end of stem)*/
3016 float firsty
, lasty
; /* y coord of first & last note (end of stem)*/
3017 float maxb0
, minb0
; /* max and min y intercepts */
3018 float stemshift
; /* x distance of stem from center of note */
3019 float b0
, b1
; /* working copy of y intercept and slope */
3020 float temp
; /* temp variable */
3021 float shortdist
; /* amount of stem shortening allowed (inches)*/
3022 int bf
; /* number of beams/flags */
3023 int shortest
; /* basictime of shortest note in group */
3026 /* set working copies from the original values */
3031 * Find half the width of a note head; the stems will need to be
3032 * shifted by that amount from the center of the notes so that they
3033 * will meet the edge of the notes properly. If the stems are up,
3034 * they will be on the right side of (normal) notes, else left. Set
3035 * the X positions for the first and last stems.
3037 stemshift
= getstemshift(first_p
);
3038 if (first_p
->stemdir
== DOWN
)
3039 stemshift
= -stemshift
;
3040 firstx
= first_p
->c
[AX
] + stemshift
; /* first group's stem */
3041 lastx
= last_p
->c
[AX
] + stemshift
; /* last group's stem */
3044 * The original line derived by linear regression must be adjusted in
3045 * certain ways. First, override it if the user wants that; otherwise
3046 * adjust according to the beamslope parameter.
3051 b1
= adjslope(start1_p
, b1
, NO
);
3055 * Calculate a new y intercept (b0). First pass parallel lines
3056 * through each note, and record the maximum and minimum y intercepts
3059 b0
= BNOTE(first_p
).c
[AY
] - b1
* first_p
->c
[AX
];
3060 maxb0
= minb0
= b0
; /* init to value for first note */
3061 /* look at rest of them on each of the two staffs */
3062 for (gs_p
= FIRSTCSB(start1_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
3063 b0
= BNOTE(gs_p
).c
[AY
] - b1
* gs_p
->c
[AX
];
3066 else if (b0
< minb0
)
3069 for (gs_p
= FIRSTCSB(start2_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
3070 b0
= BNOTE(gs_p
).c
[AY
] - b1
* gs_p
->c
[AX
];
3073 else if (b0
< minb0
)
3078 * Find the basictime of the shortest note in the CSB set, considering
3079 * also any slashes on it. Then update the default stem length based
3083 for (gs_p
= first_p
; gs_p
!= end1_p
->next
; gs_p
= nxtbmnote(gs_p
,
3084 start1_p
, end1_p
->next
)) {
3085 bf
= drmo(gs_p
->basictime
) - 2; /* no. of beams/flags */
3086 bf
+= abs(gs_p
->slash_alt
); /* slashes */
3088 * In certain cases where there are accidentals, we need to
3089 * artificially increase bf to keep the beams from overlapping
3090 * with the accidental.
3092 if (gs_p
!= first_p
&& gs_p
->stemdir
== UP
&&
3093 gs_p
->notelist
[0].accidental
!= '\0' &&
3094 gs_p
->notelist
[0].accidental
!= 'x' &&
3096 bf
+= 3.5 * b1
* (STEPSIZE
/ FLAGSEP
) * ((bf
> 1) +
3097 (gs_p
->notelist
[0].accidental
== 'B'));
3104 /* don't use "==" due to floating point roundoff error */
3105 if (deflen
> 6 * Stepsize
) {
3106 /* at least one group has a normal size note */
3107 deflen
+= (shortest
- 2) * Flagsep
;
3109 /* all groups have all small notes */
3110 deflen
+= (shortest
- 2) * 4.0 * POINT
* Staffscale
;
3115 * The outer edge of the beam should be deflen steps away from the
3116 * average position of the notes, as defined by the linear regression
3117 * line. But don't allow any note to be closer than a certain number
3118 * of steps less than that, the number as given by the stemshorten parm.
3119 * We use the average of the two stemshorten values for the two voices.
3121 shortdist
= (vvpath(start1_p
->staffno
, start1_p
->vno
, STEMSHORTEN
)
3123 vvpath(start2_p
->staffno
, start2_p
->vno
, STEMSHORTEN
)
3124 ->stemshorten
) / 2.0 * Stepsize
;
3125 if (first_p
->stemdir
== UP
) {
3126 if (maxb0
- minb0
> shortdist
)
3127 b0
= maxb0
+ deflen
- shortdist
;
3131 if (maxb0
- minb0
> shortdist
)
3132 b0
= minb0
- deflen
+ shortdist
;
3137 firsty
= b0
+ b1
* firstx
; /* y coord near left end of beam */
3138 lasty
= b0
+ b1
* lastx
; /* y coord near right end of beam */
3141 * At this point, like setbeam(), we could force the stems of notes
3142 * that are pointing to the center of their staffs to reach that center
3143 * line. But it's questionable whether that should be done in cross
3144 * staff beaming situations. We choose not to.
3148 * If y at the ends of the beam differs by less than a step (allowing a
3149 * fudge factor for roundoff error), force the beam horizontal by
3150 * setting one end farther away from the notes. But don't do it if the
3151 * user is forcing a particular slope.
3153 if ( ! slope_forced
&& fabs(firsty
- lasty
) < Stepsize
- 0.001) {
3154 if (first_p
->stemdir
== UP
) {
3155 if (firsty
> lasty
) {
3161 if (firsty
< lasty
) {
3169 /* recalculate slope and y intercept from (possibly) new endpoints */
3170 b1
= (lasty
- firsty
) / (lastx
- firstx
); /* slope */
3171 b0
= firsty
- b1
* firstx
; /* y intercept */
3174 * At this point, like setbeam(), we could do the equivalent of
3175 * embedgrace() and avoidothervoice(). But those functions themselves
3176 * wouldn't work here as they are, and/or we don't have the necessary
3177 * info handy for calling them. These problems are fairly rare, on top
3178 * of cross staff beaming already being fairly rare. If something
3179 * collides, the user can always manually set the stem lengths.
3183 * If one end's stem len was forced but not the other, now is the time
3184 * to apply that forcing. So in effect, we have taken the beam as
3185 * determined by the normal algorithm and now we change the vertical
3186 * coord of this end. If the slope was also forced, move the other
3187 * end by the same amount so that the slope won't change.
3189 if (one_end_forced
) {
3190 if (IS_STEMLEN_KNOWN(first_p
->stemlen
)) {
3191 first_p
->stemlen
*= Staffscale
;
3193 firsty
= BNOTE(first_p
).c
[AY
] + first_p
->stemlen
*
3194 (first_p
->stemdir
== UP ?
1.0 : -1.0);
3196 lasty
+= firsty
- temp
;
3199 last_p
->stemlen
*= Staffscale
;
3201 lasty
= BNOTE(last_p
).c
[AY
] + last_p
->stemlen
*
3202 (last_p
->stemdir
== UP ?
1.0 : -1.0);
3204 firsty
+= lasty
- temp
;
3209 b1
= (lasty
- firsty
) / (lastx
- firstx
); /* slope */
3210 b0
= firsty
- b1
* firstx
; /* y intercept */
3213 /* send back the newly calculated values */
3221 * Abstract: Adjust b0 and b1 when stems are in opposite directions.
3225 * Description: This function is used in the case that the stems on the two
3226 * staffs of the CSB all have opposite directions. It is given
3227 * the y intercept and slope of the beam as calculated by linear
3228 * regression. It adjusts these values if need be.
3232 oppodir(first_p
, last_p
, start1_p
, start2_p
, b0_p
, b1_p
, deflen
,
3233 one_end_forced
, slope_forced
, forced_slope
)
3235 struct GRPSYL
*first_p
, *last_p
; /* first and last note groups in CSB */
3236 struct GRPSYL
*start1_p
, *start2_p
; /* first groups of 1st & 2nd voices */
3237 float *b0_p
, *b1_p
; /* y intercept and slope */
3238 double deflen
; /* default len of a stem, based on group size*/
3239 int one_end_forced
; /* is stem len forced on one end only? */
3240 int slope_forced
; /* is the slope of the beam forced? */
3241 double forced_slope
; /* slope that the user forced */
3244 struct GRPSYL
*gs_p
; /* loop through the groups in the beamed set */
3245 float firstx
, lastx
; /* x coord of first & last note (end of stem)*/
3246 float firsty
, lasty
; /* y coord of first & last note (end of stem)*/
3247 float maxb0
, minb0
; /* max and min y intercepts */
3248 float stemshift
; /* x distance of stem from center of note */
3249 float b0
, b1
; /* working copy of y intercept and slope */
3250 float temp
; /* temp variable */
3253 /* set working copies from the original values */
3258 * Find half the width of a note head; the stems will need to be
3259 * shifted by that amount from the center of the notes so that they
3260 * will meet the edge of the notes properly. If the stems are up,
3261 * they will be on the right side of (normal) notes, else left. Set
3262 * the X positions for the first and last stems.
3264 stemshift
= getstemshift(first_p
);
3265 if (first_p
->stemdir
== DOWN
)
3266 stemshift
= -stemshift
;
3267 firstx
= first_p
->c
[AX
] + stemshift
; /* first group's stem */
3268 lastx
= last_p
->c
[AX
] + stemshift
; /* last group's stem */
3271 * The original line derived by linear regression must be adjusted in
3272 * certain ways. First, override it if the user wants that; otherwise
3273 * adjust according to the beamslope parameter.
3278 b1
= adjslope(start1_p
, b1
, YES
);
3282 * Calculate a new y intercept (b0). First pass parallel lines
3283 * through each note, and record the minimum y intercept for the top
3284 * staff and the maximum for the bottom staff that result.
3286 minb0
= 1000.0; /* init way positive */
3287 /* look at rest of them on each of the two staffs */
3288 for (gs_p
= FIRSTCSB(start1_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
3289 b0
= BNOTE(gs_p
).c
[AY
] - b1
* gs_p
->c
[AX
];
3293 maxb0
= -1000.0; /* init way negative */
3294 for (gs_p
= FIRSTCSB(start2_p
); gs_p
!= 0; gs_p
= nextcsb(gs_p
)) {
3295 b0
= BNOTE(gs_p
).c
[AY
] - b1
* gs_p
->c
[AX
];
3301 * Make the y intercept be the average of these. That means the top
3302 * staff's shortest stem will be equal in length to the bottom staff's.
3304 b0
= (maxb0
+ minb0
) / 2.0;
3306 firsty
= b0
+ b1
* firstx
; /* y coord near left end of beam */
3307 lasty
= b0
+ b1
* lastx
; /* y coord near right end of beam */
3310 * If y at the ends of the beam differs by less than a step (allowing a
3311 * fudge factor for roundoff error), force the beam horizontal,
3312 * averaging the two values.
3314 if ( ! slope_forced
&& fabs(firsty
- lasty
) < Stepsize
- 0.001) {
3315 lasty
= (firsty
+ lasty
) / 2.;
3319 /* recalculate slope and y intercept from (possibly) new endpoints */
3320 b1
= (lasty
- firsty
) / (lastx
- firstx
); /* slope */
3321 b0
= firsty
- b1
* firstx
; /* y intercept */
3324 * If one end's stem len was forced but not the other, now is the time
3325 * to apply that forcing. So in effect, we have taken the beam as
3326 * determined by the normal algorithm and now we change the vertical
3327 * coord of this end. If the slope was also forced, move the other
3328 * end by the same amount so that the slope won't change.
3330 if (one_end_forced
) {
3331 if (IS_STEMLEN_KNOWN(first_p
->stemlen
)) {
3332 first_p
->stemlen
*= Staffscale
;
3334 firsty
= BNOTE(first_p
).c
[AY
] + first_p
->stemlen
*
3335 (first_p
->stemdir
== UP ?
1.0 : -1.0);
3337 lasty
+= firsty
- temp
;
3340 last_p
->stemlen
*= Staffscale
;
3342 lasty
= BNOTE(last_p
).c
[AY
] + last_p
->stemlen
*
3343 (last_p
->stemdir
== UP ?
1.0 : -1.0);
3345 firsty
+= lasty
- temp
;
3350 b1
= (lasty
- firsty
) / (lastx
- firstx
); /* slope */
3351 b0
= firsty
- b1
* firstx
; /* y intercept */
3354 /* send back the newly calculated values */
3362 * Abstract: Find the next note group on this staff in this CSB.
3364 * Returns: pointer to next note group in CSB on this staff, 0 if none
3366 * Description: This function looks for the next group on this staff that is
3367 * still in this CSB set (therefore nongrace), and contains notes
3371 static struct GRPSYL
*
3374 struct GRPSYL
*gs_p
; /* current group, must be in a CSB */
3377 /* if we are already at the last group in the set, no next group */
3378 if (gs_p
->beamloc
== ENDITEM
)
3381 /* loop forward, considering only nongrace groups */
3382 for (gs_p
= nextnongrace(gs_p
); gs_p
!= 0; gs_p
= nextnongrace(gs_p
)) {
3383 /* if we find a note group, return it */
3384 if (gs_p
->grpcont
== GC_NOTES
)
3386 /* must be a space (rests not allowed); if enditem, give up */
3387 if (gs_p
->beamloc
== ENDITEM
)
3391 return (0); /* hit the end of the measure (shouldn't happen) */
3397 * Abstract: Find the next note group in this CSB (this staff or the other).
3399 * Returns: pointer to next note group in CSB, endnext_p if none
3401 * Description: This function looks for the next group that is still in this
3402 * CSB set (therefore nongrace), and contains notes (not a space
3403 * or a rest), whichever staff it may be on.
3406 static struct GRPSYL
*
3407 nxtbmnote(gs_p
, first_p
, endnext_p
)
3409 struct GRPSYL
*gs_p
; /* current group, must be in a CSB */
3410 struct GRPSYL
*first_p
; /* first group in top staff of the CSB */
3411 struct GRPSYL
*endnext_p
; /* what to return if we hit the end */
3415 * Keep finding the next nonspace group, until we hit the end or we
3416 * find one that is not a rest.
3419 gs_p
= nxtbmgrp(gs_p
, first_p
, endnext_p
);
3420 } while (gs_p
!= endnext_p
&& gs_p
->grpcont
!= GC_NOTES
);