X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-engraver.cc;h=fc462faffab9215e244dd389afdf88d35351a33b;hb=b89ed23afd3df22f7160ac798ed185f42cb173b2;hp=64965254d084cea85463419263cd4418631842ed;hpb=58bcc84c9480dae1b21bc24d8396b91fe19e0131;p=lilypond.git diff --git a/lily/accidental-engraver.cc b/lily/accidental-engraver.cc index 64965254d0..fc462faffa 100644 --- a/lily/accidental-engraver.cc +++ b/lily/accidental-engraver.cc @@ -3,7 +3,7 @@ source file of the GNU LilyPond music typesetter - (c) 1997--2005 Han-Wen Nienhuys + (c) 1997--2006 Han-Wen Nienhuys Modified 2001--2002 by Rune Zedeler */ @@ -11,20 +11,25 @@ #include "arpeggio.hh" #include "context.hh" #include "engraver.hh" +#include "international.hh" +#include "pitch.hh" #include "protected-scm.hh" #include "rhythmic-head.hh" #include "side-position-interface.hh" +#include "stream-event.hh" #include "tie.hh" #include "warn.hh" +#include "translator.icc" + class Accidental_entry { public: bool done_; - Music *melodic_; + Stream_event *melodic_; Grob *accidental_; Context *origin_; - Engraver *origin_trans_; + Engraver *origin_engraver_; Grob *head_; bool tied_; @@ -43,33 +48,42 @@ Accidental_entry::Accidental_entry () class Accidental_engraver : public Engraver { -public: int get_bar_number (); void update_local_key_signature (); + void create_accidental (Accidental_entry *entry, bool, bool); + Grob *make_standard_accidental (Stream_event *note, Grob *note_head, Engraver *trans); + Grob *make_suggested_accidental (Stream_event *note, Grob *note_head, Engraver *trans); protected: TRANSLATOR_DECLARATIONS (Accidental_engraver); - virtual void process_music (); - virtual void acknowledge_grob (Grob_info); - virtual void stop_translation_timestep (); + void process_music (); + + void acknowledge_tie (Grob_info); + void acknowledge_arpeggio (Grob_info); + void acknowledge_rhythmic_head (Grob_info); + void acknowledge_finger (Grob_info); + + void stop_translation_timestep (); virtual void initialize (); - virtual void process_acknowledged_grobs (); + void process_acknowledged (); virtual void finalize (); - 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_; + /* + 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_; Grob *accidental_placement_; - Array accidentals_; - Link_array ties_; + vector accidentals_; + vector ties_; }; /* @@ -81,16 +95,6 @@ public: those. */ -static void -set_property_on_children (Context *trans, char const *sym, SCM val) -{ - 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 (scm_car (p)); - set_property_on_children (trg, sym, ly_deep_copy (val)); - } -} Accidental_engraver::Accidental_engraver () { @@ -108,12 +112,16 @@ void Accidental_engraver::update_local_key_signature () { last_keysig_ = get_property ("keySignature"); - set_property_on_children (context (), "localKeySignature", last_keysig_); + set_context_property_on_children (context (), + ly_symbol2scm ("localKeySignature"), + last_keysig_); Context *trans = context ()->get_parent_context (); /* Huh. Don't understand what this is good for. --hwn. */ - while (trans && trans->where_defined (ly_symbol2scm ("localKeySignature"))) + + SCM val; + while (trans && trans->where_defined (ly_symbol2scm ("localKeySignature"), &val)) { trans->set_property ("localKeySignature", ly_deep_copy (last_keysig_)); trans = trans->get_parent_context (); @@ -175,33 +183,27 @@ number_accidentals_from_sig (bool *different, SCM sig, Pitch *pitch, SCM previous_alteration = SCM_BOOL_F; - 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_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_other_octaves = SCM_BOOL_F; for (SCM s = sig; scm_is_pair (s); s = scm_cdr (s)) { SCM entry = scm_car (s); if (scm_is_pair (scm_car (entry)) - && scm_cdar (entry) == scm_int2num (n)) + && scm_cdar (entry) == scm_from_int (n)) from_other_octaves = scm_cdr (entry); } if (from_same_octave != SCM_BOOL_F && recent_enough (bar_number, from_same_octave, laziness)) - { - previous_alteration = from_same_octave; - } + previous_alteration = from_same_octave; else if (ignore_octave && from_other_octaves != SCM_BOOL_F && recent_enough (bar_number, from_other_octaves, laziness)) - { - previous_alteration = from_other_octaves; - } + previous_alteration = from_other_octaves; else if (from_key_signature != SCM_BOOL_F) - { - previous_alteration = from_key_signature; - } + previous_alteration = from_key_signature; int num = 1; if (is_tied (previous_alteration)) @@ -216,7 +218,8 @@ number_accidentals_from_sig (bool *different, SCM sig, Pitch *pitch, if (alter == prev) num = 0; - else if ((abs (alter) < abs (prev) || prev*alter < 0) && alter != 0) + else if ((abs (alter) < abs (prev) + || prev * alter < 0) && alter != 0) num = 2; *different = (alter != prev); } @@ -232,8 +235,8 @@ number_accidentals (bool *different, *different = false; if (scm_is_pair (accidentals) && !scm_is_symbol (scm_car (accidentals))) - warning (_f ("Accidental typesetting list must begin with context-name: %s", - ly_scm2string (scm_car (accidentals)).to_str0 ())); + warning (_f ("accidental typesetting list must begin with context-name: %s", + ly_scm2string (scm_car (accidentals)).c_str ())); for (; scm_is_pair (accidentals) && origin; accidentals = scm_cdr (accidentals)) @@ -261,12 +264,11 @@ number_accidentals (bool *different, } else warning (_f ("ignoring unknown accidental: %s", - ly_symbol2string (type).to_str0 ())); + ly_symbol2string (type).c_str ())); } - /* - if symbol then it is a context name. Scan parent contexts to find it. - */ + /* if symbol then it is a context name. Scan parent contexts to + find it. */ else if (scm_is_symbol (rule)) { Context *dad = origin; @@ -276,8 +278,9 @@ number_accidentals (bool *different, if (dad) origin = dad; } - else warning (_f ("Accidental rule must be pair or context-name; Found %s", - ly_scm2string (rule).to_str0 ())); + else + warning (_f ("pair or context-name expected for accidental rule, found %s", + ly_scm2string (rule).c_str ())); } return number; @@ -286,7 +289,7 @@ number_accidentals (bool *different, int Accidental_engraver::get_bar_number () { - SCM barnum = get_property ("currentBarNumber"); + SCM barnum = get_property ("internalBarNumber"); SCM smp = get_property ("measurePosition"); int bn = robust_scm2int (barnum, 0); @@ -299,22 +302,21 @@ Accidental_engraver::get_bar_number () } void -Accidental_engraver::process_acknowledged_grobs () +Accidental_engraver::process_acknowledged () { - if (accidentals_.size () && !accidentals_.top ().done_) + if (accidentals_.size () && !accidentals_.back ().done_) { SCM accidentals = get_property ("autoAccidentals"); SCM cautionaries = get_property ("autoCautionaries"); int barnum = get_bar_number (); - bool extra_natural_b = get_property ("extraNatural") == SCM_BOOL_T; - for (int i = 0; i < accidentals_.size (); i++) + for (vsize 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_; + + Stream_event *note = accidentals_[i].melodic_; Context *origin = accidentals_[i].origin_; Pitch *pitch = unsmob_pitch (note->get_property ("pitch")); @@ -331,8 +333,8 @@ Accidental_engraver::process_acknowledged_grobs () pitch, origin, cautionaries, barnum); - bool cautionary = to_boolean (note->get_property ("cautionary")); + bool cautionary = to_boolean (note->get_property ("cautionary")); if (num_caut > num) { num = num_caut; @@ -340,58 +342,111 @@ Accidental_engraver::process_acknowledged_grobs () cautionary = true; } - if (num == 0 && to_boolean (note->get_property ("force-accidental"))) + bool forced = to_boolean (note->get_property ("force-accidental")); + if (num == 0 && forced) num = 1; - /* - Can not look for ties: it's not guaranteed that they reach - us before the notes - */ + /* 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 (num) - { - /* - We construct the accidentals at the originating Voice - level, so that we get the property settings for - Accidental from the respective Voice. - */ - 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", - a->self_scm ()); - Accidental_placement::add_accidental (accidental_placement_, a); - SCM accs = scm_cons (scm_int2num (pitch->get_alteration ()), - SCM_EOL); - if (num == 2 && extra_natural_b) - accs = scm_cons (scm_int2num (0), accs); + if (forced || cautionary) + accidentals_[i].accidental_->set_property ("forced", SCM_BOOL_T); + } + } +} - /* TODO: add cautionary option in accidental. */ +void +Accidental_engraver::create_accidental (Accidental_entry *entry, + bool restore_natural, + bool cautionary) +{ + 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_); - if (cautionary) - a->set_property ("cautionary", SCM_BOOL_T); + 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); + } - support->set_property ("accidental-grob", a->self_scm ()); + /* TODO: add cautionary option in accidental. */ + if (cautionary) + a->set_property ("cautionary", SCM_BOOL_T); - a->set_property ("accidentals", accs); - accidentals_[i].accidental_ = a; + a->set_property ("accidentals", accs); + entry->accidental_ = a; +} - /* - We add the accidentals to the support of the arpeggio, - so it is put left of the accidentals. - */ - for (int i = 0; i < left_objects_.size (); i++) - Side_position_interface::add_support (left_objects_[i], a); - for (int i = 0; i < right_objects_.size (); i++) - Side_position_interface::add_support (a, right_objects_[i]); - } - } +Grob * +Accidental_engraver::make_standard_accidental (Stream_event *note, + Grob *note_head, + Engraver *trans) +{ + + (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 ()); + + /* + We add the accidentals to the support of the arpeggio, + so it is put left of the accidentals. + */ + for (vsize i = 0; i < left_objects_.size (); i++) + { + if (left_objects_[i]->get_property ("side-axis") == scm_from_int (X_AXIS)) + 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]); + + a->set_parent (note_head, Y_AXIS); + + if (!accidental_placement_) + accidental_placement_ = make_item ("AccidentalPlacement", + a->self_scm ()); + Accidental_placement::add_accidental (accidental_placement_, a); + + note_head->set_object ("accidental-grob", a->self_scm ()); + + return a; +} + +Grob * +Accidental_engraver::make_suggested_accidental (Stream_event *note, + Grob *note_head, + Engraver *trans) +{ + (void) note; + Grob *a = trans->make_item ("AccidentalSuggestion", note_head->self_scm ()); + + Side_position_interface::add_support (a, note_head); + if (Grob *stem = unsmob_grob (a->get_object ("stem"))) + Side_position_interface::add_support (a, stem); + + a->set_parent (note_head, X_AXIS); + return a; } void @@ -403,27 +458,27 @@ Accidental_engraver::finalize () void Accidental_engraver::stop_translation_timestep () { - for (int j = ties_.size (); j--;) + for (vsize j = ties_.size (); j--;) { Grob *r = Tie::head (ties_[j], RIGHT); - for (int i = accidentals_.size (); i--;) + for (vsize i = accidentals_.size (); i--;) if (accidentals_[i].head_ == r) { if (Grob *g = accidentals_[i].accidental_) { - g->set_property ("tie", ties_[j]->self_scm ()); + g->set_object ("tie", ties_[j]->self_scm ()); accidentals_[i].tied_ = true; } - ties_.del (j); + ties_.erase (ties_.begin () + j); break; } } - for (int i = accidentals_.size (); i--;) + for (vsize i = accidentals_.size (); i--;) { int barnum = get_bar_number (); - Music *note = accidentals_[i].melodic_; + Stream_event *note = accidentals_[i].melodic_; Context *origin = accidentals_[i].origin_; Pitch *pitch = unsmob_pitch (note->get_property ("pitch")); @@ -433,15 +488,12 @@ Accidental_engraver::stop_translation_timestep () int n = pitch->get_notename (); int o = pitch->get_octave (); int a = pitch->get_alteration (); - SCM key = scm_cons (scm_int2num (o), scm_int2num (n)); + SCM key = scm_cons (scm_from_int (o), scm_from_int (n)); + SCM localsig = SCM_EOL; while (origin - && origin->where_defined (ly_symbol2scm ("localKeySignature"))) + && origin->where_defined (ly_symbol2scm ("localKeySignature"), &localsig)) { - /* - huh? we set props all the way to the top? - */ - SCM localsig = origin->get_property ("localKeySignature"); bool change = false; if (accidentals_[i].tied_) { @@ -450,7 +502,7 @@ Accidental_engraver::stop_translation_timestep () that of the tied note and of the key signature. */ localsig = ly_assoc_front_x - (localsig, key, scm_cons (SCM_BOOL_T, scm_int2num (barnum))); + (localsig, key, scm_cons (SCM_BOOL_T, scm_from_int (barnum))); change = true; } @@ -461,8 +513,8 @@ Accidental_engraver::stop_translation_timestep () noteheads with the same notename. */ localsig = ly_assoc_front_x (localsig, key, - scm_cons (scm_int2num (a), - scm_int2num (barnum))); + scm_cons (scm_from_int (a), + scm_from_int (barnum))); change = true; } @@ -480,35 +532,47 @@ Accidental_engraver::stop_translation_timestep () } void -Accidental_engraver::acknowledge_grob (Grob_info info) +Accidental_engraver::acknowledge_rhythmic_head (Grob_info info) { - Music *note = info.music_cause (); - + Stream_event *note = info.event_cause (); if (note - && note->is_mus_type ("note-event") - && Rhythmic_head::has_interface (info.grob_)) + && (note->in_event_class ("note-event") + || note->in_event_class ("trill-span-event"))) { + /* + string harmonics usually don't have accidentals. + */ if (to_boolean (get_property ("harmonicAccidentals")) - || !ly_c_equal_p (info.grob_->get_property ("style"), - ly_symbol2scm ("harmonic"))) + || !ly_is_equal (info.grob ()->get_property ("style"), + ly_symbol2scm ("harmonic"))) { - Accidental_entry entry; - entry.head_ = info.grob_; - entry.origin_trans_ = dynamic_cast (info.origin_trans_); - entry.origin_ = info.origin_trans_->context (); + entry.head_ = info.grob (); + entry.origin_engraver_ = dynamic_cast (info.origin_translator ()); + entry.origin_ = entry.origin_engraver_->context (); entry.melodic_ = note; - accidentals_.push (entry); + accidentals_.push_back (entry); } } - else if (Tie::has_interface (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_); +} + +void +Accidental_engraver::acknowledge_tie (Grob_info info) +{ + ties_.push_back (dynamic_cast (info.grob ())); +} + +void +Accidental_engraver::acknowledge_arpeggio (Grob_info info) +{ + left_objects_.push_back (info.grob ()); +} + +void +Accidental_engraver::acknowledge_finger (Grob_info info) +{ + left_objects_.push_back (info.grob ()); } void @@ -521,20 +585,23 @@ Accidental_engraver::process_music () update_local_key_signature (); } +ADD_ACKNOWLEDGER (Accidental_engraver, arpeggio); +ADD_ACKNOWLEDGER (Accidental_engraver, finger); +ADD_ACKNOWLEDGER (Accidental_engraver, rhythmic_head); +ADD_ACKNOWLEDGER (Accidental_engraver, tie); + 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", - "", - "arpeggio-interface " - "finger-interface " - "rhythmic-head-interface " - "tie-interface ", + "Accidental AccidentalSuggestion", + "autoAccidentals " "autoCautionaries " + "internalBarNumber " "extraNatural " "harmonicAccidentals " "localKeySignature",