X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-engraver.cc;h=457fd734c4ce87442e83403718b67a2ca94174f5;hb=5b4b0d6e9a197e8f9eb085b7c2ad78b8be3e5cfc;hp=9d671c11e610a0e34420ca703689247d4ba382ef;hpb=2c8c61b3a5cddbb155786a1ca027528701c91ac9;p=lilypond.git diff --git a/lily/accidental-engraver.cc b/lily/accidental-engraver.cc index 9d671c11e6..457fd734c4 100644 --- a/lily/accidental-engraver.cc +++ b/lily/accidental-engraver.cc @@ -1,23 +1,25 @@ /* - accidental-engraver.cc -- implement accidental_engraver + accidental-engraver.cc -- implement Accidental_engraver source file of the GNU LilyPond music typesetter - (c) 1997--2006 Han-Wen Nienhuys + (c) 1997--2008 Han-Wen Nienhuys Modified 2001--2002 by Rune Zedeler */ #include "accidental-placement.hh" #include "arpeggio.hh" -#include "spanner.hh" #include "context.hh" -#include "item.hh" +#include "duration.hh" #include "engraver.hh" #include "international.hh" +#include "item.hh" #include "pitch.hh" #include "protected-scm.hh" #include "rhythmic-head.hh" +#include "separation-item.hh" #include "side-position-interface.hh" +#include "spanner.hh" #include "stream-event.hh" #include "tie.hh" #include "warn.hh" @@ -50,10 +52,9 @@ Accidental_entry::Accidental_entry () class Accidental_engraver : public Engraver { - int get_bar_number (); - void update_local_key_signature (); + void update_local_key_signature (SCM new_signature); void create_accidental (Accidental_entry *entry, bool, bool); - Grob *make_standard_accidental (Stream_event *note, Grob *note_head, Engraver *trans); + Grob *make_standard_accidental (Stream_event *note, Grob *note_head, Engraver *trans, bool); Grob *make_suggested_accidental (Stream_event *note, Grob *note_head, Engraver *trans); protected: @@ -64,21 +65,17 @@ protected: void acknowledge_arpeggio (Grob_info); void acknowledge_rhythmic_head (Grob_info); void acknowledge_finger (Grob_info); + void acknowledge_note_column (Grob_info); void stop_translation_timestep (); - virtual void initialize (); void process_acknowledged (); + virtual void finalize (); virtual void derived_mark () const; public: - SCM last_keysig_; // ugh. + SCM last_keysig_; - /* - Urgh. Since the accidentals depend on lots of variables, we have - to store all information before we can really create the - accidentals. - */ vector left_objects_; vector right_objects_; @@ -86,15 +83,12 @@ public: vector accidentals_; vector ties_; + vector note_columns_; }; /* - TODO: - - ugh, it is not clear what properties are mutable and which - aren't. eg. localKeySignature is changed at runtime, which means - that references in grobs should always store ly_deep_copy ()s of - those. + localKeySignature is changed at runtime, which means that references + in grobs should always store ly_deep_copy ()s of those. */ @@ -111,30 +105,26 @@ Accidental_engraver::derived_mark () const } void -Accidental_engraver::update_local_key_signature () +Accidental_engraver::update_local_key_signature (SCM new_sig) { - last_keysig_ = get_property ("keySignature"); + last_keysig_ = new_sig; set_context_property_on_children (context (), ly_symbol2scm ("localKeySignature"), - last_keysig_); + new_sig); Context *trans = context ()->get_parent_context (); - /* Huh. Don't understand what this is good for. --hwn. */ + /* Reset parent contexts so that e.g. piano-accidentals won't remember old + cross-staff accidentals after key-sig-changes */ SCM val; - while (trans && trans->where_defined (ly_symbol2scm ("localKeySignature"), &val)) + while (trans && trans->where_defined (ly_symbol2scm ("localKeySignature"), &val)==trans) { trans->set_property ("localKeySignature", ly_deep_copy (last_keysig_)); trans = trans->get_parent_context (); } } -void -Accidental_engraver::initialize () -{ - update_local_key_signature (); -} /** Calculate the number of accidentals on basis of the current local key sig (passed as argument) @@ -152,52 +142,87 @@ recent_enough (int bar_number, SCM alteration_def, SCM laziness) || laziness == SCM_BOOL_T) return true; - return (bar_number <= scm_to_int (scm_cdr (alteration_def)) + scm_to_int (laziness)); + return (bar_number <= scm_to_int (scm_cadr (alteration_def)) + scm_to_int (laziness)); } -static int +static Rational extract_alteration (SCM alteration_def) { if (scm_is_number (alteration_def)) - return scm_to_int (alteration_def); + return ly_scm2rational (alteration_def); else if (scm_is_pair (alteration_def)) - return scm_to_int (scm_car (alteration_def)); + return ly_scm2rational (scm_car (alteration_def)); else if (alteration_def == SCM_BOOL_F) - return 0; + return Rational (0); else assert (0); - return 0; + return Rational (0); } bool is_tied (SCM alteration_def) { - return (alteration_def == SCM_BOOL_T) - || (scm_is_pair (alteration_def) && scm_car (alteration_def) == SCM_BOOL_T); + SCM tied = ly_symbol2scm ("tied"); + return (alteration_def == tied + || (scm_is_pair (alteration_def) && scm_car (alteration_def) == tied)); } -static int -number_accidentals_from_sig (bool *different, SCM sig, Pitch *pitch, - int bar_number, SCM laziness, bool ignore_octave) +struct Accidental_result +{ + bool need_acc; + bool need_restore; + + Accidental_result () + { + need_restore = need_acc = false; + } + + Accidental_result (bool restore, bool acc) + { + need_restore = restore; + need_acc = acc; + } + + Accidental_result (SCM scm) + { + need_restore = to_boolean (scm_car (scm)); + need_acc = to_boolean (scm_cdr (scm)); + } + + int score () const + { + return need_acc ? 1 : 0 + + need_restore ? 1 : 0; + } +}; + +Accidental_result +check_pitch_against_signature (SCM key_signature, Pitch const &pitch, + int bar_number, SCM laziness, bool ignore_octave) { - int n = pitch->get_notename (); - int o = pitch->get_octave (); + Accidental_result result; + int n = pitch.get_notename (); + int o = pitch.get_octave (); SCM previous_alteration = SCM_BOOL_F; SCM from_same_octave = ly_assoc_get (scm_cons (scm_from_int (o), - scm_from_int (n)), sig, SCM_BOOL_F); - SCM from_key_signature = ly_assoc_get (scm_from_int (n), sig, SCM_BOOL_F); + scm_from_int (n)), key_signature, SCM_BOOL_F); + SCM from_key_signature = ly_assoc_get (scm_from_int (n), key_signature, SCM_BOOL_F); SCM from_other_octaves = SCM_BOOL_F; - for (SCM s = sig; scm_is_pair (s); s = scm_cdr (s)) + for (SCM s = key_signature; scm_is_pair (s); s = scm_cdr (s)) { SCM entry = scm_car (s); if (scm_is_pair (scm_car (entry)) && scm_cdar (entry) == scm_from_int (n)) - from_other_octaves = scm_cdr (entry); + { + from_other_octaves = scm_cdr (entry); + break; + } } - if (from_same_octave != SCM_BOOL_F + if (!ignore_octave + && from_same_octave != SCM_BOOL_F && recent_enough (bar_number, from_same_octave, laziness)) previous_alteration = from_same_octave; else if (ignore_octave @@ -207,66 +232,85 @@ number_accidentals_from_sig (bool *different, SCM sig, Pitch *pitch, else if (from_key_signature != SCM_BOOL_F) previous_alteration = from_key_signature; - int num = 1; if (is_tied (previous_alteration)) { - num = 1; - *different = true; + result.need_acc = true; } else { - int prev = extract_alteration (previous_alteration); - int alter = pitch->get_alteration (); - - if (alter == prev) - num = 0; - else if ((abs (alter) < abs (prev) - || prev * alter < 0) && alter != 0) - num = 2; - *different = (alter != prev); + Rational prev = extract_alteration (previous_alteration); + Rational alter = pitch.get_alteration (); + + if (alter != prev) + { + result.need_acc = true; + if (alter.sign () + && (alter.abs () < prev.abs () + || (prev * alter).sign () < 0)) + result.need_restore = true; + } } - return num; + + return result; } -static int -number_accidentals (bool *different, - Pitch *pitch, Context *origin, - SCM accidentals, int bar_number) +// TODO: consider moving check_pitch_against_signature to SCM (in which case +// we can delete this function). +LY_DEFINE (ly_find_accidentals_simple, "ly:find-accidentals-simple", 5, 0, 0, + (SCM keysig, SCM pitch_scm, SCM barnum, SCM laziness, SCM octaveness ), + "Checks the need for an accidental and a @q{restore} accidental against a" + " key signature. The @var{laziness} is the number of bars for which reminder" + " accidentals are used (ie. if @var{laziness} is zero, we only cancel accidentals" + " in the same bar; if @var{laziness} is three, we cancel accidentals up to three" + " bars after they first appear. @var{octaveness} is either" + " @code{'same-octave} or @code{'any-octave} and it specifies whether" + " accidentals should be canceled in different octaves.") { - int number = 0; + LY_ASSERT_TYPE (unsmob_pitch, pitch_scm, 2); + LY_ASSERT_TYPE (scm_is_integer, barnum, 3); + LY_ASSERT_TYPE (ly_is_symbol, octaveness, 5); + + bool symbol_ok = octaveness == ly_symbol2scm ("any-octave") || + octaveness == ly_symbol2scm ("same-octave"); + + SCM_ASSERT_TYPE (symbol_ok, octaveness, SCM_ARG5, __FUNCTION__, "'any-octave or 'same-octave"); + + Pitch *pitch = unsmob_pitch (pitch_scm); - *different = false; - if (scm_is_pair (accidentals) && !scm_is_symbol (scm_car (accidentals))) + int bar_number = scm_to_int (barnum); + bool ignore_octave = ly_symbol2scm ("any-octave") == octaveness; + Accidental_result result = check_pitch_against_signature (keysig, *pitch, bar_number, + laziness, ignore_octave); + + return scm_cons (scm_from_bool (result.need_restore), scm_from_bool (result.need_acc)); +} + +static +Accidental_result +check_pitch_against_rules (Pitch const &pitch, Context *origin, + SCM rules, int bar_number, SCM measurepos) +{ + Accidental_result result; + SCM pitch_scm = pitch.smobbed_copy (); + SCM barnum_scm = scm_from_int (bar_number); + + if (scm_is_pair (rules) && !scm_is_symbol (scm_car (rules))) warning (_f ("accidental typesetting list must begin with context-name: %s", - ly_scm2string (scm_car (accidentals)).c_str ())); + ly_scm2string (scm_car (rules)).c_str ())); - for (; scm_is_pair (accidentals) && origin; - accidentals = scm_cdr (accidentals)) + for (; scm_is_pair (rules) && origin; + rules = scm_cdr (rules)) { - // If pair then it is a new accidentals typesetting rule to be checked - SCM rule = scm_car (accidentals); - if (scm_is_pair (rule)) + SCM rule = scm_car (rules); + if (ly_is_procedure (rule)) { - SCM type = scm_car (rule); - SCM laziness = scm_cdr (rule); - SCM localsig = origin->get_property ("localKeySignature"); + SCM rule_result_scm = scm_call_4 (rule, origin->self_scm (), + pitch_scm, barnum_scm, measurepos); - bool same_octave_b - = scm_is_eq (ly_symbol2scm ("same-octave"), type); - bool any_octave_b - = scm_is_eq (ly_symbol2scm ("any-octave"), type); + Accidental_result rule_result (rule_result_scm); - if (same_octave_b || any_octave_b) - { - bool d = false; - int n = number_accidentals_from_sig - (&d, localsig, pitch, bar_number, laziness, any_octave_b); - *different = *different || d; - number = max (number, n); - } - else - warning (_f ("ignoring unknown accidental: %s", - ly_symbol2string (type).c_str ())); + result.need_acc |= rule_result.need_acc; + result.need_restore |= rule_result.need_restore; } /* if symbol then it is a context name. Scan parent contexts to @@ -281,26 +325,11 @@ number_accidentals (bool *different, origin = dad; } else - warning (_f ("pair or context-name expected for accidental rule, found %s", - ly_scm2string (rule).c_str ())); + warning (_f ("procedure or context-name expected for accidental rule, found %s", + print_scm_val (rule).c_str ())); } - return number; -} - -int -Accidental_engraver::get_bar_number () -{ - SCM barnum = get_property ("internalBarNumber"); - SCM smp = get_property ("measurePosition"); - - int bn = robust_scm2int (barnum, 0); - - Moment mp = robust_scm2moment (smp, Moment (0)); - if (mp.main_part_ < Rational (0)) - bn--; - - return bn; + return result; } void @@ -308,9 +337,10 @@ Accidental_engraver::process_acknowledged () { if (accidentals_.size () && !accidentals_.back ().done_) { - SCM accidentals = get_property ("autoAccidentals"); - SCM cautionaries = get_property ("autoCautionaries"); - int barnum = get_bar_number (); + SCM accidental_rules = get_property ("autoAccidentals"); + SCM cautionary_rules = get_property ("autoCautionaries"); + SCM measure_position = get_property ("measurePosition"); + int barnum = measure_number (context()); for (vsize i = 0; i < accidentals_.size (); i++) { @@ -325,38 +355,34 @@ Accidental_engraver::process_acknowledged () if (!pitch) continue; - bool different = false; - bool different_caut = false; - - int num = number_accidentals (&different, - pitch, origin, - accidentals, barnum); - int num_caut = number_accidentals (&different_caut, - pitch, origin, - cautionaries, barnum); - + Accidental_result acc = check_pitch_against_rules (*pitch, origin, accidental_rules, + barnum, measure_position); + Accidental_result caut = check_pitch_against_rules (*pitch, origin, cautionary_rules, + barnum, measure_position); bool cautionary = to_boolean (note->get_property ("cautionary")); - if (num_caut > num) + if (caut.score () > acc.score ()) { - num = num_caut; - different = different_caut; + acc.need_acc |= caut.need_acc; + acc.need_restore |= caut.need_restore; + cautionary = true; } bool forced = to_boolean (note->get_property ("force-accidental")); - if (num == 0 && forced) - num = 1; + if (!acc.need_acc && forced) + acc.need_acc = true; /* Cannot look for ties: it's not guaranteed that they reach us before the notes. */ - if (num - && !note->in_event_class ("trill-span-event")) - create_accidental (&accidentals_[i], num > 1, cautionary); - + if (!note->in_event_class ("trill-span-event")) + { + if (acc.need_acc) + create_accidental (&accidentals_[i], acc.need_restore, cautionary); - if (forced || cautionary) - accidentals_[i].accidental_->set_property ("forced", SCM_BOOL_T); + if (forced || cautionary) + accidentals_[i].accidental_->set_property ("forced", SCM_BOOL_T); + } } } } @@ -368,44 +394,40 @@ Accidental_engraver::create_accidental (Accidental_entry *entry, { Stream_event *note = entry->melodic_; Grob *support = entry->head_; - Pitch *pitch = unsmob_pitch (note->get_property ("pitch")); - bool as_suggestion = to_boolean (entry->origin_->get_property ("suggestAccidentals")); Grob *a = 0; if (as_suggestion) a = make_suggested_accidental (note, support, entry->origin_engraver_); else - a = make_standard_accidental (note, support, entry->origin_engraver_); + a = make_standard_accidental (note, support, entry->origin_engraver_, cautionary); - SCM accs = scm_cons (scm_from_int (pitch->get_alteration ()), - SCM_EOL); if (restore_natural) { if (to_boolean (get_property ("extraNatural"))) - accs = scm_cons (scm_from_int (0), accs); + a->set_property ("restore-first", SCM_BOOL_T); } - /* TODO: add cautionary option in accidental. */ - if (cautionary) - a->set_property ("cautionary", SCM_BOOL_T); - - a->set_property ("accidentals", accs); entry->accidental_ = a; } Grob * Accidental_engraver::make_standard_accidental (Stream_event *note, Grob *note_head, - Engraver *trans) + Engraver *trans, + bool cautionary) { - (void)note; + /* We construct the accidentals at the originating Voice level, so that we get the property settings for Accidental from the respective Voice. */ - Grob *a = trans->make_item ("Accidental", note_head->self_scm ()); + Grob *a = 0; + if (cautionary) + a = trans->make_item ("AccidentalCautionary", note_head->self_scm ()); + else + a = trans->make_item ("Accidental", note_head->self_scm ()); /* We add the accidentals to the support of the arpeggio, @@ -417,9 +439,6 @@ Accidental_engraver::make_standard_accidental (Stream_event *note, Side_position_interface::add_support (left_objects_[i], a); } - /* - Hmm. Junkme? - */ for (vsize i = 0; i < right_objects_.size (); i++) Side_position_interface::add_support (a, right_objects_[i]); @@ -431,7 +450,7 @@ Accidental_engraver::make_standard_accidental (Stream_event *note, Accidental_placement::add_accidental (accidental_placement_, a); note_head->set_object ("accidental-grob", a->self_scm ()); - + return a; } @@ -441,6 +460,7 @@ Accidental_engraver::make_suggested_accidental (Stream_event *note, Engraver *trans) { (void) note; + Grob *a = trans->make_item ("AccidentalSuggestion", note_head->self_scm ()); Side_position_interface::add_support (a, note_head); @@ -477,34 +497,39 @@ Accidental_engraver::stop_translation_timestep () } for (vsize i = accidentals_.size (); i--;) - { - int barnum = get_bar_number (); - + { Stream_event *note = accidentals_[i].melodic_; Context *origin = accidentals_[i].origin_; + int barnum = measure_number (origin); + Pitch *pitch = unsmob_pitch (note->get_property ("pitch")); if (!pitch) continue; int n = pitch->get_notename (); int o = pitch->get_octave (); - int a = pitch->get_alteration (); + Rational a = pitch->get_alteration (); SCM key = scm_cons (scm_from_int (o), scm_from_int (n)); + Moment end_mp = measure_position (context (), + unsmob_duration (note->get_property ("duration"))); + SCM position = scm_cons (scm_from_int (barnum), end_mp.smobbed_copy ()); + SCM localsig = SCM_EOL; while (origin && origin->where_defined (ly_symbol2scm ("localKeySignature"), &localsig)) { bool change = false; - if (accidentals_[i].tied_) + if (accidentals_[i].tied_ + && !(to_boolean (accidentals_[i].accidental_->get_property ("forced")))) { /* Remember an alteration that is different both from that of the tied note and of the key signature. */ - localsig = ly_assoc_front_x - (localsig, key, scm_cons (SCM_BOOL_T, scm_from_int (barnum))); + localsig = ly_assoc_prepend_x (localsig, key,scm_cons (ly_symbol2scm ("tied"), + position)); change = true; } @@ -514,9 +539,9 @@ Accidental_engraver::stop_translation_timestep () not really really correct if there are more than one noteheads with the same notename. */ - localsig = ly_assoc_front_x (localsig, key, - scm_cons (scm_from_int (a), - scm_from_int (barnum))); + localsig = ly_assoc_prepend_x (localsig, key, + scm_cons (ly_rational2scm (a), + position)); change = true; } @@ -527,6 +552,10 @@ Accidental_engraver::stop_translation_timestep () } } + if (accidental_placement_) + for (vsize i = 0; i < note_columns_.size (); i++) + Separation_item::add_conditional_item (note_columns_[i], accidental_placement_); + accidental_placement_ = 0; accidentals_.clear (); left_objects_.clear (); @@ -544,9 +573,8 @@ Accidental_engraver::acknowledge_rhythmic_head (Grob_info info) /* string harmonics usually don't have accidentals. */ - if (to_boolean (get_property ("harmonicAccidentals")) - || !ly_is_equal (info.grob ()->get_property ("style"), - ly_symbol2scm ("harmonic"))) + if (info.grob ()->get_property ("style") != ly_symbol2scm ("harmonic") + || to_boolean (get_property ("harmonicAccidentals"))) { Accidental_entry entry; entry.head_ = info.grob (); @@ -565,6 +593,12 @@ Accidental_engraver::acknowledge_tie (Grob_info info) ties_.push_back (dynamic_cast (info.grob ())); } +void +Accidental_engraver::acknowledge_note_column (Grob_info info) +{ + note_columns_.push_back (info.grob ()); +} + void Accidental_engraver::acknowledge_arpeggio (Grob_info info) { @@ -581,30 +615,39 @@ void Accidental_engraver::process_music () { SCM sig = get_property ("keySignature"); - /* Detect key sig changes. - Update all parents and children. */ if (last_keysig_ != sig) - update_local_key_signature (); + update_local_key_signature (sig); } ADD_ACKNOWLEDGER (Accidental_engraver, arpeggio); ADD_ACKNOWLEDGER (Accidental_engraver, finger); ADD_ACKNOWLEDGER (Accidental_engraver, rhythmic_head); ADD_ACKNOWLEDGER (Accidental_engraver, tie); +ADD_ACKNOWLEDGER (Accidental_engraver, note_column); ADD_TRANSLATOR (Accidental_engraver, - - "Make accidentals. " - "Catch note heads, ties and notices key-change events. " - "This engraver usually lives at Staff level, but " - "reads the settings for Accidental at @code{Voice} level, " - "so you can @code{\\override} them at @code{Voice}. ", - "Accidental AccidentalSuggestion", - + /* doc */ + "Make accidentals." + " Catch note heads, ties and notices key-change events." + " This engraver usually lives at Staff level, but" + " reads the settings for Accidental at @code{Voice} level," + " so you can @code{\\override} them at @code{Voice}.", + + /* create */ + "Accidental " + "AccidentalCautionary " + "AccidentalPlacement " + "AccidentalSuggestion ", + + /* read */ "autoAccidentals " "autoCautionaries " "internalBarNumber " "extraNatural " "harmonicAccidentals " - "localKeySignature", - "localKeySignature"); + "keySignature " + "localKeySignature ", + + /* write */ + "localKeySignature " + );