manpageoptions()
description(
+dit(-f,--format=)
+ Output format for sheet music. Choices are tex (for TeX
+ output), ps (for PostScript) and scm (for GUILE)
dit(-I,--include=)
add file(FILE) to the search path for input files.
dit(-m,--midi)
+pl 64.jcn1
+ - resurrected abbreviation beam
+ - coriolan fixes
+
+pl 64.hwn1
+ - reference-manual updates.
+ - slurdash -> slurDash, keyoctaviation -> keyOctaviation
+
+pl 64.uu1
+ - \property forceHorizontalShift
+ - bf: denneboom.ly
+ - warn if translator switching to self.
+ - warn if brace at end of lyric syllable.
+ - bf: Repeated_music::alternatives_length_mom ()
+ - \property automaticMelismas: if slur then melisma
+ - \property noVoltaBraces
+ - bf: star-spangled-banner
+
+pl 63.lu2
+ - very tight: hinterfleisch -> 0 : input/bugs/spacing-very-tight.ly
+ - bfs: neutral beam and tie directions (daar was ik al bang voor:-)
+ - bf: abe: may beam over skip, as long as note present too
+ - bf: scsii-prelude: added slurs using skips
+
+*********
pl 63.uu1
- - mutopia updates courtesy Peter Chubb
+ - mutopia updates courtesy Peter Chubb
- Don't make Time_scaled_music for c4*2/3 entry, only do the
time compression. Should cure spurious Tuplet_brace/spanner warnings.
--- /dev/null
+[:16 c'1 d]
+[:8 c2 d]
+[:16 c4 d]
+[:32 c16 d]
+[:32 c16 d]
+[:16 c8 d]
--- /dev/null
+\version "1.1.64";
+
+voiceOne = \notes \relative c'' {
+ a1 a a
+ a2 a2
+ a2 a8 a a a
+}
+
+staffOne = \context Staff = one <
+ \notes \context Voice=one <
+ \voiceOne
+ >
+>
+
+voiceTwo = \notes \relative c' {
+ % we must have a Thread context before we can switch staffs
+ % in this case, the notes before the switching will do that
+ % implicitely
+ \context Thread
+
+ R1*3
+ c2 c2
+ \translator Staff=one
+ \translator Voice=one
+ c2
+ c8 c c c
+}
+
+staffTwo = \context Staff = two <
+ % notes must go to Staff context: we want to switch Staff translators
+ %\notes \context Voice=one <
+ \voiceTwo
+ %>
+>
+
+grandstaff = \context GrandStaff = one <
+ \staffOne
+ \staffTwo
+>
+
+\score{
+ \grandstaff
+ \paper{
+ linewidth=80.0\mm;
+ castingalgorithm = \Wordwrap;
+ \translator { \VoiceContext beamAuto=0; }
+ \translator { \HaraKiriStaffContext }
+ \translator { \OrchestralScoreContext skipBars = 1; }
+ }
+}
+
+
-#if 0
-
/*
abbreviation-beam-engraver.cc -- implement Abbreviation_beam_engraver
#include "abbreviation-beam.hh"
#include "musical-request.hh"
#include "misc.hh"
+#include "warn.hh"
+#include "score-engraver.hh"
-
-ADD_THIS_TRANSLATOR(Abbreviation_beam_engraver);
+ADD_THIS_TRANSLATOR (Abbreviation_beam_engraver);
Abbreviation_beam_engraver::Abbreviation_beam_engraver ()
{
- span_reqs_drul_[LEFT] = span_reqs_drul_[RIGHT] = 0;
+ reqs_drul_[LEFT] = reqs_drul_[RIGHT] = 0;
abeam_p_ = 0;
+ finished_abeam_p_ = 0;
+ prev_start_req_ = 0;
}
bool
-Abbreviation_beam_engraver::do_try_music (Music*r)
+Abbreviation_beam_engraver::do_try_music (Music* m)
+{
+ if (Abbreviation_beam_req* b = dynamic_cast <Abbreviation_beam_req *> (m))
+ {
+ Direction d = b->span_dir_;
+ if (reqs_drul_[d] && !reqs_drul_[d]->equal_b (b))
+ return false;
+
+ if ((d == STOP) && !abeam_p_)
+ {
+ m->warning (_ ("No abbreviation beam to end"));
+ return false;
+ }
+
+ reqs_drul_[d] = b;
+ return true;
+ }
+
+ return false;
+}
+
+void
+Abbreviation_beam_engraver::do_process_requests ()
{
- Abbreviation_beam_req * b = dynamic_cast <Abbreviation_beam_req *> (r);
+ if (reqs_drul_[STOP])
+ {
+ if (!abeam_p_)
+ reqs_drul_[STOP]->warning (_("No abbreviation beam to end"));
+ prev_start_req_ = 0;
+ finished_abeam_p_ = abeam_p_;
+ abeam_p_ = 0;
+ }
- if (!b)
- return false;
+ if (abeam_p_)
+ {
+ Score_engraver * e = 0;
+ Translator * t = daddy_grav_l ();
+ for (; !e && t; t = t->daddy_trans_l_)
+ {
+ e = dynamic_cast<Score_engraver*> (t);
+ }
+
+ if (!e)
+ programming_error ("No score engraver!");
+ else
+ e->forbid_breaks ();
+ }
- if (bool (abeam_p_) == bool (b->span_dir_ == START))
- return false;
+ if (reqs_drul_[START])
+ {
+ if (abeam_p_)
+ {
+ reqs_drul_[START]->warning (_ ("Already have an abbreviation beam"));
+ return;
+ }
- Direction d = (!abeam_p_) ? LEFT : RIGHT;
- if (span_reqs_drul_[d] && !span_reqs_drul_[d]->equal_b (b))
- return false;
+ prev_start_req_ = reqs_drul_[START];
- span_reqs_drul_[d] = b;
- return true;
+ abeam_p_ = new Abbreviation_beam;
+ announce_element (Score_element_info (abeam_p_, reqs_drul_[LEFT]));
+ }
}
void
-Abbreviation_beam_engraver::do_process_requests ()
+Abbreviation_beam_engraver::do_post_move_processing ()
{
- if (!abeam_p_ && span_reqs_drul_[LEFT]) {
- abeam_p_ = new Abbreviation_beam;
- announce_element (Score_element_info (abeam_p_, span_reqs_drul_[LEFT]));
- }
+ reqs_drul_ [START] = 0;
}
void
Abbreviation_beam_engraver::do_pre_move_processing ()
{
- if (abeam_p_ && span_reqs_drul_[RIGHT]) {
- typeset_element (abeam_p_);
- abeam_p_ = 0;
+ typeset_beam ();
+}
- span_reqs_drul_[RIGHT] =
- span_reqs_drul_[LEFT] = 0;
- }
+void
+Abbreviation_beam_engraver::typeset_beam ()
+{
+ if (finished_abeam_p_)
+ {
+ typeset_element (finished_abeam_p_);
+ finished_abeam_p_ = 0;
+
+ reqs_drul_[STOP] = 0;
+ }
}
void
Abbreviation_beam_engraver::do_removal_processing ()
{
+ typeset_beam ();
if (abeam_p_)
{
- span_reqs_drul_[LEFT]->warning (_("unterminated beam"));
- typeset_element (abeam_p_);
- abeam_p_ = 0;
+ prev_start_req_->warning (_ ("Unfinished abbreviation beam"));
+ finished_abeam_p_ = abeam_p_;
+ typeset_beam ();
}
}
void
Abbreviation_beam_engraver::acknowledge_element (Score_element_info i)
{
- Stem* s = dynamic_cast<Stem *> (i.elem_l_);
- if (!abeam_p_ || !s)
- return;
-
- int type_i = span_reqs_drul_[LEFT]->type_i_;
- s->flag_i_ = intlog2 (type_i) - 2;
- s->beams_i_drul_[(span_reqs_drul_[RIGHT]) ? LEFT: RIGHT] = s->flag_i_;
-
- abeam_p_->multiple_i_ = s->flag_i_;
- if (s->type_i () != 1) // no abbrev gaps on half note
- s->set_elt_property (beam_gap_scm_sym,
- gh_int2scm(s->flag_i_ - ((s->type_i () >? 2) - 2)));
-
- abeam_p_->add_stem (s);
-}
-
+ if (abeam_p_)
+ {
+ if (Stem* s = dynamic_cast<Stem *> (i.elem_l_))
+ {
+ int type_i = prev_start_req_->type_i_;
+ s->flag_i_ = intlog2 (type_i) - 2;
+
+ s->beams_i_drul_[LEFT] = s->flag_i_;
+ s->beams_i_drul_[RIGHT] = s->flag_i_;
+
+ abeam_p_->multiple_i_ = s->flag_i_;
+ /*
+ abbrev gaps on all but half note
+ */
+#if 0
+ if (s->type_i () != 1)
+ {
+ int gap_i =s->flag_i_ - ((s->type_i () >? 2) - 2);
+ s->set_elt_property (beam_gap_scm_sym, gh_int2scm(gap_i));
+ }
+#else
+ if (s->type_i () != 1)
+ {
+ int gap_i =s->flag_i_ - ((s->type_i () >? 2) - 2);
+ abeam_p_->set_elt_property (beam_gap_scm_sym, gh_int2scm(gap_i));
+ }
#endif
+
+ abeam_p_->add_stem (s);
+ }
+ }
+}
-#if 0
/*
abbreviation-beam.cc -- implement Abbreviation_beam
*/
return Beam::stem_beams (here, next, prev);
}
-#endif
#include "musical-request.hh"
#include "bar.hh"
#include "beam.hh"
+#include "abbreviation-beam.hh"
#include "rest.hh"
#include "stem.hh"
#include "debug.hh"
}
bool
-Auto_beam_engraver::do_try_music (Music* m)
+Auto_beam_engraver::do_try_music (Music*)
{
- /*
- Mag dit? Nu word-i toch maar geswallowed, en
- komt er dus ook geen announce...
- */
- if (Skip_req* s = dynamic_cast <Skip_req*> (m))
- {
- if (stem_l_arr_p_)
- end_beam ();
- return true;
- }
return false;
}
Beam* beam_p = new Beam;
for (int i = 0; i < stem_l_arr_p_->size (); i++)
- beam_p->add_stem ((*stem_l_arr_p_)[i]);
-
+ {
+ /*
+ watch out for stem tremolos and abbreviation beams
+ */
+ if ((*stem_l_arr_p_)[i]->beam_l_)
+ {
+ delete beam_p;
+ return 0;
+ }
+ beam_p->add_stem ((*stem_l_arr_p_)[i]);
+ }
+
/* urg, copied from Beam_engraver */
Scalar prop = get_property ("beamslopedamping", 0);
if (prop.isnum_b ())
else
{
finished_beam_p_ = create_beam_p ();
- finished_grouping_p_ = grouping_p_;
+ if (finished_beam_p_)
+ finished_grouping_p_ = grouping_p_;
delete stem_l_arr_p_;
stem_l_arr_p_ = 0;
grouping_p_ = 0;
void
Auto_beam_engraver::do_post_move_processing ()
{
+ /*
+ don't beam over skips
+ */
+ if (stem_l_arr_p_)
+ {
+ Moment now = now_mom ();
+ if (extend_mom_ < now)
+ {
+ end_beam ();
+ }
+ }
}
void
{
junk_beam ();
}
+ else if (Abbreviation_beam *b = dynamic_cast<Abbreviation_beam*> (info.elem_l_))
+ {
+ junk_beam ();
+ }
else if (Bar *b = dynamic_cast<Bar *> (info.elem_l_))
{
junk_beam ();
return;
}
-#if 0
/*
- Don't (start) auto-beam over empty stems.
- ugly check for rests!
- --> doesn't even work: stem-dir is not set
-
- ../flower/include/drul-array.hh:26: Real & Drul_array<double>::elem<Real>(enum Direction): Assertion `d==1 || d== -1' failed.
-/home/fred/root/usr/scripts/src/out/Linux/li: line 8: 14641 Aborted (core dumped) lilypond $opts
-
- */
- if (stem_l->extent (Y_AXIS).empty_b ())
- {
- if (stem_l_arr_p_)
- end_beam ();
- return;
- }
-#else
+ Don't (start) auto-beam over empty stems; skips or rests
+ */
if (!stem_l->head_l_arr_.size ())
{
if (stem_l_arr_p_)
end_beam ();
return;
}
-#endif
if (stem_l->beam_l_)
{
return ;
}
- /*
- now that we have last_add_mom_, perhaps we can (should) do away
- with these individual junk_beams
- */
-
int durlog =rhythmic_req->duration_.durlog_i_;
if (durlog <= 2)
{
}
Moment now = now_mom ();
- grouping_p_->add_stem (now - beam_start_moment_ + beam_start_location_, durlog - 2);
+ grouping_p_->add_stem (now - beam_start_moment_ + beam_start_location_,
+ durlog - 2);
stem_l_arr_p_->push (stem_l);
last_add_mom_ = now;
extend_mom_ = extend_mom_ >? now + rhythmic_req->length_mom ();
count[UP] = count[DOWN] = 0;
Direction d = DOWN;
- Direction beamdir;
for (int i=0; i <stems_.size (); i++)
do {
Stem *s = stems_[i];
If dir is not determined: up (see stem::get_default_dir ())
*/
+ Direction beam_dir;
+ Direction neutral_dir = (int)paper_l ()->get_var ("stem_default_neutral_direction");
+
Dir_algorithm a = (Dir_algorithm)rint(paper_l ()->get_var ("beam_dir_algorithm"));
switch (a)
{
case MAJORITY:
- beamdir = (count[UP] >= count[DOWN]) ? UP : DOWN;
+ beam_dir = (count[UP] == count[DOWN]) ? neutral_dir
+ : (count[UP] > count[DOWN]) ? UP : DOWN;
break;
case MEAN:
// mean center distance
- beamdir = (total[UP] >= total[DOWN]) ? UP : DOWN;
+ beam_dir = (total[UP] == total[DOWN]) ? neutral_dir
+ : (total[UP] > total[DOWN]) ? UP : DOWN;
break;
default:
case MEDIAN:
// median center distance
- if (!count[DOWN])
- beamdir = UP;
- if (!count[UP])
- beamdir = DOWN;
+ if (!count[DOWN] || !count[UP])
+ {
+ beam_dir = (count[UP] == count[DOWN]) ? neutral_dir
+ : (count[UP] > count[DOWN]) ? UP : DOWN;
+ }
else
- beamdir = (total[UP] / count[UP] >= total[DOWN] / count[DOWN]) ? UP : DOWN;
+ {
+ beam_dir = (total[UP] / count[UP] == total[DOWN] / count[DOWN])
+ ? neutral_dir
+ : (total[UP] / count[UP] > total[DOWN] / count[DOWN]) ? UP : DOWN;
+ }
break;
}
- return beamdir;
+ return beam_dir;
}
void
for (int i=0; i < stems_.size (); i++)
{
Stem *s = stems_[i];
+#if 0
+ // abbreviation beam needs to beam over invisible stems of wholes
if (s->invisible_b ())
continue;
+#endif
Stem_info info (s, multiple_i_);
if (leftx == 0)
Molecule rightbeams;
// UGH
- Real nw_f = paper_l ()->note_width () * 0.8;
+ Real nw_f;
+ if (here->type_i ()== 1)
+ nw_f = paper_l ()->get_var ("wholewidth");
+ else if (here->type_i () == 2)
+ nw_f = paper_l ()->note_width () * 0.8;
+ else
+ nw_f = paper_l ()->get_var ("quartwidth");
/* half beams extending to the left. */
if (prev)
SCM gap = get_elt_property (beam_gap_scm_sym);
if (gap != SCM_BOOL_F)
{
- int gap_i = gh_scm2int (gap);
+ int gap_i = gh_scm2int (SCM_CDR (gap));
int nogap = rwholebeams - gap_i;
for (; j < nogap; j++)
for (; j < rwholebeams; j++)
{
Molecule b (a);
- b.translate (Offset (gap_f, -dir_ * dy * j));
+ if (!here->invisible_b ())
+ b.translate (Offset (gap_f, -dir_ * dy * j));
+ else
+ b.translate (Offset (0, -dir_ * dy * j));
rightbeams.add_molecule (b);
}
virtual bool do_try_music (Music*);
virtual void acknowledge_element (Score_element_info);
virtual void do_pre_move_processing();
+ virtual void do_post_move_processing();
private:
- Drul_array<Abbreviation_beam_req *> span_reqs_drul_;
+ void typeset_beam ();
+ Drul_array<Abbreviation_beam_req*> reqs_drul_;
+ Abbreviation_beam_req* prev_start_req_;
Abbreviation_beam* abeam_p_;
+ Abbreviation_beam* finished_abeam_p_;
};
#endif // ABBREVIATION_BEAM_ENGRAVER_HH
public:
VIRTUAL_COPY_CONS(Music);
};
+/**
+ Start / stop an abbreviation beam. */
+class Abbreviation_beam_req : public Span_req
+{
+public:
+ VIRTUAL_COPY_CONS (Music);
+
+ Abbreviation_beam_req ();
+
+ virtual void do_print () const;
+
+ int type_i_;
+};
/**
Helping req to signal start of a melisma from within a context, and
Duration default_duration_;
Musical_pitch default_pitch_;
Scope *default_header_p_;
+ int abbrev_beam_type_i_;
bool first_b_;
int fatal_error_i_;
Sources * source_l_;
Simultaneous_music* get_rest_element (String, Duration *);
Simultaneous_music* get_word_element (String, Duration*);
String notename_str (Melodic_req* melodic);
+ void set_abbrev_beam (int type_i);
void set_last_duration (Duration const *);
void set_last_pitch (Musical_pitch const *);
friend int yyparse (void*);
{
old_accidental_idx_arr_ = accidental_idx_arr_;
key_.clear ();
- Scalar prop = get_property ("keyoctaviation", 0);
+ Scalar prop = get_property ("keyOctaviation", 0);
if (prop.length_i () > 0)
{
key_.multi_octave_b_ = ! prop.to_bool ();
span_dir_ = CENTER;
}
+Abbreviation_beam_req::Abbreviation_beam_req ()
+{
+ type_i_ = 0;
+}
+
+void
+Abbreviation_beam_req::do_print () const
+{
+#ifndef NPRINT
+ DOUT << type_i_;
+#endif
+}
void
Text_script_req::do_print () const
first_b_ = true;
source_l_ = source_l;
lexer_p_ = 0;
+ abbrev_beam_type_i_ = 0;
default_duration_.durlog_i_ = 2;
default_pitch_ = Musical_pitch (5*7, 0);
error_level_i_ = 0;
default_duration_ = *d;
}
+void
+My_lily_parser::set_abbrev_beam (int type_i)
+{
+ abbrev_beam_type_i_ = type_i;
+}
+
void
My_lily_parser::set_last_pitch (Musical_pitch const* p)
{
Input
My_lily_parser::here_input() const
{
- Source_file * f_l= lexer_p_->source_file_l();
- return Input (f_l, here_ch_C());
+ return lexer_p_->here_input ();
}
Paper_def*
b->span_type_str_ = "beam";
$$ =b;
}
+ | '[' ':' unsigned {
+ if (!Duration::duration_type_b ($3))
+ THIS->parser_error (_f ("not a duration: %d", $3));
+ else if ($3 < 8)
+ THIS->parser_error (_ ("can't abbreviate"));
+ else
+ THIS->set_abbrev_beam ($3);
+
+ Abbreviation_beam_req* a = new Abbreviation_beam_req;
+ a->span_dir_ = START;
+ a->type_i_ = THIS->abbrev_beam_type_i_;
+ $$=a;
+ }
| ']' {
- Span_req*b= new Span_req;
- b->span_dir_ = STOP;
- b->span_type_str_ = "beam";
- $$ = b;
+ if (!THIS->abbrev_beam_type_i_)
+ {
+ Span_req*b= new Span_req;
+ b->span_dir_ = STOP;
+ b->span_type_str_ = "beam";
+ $$ = b;
+ }
+ else
+ {
+ Abbreviation_beam_req* a = new Abbreviation_beam_req;
+ a->span_dir_ = STOP;
+ a->type_i_ = THIS->abbrev_beam_type_i_;
+ THIS->set_abbrev_beam (0);
+ $$ = a;
+ }
}
| BREATHE {
$$ = new Breathing_sign_req;
delete $1;
n->duration_ = *$4;
delete $4;
+ if (THIS->abbrev_beam_type_i_)
+ {
+ if (n->duration_.plet_b ())
+ THIS->parser_error (_ ("can't abbreviate tuplet"));
+ else
+ n->duration_.set_plet (1, 2);
+ }
n->cautionary_b_ = $3 % 2;
n->forceacc_b_ = $2 % 2 || n->cautionary_b_;
#include "slur.hh"
#include "debug.hh"
#include "note-column.hh"
+#include "translator-group.hh"
bool
Slur_engraver::do_try_music (Music *req_l)
if (sl->span_type_str_ != "slur")
return false;
new_slur_req_l_arr_.push (sl);
+
return true;
}
return false;
}
+void
+Slur_engraver::set_melisma (bool m)
+{
+ Translator_group *where = daddy_trans_l_;
+ get_property ("melismaBusy", &where);
+ if (!where)
+ where = daddy_trans_l_;
+
+ daddy_trans_l_->set_property ("melismaBusy", m ? "1" :"0");
+}
+
void
Slur_engraver::acknowledge_element (Score_element_info info)
{
// push a new slur onto stack.
//(use temp. array to wait for all slur STOPs)
Slur * s_p =new Slur;
- Scalar prop = get_property ("slurdash", 0);
+ Scalar prop = get_property ("slurDash", 0);
if (prop.isnum_b ())
s_p->set_elt_property (dashed_scm_sym, gh_int2scm(prop));
Slur_engraver::do_post_move_processing()
{
new_slur_req_l_arr_.clear();
+ if (get_property ("automaticMelismas",0).to_bool ())
+ {
+ set_melisma (slur_l_stack_.size ());
+ }
}
% ugh
\include "midi.ly"
-\include "dynamic.ly"
+\include "textscripts.ly"
+\include "spanners.ly"
\include "property.ly"
beamAuto = "1";
\consists "Auto_beam_engraver";
\include "auto-beam-settings.ly";
-% \consists "Abbreviation_beam_engraver";
+ \consists "Abbreviation_beam_engraver";
% \consists "Multi_measure_rest_engraver";
% ugh. Order matters here.
% poor man's array size
stem_max = 3.0;
-% stem stuff measured in staff positions.
+%{ Specify length of stems for notes in the staff
+that don't have beams.
+ Measured in staff positions.
+%}
stem_length0 = 7.;
stem_length1 = 5.;
stem_length2 = 4.;
stem_length3 = 3.;
-%
+%{
+The space taken by a note is determined by the formula
+
+arithmetic_multiplier * ( c + log2 (time) ))
+
+where code(time) is the amount of time a note occupies. The value
+of code(c) is chosen such that the smallest space within a measure is
+arithmetic_basicspace. The smallest space is the one following the
+shortest note in the measure. Typically arithmetic_basicspace is set
+to the width of a quarter note head.
+%}
arithmetic_basicspace = 2.;
arithmetic_multiplier = 0.9 * \quartwidth ;
grace_minimum_stem_length2 = \minimum_stem_length2 * \grace_factor;
grace_minimum_stem_length3 = \minimum_stem_length3 * \grace_factor;
-% stems in unnatural (forced) direction should be shortened,
-% according to [Roush & Gourlay]. Their suggestion to knock off
-% a whole staffspace seems a bit drastical: we'll do half.
-%
+%{
+ stems in unnatural (forced) direction should be shortened,
+ according to [Roush & Gourlay]. Their suggestion to knock off
+ a whole staffspace seems a bit drastical: we'll do half.
+%}
+
forced_stem_shorten0 = 1.0;
forced_stem_shorten1 = \forced_stem_shorten0;
forced_stem_shorten2 = \forced_stem_shorten1;
MAJORITY = 2.0;
MEAN = 3.0;
MEDIAN = 4.0;
+
+%{
+dit(code(beam_dir_algorithm)) Specify algorithm for determining
+whether beams go up or down. It is real valued. If set to 2.0 then
+majority selection is used. If set to 3.0, then mean selection is
+used based on the mean center distance. If set to 4.0 then median
+selection is used, based on the median center distance.
+%}
+
% [Ross]: majority
beam_dir_algorithm = \MAJORITY;
% and slope is running away steeper than
beam_steep_slope = 0.2 / 1.0;
+%{
+dit(code(slur_x_gap)) Horizontal space between note and slur. Set to
+code(\interline / 5) by default.
+
+%}
% OSU: suggested gap = ss / 5;
slur_x_gap = \interline / 5.0;
slur_y_gap = 0.25 * \interline;
slur_y_free = 0.75 * \interline;
slur_x_minimum = 3.0 * \interline;
+%{
+Like beams, slurs often aren't as steep as the notes they encompass.
+This sets the amount of damping.
+%}
% slope damping: keep dy/dx < slur_slope_damping
slur_slope_damping = 0.3;
slur_interstaff_slope_damping = 0.6;
% ugh: rename to bow (in bezier.cc and fonts.doc too...)
% slur_thickness = 1.8 * \staffline;
slur_thickness = 1.4 * \staffline;
+
+%{
+ Specifies the maximum height of slurs.
+%}
slur_height_limit = \staffheight;
+%{
+Specifes the ratio of slur hight to slur width
+to aim for. Default value is 0.3.
+%}
% slur_ratio = 0.3;
% try bit flatter slurs
gourlay_energybound = 100000.;
%{
-The following bounds the number of measures
-on a line. Decreasing it greatly reduces computation time
+Maximum number of measures per line to try when using Gourlay
+method. Decreasing this greatly reduces computation time.
%}
gourlay_maxmeasures = 10.;
castingalgorithm = \Gourlay;
slurnormal =
- \property Voice.slurdash = ""
+ \property Voice.slurDash = ""
slurdotted =
- \property Voice.slurdash = 1
+ \property Voice.slurDash = 1
tupletoff = {
--- /dev/null
+
+
+% 1st arg dynamic (louder/softer). 2nd arg spantype
+cr = \spanrequest \start "crescendo"
+decr = \spanrequest \start "decrescendo"
+rc = \spanrequest \stop "crescendo"
+rced = \spanrequest \stop "decrescendo"
--- /dev/null
+
+%
+% declare the standard dynamic identifiers.
+%
+
+pppppp = \textscript"pppppp" "dynamic"
+ppppp = \textscript"ppppp" "dynamic"
+pppp = \textscript "pppp" "dynamic"
+ppp = \textscript "ppp" "dynamic"
+pp = \textscript "pp" "dynamic"
+p = \textscript "p" "dynamic"
+mp = \textscript "mp" "dynamic"
+mf = \textscript "mf" "dynamic"
+f = \textscript "e" "dynamic" % see feta-din layout
+ff = \textscript "ff" "dynamic"
+fff = \textscript "fff" "dynamic"
+ffff = \textscript "ffff" "dynamic"
+fffff = \textscript "fffff" "dynamic"
+ffffff = \textscript "ffffff" "dynamic"
+fp = \textscript "fp" "dynamic"
+sf = \textscript "sf" "dynamic"
+sff = \textscript "sff" "dynamic"
+sfz = \textscript "sfz" "dynamic"
+fz = \textscript "fz" "dynamic"
+sp = \textscript "sp" "dynamic"
+spp = \textscript "spp" "dynamic"
+rfz = \textscript "rfz" "dynamic"
+
\version "1.1.52";
viola1 = \notes \relative c {
- \context Voice=one
c'1\ff ~ | c | f,4-. r r2 | r1 |
% copied 3 bars from three back...
%5
% starts on (actualy, most part is on) same staff as viola1
%urg, parse error
%urg \translator Staff=viola1
+ \context Thread
\translator Staff=violai
- \context Voice=one
+ \translator Voice=one
c1 ~ | c | s1*2 |
% copied 3 bars from three back...
c ~ | c | s1*2 % |
\property Staff.instrument = "Viola II"
\property Staff.instr = "Vla. II"
\clef "alto";
- \notes \context Voice=one<
+ % notes must go to Staff context: we want to switch Staff translators
+ %\notes \context Voice=one<
\global
\$viola2
- >
+ %>
>
conversions.append ((1,1,55), conv,
'\\wheel -> \\coda')
+if 1:
+ def conv(lines):
+ newlines =[]
+ for x in lines:
+ x = re.sub ('keyoctaviation','keyOctaviation', x)
+ x = re.sub ('slurdash','slurDash', x)
+ newlines.append (x)
+ return newlines
+
+ conversions.append ((1,1,65), conv,
+ 'slurdash -> slurDash, keyoctaviation -> keyOctaviation')
+
############################
projects / lilypond.git / commitdiff