X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-engraver.cc;h=4a59aced625c4365f046b0197a54e3683aae4109;hb=fe6b181832f78629fc2285dc1d23dccc7373e9ec;hp=65b83a1b611ca39563e546f1102286229a61d83e;hpb=af9078fd6d63dea5141e87a1b4d7cb5b0bcba84a;p=lilypond.git diff --git a/lily/accidental-engraver.cc b/lily/accidental-engraver.cc index 65b83a1b61..4a59aced62 100644 --- a/lily/accidental-engraver.cc +++ b/lily/accidental-engraver.cc @@ -1,325 +1,558 @@ /* accidental-engraver.cc -- implement accidental_engraver - (c) 1997--2001 Han-Wen Nienhuys - Modified 2001 by Rune Zedeler + source file of the GNU LilyPond music typesetter + + (c) 1997--2004 Han-Wen Nienhuys + Modified 2001--2002 by Rune Zedeler */ -#include "musical-request.hh" -#include "command-request.hh" -#include "local-key-item.hh" +#include "accidental-placement.hh" +#include "arpeggio.hh" +#include "context.hh" +#include "engraver.hh" +#include "event.hh" #include "item.hh" -#include "tie.hh" +#include "protected-scm.hh" #include "rhythmic-head.hh" -#include "timing-translator.hh" -#include "engraver-group-engraver.hh" - -#include "staff-symbol-referencer.hh" #include "side-position-interface.hh" -#include "engraver.hh" -#include "arpeggio.hh" - -/** - +#include "spanner.hh" +#include "tie.hh" +#include "warn.hh" - FIXME: should not compute vertical positioning of accidentals, but - get them from the noteheads - The algorithm for accidentals should be documented, and made - tweakable. +class Accidental_entry +{ +public: + bool done_; + Music *melodic_; + Grob *accidental_; + Context *origin_; + Engraver *origin_trans_; + Grob *head_; + bool tied_; + + Accidental_entry (); +}; -*/ +Accidental_entry::Accidental_entry () +{ + tied_ = false; + done_ = false; + melodic_ = 0; + accidental_ = 0; + origin_ = 0; + head_ = 0; +} +class Accidental_engraver : public Engraver +{ +public: + int get_bar_number (); + void update_local_key_signature (); -struct Accidental_engraver : Engraver { - Item *key_item_p_; protected: - TRANSLATOR_DECLARATIONS(Accidental_engraver); + 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: - - // todo -> property - 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. - */ - Link_array arpeggios_; + virtual void derived_mark () const; +public: + SCM last_keysig_; // ugh. - Link_array mel_l_arr_; - Link_array support_l_arr_; - Link_array forced_l_arr_; - Link_array tie_l_arr_; + /* 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_; + + Array accidentals_; + Link_array ties_; }; + +/* + 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, 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 () { - key_item_p_ =0; + accidental_placement_ = 0; last_keysig_ = SCM_EOL; } 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"); - daddy_trans_l_->set_property ("localKeySignature", last_keysig_); - daddy_trans_l_->set_property ("lazyKeySignature", last_keysig_); + set_property_on_children (context (), "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"))) + { + 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) + + * 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 +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); } -/** calculates the number of accidentals on basis of the current local key sig - * (passed as argument). - * Returns number of accidentals (0, 1 or 2). - * Negative (-1 or -2) if accidental has changed. - **/ static int -number_accidentals (SCM sig, Note_req * note_l) +number_accidentals_from_sig (bool *different, SCM sig, Pitch *pitch, + int bar_number, SCM laziness, bool ignore_octave) { - 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->get_notename (); + int o = pitch->get_octave (); + + 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_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)) + from_other_octaves = scm_cdr (entry); + } - SCM prev = scm_assoc (gh_cons (gh_int2scm (o), gh_int2scm (n)), sig); - if (prev == SCM_BOOL_F) - prev = scm_assoc (gh_int2scm (n), sig); - SCM prev_acc = (prev == SCM_BOOL_F) ? gh_int2scm (0) : ly_cdr (prev); - - bool different = !gh_equal_p (prev_acc , gh_int2scm (a)); - 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"))) 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; } -void -Accidental_engraver::create_grobs () +static int +number_accidentals (bool *different, + Pitch *pitch, Context *origin, + SCM accidentals, int bar_number) { - if (!key_item_p_ && mel_l_arr_.size ()) + int number = 0; + + *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 ())); + + for (; scm_is_pair (accidentals) && origin; + accidentals = scm_cdr (accidentals)) { - SCM localsig = get_property ("localKeySignature"); - SCM lazysig = get_property ("lazyKeySignature"); + // If pair then it is a new accidentals typesetting rule to be checked + SCM rule = scm_car (accidentals); + if (scm_is_pair (rule)) + { + SCM type = scm_car (rule); + SCM laziness = scm_cdr (rule); + SCM localsig = origin->get_property ("localKeySignature"); + + bool same_octave_b = + scm_is_eq (ly_symbol2scm ("same-octave"), type); + bool any_octave_b = + scm_is_eq (ly_symbol2scm ("any-octave"), type); - for (int i=0; i < mel_l_arr_.size (); i++) + 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).to_str0 ())); + } + + + /* + if symbol then it is a context name. Scan parent contexts to find it. + */ + else if (scm_is_symbol (rule)) { - Grob * support_l = support_l_arr_[i]; - Note_req * note_l = mel_l_arr_[i]; - - int local_num = number_accidentals(localsig,note_l); - bool local_diff = local_num<0; local_num = abs(local_num); - int lazy_num = number_accidentals(lazysig,note_l); - bool lazy_diff = lazy_num<0; lazy_num = abs(lazy_num); - - int num = local_num;; - bool different= local_diff; - bool cautionary = to_boolean (note_l->get_mus_property ("cautionary")); - if (to_boolean (get_property ("noResetKey"))) { - num = lazy_num; - different = lazy_diff; - } - else if (gh_equal_p (get_property ("autoReminders"),ly_symbol2scm("cautionary")) - || gh_equal_p (get_property ("autoReminders"),ly_symbol2scm("accidental"))) { - num = max(local_num,lazy_num); - if (gh_equal_p (get_property ("autoReminders"),ly_symbol2scm("cautionary")) - && lazy_num>local_num) - cautionary = true; - } + Context *dad = origin; + while (dad && !dad->is_alias (rule)) + dad = dad->get_parent_context (); + + if (dad) + origin = dad; + } + else warning (_f ("Accidental rule must be pair or context-name; Found %s", + ly_scm2string (rule).to_str0 ())); + } - /* see if there's a tie that "changes" the accidental */ - /* works because if there's a tie, the note to the left - is of the same pitch as the actual note */ + return number; +} +int +Accidental_engraver::get_bar_number () +{ + SCM barnum = get_property ("currentBarNumber"); + SCM smp = get_property ("measurePosition"); - Grob *tie_break_reminder = 0; - bool tie_changes = false; - for (int i=0; i < tie_l_arr_.size (); i++) - if (support_l == Tie::head (tie_l_arr_[i], RIGHT)) - { - tie_changes = different; - /* Enable accidentals for broken tie - - We only want an accidental on a broken tie, - if the tie changes the accidental. - - Maybe check property noTieBreakForceAccidental? */ - if (different) - tie_break_reminder = tie_l_arr_[i]; - break; - } + int bn = robust_scm2int (barnum, 0); + + Moment mp = robust_scm2moment (smp, Moment (0)); + if (mp.main_part_ < Rational (0)) + bn--; + + return bn; +} - if (num) +void +Accidental_engraver::process_acknowledged_grobs () +{ + if (accidentals_.size () && !accidentals_.top ().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++) + { + if (accidentals_[i].done_ ) + continue; + accidentals_[i].done_ = true; + Grob *support = accidentals_[i].head_; + Music *note = accidentals_[i].melodic_; + Context *origin = accidentals_[i].origin_; + + Pitch *pitch = unsmob_pitch (note->get_property ("pitch")); + 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); + + bool cautionary = to_boolean (note->get_property ("cautionary")); + + if (num_caut > num) { - if (!key_item_p_) - { - key_item_p_ = new Item (get_property ("Accidentals")); - Local_key_item::set_interface (key_item_p_); - - - Staff_symbol_referencer::set_interface (key_item_p_); - 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_, 0); - } - - - Local_key_item::add_pitch (key_item_p_, *unsmob_pitch (note_l->get_mus_property ("pitch")), - cautionary, - num==2, - tie_break_reminder); - Side_position_interface::add_support (key_item_p_,support_l); + num = num_caut; + different = different_caut; + cautionary = true; } + + if (num == 0 && to_boolean (note->get_property ("force-accidental"))) + num = 1; /* - We should not record the accidental if it is the first - note and it is tied from the previous measure. - - Checking whether it is tied also works mostly, but will it - always do the correct thing? - (???? -Rune ) + Can not look for ties: it's not guaranteed that they reach + us before the notes */ - - 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 = gh_cons (gh_int2scm (o), gh_int2scm (n)); - bool forget = to_boolean (get_property ("forgetAccidentals")); - if (tie_changes) - { - /* - Remember an alteration that is different both from - that of the tied note and of the key signature. - */ - localsig = scm_assoc_set_x (localsig, on, SCM_BOOL_T); - lazysig = scm_assoc_set_x (lazysig, on, SCM_BOOL_T); - } - else if (!forget) + + if (num) { /* - not really really correct if there are more than one - noteheads with the same notename. + We construct the accidentals at the originating Voice + level, so that we get the property settings for + Accidental from the respective Voice. */ - localsig = scm_assoc_set_x (localsig, on, gh_int2scm (a)); - lazysig = scm_assoc_set_x (lazysig, on, gh_int2scm (a)); - } - } - - daddy_trans_l_->set_property ("localKeySignature", localsig); - daddy_trans_l_->set_property ("lazyKeySignature", lazysig); - } - - - if (key_item_p_) - { - /* - Hmm. Which one has to be on the left? - - On which left, code or paper? + 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); + + /* TODO: add cautionary option in accidental. */ + + if (cautionary) + a->set_property ("cautionary", SCM_BOOL_T); + + support->set_property ("accidental-grob", a->self_scm ()); - (Arpeggios are engraved left of accidentals, of course.) - */ - for (int i=0; i < arpeggios_.size (); i++) - Side_position_interface::add_support (arpeggios_[i], key_item_p_); + a->set_property ("accidentals", accs); + accidentals_[i].accidental_ = a; - arpeggios_.clear (); + /* + 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]); + } + } } } void Accidental_engraver::finalize () { - + last_keysig_ = SCM_EOL; } void Accidental_engraver::stop_translation_timestep () { - if (key_item_p_) + for (int j = ties_.size (); j--;) { - for (int i=0; i < support_l_arr_.size (); i++) - Side_position_interface::add_support (key_item_p_,support_l_arr_[i]); - - typeset_grob (key_item_p_); - key_item_p_ =0; + Grob *r = Tie::head (ties_[j], RIGHT); + for (int i = accidentals_.size (); i--;) + if (accidentals_[i].head_ == r) + { + if (Grob *g = accidentals_[i].accidental_) + { + g->set_property ("tie", ties_[j]->self_scm ()); + accidentals_[i].tied_ = true; + } + ties_.del (j); + break; + } } + for (int i = accidentals_.size (); i--;) + { + int barnum = get_bar_number (); + + Music *note = accidentals_[i].melodic_; + Context * origin = accidentals_[i].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 (); + SCM key = scm_cons (scm_int2num (o), scm_int2num (n)); + + while (origin + && origin->where_defined (ly_symbol2scm ("localKeySignature"))) + { + /* + huh? we set props all the way to the top? + */ + SCM localsig = origin->get_property ("localKeySignature"); + bool change = false; + if (accidentals_[i].tied_) + { + /* + 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_int2num (barnum))); + + change = true; + } + else + { + /* + 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_int2num (a), + scm_int2num (barnum))); + change = true; + } + + if (change) + origin->set_property ("localKeySignature", localsig); - mel_l_arr_.clear (); - arpeggios_.clear (); - tie_l_arr_.clear (); - support_l_arr_.clear (); - forced_l_arr_.clear (); + origin = origin->get_parent_context (); + } + } + + accidental_placement_ = 0; + accidentals_.clear (); + left_objects_.clear (); + right_objects_.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_)) - { - mel_l_arr_.push (note_l); - support_l_arr_.push (info.grob_l_); - } - else if (Tie::has_interface (info.grob_l_)) - { - tie_l_arr_.push (info.grob_l_); - } - else if (Arpeggio::has_interface (info.grob_l_)) + if (note + && note->is_mus_type ("note-event") + && Rhythmic_head::has_interface (info.grob_)) { - arpeggios_.push (info.grob_l_); + if (to_boolean ( get_property ("harmonicAccidentals")) + || !ly_c_equal_p (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.melodic_ = note; + + accidentals_.push (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_); } -/* - ugh. repeated deep_copy generates lots of garbage. - */ void Accidental_engraver::process_music () { - SCM smp = get_property ("measurePosition"); - Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0); - SCM sig = get_property ("keySignature"); - - /* - Detect key sig changes. If we haven't found any, check if at start - of measure, and set localKeySignature anyhow. */ - if (last_keysig_ != sig) - { - daddy_trans_l_->set_property ("localKeySignature", ly_deep_copy (sig)); - daddy_trans_l_->set_property ("lazyKeySignature", ly_deep_copy (sig)); - last_keysig_ = sig; - } - else if (!mp.to_bool () ) - { - daddy_trans_l_->set_property ("localKeySignature", ly_deep_copy (sig)); - } + /* Detect key sig changes. + Update all parents and children. */ + if (last_keysig_ != sig) + update_local_key_signature (); } - - - - -ENTER_DESCRIPTION(Accidental_engraver, -/* descr */ "Make accidentals. Catches note heads, ties and notices key-change -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. FIXME", -/* creats*/ "Accidentals", -/* acks */ "rhythmic-head-interface tie-interface arpeggio-interface", -/* reads */ "localKeySignature forgetAccidentals noResetKey autoReminders", -/* write */ ""); +ENTER_DESCRIPTION (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 " + , + "autoAccidentals " + "autoCautionaries " + "extraNatural " + "harmonicAccidentals " + "localKeySignature" + , + "localKeySignature" + );