💾 Archived View for runjimmyrunrunyoufuckerrun.com › src › foreign › pmw › src › out2.c captured on 2021-12-17 at 13:26:06.
View Raw
More Information
-=-=-=-=-=-=-
/*************************************************
- The PMW Music Typesetter - 3rd incarnation *
- ************************************************/
/* Copyright (c) Philip Hazel, 1991 - 2021 */
/* Written by Philip Hazel, starting November 1991 */
/* This file last modified: January 2021 */
/* This file contains miscellaneous subroutines for outputting a page */
#include "pmwhdr.h"
#include "pagehdr.h"
#include "outhdr.h"
/* Clef style can currently take values 0, 1, 2, or 3; the columns below
correspond to this. */
static int clef_chars[] = {
mc_trebleclef, mc_trebleclef, mc_trebleclef, mc_trebleclef,
mc_sopranoclef, mc_sopranoclef, mc_oldsopranoclef, mc_oldsopranoclef,
mc_mezzoclef, mc_mezzoclef, mc_oldmezzoclef, mc_oldmezzoclef,
mc_altoclef, mc_altoclef, mc_oldaltoclef, mc_oldaltoclef,
mc_tenorclef, mc_tenorclef, mc_oldtenorclef, mc_oldtenorclef,
mc_cbaritoneclef, mc_oldcbaritoneclef, mc_cbaritoneclef, mc_oldcbaritoneclef,
mc_baritoneclef, mc_oldbaritoneclef, mc_baritoneclef, mc_oldbaritoneclef,
mc_bassclef, mc_oldbassclef, mc_bassclef, mc_oldbassclef,
mc_deepbassclef, mc_olddeepbassclef, mc_deepbassclef, mc_olddeepbassclef,
mc_hclef, mc_hclef, mc_hclef, mc_hclef,
0, 0, 0, 0,
mc_trebleDclef, mc_trebleDclef, mc_trebleDclef, mc_trebleDclef,
mc_trebleTclef, mc_trebleTclef, mc_trebleTclef, mc_trebleTclef,
mc_trebleTBclef, mc_trebleTBclef, mc_trebleTBclef, mc_trebleTBclef,
mc_Sbassclef, mc_oldSbassclef, mc_Sbassclef, mc_oldSbassclef,
mc_Cbassclef, mc_oldCbassclef, mc_Cbassclef, mc_oldCbassclef
};
static uschar clef_adjusts[] = { 4, 0, 4, 8, 12, 16, 8, 12, 16, 0, 0, 4, 4, 4, 12, 12 };
/* These are the clef adjustments for custom key signatures. */
static int xclef_adjusts[] = {
-1, /* treble */
-6, /* soprano */
-4, /* mezzo */
-2, /* alto */
0, /* tenor */
2, /* cbaritone */
-5, /* baritone */
-3, /* bass */
-1, /* deepbass */
-1, /* h-clef */
-1, /* none */
-1, /* trebledescant */
-1, /* trebletenor */
-1, /* trebletenorB */
-3, /* soprabass */
-3 /* contrabass */
};
/************************************************
- Output a stave joining sign *
- ***********************************************/
/* This procedure is used for outputting lines, brackets, or braces at the
start of a system. It returns a bit map of the staves it referenced. For braces
and thin brackets, prev is the bit map of the (thick) bracketed staves. */
/* Local subroutine to determine if a stave is being printed.
Arguments:
stave stave number
bar bar number
Returns: TRUE if the bar is to be printed
static BOOL
is_printing(int stave, int bar)
{
stavestr *ss = curmovt->stavetable[stave];
return mac_teststave(out_sysblock->notsuspend, stave) &&
(!ss->omitempty || (ss->barindex)[bar] != NULL);
}
/* If yield is not null, bits are set for those staves that are included in the
joining item.
Arguments:
list pointer to chain of stave selections
prev bitvector of previous thick bracket for thin bracket and brace;
can be NULL for other types (not used)
which type of join sign, e.g. join_brace
bartype barline type when which == join_barline
bar number of the first bar in the system
yield a stave bitvector, or NULL
Returns: nothing
void
out_dojoinsign(stave_list *list, usint *prev, int which, int bartype, int bar,
usint *yield)
{
if (yield != NULL) mac_initstave(yield, 0);
for (; list != NULL; list = list->next)
{
int pb1 = list->first;
int pb2 = list->last;
if (pb1 > curmovt->laststave) continue;
if (pb2 > curmovt->laststave) pb2 = curmovt->laststave;
while (pb1 < out_laststave && pb1 < pb2 && !is_printing(pb1, bar)) pb1++;
while (pb2 > pb1 && !is_printing(pb2, bar)) pb2--;
if (is_printing(pb1, bar) || is_printing(pb2, bar))
{
int i, xx;
stavestr *ss = curmovt->stavetable[pb1];
mac_setstavesize(pb1);
xx = main_stavemagn * ((ss->stavelines == 6)? 4 : (ss->stavelines == 4)? -4 : 0);
switch(which)
{
case join_thinbracket:
case join_brace:
/* Should never be printed for one stave; there is some old code
that gets a brace positioned right if it ever is, but at present that
code is never triggered. */
if (out_depthvector[pb1] != out_depthvector[pb2])
{
BOOL overlap = FALSE;
for (i = pb1; i <= pb2; i++)
if (mac_teststave(prev, i)) { overlap = TRUE; break; }
if (which == join_brace)
{
int adjust = (out_depthvector[pb1] == out_depthvector[pb2])? 7000:8500;
if (overlap) adjust += 1500;
ps_brace(out_joinxposition - adjust,
out_yposition + out_depthvector[pb1] - xx,
out_yposition + out_depthvector[pb2], main_stavemagn);
}
else /* thin bracket */
{
int x[4], y[4];
out_ystave = out_yposition;
x[0] = x[3] = out_joinxposition;
x[1] = x[2] = x[0] - (overlap? 2500:1000) - 3000;
y[0] = y[1] = - out_depthvector[pb1] + 16*main_stavemagn + xx;
y[2] = y[3] = - out_depthvector[pb2];
ps_lines(x, y, 4, 400);
}
}
break;
case join_bracket:
ps_bracket(out_joinxposition-3500, out_yposition + out_depthvector[pb1] - xx,
out_yposition + out_depthvector[pb2], main_stavemagn);
break;
case join_barline:
ps_barline(out_joinxposition, out_yposition + out_depthvector[pb1] - xx,
out_yposition + out_depthvector[pb2], bartype);
break;
}
if (yield != NULL) for (i = pb1; i <= pb2; i++) mac_setstave(yield, i);
}
}
}
/************************************************
- Output a clef *
- ***********************************************/
/* The clef characters all print a little to the right of the given position.
The reason is historical. It does not matter at all, except when staves of
different sizes are printed - then the different size causes an uneven spacing
at the start of a line. So attempt to correct for this.
We must also adjust the vertical position for clefs that are not of full size,
so that they appear at the correct position on the stave.
Arguments:
x x-position
y y-position
clef which clef
size size
midbar TRUE if a mid-bar clef
Returns: nothing
void
out_writeclef(int x, int y, int clef, int size, BOOL midbar)
{
switch(clef)
{
case clef_none:
return;
case clef_cbaritone:
case clef_tenor:
case clef_alto:
case clef_soprano:
case clef_mezzo:
x += (2000 * (1000 - main_stavemagn))/1000;
break;
case clef_baritone:
case clef_deepbass:
case clef_bass:
case clef_contrabass:
case clef_soprabass:
x -= ((midbar? 15:5)*main_stavemagn)/10; /* move left 0.5 pt or 1.5 pt in mid bar */
x += (750 * (1000 - main_stavemagn))/1000;
break;
case clef_h:
break;
case clef_treble:
case clef_trebletenor:
case clef_trebletenorB:
case clef_trebledescant:
x += (700 * (1000 - main_stavemagn))/1000;
break;
}
ps_muschar(x,
y - mac_muldiv(10000 - size, clef_adjusts[clef]*main_stavemagn, 10000),
clef_chars[clef*4 + curmovt->clefstyle], (size*main_stavemagn)/1000);
}
/************************************************
- Output a key *
- ***********************************************/
/* This handles both standard and custom keys, taking note of any "printkey"
settings. The 0x40 bit is set when a naturalizing key is required.
Arguments:
x x-position
y y-position
clef the current clef
key the key signature
Returns: nothing
void
out_writekey(int x, int y, int clef, int key)
{
int i, ch, chwidth, n, *order;
int key63 = key & 63;
BOOL use_naturals = (key & 0x40) != 0;
pkeystr *pk;
for (pk = main_printkey; pk != NULL; pk = pk->next)
{
if (key63 == pk->key && clef == pk->clef &&
pk->movt_number <= curmovt->number)
break;
}
/* There is a special string for this key. */
if (pk != NULL)
{
out_string((key > 63)? pk->cstring : pk->string, font_mf, 10*main_stavemagn,
x, y, 0);
return;
}
/* Handle standard key signature printing */
if (key63 < X_key)
{
if ((n = main_keysigtable[key63]) > 0)
{
ch = mc_sharp;
chwidth = (curmovt->accspacing)[ac_sharp];
order = main_sharporder;
}
else
{
ch = mc_flat;
chwidth = (curmovt->accspacing)[ac_flat];
order = main_flatorder;
n = -n;
}
if (use_naturals)
{
ch = mc_natural;
chwidth = (curmovt->accspacing)[ac_natural];
}
order += main_clefoffset[clef];
chwidth = (chwidth * main_stavemagn)/1000;
for (i = 0; i < n; i++)
{
ps_muschar(x, y-(order[i]*main_stavemagn)/1000, ch, 10*main_stavemagn);
x += chwidth;
}
}
/* Handle custom key signature. To preserve the accidental order in which the
key was defined, we use an additional vector, which can be terminated early by
a value greater than 9. */
else
{
uschar *p = main_xkeys[key63 - X_key];
int clef_offset = xclef_adjusts[clef];
for (i = 0; i < 10; i++)
{
int level, offset, baseacc;
int k = main_xkeyorder[key63 - X_key][i];
if (k > 9) break; /* Early end of order list (normally the case) */
baseacc = p[k] & 0x7f;
level = k + clef_offset;
if (level > 9) level -= 7; else if (level < 0) level += 7;
if (use_naturals)
{
offset = baseacc = ac_natural;
}
else
{
offset = baseacc;
if ((p[k] & 0x80) != 0)
offset += ((offset == ac_sharp)? (curmovt->hsharpstyle == 0) :
(curmovt->hflatstyle == 0))? 18:36;
}
ps_muschar(x, y-(level*2*main_stavemagn), out_acctable[offset],
10*main_stavemagn);
x += (curmovt->accspacing[baseacc] * main_stavemagn)/1000;
}
}
}
/************************************************
- Output a time *
- ***********************************************/
/*
Arguments:
x x-position
y y-position
ts time signature
Returns: nothing
void
out_writetime(int x, int y, int ts)
{
ptimestr *pt = main_printtime;
int *fontvector = (curmovt->fontsizes)->fontsize_text;
int offsetn, offsetd, sizen, sized;
uschar vn[16];
uschar vd[16];
uschar *topstring = vn;
uschar *botstring = vd;
/* If not printing time signatures, return */
if (!curmovt->showtime) return;
/* First see if this time signature has special strings specified for its
printing. The printtime directive must have happened in this movement or
earlier for it to be applicable. */
while (pt != NULL)
{
if (pt->time == ts && pt->movt_number <= curmovt->number) break;
pt = pt->next;
}
/* If found special case, get strings and sizes from it */
if (pt != NULL)
{
offsetn = pt->offsettop;
offsetd = pt->offsetbot;
topstring = pt->top;
botstring = pt->bot;
}
/* Default printing for this time signature. First mask off the multiplier,
then check for the special cases of C and A. */
else
{
ts &= 0xFFFF;
/* C and A are special cases */
if (ts == time_common || ts == time_cut)
{
ps_muschar(x, y - 4*main_stavemagn,
((ts == time_common)? mc_common : mc_cut), 10*main_stavemagn);
return;
}
/* Non-special case - set up numerator and denominator, in the
time signature font. */
sprintf(CS vn, "%d", ts >> 8);
sprintf(CS vd, "%d", ts & 255);
offsetn = offsetd = ff_offset_ts;
}
/* We now have in topstring and botstring two strings to print. Arrange that
they are centred with respect to each other when both are to be printed. Also
arrange to adjust the heights according to the font size. We assume that at
12-points, the height is 8 points, which is true for the default bold font.
However, it is not true for the music font, so there is a fudge to check for
that case which will catch the common cases. This is all rather
unsatisfactory... */
sizen = (fontvector[offsetn]*main_stavemagn)/1000;
sized = (fontvector[offsetd]*main_stavemagn)/1000;
if (curmovt->showtimebase && botstring[0] != 0)
{
int stdsize = 12;
int nx = 0;
int dx = 0;
int widthn = string_width(topstring, font_bf, sizen);
int widthd = string_width(botstring, font_bf, sized);
if (widthn > widthd) dx = (widthn - widthd)/2; else
nx = (widthd - widthn)/2;
out_string(topstring, curmovt->font_time, sizen, x+nx,
y - (8000*main_stavemagn)/1000, 0);
if (Ustrncmp(botstring, "\\mf\\", 4) == 0) stdsize = 10;
out_string(botstring, curmovt->font_time, sized, x+dx,
y + ((3*(sized-stdsize*main_stavemagn)/4)*main_stavemagn)/1000, 0);
}
else
{
int stdsize = 12;
if (Ustrncmp(topstring, "\\mf\\", 4) == 0) stdsize = 10;
out_string(topstring, curmovt->font_time, sizen, x,
y - ((4000 - (sizen-stdsize*main_stavemagn)/3)*main_stavemagn)/1000, 0);
}
}
/*************************************************
- Output repeat marks *
- ************************************************/
static int repspacing[] = {
/* righthand repeats */
/* thick thin dots */
50, 31, 6, /* repeatstyle = 0 */
-1, 50, 25, /* repeatstyle = 1 */
-1, 50, 25, /* repeatstyle = 2 */
-1, -1, 25, /* repeatstyle = 3 */
50, 31, 6, /* repeatstyle = 4 */
/* lefthand repeats */
/* thick thin dots */
0, 35, 51, /* repeatstyle = 0 */
-1, 0, 15, /* repeatstyle = 1 */
-1, 0, 15, /* repeatstyle = 2 */
-1, -1, 15, /* repeatstyle = 3 */
0, 35, 51, /* repeatstyle = 4 */
/* righthand double repeats */
/* thick thin dots */
50, 31, 6, /* repeatstyle = 0 */
-1, 50, 25, /* repeatstyle = 1 */
-1, 50, 25, /* repeatstyle = 2 */
-1, -1, 25, /* repeatstyle = 3 */
34, -1, 6, /* repeatstyle = 4 */
/* lefthand double repeats */
/* thick thin dots */
0, 35, 51, /* repeatstyle = 0 */
-1, 0, 15, /* repeatstyle = 1 */
-1, 0, 15, /* repeatstyle = 2 */
-1, -1, 15, /* repeatstyle = 3 */
17, -1, 51 /* repeatstyle = 4 */
};
/*
Arguments:
x x-position
type type of repeat
magn magnification
Returns: nothing
void
out_writerepeat(int x, int type, int magn)
{
int *xx = repspacing + type + curmovt->repeatstyle * 3;
if (xx[0] >= 0)
ps_barline(x + (xx[0]*magn)/10, out_ystave, out_ybarend, bar_thick);
if (xx[1] >= 0)
ps_barline(x + (xx[1]*magn)/10, out_ystave, out_ybarend,
(curmovt->repeatstyle == 2)? bar_dotted : bar_single);
out_string((curmovt->repeatstyle != 3)? US"xI" : US"IxxyyyyyyI", font_mf,
10*main_stavemagn, x + (xx[2]*magn)/10 + (65*(magn - main_stavemagn))/100,
out_ystave, 0);
}
/*************************************************
- Find X offset for given M offset *
- ************************************************/
/* The search starts at the current out_posptr. We never search for a value
that is less than a previous one. When setting up a beam over a bar line, the
moff can be greater than the bar length. In this case, and also in the case
when it is equal to the bar length, we must search the NEXT bar.
Argument: the musical offset in the bar
Returns: the x offset in the bar
int
out_findXoffset(int moff)
{
if (!beam_overbeam || moff < out_poslast->moff)
{
while (moff > out_posptr->moff && out_posptr < out_poslast) out_posptr++;
while (moff < out_posptr->moff && out_posptr > out_postable) out_posptr--;
if (moff == out_posptr->moff) return out_posptr->xoff;
}
/* Handle the beam over bar line case */
else
{
int newmoff = moff - out_poslast->moff;
posstr *new_postable, *new_posptr, *new_poslast;
barposstr *bp = curmovt->posvector + out_bar + 1;
new_postable = new_posptr = bp->vector;
new_poslast = new_postable + bp->count - 1;
while (newmoff > new_posptr->moff && new_posptr < new_poslast) new_posptr++;
while (newmoff < new_posptr->moff && new_posptr > new_postable) new_posptr--;
if (newmoff == new_posptr->moff)
return new_posptr->xoff + out_poslast->xoff + out_sysblock->barlinewidth;
}
/* Cannot find a position for this moff. This error is hard, but need to keep
the compiler happy. */
error_moan(ERR60, out_bar, out_stave, moff, moff);
return 0;
}
/*************************************************
- Find X offset for one of two given M offsets *
- ************************************************/
/* This is used only in the non-overbeaming case. It returns the x offset of
the first moff if it exists, otherwise the x offset of the second moff.
Arguments:
moff1 the first music offset
moff2 the second music offset
Returns: the x offset
int
out_findGoffset(int moff1, int moff2)
{
while (moff1 > out_posptr->moff && out_posptr < out_poslast) out_posptr++;
while (moff1 < out_posptr->moff && out_posptr > out_postable) out_posptr--;
if (moff1 == out_posptr->moff) return out_posptr->xoff;
return out_findXoffset(moff2);
}
/*************************************************
- Find postable entry for given M offset *
- ************************************************/
/*
Argument: the music offset
Returns: pointer to the postable entry, or NULL if not found
posstr *
out_findTentry(int moff)
{
while (moff > out_posptr->moff && out_posptr < out_poslast) out_posptr++;
while (moff < out_posptr->moff && out_posptr > out_postable) out_posptr--;
return (moff == out_posptr->moff)? out_posptr : NULL;
}
/*************************************************
- Find X offset or interpolate in current bar *
- ************************************************/
/* This is used to implement MusicXML-styole "offsets", which may be positive
or negative. Don't alter out_posptr. If we don't find an exact moff,
interpolate between two entries or, if off the end, fudge assuming 16 points
per crotchet.
Argument: the music offset
Returns: an x offset
int
out_findAoffset(int moff)
{
posstr *a, *b;
posstr *p = out_posptr;
while (moff > p->moff && p < out_poslast) p++;
while (moff < p->moff && p > out_postable) p--;
if (moff == p->moff) return p->xoff;
if (moff > p->moff)
{
if (p == out_poslast) /* After last entry */
return p->xoff + mac_muldiv(16000, moff - p->moff, len_crotchet);
a = p;
b = p + 1;
}
else
{
if (p == out_postable) /* Before first entry */
return p->xoff - mac_muldiv(16000, p->moff - moff, len_crotchet);
b = p;
a = p - 1;
}
/* In between two entries; interpolate. */
return a->xoff +
mac_muldiv(b->xoff - a->xoff, moff - a->moff, b->moff - a->moff);
}
/* End of out2.c */