X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-engraver.cc;h=a60c3880bc4f63424385ae309893dbb253765fc3;hb=c93997ee6226dae036e411b39e5af873b8726293;hp=0258e9d889b6d5b95aab51e7c8b2315cbb5d5556;hpb=ba858880848d6aca1de4401d185860eb2017a01c;p=lilypond.git diff --git a/lily/accidental-engraver.cc b/lily/accidental-engraver.cc index 0258e9d889..a60c3880bc 100644 --- a/lily/accidental-engraver.cc +++ b/lily/accidental-engraver.cc @@ -1,32 +1,33 @@ /* accidental-engraver.cc -- implement accidental_engraver - (c) 1997--2004 Han-Wen Nienhuys + source file of the GNU LilyPond music typesetter + + (c) 1997--2005 Han-Wen Nienhuys Modified 2001--2002 by Rune Zedeler */ -#include "event.hh" -#include "spanner.hh" -#include "item.hh" -#include "tie.hh" -#include "rhythmic-head.hh" -#include "engraver-group-engraver.hh" #include "accidental-placement.hh" -#include "side-position-interface.hh" -#include "engraver.hh" #include "arpeggio.hh" -#include "warn.hh" #include "context.hh" +#include "engraver.hh" #include "protected-scm.hh" +#include "rhythmic-head.hh" +#include "side-position-interface.hh" +#include "tie.hh" +#include "warn.hh" - -struct Accidental_entry { +class Accidental_entry +{ +public: bool done_; - Music * melodic_; - Grob * accidental_; + Music *melodic_; + Grob *accidental_; Context *origin_; - Grob* head_; + Engraver *origin_trans_; + Grob *head_; bool tied_; + Accidental_entry (); }; @@ -34,13 +35,18 @@ Accidental_entry::Accidental_entry () { tied_ = false; done_ = false; - melodic_ =0; + melodic_ = 0; accidental_ = 0; origin_ = 0; head_ = 0; } -struct Accidental_engraver : Engraver { +class Accidental_engraver : public Engraver +{ +public: + int get_bar_number (); + void update_local_key_signature (); + protected: TRANSLATOR_DECLARATIONS (Accidental_engraver); virtual void process_music (); @@ -49,33 +55,40 @@ protected: virtual void initialize (); virtual void process_acknowledged_grobs (); virtual void finalize (); -public: - Protected_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. - */ + virtual void derived_mark () const; +public: + SCM last_keysig_; // ugh. + + /* Urgh. Since the accidentals depend on lots of variables, we have + to store all information before we can really create the + accidentals. */ Link_array left_objects_; Link_array right_objects_; - Grob * accidental_placement_; + Grob *accidental_placement_; Array accidentals_; Link_array ties_; - - SCM get_bar_num (); }; +/* + 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. + */ + static void -set_property_on_children (Context * trans, const char * sym, SCM val) +set_property_on_children (Context *trans, char const *sym, SCM val) { - trans->set_property (sym, val); - for (SCM p = trans->children_contexts (); ly_c_pair_p (p); p = ly_cdr (p)) + trans->set_property (sym, ly_deep_copy (val)); + for (SCM p = trans->children_contexts (); scm_is_pair (p); p = scm_cdr (p)) { - Context *trg = unsmob_context (ly_car (p)); + Context *trg = unsmob_context (scm_car (p)); set_property_on_children (trg, sym, ly_deep_copy (val)); } } @@ -87,106 +100,166 @@ Accidental_engraver::Accidental_engraver () } void -Accidental_engraver::initialize () +Accidental_engraver::derived_mark () const +{ + scm_gc_mark (last_keysig_); +} + +void +Accidental_engraver::update_local_key_signature () { last_keysig_ = get_property ("keySignature"); + set_property_on_children (context (), "localKeySignature", last_keysig_); - Context * trans_ = get_parent_context (); - while (trans_) + Context *trans = context ()->get_parent_context (); + + /* Huh. Don't understand what this is good for. --hwn. */ + while (trans && trans->where_defined (ly_symbol2scm ("localKeySignature"))) { - trans_ -> set_property ("localKeySignature", - ly_deep_copy (last_keysig_)); - trans_ = trans_->get_parent_context (); + trans->set_property ("localKeySignature", ly_deep_copy (last_keysig_)); + trans = trans->get_parent_context (); } - set_property_on_children (get_parent_context (),"localKeySignature", last_keysig_); } -/* +void +Accidental_engraver::initialize () +{ + update_local_key_signature (); +} - calculates the number of accidentals on basis of the current local key - sig (passed as argument) - Returns number of accidentals (0, 1 or 2). +/** Calculate the number of accidentals on basis of the current local key + sig (passed as argument) + + * First check step+octave (taking into account barnumbers if necessary). + + * Then check the global signature (only step). + + Return number of accidentals (0, 1 or 2). */ + +static bool +recent_enough (int bar_number, SCM alteration_def, SCM laziness) +{ + if (scm_is_number (alteration_def) + || laziness == SCM_BOOL_T) + return true; + + return (bar_number <= scm_to_int (scm_cdr (alteration_def)) + scm_to_int (laziness)); +} -*/ static int -number_accidentals_from_sig (bool *different, - SCM sig, Pitch *pitch, SCM curbarnum, SCM lazyness, - bool ignore_octave) +extract_alteration (SCM alteration_def) +{ + if (scm_is_number (alteration_def)) + return scm_to_int (alteration_def); + else if (scm_is_pair (alteration_def)) + return scm_to_int (scm_car (alteration_def)); + else if (alteration_def == SCM_BOOL_F) + return 0; + else + assert (0); + return 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); +} + +static int +number_accidentals_from_sig (bool *different, SCM sig, Pitch *pitch, + int bar_number, SCM laziness, bool ignore_octave) { int n = pitch->get_notename (); int o = pitch->get_octave (); - int a = pitch->get_alteration (); - int curbarnum_i = ly_scm2int (curbarnum); - int accbarnum_i = 0; - SCM prev; - if (ignore_octave) - prev = ly_assoc_cdr (scm_int2num (n), sig); - else - prev = scm_assoc (scm_cons (scm_int2num (o), scm_int2num (n)), sig); + SCM previous_alteration = SCM_BOOL_F; - /* should really be true unless prev == SCM_BOOL_F */ - if (ly_c_pair_p (prev) && ly_c_pair_p (ly_cdr (prev))) + + SCM from_same_octave = ly_assoc_get (scm_cons (scm_int2num (o), + scm_int2num (n)), sig, SCM_BOOL_F); + SCM from_key_signature = ly_assoc_get (scm_int2num (n), sig, SCM_BOOL_F); + SCM from_other_octaves = SCM_BOOL_F; + for (SCM s = sig ; scm_is_pair (s); s = scm_cdr (s)) { - accbarnum_i = ly_scm2int (ly_cddr (prev)); - prev = scm_cons (ly_car (prev), ly_cadr (prev)); + SCM entry = scm_car (s); + if (scm_is_pair (scm_car (entry)) + && scm_cdar (entry) == scm_int2num (n)) + from_other_octaves = scm_cdr (entry); } - /* If an accidental was not found or the accidental was too old */ - if (prev == SCM_BOOL_F || - (is_number (lazyness) && curbarnum_i > accbarnum_i + ly_scm2int (lazyness))) - prev = scm_assoc (scm_int2num (n), sig); - - SCM prev_acc = (prev == SCM_BOOL_F) ? scm_int2num (0) : ly_cdr (prev); - - int p = is_number (prev_acc) ? ly_scm2int (prev_acc) : 0; - - int num; - if (a == p && is_number (prev_acc)) - num = 0; - else if ( (abs (a)get_alteration (); + + if (alter == prev) + num = 0; + else if ((abs (alter) < abs (prev) || prev*alter < 0) && alter != 0) + num = 2; + *different = (alter != prev); + } return num; } static int number_accidentals (bool *different, - Pitch *pitch, Context * origin, - SCM accidentals, SCM curbarnum) + Pitch *pitch, Context *origin, + SCM accidentals, int bar_number) { int number = 0; *different = false; - if (ly_c_pair_p (accidentals) && !is_symbol (ly_car (accidentals))) + if (scm_is_pair (accidentals) && !scm_is_symbol (scm_car (accidentals))) warning (_f ("Accidental typesetting list must begin with context-name: %s", - ly_scm2string (ly_car (accidentals)).to_str0 ())); + ly_scm2string (scm_car (accidentals)).to_str0 ())); - for (; ly_c_pair_p (accidentals) && origin; accidentals = ly_cdr (accidentals)) + for (; scm_is_pair (accidentals) && origin; + accidentals = scm_cdr (accidentals)) { // If pair then it is a new accidentals typesetting rule to be checked - SCM rule = ly_car (accidentals); - if (ly_c_pair_p (rule)) + SCM rule = scm_car (accidentals); + if (scm_is_pair (rule)) { - SCM type = ly_car (rule); - SCM lazyness = ly_cdr (rule); + SCM type = scm_car (rule); + SCM laziness = scm_cdr (rule); SCM localsig = origin->get_property ("localKeySignature"); bool same_octave_b = - is_eq (ly_symbol2scm ("same-octave"), type); + scm_is_eq (ly_symbol2scm ("same-octave"), type); bool any_octave_b = - is_eq (ly_symbol2scm ("any-octave"), type); + scm_is_eq (ly_symbol2scm ("any-octave"), type); if (same_octave_b || any_octave_b) { bool d = false; int n = number_accidentals_from_sig - (&d, localsig, pitch, curbarnum, lazyness, any_octave_b); + (&d, localsig, pitch, bar_number, laziness, any_octave_b); *different = *different || d; number = max (number, n); } @@ -199,9 +272,9 @@ number_accidentals (bool *different, /* if symbol then it is a context name. Scan parent contexts to find it. */ - else if (is_symbol (rule)) + else if (scm_is_symbol (rule)) { - Context * dad = origin; + Context *dad = origin; while (dad && !dad->is_alias (rule)) dad = dad->get_parent_context (); @@ -215,18 +288,19 @@ number_accidentals (bool *different, return number; } -SCM -Accidental_engraver::get_bar_num () +int +Accidental_engraver::get_bar_number () { SCM barnum = get_property ("currentBarNumber"); SCM smp = get_property ("measurePosition"); - - Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0); - if (mp.main_part_ < Rational (0) - && is_number (barnum)) - barnum = scm_int2num (ly_scm2int (barnum) - 1); - - return barnum ; + + int bn = robust_scm2int (barnum, 0); + + Moment mp = robust_scm2moment (smp, Moment (0)); + if (mp.main_part_ < Rational (0)) + bn--; + + return bn; } void @@ -236,19 +310,19 @@ Accidental_engraver::process_acknowledged_grobs () { SCM accidentals = get_property ("autoAccidentals"); SCM cautionaries = get_property ("autoCautionaries"); - SCM barnum = get_bar_num (); + int barnum = get_bar_number (); bool extra_natural_b = get_property ("extraNatural") == SCM_BOOL_T; - for (int i = 0; i < accidentals_.size (); i++) + for (int i = 0; i < accidentals_.size (); i++) { if (accidentals_[i].done_ ) continue; accidentals_[i].done_ = true; - Grob * support = accidentals_[i].head_; - Music * note = accidentals_[i].melodic_; - Context * origin = accidentals_[i].origin_; + Grob *support = accidentals_[i].head_; + Music *note = accidentals_[i].melodic_; + Context *origin = accidentals_[i].origin_; - Pitch * pitch = unsmob_pitch (note->get_property ("pitch")); + Pitch *pitch = unsmob_pitch (note->get_property ("pitch")); if (!pitch) continue; @@ -287,34 +361,27 @@ Accidental_engraver::process_acknowledged_grobs () level, so that we get the property settings for Accidental from the respective Voice. */ - Grob * a = make_item_from_properties (origin, - ly_symbol2scm ("Accidental")); + Grob *a + = make_item_from_properties (accidentals_[i].origin_trans_, + ly_symbol2scm ("Accidental"), + note->self_scm (), + "Accidental" + ); a->set_parent (support, Y_AXIS); if (!accidental_placement_) - { - accidental_placement_ = make_item ("AccidentalPlacement"); - announce_grob (accidental_placement_, a->self_scm ()); - } - + accidental_placement_ = make_item ("AccidentalPlacement", + a->self_scm ()); Accidental_placement::add_accidental (accidental_placement_, a); - announce_grob (a, SCM_EOL); - - - SCM accs = scm_cons (scm_int2num (pitch->get_alteration ()), SCM_EOL); + SCM accs = scm_cons (scm_int2num (pitch->get_alteration ()), + SCM_EOL); if (num == 2 && extra_natural_b) accs = scm_cons (scm_int2num (0), accs); - /* TODO: - - add cautionary option in accidental. - */ + /* TODO: add cautionary option in accidental. */ if (cautionary) - { - a->set_property ("cautionary", SCM_BOOL_T); - } - + a->set_property ("cautionary", SCM_BOOL_T); support->set_property ("accidental-grob", a->self_scm ()); @@ -334,9 +401,6 @@ Accidental_engraver::process_acknowledged_grobs () } } - - - void Accidental_engraver::finalize () { @@ -346,18 +410,17 @@ Accidental_engraver::finalize () void Accidental_engraver::stop_translation_timestep () { - for (int j = ties_.size (); j --; ) + for (int j = ties_.size (); j--;) { - Grob * r = Tie::head (ties_[j], RIGHT); + Grob *r = Tie::head (ties_[j], RIGHT); for (int i = accidentals_.size (); i--;) if (accidentals_[i].head_ == r) { - if (Grob * g = accidentals_[i].accidental_) + if (Grob *g = accidentals_[i].accidental_) { g->set_property ("tie", ties_[j]->self_scm ()); - accidentals_[i].tied_ = true; + accidentals_[i].tied_ = true; } - ties_.del (j); break; } @@ -365,21 +428,22 @@ Accidental_engraver::stop_translation_timestep () for (int i = accidentals_.size (); i--;) { - SCM barnum = get_bar_num (); + int barnum = get_bar_number (); - Music * note = accidentals_[i].melodic_; + Music *note = accidentals_[i].melodic_; Context * origin = accidentals_[i].origin_; - Pitch * pitch = unsmob_pitch (note->get_property ("pitch")); + 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 (); - SCM on_s = scm_cons (scm_int2num (o), scm_int2num (n)); + SCM key = scm_cons (scm_int2num (o), scm_int2num (n)); - while (origin) + while (origin + && origin->where_defined (ly_symbol2scm ("localKeySignature"))) { /* huh? we set props all the way to the top? @@ -393,7 +457,7 @@ Accidental_engraver::stop_translation_timestep () that of the tied note and of the key signature. */ localsig = ly_assoc_front_x - (localsig, on_s, scm_cons (SCM_BOOL_T, barnum)); + (localsig, key, scm_cons (SCM_BOOL_T, scm_int2num (barnum))); change = true; } @@ -403,29 +467,20 @@ 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, on_s, scm_cons (scm_int2num (a), barnum)); - + localsig = ly_assoc_front_x (localsig, key, + scm_cons (scm_int2num (a), + scm_int2num (barnum))); change = true; } if (change) - origin->set_property ("localKeySignature", localsig); + origin->set_property ("localKeySignature", localsig); + origin = origin->get_parent_context (); } } - - for (int i = 0; i < accidentals_.size (); i++) - { - if (Grob *a = accidentals_[i].accidental_) - typeset_grob (a); - } - - if (accidental_placement_) - typeset_grob (accidental_placement_); accidental_placement_ = 0; - accidentals_.clear (); left_objects_.clear (); right_objects_.clear (); @@ -434,74 +489,66 @@ Accidental_engraver::stop_translation_timestep () void Accidental_engraver::acknowledge_grob (Grob_info info) { - Music * note = info.music_cause (); + Music *note = info.music_cause (); if (note && note->is_mus_type ("note-event") && Rhythmic_head::has_interface (info.grob_)) { if (to_boolean ( get_property ("harmonicAccidentals")) - || !is_equal (info.grob_->get_property ("style"), + || !ly_c_equal_p (info.grob_->get_property ("style"), ly_symbol2scm ("harmonic"))) { Accidental_entry entry ; entry.head_ = info.grob_; - entry.origin_ = info.origin_trans_->get_parent_context (); + entry.origin_trans_ = dynamic_cast (info.origin_trans_); + entry.origin_ = info.origin_trans_->context (); entry.melodic_ = note; accidentals_.push (entry); } } else if (Tie::has_interface (info.grob_)) - { - ties_.push (dynamic_cast (info.grob_)); - } + ties_.push (dynamic_cast (info.grob_)); else if (Arpeggio::has_interface (info.grob_)) - { - left_objects_.push (info.grob_); - } - else if (info.grob_->internal_has_interface (ly_symbol2scm ("finger-interface"))) - { - left_objects_.push (info.grob_); - } + left_objects_.push (info.grob_); + else if (info.grob_ + ->internal_has_interface (ly_symbol2scm ("finger-interface"))) + left_objects_.push (info.grob_); } void Accidental_engraver::process_music () { SCM sig = get_property ("keySignature"); - /* Detect key sig changes. - Update all parents and children - */ + Update all parents and children. */ if (last_keysig_ != sig) - { - Context * trans_ = get_parent_context (); - while (trans_) - { - trans_ -> set_property ("localKeySignature", ly_deep_copy (sig)); - trans_ = trans_->get_parent_context (); - } - set_property_on_children (get_parent_context (),"localKeySignature", sig); - - last_keysig_ = sig; - } + update_local_key_signature (); } - - - - -ENTER_DESCRIPTION (Accidental_engraver, - "Make accidentals. Catches note heads, ties and notices key-change " - "events. This engraver usually lives at Staff level, but " +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", - "", - "finger-interface rhythmic-head-interface tie-interface arpeggio-interface", - "localKeySignature harmonicAccidentals extraNatural autoAccidentals autoCautionaries", - "localKeySignature"); + "Accidental" + , + "" + , + "arpeggio-interface " + "finger-interface " + "rhythmic-head-interface " + "tie-interface " + , + "autoAccidentals " + "autoCautionaries " + "extraNatural " + "harmonicAccidentals " + "localKeySignature" + , + "localKeySignature" + );