X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-engraver.cc;h=803fa1a5248ab04fe13e4c22991ad6a40e0f5172;hb=1b9fc29140bd1d9345f784595afd22158876dfb7;hp=6ee866df9b289a778f13b5985f60891cc88015a4;hpb=b1a2da9808d72008166aec4c7af9f923ca38064b;p=lilypond.git diff --git a/lily/accidental-engraver.cc b/lily/accidental-engraver.cc index 6ee866df9b..803fa1a524 100644 --- a/lily/accidental-engraver.cc +++ b/lily/accidental-engraver.cc @@ -5,15 +5,13 @@ Modified 2001-2002 by Rune Zedeler */ -#include "musical-request.hh" -#include "command-request.hh" -#include "local-key-item.hh" +#include "request.hh" + #include "item.hh" #include "tie.hh" #include "rhythmic-head.hh" #include "engraver-group-engraver.hh" - -#include "staff-symbol-referencer.hh" +#include "accidental-placement.hh" #include "side-position-interface.hh" #include "engraver.hh" #include "arpeggio.hh" @@ -32,16 +30,32 @@ tweakable. */ +struct Accidental_entry { + bool done_; + Music * melodic_; + Grob * accidental_; + Translator_group *origin_; + Grob* head_; + Accidental_entry(); +}; + +Accidental_entry::Accidental_entry() +{ + done_ = false; + melodic_ =0; + accidental_ = 0; + origin_ = 0; + head_ = 0; +} struct Accidental_engraver : Engraver { - Item *key_item_p_; protected: TRANSLATOR_DECLARATIONS (Accidental_engraver); virtual void process_music (); virtual void acknowledge_grob (Grob_info); virtual void stop_translation_timestep (); virtual void initialize (); - virtual void create_grobs (); + virtual void process_acknowledged_grobs (); virtual void finalize (); public: @@ -50,8 +64,6 @@ public: This is not a property, and it is not protected. This poses a very small risk of the value being GC'd from under us. - - Oh well. */ SCM last_keysig_; @@ -60,19 +72,33 @@ public: store all information before we can really create the accidentals. */ Link_array arpeggios_; + + Grob * accidental_placement_; + + + /* + The next + */ + Array accidentals_; - Link_array mel_l_arr_; - Link_array head_l_arr_; - Link_array forced_l_arr_; - Link_array tie_l_arr_; - Link_array origin_l_arr_; + Link_array ties_; + }; +static void set_property_on_children (Translator_group * trans, const char * sym, SCM val) +{ + trans->set_property (sym, val); + for (SCM p = trans -> trans_group_list_; gh_pair_p (p); p = ly_cdr(p)) { + Translator_group *trg = dynamic_cast (unsmob_translator (ly_car (p))); + set_property_on_children(trg,sym,ly_deep_copy(val)); + } +} + Accidental_engraver::Accidental_engraver () { - key_item_p_ = 0; + accidental_placement_ = 0; last_keysig_ = SCM_EOL; } @@ -81,13 +107,13 @@ Accidental_engraver::initialize () { last_keysig_ = get_property ("keySignature"); - Translator_group * trans_ = daddy_trans_l_; + Translator_group * trans_ = daddy_trans_; while (trans_) { trans_ -> set_property ("localKeySignature", ly_deep_copy (last_keysig_)); - trans_ = trans_->daddy_trans_l_; + trans_ = trans_->daddy_trans_; } - daddy_trans_l_->set_children_property ("localKeySignature", last_keysig_); + set_property_on_children (daddy_trans_,"localKeySignature", last_keysig_); } /* @@ -99,21 +125,20 @@ calculates the number of accidentals on basis of the current local key sig */ static int -number_accidentals (SCM sig, Note_req * note_l, SCM curbarnum, SCM lazyness, +number_accidentals (SCM sig, Music * note, Pitch *pitch, SCM curbarnum, SCM lazyness, bool ignore_octave_b) { - Pitch *pitch = unsmob_pitch (note_l->get_mus_property ("pitch")); - int n = pitch->notename_i_; - int o = pitch->octave_i_; - int a = pitch->alteration_i_; + int n = pitch->notename_; + int o = pitch->octave_; + int a = pitch->alteration_; int curbarnum_i = gh_scm2int (curbarnum); int accbarnum_i = 0; SCM prev; if (ignore_octave_b) - prev = ly_assoc_cdr (gh_int2scm (n), sig); + prev = ly_assoc_cdr (scm_int2num (n), sig); else - prev = gh_assoc (gh_cons (gh_int2scm (o), gh_int2scm (n)), sig); + prev = gh_assoc (gh_cons (scm_int2num (o), scm_int2num (n)), sig); /* should really be true unless prev == SCM_BOOL_F */ if (gh_pair_p (prev) && gh_pair_p (ly_cdr (prev))) @@ -125,16 +150,16 @@ number_accidentals (SCM sig, Note_req * note_l, SCM curbarnum, SCM lazyness, /* If an accidental was not found or the accidental was too old */ if (prev == SCM_BOOL_F || (gh_number_p (lazyness) && curbarnum_i > accbarnum_i + gh_scm2int (lazyness))) - prev = gh_assoc (gh_int2scm (n), sig); + prev = gh_assoc (scm_int2num (n), sig); - SCM prev_acc = (prev == SCM_BOOL_F) ? gh_int2scm (0) : ly_cdr (prev); + SCM prev_acc = (prev == SCM_BOOL_F) ? scm_int2num (0) : ly_cdr (prev); int p = gh_number_p (prev_acc) ? gh_scm2int (prev_acc) : 0; int num; if (a == p - && !to_boolean (note_l->get_mus_property ("force-accidental")) + && !to_boolean (note->get_mus_property ("force-accidental")) && gh_number_p (prev_acc)) num = 0; else if ( (abs (a)get_property ("localKeySignature"); + SCM localsig = origin->get_property ("localKeySignature"); bool same_octave_b = gh_eq_p (ly_symbol2scm ("same-octave"), type); @@ -173,13 +198,13 @@ number_accidentals (Note_req * note_l, Translator_group * origin_l, if (same_octave_b || any_octave_b) { int n = number_accidentals - (localsig, note_l, curbarnum, lazyness, any_octave_b); + (localsig, note, pitch, curbarnum, lazyness, any_octave_b); diff = diff || (n < 0); number = max (number, abs (n)); } else warning (_f ("unknown accidental typesetting: %s. Ignored", - ly_symbol2string (type).ch_C ())); + ly_symbol2string (type).to_str0 ())); } @@ -190,15 +215,15 @@ number_accidentals (Note_req * note_l, Translator_group * origin_l, { String context = ly_symbol2string (ly_car (accidentals)); - while (origin_l && !origin_l->is_alias_b (context)) - origin_l = origin_l->daddy_trans_l_; + while (origin && !origin->is_alias_b (context)) + origin = origin->daddy_trans_; - if (!origin_l) + if (!origin) warning (_f ("Symbol is not a parent context: %s. Ignored", - context.ch_C ())); + context.to_str0 ())); } else warning (_f ("Accidental typesetting must be pair or context-name: %s", - ly_scm2string (ly_car (accidentals)).ch_C ())); + ly_scm2string (ly_car (accidentals)).to_str0 ())); accidentals = ly_cdr (accidentals); } @@ -206,27 +231,33 @@ number_accidentals (Note_req * note_l, Translator_group * origin_l, } void -Accidental_engraver::create_grobs () +Accidental_engraver::process_acknowledged_grobs () { - if (!key_item_p_ && mel_l_arr_.size ()) + if (accidentals_.size () && !accidentals_.top().done_) { //SCM localsig = get_property ("localKeySignature"); SCM accidentals = get_property ("autoAccidentals"); SCM cautionaries = get_property ("autoCautionaries"); SCM barnum = get_property ("currentBarNumber"); - + SCM smp = get_property("measurePosition"); + Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0); + if(mp<0 && gh_number_p(barnum)) barnum = scm_int2num(gh_scm2int(barnum)-1); bool extra_natural_b = get_property ("extraNatural") == SCM_BOOL_T; - for (int i = 0; i < mel_l_arr_.size (); i++) + for (int i = 0; i < accidentals_.size (); i++) { - Grob * support_l = head_l_arr_[i]; - Note_req * note_l = mel_l_arr_[i]; - Translator_group * origin_l = origin_l_arr_[i]; - - int num = number_accidentals (note_l, origin_l, accidentals, barnum); - int num_caut = number_accidentals (note_l, origin_l, cautionaries, barnum); - bool cautionary = to_boolean (note_l->get_mus_property ("cautionary")); + if (accidentals_[i].done_ ) + continue; + accidentals_[i].done_ = true; + Grob * support = accidentals_[i].head_; + Music * note = accidentals_[i].melodic_; + Translator_group * origin = accidentals_[i].origin_; + + Pitch * pitch = unsmob_pitch (note->get_mus_property ("pitch")); + int num = number_accidentals (note, pitch, origin, accidentals, barnum); + int num_caut = number_accidentals (note, pitch, origin, cautionaries, barnum); + bool cautionary = to_boolean (note->get_mus_property ("cautionary")); - if (abs (num_caut)>abs (num)) + if (abs (num_caut) > abs (num)) { num = num_caut; cautionary = true; @@ -241,8 +272,8 @@ Accidental_engraver::create_grobs () Grob *tie_break_reminder = 0; bool tie_changes = false; - for (int j = 0; j < tie_l_arr_.size (); j++) - if (support_l == Tie::head (tie_l_arr_[j], RIGHT)) + for (int j = 0; j < ties_.size (); j++) + if (support == Tie::head (ties_[j], RIGHT)) { tie_changes = different; @@ -253,31 +284,57 @@ Accidental_engraver::create_grobs () Maybe check property noTieBreakForceAccidental? */ if (different) - tie_break_reminder = tie_l_arr_[j]; + tie_break_reminder = ties_[j]; break; } if (num) { - if (!key_item_p_) - { - key_item_p_ = new Item (get_property ("Accidentals")); + Grob * a = new Item (get_property ("Accidental")); + a->set_parent (support, Y_AXIS); - SCM c0 = get_property ("centralCPosition"); - if (gh_number_p (c0)) - Staff_symbol_referencer::set_position (key_item_p_, gh_scm2int (c0)); - - announce_grob (key_item_p_, SCM_EOL); + if (!accidental_placement_) + { + accidental_placement_ = new Item (get_property ("AccidentalPlacement")); + announce_grob (accidental_placement_, a->self_scm()); } + + Accidental_placement::add_accidental (accidental_placement_, a); + announce_grob (a, SCM_EOL); - Local_key_item::add_pitch (key_item_p_, *unsmob_pitch (note_l->get_mus_property ("pitch")), - cautionary, - num == 2 && extra_natural_b, - tie_break_reminder); - Side_position_interface::add_support (key_item_p_, support_l); + SCM accs = gh_cons (scm_int2num (pitch->alteration_), SCM_EOL); + if (num == 2 && extra_natural_b) + accs = gh_cons (scm_int2num (0), accs); + + /* TODO: + + add cautionary option in accidental. + */ + + if (cautionary) + { + a->set_grob_property ("cautionary", SCM_BOOL_T); + } + + if (tie_break_reminder) + { + // TODO. + a->set_grob_property ("tie", tie_break_reminder->self_scm()); + } - support_l->set_grob_property ("accidentals-grob", key_item_p_->self_scm ()); + + support->set_grob_property ("accidental-grob", a->self_scm ()); + + a->set_grob_property ("accidentals", accs); + accidentals_[i].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 < arpeggios_.size (); i++) + Side_position_interface::add_support (arpeggios_[i], a); } @@ -289,11 +346,11 @@ Accidental_engraver::create_grobs () always do the correct thing? */ - Pitch *pitch = unsmob_pitch (note_l->get_mus_property ("pitch")); - int n = pitch->notename_i_; - int o = pitch->octave_i_; - int a = pitch->alteration_i_; - SCM on_s = gh_cons (gh_int2scm (o), gh_int2scm (n)); + + int n = pitch->notename_; + int o = pitch->octave_; + int a = pitch->alteration_; + SCM on_s = gh_cons (scm_int2num (o), scm_int2num (n)); /* TODO: Speed this up! @@ -312,10 +369,10 @@ Accidental_engraver::create_grobs () */ - Translator_group * trans_ = origin_l_arr_[i]; - while (trans_) + + while (origin) { - SCM localsig = trans_->get_property ("localKeySignature"); + SCM localsig = origin->get_property ("localKeySignature"); if (tie_changes) { /* @@ -332,27 +389,13 @@ Accidental_engraver::create_grobs () noteheads with the same notename. */ localsig = ly_assoc_front_x - (localsig, on_s, gh_cons (gh_int2scm (a), barnum)); + (localsig, on_s, gh_cons (scm_int2num (a), barnum)); } - trans_->set_property ("localKeySignature", localsig); - trans_ = trans_->daddy_trans_l_; + origin->set_property ("localKeySignature", localsig); + origin = origin->daddy_trans_; } } } - - - if (key_item_p_) - { - /* - We add the accidentals to the support of the arpeggio, so it is put left of the - accidentals. - - */ - for (int i = 0; i < arpeggios_.size (); i++) - Side_position_interface::add_support (arpeggios_[i], key_item_p_); - - arpeggios_.clear (); - } } void @@ -364,42 +407,47 @@ Accidental_engraver::finalize () void Accidental_engraver::stop_translation_timestep () { - if (key_item_p_) + for (int i = 0; i < accidentals_.size(); i++) { - for (int i = 0; i < head_l_arr_.size (); i++) - Side_position_interface::add_support (key_item_p_, head_l_arr_[i]); - - typeset_grob (key_item_p_); - key_item_p_ = 0; + Grob *a = accidentals_[i].accidental_; + if (a) + { + typeset_grob (a); + } } - - mel_l_arr_.clear (); + if (accidental_placement_) + typeset_grob(accidental_placement_); + accidental_placement_ = 00; + + accidentals_.clear(); arpeggios_.clear (); - tie_l_arr_.clear (); - head_l_arr_.clear (); - forced_l_arr_.clear (); - origin_l_arr_.clear (); + ties_.clear (); } void Accidental_engraver::acknowledge_grob (Grob_info info) { - Note_req * note_l = dynamic_cast (info.music_cause ()); + Music * note = info.music_cause (); - if (note_l && Rhythmic_head::has_interface (info.grob_l_)) + if (note + && note->is_mus_type("note-event") + && Rhythmic_head::has_interface (info.grob_)) { - mel_l_arr_.push (note_l); - head_l_arr_.push (info.grob_l_); - origin_l_arr_.push (info.origin_trans_l_->daddy_trans_l_); + Accidental_entry entry ; + entry.head_ = info.grob_; + entry.origin_ = info.origin_trans_->daddy_trans_; + entry.melodic_ = note; + + accidentals_.push (entry); } - else if (Tie::has_interface (info.grob_l_)) + else if (Tie::has_interface (info.grob_)) { - tie_l_arr_.push (info.grob_l_); + ties_.push (info.grob_); } - else if (Arpeggio::has_interface (info.grob_l_)) + else if (Arpeggio::has_interface (info.grob_)) { - arpeggios_.push (info.grob_l_); + arpeggios_.push (info.grob_); } } @@ -414,13 +462,13 @@ Accidental_engraver::process_music () */ if (last_keysig_ != sig) { - Translator_group * trans_ = daddy_trans_l_; + Translator_group * trans_ = daddy_trans_; while (trans_) { trans_ -> set_property ("localKeySignature", ly_deep_copy (sig)); - trans_ = trans_->daddy_trans_l_; + trans_ = trans_->daddy_trans_; } - daddy_trans_l_->set_children_property ("localKeySignature", sig); + set_property_on_children(daddy_trans_,"localKeySignature", sig); last_keysig_ = sig; } @@ -435,7 +483,8 @@ ENTER_DESCRIPTION (Accidental_engraver, events. Due to interaction with ties (which don't come together with note heads), this needs to be in a context higher than Tie_engraver.", - "Accidentals", + "Accidental", +/* accepts */ "", "rhythmic-head-interface tie-interface arpeggio-interface", "localKeySignature extraNatural autoAccidentals autoCautionaries", "localKeySignature");