@uref{ftp://ftp.ctan.org/tex-archive/macros/latex/contrib/supported/geometry,ftp://ftp.ctan.org/tex-archive/macros/latex/contrib/supported/geometry}
or at mirror site @uref{ftp://ftp.dante.de,ftp://ftp.dante.de}
-@item MetaPost, if you want to use direct PostScript output. Please
-note that tetex-0.4pl8 (included with Redhat 5.x) does not include
-@file{mfplain.mp}, which is needed for producing the scaleable font files.
+@item MetaPost, needed for generating PostScript fonts. Please
+note that tetex-0.4pl8 (included with Redhat 5.x) does not include
+@file{mfplain.mp}, which is needed for producing the scalable font
+files.
+
+If you do not want to use PostScript output, edit @file{mf/GNUmakefile}.
+
@end itemize
@example
- @var{tonic}[@var{duration}][@code{-}@var{modifiers}][@code{^}@var{subtractions}][@code{/}@var{inversion}].
+ @var{tonic}[@var{duration}][@code{-}@var{modifiers}][@code{^}@var{subtractions}][@code{/}@var{inversion}][@code{/+}@var{bass}].
@end example
@var{tonic} should be the tonic note of the chord, and @var{duration}
@mudela[fragment,verbatim]
\transpose c'' {
\chords {
- c1 c-3- c-7 c-8
- c-9 c-9-.5+.7+ c-3-.5- c-4.6.8
+ c1 c:3- c:7 c:8
+ c:9 c:9-.5+.7+ c:3-.5- c:4.6.8
}
}
@end mudela
@end quotation
-The second type of modifier that may appear after the `@code{-}' is a
+The second type of modifier that may appear after the `@code{:}' is a
named modifier. Named modifiers are listed in the file
@file{chord-modifiers.ly}. The available modifiers are `@code{m}' and
`@code{min}' which lower the 3rd half a step, `@code{aug}@indexcode{aug}' which
@mudela[fragment,verbatim]
\transpose c'' {
\chords {
- c1-m c-min7 c-maj c-aug c-dim c-sus
+ c1:m c:min7 c:maj c:aug c:dim c:sus
}
}
@mudela[fragment,verbatim,center]
\transpose c'' {
\chords {
- c1^3 c-7^5.3 c-8^7
+ c1^3 c:7^5.3 c:8^7
}
}
@end mudela
@mudela[fragment,verbatim,center]
\transpose c''' {
\chords {
- c1 c/e c/g c-7/e
+ c1 c/e c/g c:7/e
+ }
+ }
+
+@end mudela
+
+Bass notes can be added by `@code{/+}@indexcode{/+}' and
+the name of a single note to a chord. This has the effect of
+adding the specified note to the chord, lowered by an octave,
+so it becomes the lowest note in the chord.
+
+@mudela[fragment,verbatim,center]
+ \transpose c''' {
+ \chords {
+ c1 c/+c c/+g c:7/+b
}
}
accompaniment =\chords @{
r8
- c2-3- f-3-.7 d-min es4 c8-min r8
- c2-min f-min7 g-7^3.5 c-min @}
+ c2:3- f:3-.7 d:min es4 c8:min r8
+ c2:min f:min7 g:7^3.5 c:min @}
\score @{
\simultaneous @{
accompaniment =\chords {
r8
- c2-3- f-3-.7 d-min es4 c8-min r8
- c2-min f-min7 g-7^3.5 c-min }
+ c2:3- f:3-.7 d:min es4 c8:min r8
+ c2:min f:min7 g:7^3.5 c:min }
\score {
\simultaneous {
@end example
There is no accompaniment during the anacrusis.@example
- c2-3- f-3-.7
+ c2:3- f:3-.7
@end example
A chord is started by the tonic of the chord. The
to create the @code{f a c es} chord. Multiple modifiers must be
separated by a dot.@example
- d-min es4 c8-min r8
+ d:min es4 c8:min r8
@end example
Some modifiers have predefined names, eg. @code{min} is the same as
@code{3-}, so @code{d-min} is a minor @code{d} chord.@example
- c2-min f-min7 g-7^3.5 c-min @}
+ c2:min f:min7 g:7^3.5 c:min @}
@end example
A named modifier @code{min} and a normal modifier @code{7} do not have
to be separated by a dot. Tones from a chord are removed with chord
subtractions. Subtractions are started with a caret, and they are
-also separated by dots. In this example, @code{g-7^3.5} produces a
+also separated by dots. In this example, @code{g:7^3.5} produces a
minor seventh. The brace ends the sequential music. @example
\score @{
. * fix or replace feta-accordion.mf
. * script engraver
. * bracket pdf hack
-. * Chords:
-. * Bass/inversion pitch when not part of Chord
-Sometimes a series of changing chords will be blocked out over a static tone
-in the bass, usually this was referred to as a pedal tone (and it's been
-continued to be used, even in contemporary music). Another less frequently
-used practice is putting a non-chordal tone in the bass (that is not acting
-as a pedal tone) in order to create tension or make a more colorful sound.
-There are examples of this in the classsical literature, but its use is much
-more prevalent today. For example, the chord sequence Dm7 - Dm7/G is such a
-sequence, and the Dm7/G defies easy classification. Is it a G7(no 3rd)add
-9/11? Or is it a G7(no 3rd)add2/4? Or perhaps Dm7 add11? It's a heck of a
-lot easier to read to just leave it as Dm7/G!
-. * Diminished does not mean 5-
-When speaking of a chord, dimished can mean one of two things: A diminished
-triad or a dimished seventh chord (which is distinctly different from what's
-known as the 'half-diminished' chord). The triad is a root with a flat
-third and flat fifth, and is notated (at least in America, someone else will
-have to fill me in on other countries) as (using C as the root) Cdim, or Co.
-The diminished seventh has a root with a flat third, flat fifth, and a
-doubly flatted seventh (which is enharmonically equivalent to a sixth, and
-from which comes tons of confusion). It is usually notated as (again, using
-C as the root) Cdim7 or Co7.
. * Mondrup:
- I would like the possibility of forcing clef- and key- changes to be
accompaniment =\chords \sequential {
r8
- c2-min f-min 7
+ c2:min f:min 7
}
\score {
+%% Chord gurus, is this ok now??
+
monstrous= \chords{
\property Score.chordInversion = "1"
- % /c is missing:
- bes-6/c
+ % /c is/was missing:
+ bes:6/+c
- % Cdim7 ??
- cis-3-.5-.6
+ % Cdim7
+ c:dim7
}
\score{
\score{
\context ChordNames \chords{
- \property Score.chordInversion = 1
\property Score.barAtLineStart = 1
\repeat semi 2 {
- f1-maj f-maj f-7 bes-7
- c-maj c-maj es es
- d-7 g-7 b2-7/fis e-7 a1-7\break
- d-7 d-7 d-7 g2-7 ges-7
-
- f1-maj f1-maj f-7 bes-7
- c-maj c-maj es es
- d-7 g-7 b2-7/fis e-7 a1-7\break
- d-7 d2-7 g-7 c1-6 g2-7 c-7
+ f1:maj f:maj f:7 bes:7
+ c:maj c:maj es es
+ d:7 g:7 b2:7/fis e:7 a1:7\break
+ d:7 d:7 d:7 g2:7 ges:7
+
+ f1:maj f1:maj f:7 bes:7
+ c:maj c:maj es es
+ d:7 g:7 b2:7/fis e:7 a1:7\break
+ d:7 d2:7 g:7 c1:6 g2:7 c:7
}
}
\paper{
}
inversions = \notes\transpose c''\chords{
- % inversions ignored here
- c1 c-sus c-6 c/e c/g c/d
- % now try to find chords with inversions
- \property Score.chordInversion = 1
- c1 c-sus c-6
- c/e
- c/g
+ % inversions
+ c1 c:sus c:6 c/e c/g
c/d % this triggers a warning: no 'd' in chord of c
+
+ % added bass
+ c/+e c/+c c/+b
}
\score{
}
tab = \notes\transpose c'''\chords{
- c1 c-m c-4 c-m4 c-5+ c-5- c-m5- c-5-.5+ c-6\break %c-m6\break
+ c1 c:m c:4 c:m4 c:5+ c:5- c:dim c:5-.5+ c:6\break %c:m6\break
}
\score{
C# cis
Cb ces
- Cm; Cmin c-3-; c-m; c-min
- Caug c-5+; c-aug;
- Cdim c-5-; c-dim
- Cmaj7 c-7+; c-maj
- C7 c-7
- Csus; Csus4 c-4; c-sus
+ Cm; Cmin c:3-; c:m; c:min
+ Caug c:5+; c:aug;
+ Cdim c:3-:5-; c:dim
+ Cmaj7 c:7+; c:maj
+ C7 c:7
+ Csus; Csus4 c:4; c:sus
%}
scales = \notes \transpose c'' \chords{
%<c1 e g>
- c1-m c-min c4-dim c-aug c-sus c-maj
- c1-6 c4-7 c-9 c-11 c-13
- c-m7 c-m.sus c-m7.sus
- c1-7^5 c-13^5.7.9.11
- % c1-7^5 c-13^5
+ c1:m c:min c4:dim c:aug c:sus c:maj
+ c1:6 c4:7 c:9 c:11 c:13
+ c:m7 c:m.sus c:m7.sus
+ c4:dim7 c:dim9 c2:7^5
+ c:13^5.7.9.11
+ % c1:7^5 c:13^5
c1 g d a e b fis
c1 f bes es as des ges
- % wierd, multiple -add, ^sub
- c-7+.9-^3.5
+ % wierd, multiple :add, ^sub
+ c:7+.9-^3.5
% long
c\breve c\longa
}
gmsus=\notes\relative c \chords{
g1
% Gm7sus4: the hard way
- g1-3-.4.7
+ g1:3-.4.7
% another hard way:
\notes< g'1 bes c d f >
% bit easier:
- g1-m.4.7
+ g1:m.4.7
- g1-m7.sus
- g1-m7.sus4
+ g1:m7.sus
+ g1:m7.sus4
% and finally:
- \property Score.chordInversion = 1
- g1-m7.sus/d
+ g1:m7.sus/d
}
\score{
% 1.1.53: @x@ syntax dropped
% if you want fingering, write chord explicitily; eg < c1-1 e-2 g-3 >
% @c1@ @c-7@ @c-7^5@-1-3
- \chords { c1 c-7 c-7^5 }
+ \chords { c1 c:7 c:7^5 }
}
}
accompaniment =\chords {
r8
- c2-3- f-3-.7 d-min es4 c8-min r8
- c2-min f-min7 g-7^3.5 c-min }
+ c2:3- f:3-.7 d:min es4 c8:min r8
+ c2:min f:min7 g:7^3.5 c:min }
\score {
\simultaneous {
acc = \chords {
% why don't \skip, s4 work?
c2 c f c
- f c g-7 c
- g f c g-7 % urg, bug!
- g f c g-7
+ f c g:7 c
+ g f c g:7 % urg, bug!
+ g f c g:7
% copy 1-8
c2 c f c
- f c g-7 c
+ f c g:7 c
}
text = \lyrics{
SCM prop = get_property (type_ + "Direction", 0);
if (isdir_b (prop))
{
- staff_side_p_->dir_ = to_dir (prop);
+ staff_side_p_->set_direction ( to_dir (prop));
}
else
{
- staff_side_p_->dir_ = UP;
+ staff_side_p_->set_direction ( UP);
}
staff_side_p_->set_victim(text_p_);
{
int y = (int)(stems_[i]->chord_start_f () / internote_f)
+ (int)sinfo_[i].interstaff_f_;
- stems_[i]->dir_ = y < knee_y ? UP : DOWN;
+ stems_[i]->set_direction ( y < knee_y ? UP : DOWN);
stems_[i]->set_elt_property ("dir-forced", SCM_BOOL_T);
}
}
urg: it seems that info on whether beam (voice) dir was forced
is being junked here?
*/
- if (!dir_)
- dir_ = get_default_dir ();
+ if (!get_direction ())
+ set_direction ( get_default_dir ());
- set_direction (dir_);
+ set_direction (get_direction ());
}
void
if auto-knee did its work, most probably stem directions
have changed, so we must recalculate all.
*/
- dir_ = get_default_dir ();
- set_direction (dir_);
+ set_direction ( get_default_dir ());
+ set_direction (get_direction ());
/* auto-knees used to only work for slope = 0
anyway, should be able to set slope per beam
for (int i=0; i <stems_.size (); i++)
do {
Stem *s = stems_[i];
- int current = s->dir_
- ? (1 + d * s->dir_)/2
+ int current = s->get_direction ()
+ ? (1 + d * s->get_direction ())/2
: s->get_center_distance ((Direction)-d);
if (current)
void
Beam::set_direction (Direction d)
{
- dir_ = d;
+ set_direction ( d);
for (int i=0; i <stems_.size (); i++)
{
Stem *s = stems_[i];
SCM force = s->remove_elt_property ("dir-forced");
if (force == SCM_UNDEFINED)
- s->dir_ = d;
+ s->set_direction ( d);
}
}
Real y = sinfo_[i].x_ * slope_f_ + left_y_;
// correct for knee
- if (dir_ != sinfo_[i].dir_)
+ if (get_direction () != sinfo_[i].get_direction ())
{
Real internote_f = sinfo_[i].stem_l_->staff_line_leading_f ()/2;
- y -= dir_ * (beam_f / 2
+ y -= get_direction () * (beam_f / 2
+ (sinfo_[i].mult_i_ - 1) * interbeam_f) / internote_f;
if (!i && sinfo_[i].stem_l_->staff_symbol_l () !=
sinfo_.top ().stem_l_->staff_symbol_l ())
- y += dir_ * (multiple_i_ - (sinfo_[i].stem_l_->flag_i_ - 2) >? 0)
+ y += get_direction () * (multiple_i_ - (sinfo_[i].stem_l_->flag_i_ - 2) >? 0)
* interbeam_f / internote_f;
}
if (set_b)
sinfo_[i].stem_l_->set_stemend (y - sinfo_[i].interstaff_f_);
- y *= dir_;
+ y *= get_direction ();
if (y > sinfo_[i].maxy_f_)
dy_f = dy_f <? sinfo_[i].maxy_f_ - y;
if (y < sinfo_[i].miny_f_)
s->set_default_extents ();
if (s->invisible_b ())
continue;
- if (((int)s->chord_start_f ()) && (s->dir_ != s->get_default_dir ()))
+ if (((int)s->chord_start_f ()) && (s->get_direction () != s->get_default_dir ()))
forced_count_i++;
total_count_i++;
}
if (leftx == 0)
leftx = info.x_;
info.x_ -= leftx;
- if (info.dir_ == dir_)
+ if (info.get_direction () == get_direction ())
{
if (forced_count_i == total_count_i)
info.idealy_f_ -= shorten_f;
{
slope_f_ = 0;
left_y_ = sinfo_[0].idealy_f_;
- left_y_ *= dir_;
+ left_y_ *= get_direction ();
}
else
{
Real damped_slope_dy_f = (solved_slope_f - slope_f_) * dx_f / 2;
left_y_ += damped_slope_dy_f;
- left_y_ *= dir_;
- slope_f_ *= dir_;
+ left_y_ *= get_direction ();
+ slope_f_ *= get_direction ();
}
}
// isn't this asymmetric ? --hwn
// dim(left_y_) = internote
- Real dy_f = dir_ * left_y_ * internote_f;
+ Real dy_f = get_direction () * left_y_ * internote_f;
Real beamdx_f = stems_.top ()->hpos_f () - stems_[0]->hpos_f ();
Real beamdy_f = beamdx_f * slope_f_ * internote_f;
quanty_f = iv[BIGGER];
// dim(left_y_) = internote
- left_y_ = dir_ * quanty_f / internote_f;
+ left_y_ = get_direction () * quanty_f / internote_f;
}
void
Real dy_f = check_stemlengths_f (false);
for (int i = 0; i < 2; i++) // 2 ?
{
- left_y_ += dy_f * dir_;
+ left_y_ += dy_f * get_direction ();
quantise_left_y (dy_f);
dy_f = check_stemlengths_f (true);
if (abs (dy_f) <= epsilon_f)
for (int j = 0; j < lhalfs; j++)
{
Molecule b (a);
- b.translate_axis (-dir_ * dy * (lwholebeams+j), Y_AXIS);
+ b.translate_axis (-get_direction () * dy * (lwholebeams+j), Y_AXIS);
leftbeams.add_molecule (b);
}
}
for (; j < nogap; j++)
{
Molecule b (a);
- b.translate_axis (-dir_ * dy * j, Y_AXIS);
+ b.translate_axis (-get_direction () * dy * j, Y_AXIS);
rightbeams.add_molecule (b);
}
// TODO: notehead widths differ for different types
{
Molecule b (a);
if (!here->invisible_b ())
- b.translate (Offset (gap_f, -dir_ * dy * j));
+ b.translate (Offset (gap_f, -get_direction () * dy * j));
else
- b.translate (Offset (0, -dir_ * dy * j));
+ b.translate (Offset (0, -get_direction () * dy * j));
rightbeams.add_molecule (b);
}
for (; j < rwholebeams + rhalfs; j++)
{
Molecule b (a);
- b.translate_axis (-dir_ * dy * j, Y_AXIS);
+ b.translate_axis (-get_direction () * dy * j, Y_AXIS);
rightbeams.add_molecule (b);
}
Real end_dy = 0 >? end_h - clip_h;
Real pi = M_PI;
- Real begin_alpha = (control_[1] - control_[0]).arg () + dir_ * alpha_;
- Real end_alpha = pi - (control_[2] - control_[3]).arg () - dir_ * alpha_;
+ Real begin_alpha = (control_[1] - control_[0]).arg () + get_direction () * alpha_;
+ Real end_alpha = pi - (control_[2] - control_[3]).arg () - get_direction () * alpha_;
Real max_alpha = clip_angle / 90 * pi / 2;
if ((begin_dy < 0) && (end_dy < 0)
{
Real dy = (begin_dy + end_dy) / 4;
dy *= cos (alpha_);
- encompass_[0][Y_AXIS] += dir_ * dy;
- encompass_[encompass_.size () - 1][Y_AXIS] += dir_ * dy;
+ encompass_[0][Y_AXIS] += get_direction () * dy;
+ encompass_[encompass_.size () - 1][Y_AXIS] += get_direction () * dy;
}
else
{
if (end_alpha >= max_alpha)
end_dy = 0 >? c * end_alpha / max_alpha * end_h;
- encompass_[0][Y_AXIS] += dir_ * begin_dy;
- encompass_[encompass_.size () - 1][Y_AXIS] += dir_ * end_dy;
+ encompass_[0][Y_AXIS] += get_direction () * begin_dy;
+ encompass_[encompass_.size () - 1][Y_AXIS] += get_direction () * end_dy;
Offset delta = encompass_[encompass_.size () - 1] - encompass_[0];
alpha_ = delta.arg ();
end_p = ijk_p;
end_rc = default_rc;
}
- BEZIER_BOW_DEBUG_OUT << "begin " << begin_p[X_AXIS] << ", " << begin_p[Y_AXIS] << endl;
- BEZIER_BOW_DEBUG_OUT << "end " << end_p[X_AXIS] << ", " << end_p[Y_AXIS] << endl;
Real height =control_[1][Y_AXIS];
for (int i = 0; i < encompass_.size (); i++ )
Real c3 = begin_p[Y_AXIS] > end_p[Y_AXIS] ? begin_p[Y_AXIS]
- rc3 * begin_p[X_AXIS] : end_p[Y_AXIS] - rc3 * end_p[X_AXIS];
- BEZIER_BOW_DEBUG_OUT << "y1 = " << rc1 << " x + 0" << endl;
- BEZIER_BOW_DEBUG_OUT << "y2 = " << rc2 << " x + " << c2 << endl;
- BEZIER_BOW_DEBUG_OUT << "y3 = " << rc3 << " x + " << c3 << endl;
control_[1][X_AXIS] = c3 / (rc1 - rc3);
control_[1][Y_AXIS] = rc1 * control_[1][X_AXIS];
control_[2][X_AXIS] = (c3 - c2) / (rc2 - rc3);
- BEZIER_BOW_DEBUG_OUT << "c2[X_AXIS] = " << control_[2][X_AXIS] << endl;
- BEZIER_BOW_DEBUG_OUT << "(c3 - c2) = " << (c3 - c2) << endl;
- BEZIER_BOW_DEBUG_OUT << "(rc2 - rc3) = " << (rc2 - rc3) << endl;
control_[2][Y_AXIS] = rc2 * control_[2][X_AXIS] + c2;
- BEZIER_BOW_DEBUG_OUT << "c2[Y_AXIS]" << control_[2][Y_AXIS] << endl;
calc_return (begin_alpha, end_alpha);
}
}
void
-Bezier_bow::set (Array<Offset> points, int dir)
+Bezier_bow::set (Array<Offset> points, Direction dir)
{
- dir_ = dir;
+ set_direction (dir);
encompass_ = points;
}
encompass_.rotate (-alpha_);
- if (dir_ == DOWN)
+ if (get_direction () == DOWN)
encompass_.flipy ();
}
void
Bezier_bow::transform_back ()
{
- if (dir_ == DOWN)
+ if (get_direction () == DOWN)
{
control_.flipy ();
return_.flipy ();
Bow::curve_extent_drul () const
{
Bezier_bow b (paper_l ());
- b.set (get_encompass_offset_arr (), dir_);
+ b.set (get_encompass_offset_arr (), get_direction ());
b.calc ();
return b.curve_extent_drul_;
}
Bow::get_controls () const
{
Bezier_bow b (paper_l ());
- b.set (get_encompass_offset_arr (), dir_);
+ b.set (get_encompass_offset_arr (), get_direction ());
b.calc ();
Array<Offset> controls;
controls.set_size (8);
Breathing_sign::Breathing_sign ()
{
- dir_ = UP;
+ set_direction (UP);
set_elt_property ("breakable", SCM_BOOL_T);
set_elt_property ("visibility-lambda",
ly_ch_C_eval_scm ("non_postbreak_visibility"));
assert(updown >= -1 && updown <= +1);
if(updown != 0)
- dir_ = updown;
+ set_direction (updown);
}
Molecule*
{
Real dl = staff_line_leading_f();
- translate_axis(2.0 * dl * dir_, Y_AXIS);
+ translate_axis(2.0 * dl * get_direction (), Y_AXIS);
}
Chord_name_engraver::Chord_name_engraver ()
{
tonic_req_ = 0;
- // bass_req_ = 0;
+ inversion_req_ = 0;
+ bass_req_ = 0;
}
void
tonic_req_ = t;
return true;
}
-#if 0
+ if (Inversion_req* i = dynamic_cast<Inversion_req*> (m))
+ {
+ inversion_req_ = i;
+ return true;
+ }
if (Bass_req* b = dynamic_cast<Bass_req*> (m))
{
bass_req_ = b;
return true;
}
-#endif
-
return false;
}
if (!pitch_arr_.size ())
return;
- Chord chord (pitch_arr_);
- Musical_pitch* inversion = 0;
+ bool find_inversion_b = false;
SCM chord_inversion = get_property ("chordInversion", 0);
- if (gh_boolean_p (chord_inversion) && gh_scm2bool (chord_inversion))
- {
- int tonic_i = tonic_req_
- ? chord.find_notename_i (tonic_req_->pitch_) : chord.find_tonic_i ();
-
- if (tonic_i)
- {
- inversion = &pitch_arr_[0];
- chord.rebuild_insert_inversion (tonic_i);
- }
- }
+ if (gh_boolean_p (chord_inversion))
+ find_inversion_b = gh_scm2bool (chord_inversion);
+
+ Chord chord = to_chord (pitch_arr_, tonic_req_, inversion_req_, bass_req_,
+ find_inversion_b);
Text_item* item_p = new Text_item;
item_p->text_str_ = chord.banter_str (inversion);
*/
- item_p->text_str_ = chord.banter_str (inversion);
+ item_p->text_str_ = chord.banter_str ();
text_p_arr_.push (item_p);
announce_element (Score_element_info (item_p, 0));
text_p_arr_.clear ();
pitch_arr_.clear ();
tonic_req_ = 0;
+ inversion_req_ = 0;
+ bass_req_ = 0;
}
+
(c) 1999 Jan Nieuwenhuizen <janneke@gnu.org>
*/
+#include "chord.hh"
+#include "musical-request.hh"
+#include "warn.hh"
+
+
/*
- FIXME:
+ construct from parser output
+*/
+Chord
+to_chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p, Musical_pitch* bass_p)
+{
+ // urg: catch dim modifier: 5th and 7th should be lowered
+ bool dim_b = false;
+ for (int i=0; i < add_arr_p->size (); i++)
+ {
+ Musical_pitch* p = &(*add_arr_p)[i];
+ if (p->octave_i_ == -100)
+ {
+ p->octave_i_ = 0;
+ dim_b = true;
+ }
+ }
+ Chord::rebuild_transpose (add_arr_p, tonic);
+ Chord::rebuild_transpose (sub_arr_p, tonic);
+
+ Musical_pitch fifth = tonic;
+ fifth.transpose (Musical_pitch (2));
+ fifth.transpose (Musical_pitch (2, -1));
+
+ /*
+ remove double adds (urg: sus4)
+ */
+ for (int i = add_arr_p->size () - 1; i >= 0 ; i--)
+ {
+ int j = Chord::find_pitch_i (add_arr_p, (*add_arr_p)[i]);
+ if ((j != -1) && (i != j))
+ {
+ add_arr_p->get (i);
+ }
+ }
+
+ /*
+ default chord includes upto 5: <1, 3, 5>
+ */
+ add_arr_p->insert (tonic, 0);
+ Array<Musical_pitch> tmp = *add_arr_p;
+ int highest_step = Chord::step_i (tonic, tmp.top ());
+ if (highest_step < 5)
+ tmp.push (fifth);
+ else if (dim_b)
+ {
+ Musical_pitch* p = &add_arr_p->top ();
+ p->accidental_i_--;
+ }
+
+ /*
+ find missing thirds
+ */
+ Array<Musical_pitch> missing_arr = Chord::missing_thirds_pitch_arr (&tmp);
+ if (highest_step < 5)
+ missing_arr.push (fifth);
+
+ if (dim_b)
+ {
+ for (int i=0; i < missing_arr.size (); i++)
+ {
+ missing_arr[i].accidental_i_--;
+ }
+ }
+
+ /*
+ if additions include some 3, don't add third
+ */
+ Musical_pitch third = tonic;
+ third.transpose (Musical_pitch (2));
+ if (Chord::find_notename_i (add_arr_p, third) != -1)
+ {
+ int i = Chord::find_pitch_i (&missing_arr, third);
+ if (i != -1)
+ missing_arr.get (i);
+ }
+
+ /*
+ if additions include 4, assume sus4 and don't add third implicitely
+ C-sus (4) = c f g (1 4 5)
+ */
+ Musical_pitch sus = tonic;
+ sus.transpose (Musical_pitch (3));
+ if (Chord::find_pitch_i (add_arr_p, sus) != -1)
+ {
+ int i = Chord::find_pitch_i (&missing_arr, third);
+ if (i != -1)
+ missing_arr.get (i);
+ }
- A triad is a chord of three tones, and not an interval of a third.
+ /*
+ if additions include some 5, don't add fifth
+ */
+ if (Chord::find_notename_i (add_arr_p, fifth) != -1)
+ {
+ int i = Chord::find_pitch_i (&missing_arr, fifth);
+ if (i != -1)
+ missing_arr.get (i);
+ }
+
+
+ /*
+ complete the list of thirds to be added
+ */
+ add_arr_p->concat (missing_arr);
+ add_arr_p->sort (Musical_pitch::compare);
+
+ Array<Musical_pitch> pitch_arr;
+ /*
+ add all that aren't subtracted
+ */
+ for (int i = 0; i < add_arr_p->size (); i++)
+ {
+ Musical_pitch p = (*add_arr_p)[i];
+ int j = 0;
+ for (; j < sub_arr_p->size (); j++)
+ if (p == (*sub_arr_p)[j])
+ {
+ sub_arr_p->del (j);
+ j = -1;
+ break;
+ }
+ if (j == sub_arr_p->size ())
+ pitch_arr.push (p);
+ }
+
+ pitch_arr.sort (Musical_pitch::compare);
+
+ for (int i = 0; i < sub_arr_p->size (); i++)
+ warning (_f ("invalid subtraction: not part of chord: %s",
+ (*sub_arr_p)[i].str ()));
+
+ return Chord (pitch_arr, inversion_p, bass_p);
+}
+
+/*
+ Construct from list of pitches and requests
*/
+Chord
+to_chord (Array<Musical_pitch> pitch_arr, Tonic_req* tonic_req, Inversion_req* inversion_req, Bass_req* bass_req, bool find_inversion_b)
+{
+ Musical_pitch* inversion_p = 0;
+ Musical_pitch* bass_p = 0;
-#include "chord.hh"
-#include "warn.hh"
+ if (bass_req)
+ {
+ assert (pitch_arr[0].notename_i_ == bass_req->pitch_.notename_i_);
+ bass_p = new Musical_pitch (pitch_arr.get (0));
+ }
+
+ if (inversion_req)
+ {
+ assert (pitch_arr[0].notename_i_ == inversion_req->pitch_.notename_i_);
+ inversion_p = new Musical_pitch (inversion_req->pitch_);
+ assert (tonic_req);
+ int tonic_i = Chord::find_notename_i (&pitch_arr, tonic_req->pitch_);
+ if (tonic_i)
+ Chord::rebuild_insert_inversion (&pitch_arr, tonic_i);
+ }
+
+ if (find_inversion_b && !inversion_p)
+ {
+ int tonic_i = tonic_req
+ ? Chord::find_notename_i (&pitch_arr, tonic_req->pitch_)
+ : Chord::find_tonic_i (&pitch_arr);
+
+ if (tonic_i)
+ {
+ inversion_p = &pitch_arr[0];
+ Chord::rebuild_insert_inversion (&pitch_arr, tonic_i);
+ }
+ }
+
+ if (tonic_req)
+ {
+ assert (pitch_arr[0].notename_i_ == tonic_req->pitch_.notename_i_);
+ }
-// doesn't seem common, and we should know about this during parsing
-// #define INVERSION_ADDED_AS_BASE 1
+ return Chord (pitch_arr, inversion_p, bass_p);
+}
-Chord::Chord (Array<Musical_pitch> pitch_arr)
+Chord::Chord (Array<Musical_pitch> pitch_arr, Musical_pitch* inversion_p, Musical_pitch* bass_p)
{
pitch_arr_ = pitch_arr;
+ inversion_p_ = inversion_p;
+ bass_p_ = bass_p;
+}
+
+Chord::Chord (Chord const& chord)
+{
+ pitch_arr_ = chord.pitch_arr_;
+ inversion_p_ = chord.inversion_p_ ? new Musical_pitch (*chord.inversion_p_) : 0;
+ bass_p_ = chord.bass_p_ ? new Musical_pitch (*chord.bass_p_) : 0;
+}
+
+Chord::~Chord ()
+{
+ delete inversion_p_;
+ delete bass_p_;
}
-static void
-rebuild_transpose (Musical_pitch tonic, Array<Musical_pitch>* pitch_arr_p)
+void
+Chord::rebuild_transpose (Array<Musical_pitch>* pitch_arr_p, Musical_pitch tonic)
{
for (int i = 0; i < pitch_arr_p->size (); i++)
{
pitch_arr_p->sort (Musical_pitch::compare);
}
-static int
-find_pitch_i (Array<Musical_pitch> const* pitch_arr_p, Musical_pitch p)
+int
+Chord::find_pitch_i (Array<Musical_pitch> const* pitch_arr_p, Musical_pitch p)
{
for (int i = 0; i < pitch_arr_p->size (); i++)
if (p == (*pitch_arr_p)[i])
return -1;
}
-static int
-find_notename_i (Array<Musical_pitch> const* pitch_arr_p, Musical_pitch p)
+int
+Chord::find_notename_i (Array<Musical_pitch> const* pitch_arr_p, Musical_pitch p)
{
int i = find_pitch_i (pitch_arr_p, p);
if (i == -1)
return i;
}
-/*
- trap (NL) != trap(english)
- */
-static int
-trap_i (Musical_pitch tonic, Musical_pitch p)
+int
+Chord::step_i (Musical_pitch tonic, Musical_pitch p)
{
int i = p.notename_i_ - tonic.notename_i_
+ (p.octave_i_ - tonic.octave_i_) * 7;
return i;
}
-static Array<Musical_pitch>
-missing_triads_pitch_arr (Array<Musical_pitch>const* pitch_arr_p)
+Array<Musical_pitch>
+Chord::missing_thirds_pitch_arr (Array<Musical_pitch> const* pitch_arr_p)
{
- Array<Musical_pitch> triads;
+ Array<Musical_pitch> thirds;
/* is the third c-e, d-f, etc. small or large? */
int minormajor_a[] = {0, -1, -1, 0,0,-1,-1};
for (int i=0; i < 7; i++)
- triads.push (Musical_pitch( 2, minormajor_a[i]));
+ thirds.push (Musical_pitch( 2, minormajor_a[i]));
Musical_pitch tonic = (*pitch_arr_p)[0];
Musical_pitch last = tonic;
for (int i = 0; i < pitch_arr_p->size ();)
{
Musical_pitch p = (*pitch_arr_p)[i];
- int trap = trap_i (tonic, p);
+ int step = step_i (tonic, p);
if (last.notename_i_ == p.notename_i_)
- last.transpose (triads[(last.notename_i_ - tonic.notename_i_ + 7) % 7]);
- if (trap > trap_i (tonic, last))
+ last.transpose (thirds[(last.notename_i_ - tonic.notename_i_ + 7) % 7]);
+ if (step > step_i (tonic, last))
{
- while (trap > trap_i (tonic, last))
+ while (step > step_i (tonic, last))
{
if ((last.notename_i_ - tonic.notename_i_ + 7) % 7 == 6)
{
{
missing_arr.push (last);
}
- last.transpose (triads[(last.notename_i_ - tonic.notename_i_ + 7) % 7]);
+ last.transpose (thirds[(last.notename_i_ - tonic.notename_i_ + 7) % 7]);
}
}
else
/*
- construct from parser output
-*/
-Chord::Chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p)
+ Mangle into list of pitches.
+ For normal chord entry, inversion and bass pitches are retained in
+ specific *_requests
+ */
+Array<Musical_pitch>
+Chord::to_pitch_arr () const
{
- rebuild_transpose (tonic, add_arr_p);
- rebuild_transpose (tonic, sub_arr_p);
-
- Musical_pitch fifth = tonic;
- fifth.transpose (Musical_pitch (2));
- fifth.transpose (Musical_pitch (2, -1));
-
- /*
- remove double adds (urg: sus4)
- */
- for (int i = add_arr_p->size () - 1; i >= 0 ; i--)
- {
- int j = ::find_pitch_i (add_arr_p, (*add_arr_p)[i]);
- if ((j != -1) && (i != j))
- {
- add_arr_p->get (i);
- }
- }
-
- /*
- default chord includes upto 5: <1, 3, 5>
- */
- add_arr_p->insert (tonic, 0);
- Array<Musical_pitch> tmp = *add_arr_p;
- int highest_trap = trap_i (tonic, tmp.top ());
- if (highest_trap < 5)
- tmp.push (fifth);
-
- /*
- find missing triads
- */
- Array<Musical_pitch> missing_arr = missing_triads_pitch_arr (&tmp);
- if (highest_trap < 5)
- missing_arr.push (fifth);
-
- /*
- if additions include some 3, don't add third
- */
- Musical_pitch third = tonic;
- third.transpose (Musical_pitch (2));
- if (::find_notename_i (add_arr_p, third) != -1)
- {
- int i = ::find_pitch_i (&missing_arr, third);
- if (i != -1)
- missing_arr.get (i);
- }
-
- /*
- if additions include 4, assume sus4 and don't add third implicitely
- C-sus (4) = c f g (1 4 5)
- */
- Musical_pitch sus = tonic;
- sus.transpose (Musical_pitch (3));
- if (::find_pitch_i (add_arr_p, sus) != -1)
- {
- int i = ::find_pitch_i (&missing_arr, third);
- if (i != -1)
- missing_arr.get (i);
- }
-
- /*
- if additions include some 5, don't add fifth
- */
- if (::find_notename_i (add_arr_p, fifth) != -1)
- {
- int i = ::find_pitch_i (&missing_arr, fifth);
- if (i != -1)
- missing_arr.get (i);
- }
-
-
- /*
- complete the list of triads to be added
- */
- add_arr_p->concat (missing_arr);
- add_arr_p->sort (Musical_pitch::compare);
-
- /*
- add all that aren't subtracted
- */
- for (int i = 0; i < add_arr_p->size (); i++)
- {
- Musical_pitch p = (*add_arr_p)[i];
- int j = 0;
- for (; j < sub_arr_p->size (); j++)
- if (p == (*sub_arr_p)[j])
- {
- sub_arr_p->del (j);
- j = -1;
- break;
- }
- if (j == sub_arr_p->size ())
- pitch_arr_.push (p);
- }
-
- pitch_arr_.sort (Musical_pitch::compare);
-
- for (int i = 0; i < sub_arr_p->size (); i++)
- warning (_f ("invalid subtraction: not part of chord: %s",
- (*sub_arr_p)[i].str ()));
-
- if (inversion_p)
+ Array<Musical_pitch> pitch_arr = pitch_arr_;
+ if (inversion_p_)
{
int i = 0;
- for (; i < pitch_arr_.size (); i++)
+ for (; i < pitch_arr.size (); i++)
{
- if ((pitch_arr_[i].notename_i_ == inversion_p->notename_i_)
- && (pitch_arr_[i].accidental_i_ == inversion_p->accidental_i_))
+ if ((pitch_arr[i].notename_i_ == inversion_p_->notename_i_)
+ && (pitch_arr[i].accidental_i_ == inversion_p_->accidental_i_))
break;
}
- if (i == pitch_arr_.size ())
+ if (i == pitch_arr.size ())
{
warning (_f ("invalid inversion pitch: not part of chord: %s",
- inversion_p->str ()));
+ inversion_p_->str ()));
}
else
- {
-#if INVERSION_ADDED_AS_BASE
- pitch_arr_.insert (pitch_arr_[i], 0);
- rebuild_with_bass (0);
-#else
- rebuild_with_bass (i);
-#endif
-
- }
- delete inversion_p;
+ rebuild_with_bass (&pitch_arr, i);
}
+
+ if (bass_p_)
+ {
+ pitch_arr.insert (*bass_p_, 0);
+ rebuild_with_bass (&pitch_arr, 0);
+ }
+ return pitch_arr;
}
void
-Chord::find_additions_and_subtractions(Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p) const
+Chord::find_additions_and_subtractions (Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p) const
{
Musical_pitch tonic = pitch_arr_[0];
/*
- construct an array of triads for a normal chord
+ construct an array of thirds for a normal chord
*/
Array<Musical_pitch> all_arr;
all_arr.push (tonic);
all_arr.push (pitch_arr_.top ());
- all_arr.concat (missing_triads_pitch_arr (&all_arr));
+ all_arr.concat (missing_thirds_pitch_arr (&all_arr));
all_arr.sort (Musical_pitch::compare);
int i = 0;
(j < pitch_arr_.size ()) ? j++ : i++;
}
/*
- a triad is missing: chord subtraction
+ a third is missing: chord subtraction
*/
else
{
add highest addition, because it names chord
(1, 3 and) 5 not an addition: part of normal chord
*/
- if (trap_i (tonic, pitch_arr_.top () > 5))
+ if (step_i (tonic, pitch_arr_.top () > 5))
add_arr_p->push (pitch_arr_.top ());
}
+/*
+ TODO:
+ reduce guess work: dim chord
+ other naming conventions `American'?
+ don't use TeX constructs
+ user defined chords-names for specific chords:
+ tonic, additions, subtractions, inversion, bass -> "my-chord-name"
+ */
String
-Chord::banter_str (Musical_pitch* inversion) const
+Chord::banter_str () const
{
Musical_pitch tonic = pitch_arr_[0];
// 7 always means 7-...
// scale.push (Musical_pitch (6, -1)); // b
- rebuild_transpose (tonic, &scale);
+ rebuild_transpose (&scale, tonic);
bool has3m_b = false;
bool has4_b = false;
+ bool has5m_b = false;
String str;
+ String minor_str;
String sep_str;
for (int i = 0; i < add_arr.size (); i++)
{
Musical_pitch p = add_arr[i];
- int trap = trap_i (tonic, p);
- if (trap == 4)
+ int step = step_i (tonic, p);
+ if (step == 4)
has4_b = true;
- int accidental = p.accidental_i_ - scale[(trap - 1) % 7].accidental_i_;
- if ((trap == 3) && (accidental == -1))
+ int accidental = p.accidental_i_ - scale[(step - 1) % 7].accidental_i_;
+ if ((step == 3) && (accidental == -1))
{
- tonic_str += "m";
+ minor_str = "m";
has3m_b = true;
}
+ /*
+ have Cdim rather than Cm5-, even if it's a prefix
+ */
+ else if ((step == 5) && (accidental == -1) && has3m_b)
+ {
+ minor_str = "dim";
+ has5m_b = true;
+ }
else if (accidental
- || (!(trap % 2) || ((i + 1 == add_arr.size ()) && (trap > 5))))
+ || (!(step % 2) || ((i + 1 == add_arr.size ()) && (step > 5))))
{
str += sep_str;
- if ((trap == 7) && (accidental == 1))
- str += "maj7";
- else
+ sep_str = "/";
+ if ((step == 7) && (accidental == 1))
+ {
+ str += "maj7";
+ }
+ else
{
- str += to_str (trap);
- if (accidental)
- str += accidental < 0 ? "-" : "+";
+ /*
+ if has3m_b and has5m_b, assume dim
+ don't mention dim-addition, except for chord-namer
+ */
+ if (((step/2) && (accidental == -1))
+ && has3m_b && has5m_b)
+ {
+ if (i == add_arr.size () - 1)
+ str += to_str (step);
+ else
+ sep_str = "";
+ }
+ else
+ {
+ str += to_str (step);
+ if (accidental)
+ str += accidental < 0 ? "-" : "+";
+ }
}
- sep_str = "/";
}
}
for (int i = 0; i < sub_arr.size (); i++)
{
Musical_pitch p = sub_arr[i];
- int trap = trap_i (tonic, p);
+ int step = step_i (tonic, p);
/*
if chord has 3-, assume minor and don't display 'no3'
if additions include 4, assume sus4 and don't display 'no3'
+ if has3m_b and has5m_b, assume 'dim' chord
*/
- if (!((trap == 3) && (has3m_b || has4_b)))
+ if (!((step == 3) && (has3m_b || has4_b))
+ && !((step/2) && (step !=3) && (step !=7 ) && (p.accidental_i_ == 0) && has3m_b && has5m_b)
+ && !((step == 7) && (p.accidental_i_ == -1) && has3m_b && has5m_b))
{
- str += sep_str + "no" + to_str (trap);
+ str += sep_str + "no" + to_str (step);
sep_str = "/";
}
}
+ /*
+ have Co rather than Cdim7
+ */
+ if (minor_str + str == "dim7")
+ {
+ minor_str = "";
+ str = "o";
+ }
+
+
String inversion_str;
- if (inversion)
+ if (inversion_p_)
{
- inversion_str = inversion->str ();
+ inversion_str = inversion_p_->str ();
inversion_str = "/" + inversion_str.left_str (1).upper_str ()
- + acc[inversion->accidental_i_ + 2];
-
+ + acc[inversion_p_->accidental_i_ + 2];
}
- return tonic_str + "$^{" + str + "}$" + inversion_str;
-}
+ String bass_str;
+ if (bass_p_)
+ {
+ bass_str = bass_p_->str ();
+ bass_str = "/" + bass_str.left_str (1).upper_str ()
+ + acc[bass_p_->accidental_i_ + 2];
-int
-Chord::find_notename_i (Musical_pitch p) const
-{
- return ::find_notename_i (&pitch_arr_, p);
-}
+ }
-int
-Chord::find_pitch_i (Musical_pitch p) const
-{
- return ::find_pitch_i (&pitch_arr_, p);
+ return tonic_str + minor_str + "$^{" + str + "}$" + inversion_str + bass_str;
}
int
-Chord::find_tonic_i () const
+Chord::find_tonic_i (Array<Musical_pitch> const* pitch_arr_p)
{
/*
find tonic
- first try: base of longest line of triads
+ first try: base of longest line of thirds
*/
int tonic_i = 0;
int longest_i = 0;
- for (int i = 0; i < pitch_arr_.size (); i++)
+ for (int i = 0; i < pitch_arr_p->size (); i++)
{
- int no_triad_i = 0;
- int last_i = pitch_arr_[i % pitch_arr_.size ()].notename_i_;
+ int no_third_i = 0;
+ int last_i = (*pitch_arr_p)[i % pitch_arr_p->size ()].notename_i_;
int j = 0;
- for (; j < pitch_arr_.size (); j++)
+ for (; j < pitch_arr_p->size (); j++)
{
- int cur_i = pitch_arr_[(i + j + 1) % pitch_arr_.size ()].notename_i_;
+ int cur_i = (*pitch_arr_p)[(i + j + 1) % pitch_arr_p->size ()].notename_i_;
int gap = cur_i - last_i;
while (gap < 0)
gap += 7;
if (gap == 2)
last_i = cur_i;
else
- no_triad_i++;
+ no_third_i++;
}
- if (j - no_triad_i > longest_i)
+ if (j - no_third_i > longest_i)
{
- longest_i = j - no_triad_i;
+ longest_i = j - no_third_i;
tonic_i = i;
}
}
int biggest_i = 0;
// if (longest_i)
if (longest_i <= 1)
- for (int i = 0; i < pitch_arr_.size (); i++)
+ for (int i = 0; i < pitch_arr_p->size (); i++)
{
- int gap = pitch_arr_[i].notename_i_
- - pitch_arr_[(i - 1 + pitch_arr_.size ())
- % pitch_arr_.size ()].notename_i_;
+ int gap = (*pitch_arr_p)[i].notename_i_
+ - (*pitch_arr_p)[(i - 1 + pitch_arr_p->size ())
+ % pitch_arr_p->size ()].notename_i_;
while (gap < 0)
gap += 7;
gap %= 7;
}
void
-Chord::rebuild_from_base (int base_i)
+Chord::rebuild_from_base (Array<Musical_pitch>* pitch_arr_p, int base_i)
{
assert (base_i >= 0);
Musical_pitch last (0, 0, -5);
Array<Musical_pitch> new_arr;
- for (int i = 0; i < pitch_arr_.size (); i++)
+ for (int i = 0; i < pitch_arr_p->size (); i++)
{
- Musical_pitch p = pitch_arr_[(base_i + i) % pitch_arr_.size ()];
+ Musical_pitch p = (*pitch_arr_p)[(base_i + i) % pitch_arr_p->size ()];
if (p < last)
{
p.octave_i_ = last.octave_i_;
new_arr.push (p);
last = p;
}
- pitch_arr_ = new_arr;
+ *pitch_arr_p = new_arr;
}
void
-Chord::rebuild_insert_inversion (int tonic_i)
+Chord::rebuild_insert_inversion (Array<Musical_pitch>* pitch_arr_p, int tonic_i)
{
assert (tonic_i > 0);
-#if INVERSION_ADDED_AS_BASE
- // inversion was added; don't insert
- Musical_pitch inversion = pitch_arr_.get (0);
- (void)inversion;
-#else
- Musical_pitch inversion = pitch_arr_.get (0);
- rebuild_from_base (tonic_i - 1);
- if (pitch_arr_.size ())
+ Musical_pitch inversion = pitch_arr_p->get (0);
+ rebuild_from_base (pitch_arr_p, tonic_i - 1);
+ if (pitch_arr_p->size ())
{
- inversion.octave_i_ = pitch_arr_[0].octave_i_ - 1;
- while (inversion < pitch_arr_[0])
+ inversion.octave_i_ = (*pitch_arr_p)[0].octave_i_ - 1;
+ while (inversion < (*pitch_arr_p)[0])
inversion.octave_i_++;
}
- for (int i = 0; i < pitch_arr_.size (); i++)
- if (pitch_arr_[i] > inversion)
+ for (int i = 0; i < pitch_arr_p->size (); i++)
+ if ((*pitch_arr_p)[i] > inversion)
{
- pitch_arr_.insert (inversion, i);
+ pitch_arr_p->insert (inversion, i);
break;
}
-#endif
}
void
-Chord::rebuild_with_bass (int bass_i)
+Chord::rebuild_with_bass (Array<Musical_pitch>* pitch_arr_p, int bass_i)
{
assert (bass_i >= 0);
- Musical_pitch inversion = pitch_arr_.get (bass_i);
+ Musical_pitch bass = pitch_arr_p->get (bass_i);
// is lowering fine, or should others be raised?
- if (pitch_arr_.size ())
- while (inversion > pitch_arr_[0])
- inversion.octave_i_--;
- pitch_arr_.insert (inversion, 0);
+ if (pitch_arr_p->size ())
+ while (bass > (*pitch_arr_p)[0])
+ bass.octave_i_--;
+ pitch_arr_p->insert (bass, 0);
}
void
Directional_spanner::do_pre_processing()
{
- if (!dir_)
- dir_ = get_default_dir();
+ if (!get_direction ())
+ set_direction (get_default_dir());
}
Directional_spanner::Directional_spanner()
{
- dir_ = CENTER;
+ set_direction (CENTER);
}
Offset
text_p_ = new Text_item;
text_p_->text_str_ = loud; // ugh
+ text_p_->set_elt_property ("style", gh_str02scm ("dynamic"));
staff_side_p_ = new Staff_side_item;
staff_side_p_->set_elt_property ("script-priority",
staff_side_p_->set_victim (text_p_);
staff_side_p_->axis_ = Y_AXIS;
- staff_side_p_->dir_ = DOWN;
+ staff_side_p_->set_direction (DOWN);
SCM prop = get_property ("verticalDirection", 0);
if (isdir_b (prop))
{
- staff_side_p_->dir_ = to_dir (prop);
+ staff_side_p_->set_direction (to_dir (prop));
}
prop = get_property ("dynamicDirection", 0);
if (gh_number_p(prop))
{
- staff_side_p_->dir_ = to_dir (prop);
+ staff_side_p_->set_direction (to_dir (prop));
}
- if (absd->dir_)
+ if (absd->get_direction ())
{
- staff_side_p_->dir_ = absd->dir_;
+ staff_side_p_->set_direction (absd->get_direction ());
}
prop = get_property ("dynamicPadding", 0);
SCM prop = get_property ("verticalDirection", 0);
if (isdir_b (prop))
{
- to_end_ss_span_p_->dir_ = to_dir (prop);
+ to_end_ss_span_p_->set_direction (to_dir (prop));
}
prop = get_property ("dynamicDirection", 0);
if (isdir_b (prop))
{
- to_end_ss_span_p_->dir_ = to_dir (prop);
+ to_end_ss_span_p_->set_direction (to_dir (prop));
}
prop = get_property ("dynamicPadding", 0);
if (gh_number_p(prop))
bool check_fit_bo ();
Real check_fit_f ();
void print () const;
- void set (Array<Offset> points, int dir);
+ void set (Array<Offset> points, Direction dir);
void transform ();
void transform_back ();
Paper_def* paper_l_;
Curve encompass_;
- int dir_;
+ Direction dir_;
+ void set_direction (Direction d ) { dir_ = d; }
+ Direction get_direction () const { return dir_; }
+
Real alpha_;
Offset origin_;
Curve return_;
Breathing_sign ();
void set_vertical_position (Direction);
+ void set_direction (Direction d ) { dir_ = d; }
+ Direction get_direction () const { return dir_; }
+
protected:
virtual void do_post_processing ();
Link_array<Item> text_p_arr_;
Array<Musical_pitch> rebuild_pitch_arr (int tonic_i) const;
Tonic_req* tonic_req_;
+ Inversion_req* inversion_req_;
+ Bass_req* bass_req_;
};
#endif // CHORD_NAME_ENGRAVER_HH
class Chord
{
public:
- Chord (Array<Musical_pitch> pitch_arr);
- Chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p);
+ static int find_tonic_i (Array<Musical_pitch> const*);
+ static int find_pitch_i (Array<Musical_pitch> const*, Musical_pitch p);
+ static int find_notename_i (Array<Musical_pitch> const*, Musical_pitch p);
+ static Array<Musical_pitch> missing_thirds_pitch_arr (Array<Musical_pitch> const* pitch_arr_p);
+ static void rebuild_from_base (Array<Musical_pitch>*, int base_i);
+ static void rebuild_insert_inversion (Array<Musical_pitch>*, int tonic_i);
+ static void rebuild_transpose (Array<Musical_pitch>*, Musical_pitch tonic);
+ static void rebuild_with_bass (Array<Musical_pitch>*, int bass_i);
+ static int step_i (Musical_pitch tonic, Musical_pitch p);
- void rebuild_from_base (int base_i);
- void rebuild_insert_inversion (int tonic_i);
- void rebuild_with_bass (int bass_i);
+ Chord (Array<Musical_pitch> pitch_arr, Musical_pitch* inversion_p, Musical_pitch* bass_p);
+ Chord (Chord const& chord);
+ ~Chord ();
- String banter_str (Musical_pitch* inversion) const;
- int find_tonic_i () const;
- int find_pitch_i (Musical_pitch p) const;
- int find_notename_i (Musical_pitch p) const;
+
+ Array<Musical_pitch> to_pitch_arr () const;
+
+ String banter_str () const;
void find_additions_and_subtractions(Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p) const;
Array<Musical_pitch> pitch_arr_;
+ Musical_pitch* inversion_p_;
+ Musical_pitch* bass_p_;
};
+Chord to_chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p, Musical_pitch* bass_p);
+
+Chord to_chord (Array<Musical_pitch> pitch_arr, Tonic_req* tonic_req, Inversion_req* inversion_req, Bass_req* bass_req, bool find_inversion_b);
+
#endif // CHORD_HH
JUNKME?
*/
class Directional_spanner : public Spanner{
-public:
-
/// -1 below heads, +1 above heads.
Direction dir_;
+
+public:
Directional_spanner();
-
+
+ void set_direction (Direction d ) { dir_ = d; }
+ Direction get_direction () const { return dir_; }
+
/// offset of "center" relative to left-column/0-pos of staff
virtual Offset center() const;
virtual Direction get_default_dir() const;
struct Bar_engraver;
struct Bar_req;
struct Barcheck_req;
+struct Bass_req;
struct Beam;
struct Beam_engraver;
struct Beaming_info;
struct Idealspacing;
struct Identifier;
struct Input_file;
+struct Inversion_req;
struct Item;
struct Key;
struct Key_change_req;
/// specify tonic of a chord
struct Tonic_req : public Melodic_req
{
- VIRTUAL_COPY_CONS(Music);
+ VIRTUAL_COPY_CONS (Music);
+};
+
+/// specify inversion of a chord
+struct Inversion_req : public Melodic_req
+{
+ VIRTUAL_COPY_CONS (Music);
+};
+
+/// specify bass of a chord
+struct Bass_req : public Melodic_req
+{
+ VIRTUAL_COPY_CONS (Music);
};
/// Put a note of specified type, height, and with accidental on the staff.
String init_str_;
Simultaneous_music * get_note_element (Note_req * ,Duration *);
- Simultaneous_music * get_chord (Musical_pitch, Array<Musical_pitch>*, Array<Musical_pitch>*, Musical_pitch*, Duration);
+ Simultaneous_music * get_chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p, Musical_pitch* bass_p, Duration d);
Simultaneous_music* get_rest_element (String, Duration *);
Simultaneous_music* get_word_element (String, Duration*);
String notename_str (Melodic_req* melodic);
{
public:
Direction dir_;
+ void set_direction (Direction d ) { dir_ = d; }
+ Direction get_direction () const { return dir_; }
+
VIRTUAL_COPY_CONS(Music);
Script_req ();
};
class Staff_side_element : public Staff_symbol_referencer
{
void position_self ();
-
+ Direction dir_;
public:
Score_element * to_position_l_;
- Direction dir_;
+
+ void set_direction (Direction d ) { dir_ = d; }
+ Direction get_direction () const { return dir_; }
+
+
Link_array<Score_element> support_l_arr_;
Axis axis_;
//junkme.
struct Stem_info {
Real x_;
- int dir_;
+ Direction dir_;
+ void set_direction (Direction d ) { dir_ = d; }
+ Direction get_direction () const { return dir_; }
+
int beam_dir_;
Real idealy_f_;
Real miny_f_;
*/
Drul_array<Real> yextent_drul_;
+ /// direction stem (that's me)
+ Direction dir_;
+
public:
+ void set_direction (Direction d);
+ Direction get_direction () const { return dir_; }
+
Link_array<Note_head> head_l_arr_;
Link_array<Rest> rest_l_arr_;
Beam* beam_l_;
Drul_array<int> beams_i_drul_;
-
- void set_direction (Direction d);
- /// direction stem (that's me)
- Direction dir_;
-
-
Stem ();
/// ensure that this Stem also encompasses the Notehead #n#
void do_print() const;
void set_stemend (Real);
Direction get_default_dir() const;
- Direction get_dir () const;
int get_center_distance(Direction) const;
- {
return CHORD_MINUS;
}
+ : {
+ return CHORD_COLON;
+ }
+ \/\+ {
+ return CHORD_BASS;
+ }
\^ {
return CHORD_CARET;
}
Script_req::Script_req ()
{
- dir_ = CENTER;
+ set_direction (CENTER);
}
// junk me
Simultaneous_music *
-My_lily_parser::get_chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p, Duration d)
+My_lily_parser::get_chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p, Musical_pitch* bass_p, Duration d)
{
Simultaneous_music*v = new Request_chord;
v->set_spot (here_input ());
- Chord chord (tonic, add_arr_p, sub_arr_p, inversion_p);
+ Chord chord = to_chord (tonic, add_arr_p, sub_arr_p, inversion_p, bass_p);
Tonic_req* t = new Tonic_req;
t->pitch_ = tonic;
v->add_music (t);
- for (int i = 0; i < chord.pitch_arr_.size (); i++)
+ //urg
+ if (inversion_p
+ && Chord::find_notename_i (&chord.pitch_arr_, *inversion_p) > 0)
{
- Musical_pitch p = chord.pitch_arr_[i];
+ Inversion_req* i = new Inversion_req;
+ i->pitch_ = *inversion_p;
+ v->add_music (i);
+ }
+
+ if (bass_p)
+ {
+ Bass_req* b = new Bass_req;
+ b->pitch_ = *bass_p;
+ v->add_music (b);
+ }
+
+ Array<Musical_pitch> pitch_arr = chord.to_pitch_arr ();
+ for (int i = 0; i < pitch_arr.size (); i++)
+ {
+ Musical_pitch p = pitch_arr[i];
Note_req* n = new Note_req;
n->pitch_ = p;
n->duration_ = d;
Note_column::dir () const
{
if (stem_l_)
- return stem_l_->dir_;
+ return stem_l_->get_direction ();
else if (head_l_arr_.size ())
return (Direction)sign (head_positions_interval().center ());
return;
/* ugh. Should be done by beam. */
- Direction d = stem_l_->get_dir ();
+ Direction d = stem_l_->get_direction ();
Real beamy = (stem_l_->hpos_f () - b->stems_[0]->hpos_f ()) * b->slope_f_ + b->left_y_;
Real staff_space = rest_l_arr_[0]->staff_line_leading_f ();
{
return true;
}
+ else if (Inversion_req* i = dynamic_cast<Inversion_req*> (m))
+ {
+ return true;
+ }
+ else if (Bass_req* b = dynamic_cast<Bass_req*> (m))
+ {
+ return true;
+ }
else if (Busy_playing_req * p = dynamic_cast<Busy_playing_req*> (m))
{
return notes_end_pq_.size ();
%token VERSION
/* escaped */
-%token E_EXCLAMATION E_SMALLER E_BIGGER E_CHAR CHORD_MINUS CHORD_CARET
+%token E_CHAR E_EXCLAMATION E_SMALLER E_BIGGER
+%token CHORD_BASS CHORD_COLON CHORD_MINUS CHORD_CARET
%type <i> exclamations questions
%token <i> DIGIT
%type <pitch_arr> pitch_list
%type <music> chord
%type <pitch_arr> chord_additions chord_subtractions chord_notes chord_step
-%type <pitch> chord_note chord_inversion
+%type <pitch> chord_note chord_inversion chord_bass
%type <midi> midi_block midi_body
%type <duration> duration_length
;
chord:
- steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion {
- $$ = THIS->get_chord (*$1, $3, $4, $5, *$2);
+ steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
+ $$ = THIS->get_chord (*$1, $3, $4, $5, $6, *$2);
};
chord_additions:
{
$$ = new Array<Musical_pitch>;
}
- | CHORD_MINUS chord_notes {
+ | CHORD_COLON chord_notes {
$$ = $2;
}
;
$$ = 0;
}
| '/' steno_tonic_pitch {
- $$ = $2
+ $$ = $2;
+ $$->set_spot (THIS->here_input ());
+ }
+ ;
+
+chord_bass:
+ {
+ $$ = 0;
+ }
+ | CHORD_BASS steno_tonic_pitch {
+ $$ = $2;
+ $$->set_spot (THIS->here_input ());
}
;
for (int i=0; i < staff_sided_item_l_arr_.size (); i++)
{
Staff_side_item * ip = get_Staff_side (staff_sided_item_l_arr_[i]);
- arrs[ip->dir_].push (staff_sided_item_l_arr_[i]);
+ arrs[ip->get_direction ()].push (staff_sided_item_l_arr_[i]);
}
Direction d = DOWN;
if (relative_stem_dir)
ss->relative_dir_ = (Direction)relative_stem_dir;
else
- ss->dir_ = (Direction)force_dir;
+ ss->set_direction ((Direction)force_dir);
SCM dir_prop (get_property ("articulationScriptVerticalDirection", 0));
if (gh_number_p(dir_prop))
- ss->dir_ = to_dir (dir_prop);
+ ss->set_direction (to_dir (dir_prop));
- if (l->dir_)
- ss->dir_ = l->dir_;
+ if (l->get_direction ())
+ ss->set_direction (l->get_direction ());
SCM paddingprop = get_property ("articulationScriptPadding", 0);
if (gh_number_p(paddingprop))
void
Script::do_post_processing ()
{
- Direction d = staff_side_l_->dir_;
+ Direction d = staff_side_l_->get_direction ();
Molecule m (get_molecule(d));
/*
Molecule*
Script::do_brew_molecule_p () const
{
- return new Molecule (get_molecule (staff_side_l_->dir_));
+ return new Molecule (get_molecule (staff_side_l_->get_direction ()));
}
void
for (int i = 0; i < end_slur_l_arr_.size(); i++)
{
- end_slur_l_arr_[i]->dir_ = slurdir;
+ end_slur_l_arr_[i]->set_direction (slurdir);
typeset_element (end_slur_l_arr_[i]);
}
end_slur_l_arr_.clear();
{
warning (_ ("Slur over rest?"));
o[X_AXIS] = col->hpos_f ();
- o[Y_AXIS] = col->extent (Y_AXIS)[dir_];
+ o[Y_AXIS] = col->extent (Y_AXIS)[get_direction ()];
return o;
}
Simply set x to middle of notehead
*/
- o[X_AXIS] -= 0.5 * stem_l->dir_ * col->extent (X_AXIS).length ();
+ o[X_AXIS] -= 0.5 * stem_l->get_direction () * col->extent (X_AXIS).length ();
- if ((stem_l->dir_ == dir_)
+ if ((stem_l->get_direction () == get_direction ())
&& !stem_l->extent (Y_AXIS).empty_b ())
{
- o[Y_AXIS] = stem_l->extent (Y_AXIS)[dir_];
+ o[Y_AXIS] = stem_l->extent (Y_AXIS)[get_direction ()];
}
else
{
- o[Y_AXIS] = col->extent (Y_AXIS)[dir_];
+ o[Y_AXIS] = col->extent (Y_AXIS)[get_direction ()];
}
/*
leave a gap: slur mustn't touch head/stem
*/
- o[Y_AXIS] += dir_ * paper_l ()->get_var ("slur_y_free");
+ o[Y_AXIS] += get_direction () * paper_l ()->get_var ("slur_y_free");
o[Y_AXIS] += calc_interstaff_dist (stem_l, this);
return o;
}
Slur::do_post_processing ()
{
encompass_arr_.sort (Note_column_compare);
- if (!dir_)
- dir_ = get_default_dir ();
+ if (!get_direction ())
+ set_direction (get_default_dir ());
/*
Slur and tie placement [OSU]
no beam getting in the way
*/
if ((stem_l->extent (Y_AXIS).empty_b ()
- || !((stem_l->dir_ == dir_) && (dir_ != d)))
- && !((dir_ == stem_l->dir_)
+ || !((stem_l->get_direction () == get_direction ()) && (get_direction () != d)))
+ && !((get_direction () == stem_l->get_direction ())
&& stem_l->beam_l_ && (stem_l->beams_i_drul_[-d] >= 1)))
{
dx_f_drul_[d] = spanned_drul_[d]->extent (X_AXIS).length () / 2;
dx_f_drul_[d] -= d * x_gap_f;
- if (stem_l->dir_ != dir_)
+ if (stem_l->get_direction () != get_direction ())
{
- dy_f_drul_[d] = note_column_drul[d]->extent (Y_AXIS)[dir_];
+ dy_f_drul_[d] = note_column_drul[d]->extent (Y_AXIS)[get_direction ()];
}
else
{
dy_f_drul_[d] = stem_l->chord_start_f ()
- + dir_ * internote_f;
+ + get_direction () * internote_f;
}
- dy_f_drul_[d] += dir_ * y_gap_f;
+ dy_f_drul_[d] += get_direction () * y_gap_f;
}
/*
side attached to (visible) stem
*/
if (stem_l->beam_l_ && (stem_l->beams_i_drul_[-d] >= 1))
{
- dy_f_drul_[d] = stem_l->extent (Y_AXIS)[dir_];
- dy_f_drul_[d] += dir_ * 2 * y_gap_f;
+ dy_f_drul_[d] = stem_l->extent (Y_AXIS)[get_direction ()];
+ dy_f_drul_[d] += get_direction () * 2 * y_gap_f;
}
/*
side attached to notehead, with stem getting in the way
dx_f_drul_[d] -= d * x_gap_f;
dy_f_drul_[d] = stem_l->chord_start_f ()
- + dir_ * internote_f;
- dy_f_drul_[d] += dir_ * y_gap_f;
+ + get_direction () * internote_f;
+ dy_f_drul_[d] += get_direction () * y_gap_f;
}
}
}
Real slope_ratio_f = abs (dy_f / dx_f);
if (slope_ratio_f > slope_damp_f)
{
- Direction d = (Direction)(- dir_ * (sign (dy_f)));
+ Direction d = (Direction)(- get_direction () * (sign (dy_f)));
if (!d)
d = LEFT;
Real damp_f = (slope_ratio_f - slope_damp_f) * dx_f;
must never change sign of dy
*/
damp_f = damp_f <? abs (dy_f);
- dy_f_drul_[d] += dir_ * damp_f;
+ dy_f_drul_[d] += get_direction () * damp_f;
}
/*
Real height_ratio_f = abs (height_f / width_f);
if (height_ratio_f > height_damp_f)
{
- Direction d = (Direction)(- dir_ * (sign (dy_f)));
+ Direction d = (Direction)(- get_direction () * (sign (dy_f)));
if (!d)
d = LEFT;
/* take third step */
*/
if (abs (dy_f / dx_f ) < slope_damp_f)
{
- dy_f_drul_[-d] += dir_ * damp_f;
- dy_f_drul_[d] += dir_ * damp_f;
+ dy_f_drul_[-d] += get_direction () * damp_f;
+ dy_f_drul_[d] += get_direction () * damp_f;
}
/*
don't change slope too much, would have been catched by slope damping
else
{
damp_f = damp_f <? abs (dy_f/2);
- dy_f_drul_[d] += dir_ * damp_f;
+ dy_f_drul_[d] += get_direction () * damp_f;
}
}
}
Note_column * nc = note_column_drul[d];
if (nc == spanned_drul_[d]
&& nc->stem_l_
- && nc->stem_l_->dir_ == dir_
- && abs (nc->stem_l_->extent (Y_AXIS)[dir_]
+ && nc->stem_l_->get_direction () == get_direction ()
+ && abs (nc->stem_l_->extent (Y_AXIS)[get_direction ()]
- dy_f_drul_[d] + (d == LEFT ? 0 : interstaff_f))
<= snap_f)
{
snapx_f_drul[d] = nc->stem_l_->hpos_f ()
- spanned_drul_[d]->relative_coordinate (0, X_AXIS);
- snapy_f_drul[d] = nc->stem_l_->extent (Y_AXIS)[dir_]
+ snapy_f_drul[d] = nc->stem_l_->extent (Y_AXIS)[get_direction ()]
+ interstaff_interval[d]
- + dir_ * 2 * y_gap_f;
+ + get_direction () * 2 * y_gap_f;
snapped_b_drul[d] = true;
}
{
create_items (0);
text_p_->text_str_ = ly_scm2string (long_name);
- staff_side_p_->dir_ = LEFT;
+ staff_side_p_->set_direction (LEFT);
Bar_script_engraver::attach_script_to_item (i);
/*
Staff_side_element::Staff_side_element ()
{
- dir_ = CENTER;
+ set_direction (CENTER);
to_position_l_ = 0;
set_elt_property ("transparent", SCM_BOOL_T);
axis_ = Y_AXIS;
void
Staff_side_element::do_pre_processing ()
{
- if (!dir_)
- dir_ = get_default_direction ();
+ if (!get_direction ())
+ set_direction (get_default_direction ());
if (axis_ == X_AXIS)
position_self ();
SCM pad = remove_elt_property ("padding");
if (pad != SCM_UNDEFINED)
{
- off += gh_scm2double (pad) * dir_;
+ off += gh_scm2double (pad) * get_direction ();
}
- Real total_off = dim[dir_] + off;
+ Real total_off = dim[get_direction ()] + off;
/*
"no-staff-support" is ugh bugfix to get staccato dots right.
*/
if (to_position_l_ && to_position_l_->get_elt_property ("no-staff-support") == SCM_UNDEFINED)
- total_off += - sym_dim[-dir_];
+ total_off += - sym_dim[-get_direction ()];
dim_cache_[axis_]->set_offset (total_off);
if (fabs (total_off) > 100 CM)
DEBUG_OUT << "positioning " << to_position_l_->name();
DEBUG_OUT << "axis == " << axis_name_str (axis_)
- << ", dir == " << to_str ((int)dir_ );
+ << ", dir == " << to_str ((int)get_direction () );
#endif
}
SCM prop = get_property ("verticalDirection", 0);
if (gh_number_p(prop))
{
- stem_p_->dir_ = to_dir (prop);
+ stem_p_->set_direction (to_dir (prop));
stem_p_->set_elt_property ("dir-forced", SCM_BOOL_T);
}
mult_i_ =mult;
stem_l_ = s;
x_ = stem_l_->hpos_f ();
- dir_ = stem_l_->dir_;
+ set_direction (stem_l_->get_direction ());
SCM bd = stem_l_->remove_elt_property ("beam-dir");
beam_dir_ = gh_scm2int (bd);
Real stem_f = paper_l->get_var (type_str + "stem_length"
+ to_str (mult_i_ <? stem_max))* internote_f;
- if (!beam_dir_ || (beam_dir_ == dir_))
+ if (!beam_dir_ || (beam_dir_ == get_direction ()))
/* normal beamed stem */
{
if (mult_i_)
Direction
Stem_staff_side_item::get_default_direction () const
{
- return (Direction)(relative_dir_ * stem_l_->dir_);
+ return (Direction)(relative_dir_ * stem_l_->get_direction ());
}
void
Real self_coord = relative_coordinate (c, Y_AXIS);
Real now_coord = self_coord - staff_coord;
- Real desired_coord = ceil (dir_ * 2.0 * now_coord / staff_line_leading_f ());
+ Real desired_coord = ceil (get_direction () * 2.0 * now_coord / staff_line_leading_f ());
if (! (int (desired_coord) % 2))
{
desired_coord ++;
}
- translate_axis (desired_coord * dir_ * staff_line_leading_f () / 2.0 - now_coord, Y_AXIS);
+ translate_axis (desired_coord * get_direction () * staff_line_leading_f () / 2.0 - now_coord, Y_AXIS);
}
}
{
beams->translate (Offset(stem_l_->hpos_f () - hpos_f (),
stem_l_->stem_end_f () * internote_f -
- stem_l_->beam_l_->dir_ * beams_i * interbeam_f));
+ stem_l_->beam_l_->get_direction () * beams_i * interbeam_f));
}
else
{
/*
Beams should intersect one beamthickness below staff end
*/
- Real dy = - beams->extent ()[Y_AXIS].length () / 2 * stem_l_->dir_;
+ Real dy = - beams->extent ()[Y_AXIS].length () / 2 * stem_l_->get_direction ();
/*
uhg. Should use relative coords and placement
*/
Real whole_note_correction = (stem_l_ && stem_l_->invisible_b( ))
- ? -stem_l_->get_dir () * stem_l_->note_delta_f ()/2
+ ? -stem_l_->get_direction () * stem_l_->note_delta_f ()/2
: 0.0;
/*
void
Stem::set_direction (Direction d)
{
- if (!dir_)
+ if (!get_direction ())
warning (_ ("stem direction set already!"));
dir_ = d;
beams_i_drul_[LEFT] = beams_i_drul_[RIGHT] = -1;
yextent_drul_[DOWN] = yextent_drul_[UP] = 0;
flag_i_ = 2;
- dir_ = CENTER;
+ set_direction (CENTER);
beam_l_ = 0;
}
Real
Stem::stem_begin_f () const
{
- return yextent_drul_[Direction(-dir_)];
+ return yextent_drul_[Direction(-get_direction ())];
}
Real
Stem::chord_start_f () const
{
- return head_positions()[dir_] * staff_line_leading_f ()/2.0;
+ return head_positions()[get_direction ()] * staff_line_leading_f ()/2.0;
}
Real
Stem::stem_end_f () const
{
- return yextent_drul_[dir_];
+ return yextent_drul_[get_direction ()];
}
void
Stem::set_stemend (Real se)
{
// todo: margins
- if (dir_ && dir_ * head_positions()[dir_] >= se*dir_)
+ if (get_direction () && get_direction () * head_positions()[get_direction ()] >= se*get_direction ())
warning (_ ("Weird stem size; check for narrow beams"));
- yextent_drul_[dir_] = se;
- yextent_drul_[Direction(-dir_)] = head_positions()[-dir_];
+ yextent_drul_[get_direction ()] = se;
+ yextent_drul_[Direction(-get_direction ())] = head_positions()[-get_direction ()];
}
int
return Direction (int(paper_l ()->get_var ("stem_default_neutral_direction")));
}
-Direction
-Stem::get_dir () const
-{
- return dir_;
-}
void
Real shorten_f = paper_l ()->get_var (type_str + "forced_stem_shorten0");
- if (!dir_)
- dir_ = get_default_dir ();
+ if (!get_direction ())
+ set_direction (get_default_dir ());
/*
stems in unnatural (forced) direction should be shortened,
according to [Roush & Gourlay]
*/
if (((int)chord_start_f ())
- && (dir_ != get_default_dir ()))
+ && (get_direction () != get_default_dir ()))
length_f -= shorten_f;
if (flag_i_ >= 5)
if (flag_i_ >= 6)
length_f += 1.0;
- set_stemend ((dir_ > 0) ? head_positions()[BIGGER] + length_f:
+ set_stemend ((get_direction () > 0) ? head_positions()[BIGGER] + length_f:
head_positions()[SMALLER] - length_f);
bool no_extend_b = get_elt_property ("no-stem-extend") != SCM_UNDEFINED;
- if (!grace_b && !no_extend_b && (dir_ * stem_end_f () < 0))
+ if (!grace_b && !no_extend_b && (get_direction () * stem_end_f () < 0))
set_stemend (0);
}
if (!head_l_arr_.size ())
return;
head_l_arr_.sort (Note_head::compare);
- if (dir_ < 0)
+ if (get_direction () < 0)
head_l_arr_.reverse ();
Note_head * beginhead = head_l_arr_[0];
if (dy <= 1)
{
if (parity)
- head_l_arr_[i]->flip_around_stem (dir_);
+ head_l_arr_[i]->flip_around_stem (get_direction ());
parity = !parity;
}
else
{
if (!invisible_b ())
{
- SCM scmdir = gh_int2scm (dir_);
+ SCM scmdir = gh_int2scm (get_direction ());
SCM dirlist = column_l ()->get_elt_property ("dir-list");
if (dirlist == SCM_UNDEFINED)
dirlist = SCM_EOL;
style = ly_scm2string (st);
}
- char c = (dir_ == UP) ? 'u' : 'd';
+ char c = (get_direction () == UP) ? 'u' : 'd';
Molecule m = lookup_l ()->afm_find (String ("flags-") + to_str (c) +
to_str (flag_i_));
if (!style.empty_b ())
Real head_wid = 0;
if (head_l_arr_.size ())
head_wid = head_l_arr_[0]->extent (X_AXIS).length ();
- stem_y[Direction(-dir_)] += dir_ * head_wid * tan(ANGLE)/(2*dy);
+ stem_y[Direction(-get_direction ())] += get_direction () * head_wid * tan(ANGLE)/(2*dy);
if (!invisible_b ())
{
if (!beam_l_ && abs (flag_i_) > 2)
{
Molecule fl = flag ();
- fl.translate_axis(stem_y[dir_]*dy, Y_AXIS);
+ fl.translate_axis(stem_y[get_direction ()]*dy, Y_AXIS);
mol_p->add_molecule (fl);
}
Real rule_thick = paper_l ()->get_var ("stemthickness");
Interval stem_wid(-rule_thick/2, rule_thick/2);
- if (dir_ == CENTER)
+ if (get_direction () == CENTER)
r = head_wid.center ();
else
- r = head_wid[dir_] - stem_wid[dir_];
+ r = head_wid[get_direction ()] - stem_wid[get_direction ()];
}
return r;
}
ss->set_elt_property ("script-priority",
gh_int2scm (200));
- ss->dir_ = r->dir_;
+ ss->set_direction (r->get_direction ());
text->text_str_ = r->text_str_;
for (int i=0; i< tie_p_arr_.size (); i++)
{
- tie_p_arr_[i]->dir_ = tie_dir;
+ tie_p_arr_[i]->set_direction (tie_dir);
typeset_element (tie_p_arr_[i]);
}
tie_p_arr_.clear ();
if (dx_f < paper_l ()->get_var ("tie_staffspace_length"))
{
if (abs (ypos_i) % 2)
- y_f += dir_ * internote_f;
- y_f += dir_ * y_gap_f;
+ y_f += get_direction () * internote_f;
+ y_f += get_direction () * y_gap_f;
}
else
{
if (! (abs (ypos_i) % 2))
- y_f += dir_ * internote_f;
- y_f += dir_ * internote_f;
- y_f -= dir_ * y_gap_f;
+ y_f += get_direction () * internote_f;
+ y_f += get_direction () * internote_f;
+ y_f -= get_direction () * y_gap_f;
}
dy_f_drul_[LEFT] = dy_f_drul_[RIGHT] = y_f;
num.align_to (X_AXIS, CENTER);
num.translate_axis (w/2, X_AXIS);
Real interline = paper_l ()->get_var ("interline");
- Real dy = column_arr_.top ()->extent (Y_AXIS) [dir_]
- - column_arr_[0]->extent (Y_AXIS) [dir_];
+ Real dy = column_arr_.top ()->extent (Y_AXIS) [get_direction ()]
+ - column_arr_[0]->extent (Y_AXIS) [get_direction ()];
num.align_to (Y_AXIS, CENTER);
- num.translate_axis (dir_ * interline, Y_AXIS);
+ num.translate_axis (get_direction () * interline, Y_AXIS);
num.translate_axis (dy/2, Y_AXIS);
{
Real gap = paper_l () -> get_var ("tuplet_spanner_gap");
- mol_p->add_molecule (lookup_l ()->tuplet_bracket (dy, w, thick, gap, interline, dir_));
+ mol_p->add_molecule (lookup_l ()->tuplet_bracket (dy, w, thick, gap, interline, get_direction ()));
}
if (number_visibility)
{
mol_p->add_molecule (num);
}
- mol_p->translate_axis (dir_ * interline, Y_AXIS);
+ mol_p->translate_axis (get_direction () * interline, Y_AXIS);
}
return mol_p;
}
Tuplet_spanner::do_post_processing ()
{
if (column_arr_.size())
- translate_axis (column_arr_[0]->extent (Y_AXIS)[dir_], Y_AXIS);
+ translate_axis (column_arr_[0]->extent (Y_AXIS)[get_direction ()], Y_AXIS);
if (beam_l_arr_.size () == 1)
{
m = \musicalpitch { 0 2 -1 }
min = \musicalpitch { 0 2 -1 }
aug = \musicalpitch { 0 4 1 }
- dim = \musicalpitch { 0 4 -1 }
+ % urg!
+ % dim = \musicalpitch { -100 4 -1 }
+ dim = \musicalpitch { -100 2 -1 }
% urg, not actually a chord-modifier, but it works
% c7 -> <c bes>, c 7+ -> c b
maj = \musicalpitch { 0 6 1 }
INSTALLATION_OUT_DIR3=$(datadir)/tfm
INSTALLATION_OUT_FILES3=$(TFM_FILES)
+# comment these out if you don't want pfa's to be generated
+# or you don't have metapost.
INSTALLATION_OUT_DIR4=$(datadir)/pfa
INSTALLATION_OUT_FILES4=$(PFA_FILES)
#
# For now let people define these in their environments
#
- : ${MFPLAIN_MP=`kpsewhich mfplain.mp`}
+ : ${MFPLAIN_MP=`kpsewhich mp mfplain.mp`}
: ${INIMETAPOST_FLAGS='-interaction=nonstopmode'}
rm -f mfput.*
projects / lilypond.git / commitdiff