X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-engraver.cc;h=3bd03fb69719c684e598189a7a8675bf47a51f6c;hb=eb38d3262cc0c09668ecf330a792e6d1d95f6f8a;hp=f41260d6b65428042c65bdf83d998db03f6928fe;hpb=7e72a1e50e94a7f9738d62599de79fe7745f600c;p=lilypond.git diff --git a/lily/accidental-engraver.cc b/lily/accidental-engraver.cc index f41260d6b6..3bd03fb697 100644 --- a/lily/accidental-engraver.cc +++ b/lily/accidental-engraver.cc @@ -1,92 +1,100 @@ /* accidental-engraver.cc -- implement accidental_engraver - (c) 1997--2004 Han-Wen Nienhuys + source file of the GNU LilyPond music typesetter + + (c) 1997--2006 Han-Wen Nienhuys Modified 2001--2002 by Rune Zedeler */ -#include "event.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 "translator-group.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" -/** - - -FIXME: should not compute vertical positioning of accidentals, but -get them from the noteheads - -The algorithm for accidentals should be documented, and made -tweakable. - -*/ +#include "translator.icc" -struct Accidental_entry { +class Accidental_entry +{ +public: bool done_; - Music * melodic_; - Grob * accidental_; - Translator_group *origin_; - Grob* head_; - Accidental_entry(); + Stream_event *melodic_; + Grob *accidental_; + Context *origin_; + Engraver *origin_engraver_; + Grob *head_; + bool tied_; + + Accidental_entry (); }; -Accidental_entry::Accidental_entry() +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 +{ + 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 (); -public: + virtual void derived_mark () const; - Protected_scm last_keysig_; +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. + 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_; + vector left_objects_; + vector right_objects_; - Grob * accidental_placement_; + Grob *accidental_placement_; - /* - The next - */ - Array accidentals_; - Link_array ties_; + vector accidentals_; + vector 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 (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 () { @@ -95,303 +103,350 @@ 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_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. */ - Translator_group * trans_ = daddy_trans_; - while (trans_) + SCM val; + while (trans && trans->where_defined (ly_symbol2scm ("localKeySignature"), &val)) { - trans_ -> set_property ("localKeySignature", ly_deep_copy (last_keysig_)); - trans_ = trans_->daddy_trans_; + trans->set_property ("localKeySignature", ly_deep_copy (last_keysig_)); + trans = trans->get_parent_context (); } - set_property_on_children (daddy_trans_,"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). - Negative (-1 or -2) if accidental has changed. +/** 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 (SCM sig, Music *, Pitch *pitch, SCM curbarnum, SCM lazyness, - bool ignore_octave_b) +extract_alteration (SCM alteration_def) { - int n = pitch->get_notename (); - int o = pitch->get_octave(); - int a = pitch->get_alteration (); - int curbarnum_i = gh_scm2int (curbarnum); - int accbarnum_i = 0; - - SCM prev; - if (ignore_octave_b) - prev = ly_assoc_cdr (scm_int2num (n), sig); + 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 - prev = scm_assoc (gh_cons (scm_int2num (o), scm_int2num (n)), sig); + assert (0); + return 0; +} - /* should really be true unless prev == SCM_BOOL_F */ - if (gh_pair_p (prev) && gh_pair_p (ly_cdr (prev))) - { - accbarnum_i = gh_scm2int (ly_cddr (prev)); - prev = gh_cons (ly_car (prev), ly_cadr (prev)); - } - - /* 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 = scm_assoc (scm_int2num (n), sig); +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 (); - SCM prev_acc = (prev == SCM_BOOL_F) ? scm_int2num (0) : ly_cdr (prev); + SCM previous_alteration = SCM_BOOL_F; - int p = gh_number_p (prev_acc) ? gh_scm2int (prev_acc) : 0; + 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_from_int (n)) + from_other_octaves = scm_cdr (entry); + } - int num; - if (a == p && gh_number_p (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 (Music * note, Pitch *pitch, Translator_group * origin, - SCM accidentals, SCM curbarnum) +number_accidentals (bool *different, + Pitch *pitch, Context *origin, + SCM accidentals, int bar_number) { int number = 0; - bool diff = false; - if (gh_pair_p (accidentals) && !gh_symbol_p (ly_car (accidentals))) - warning (_f ("Accidental typesetting list must begin with context-name: %s", - ly_scm2string (ly_car (accidentals)).to_str0 ())); - - for (; gh_pair_p (accidentals) && origin; accidentals = gh_cdr (accidentals)) + *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)).c_str ())); + + 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 = gh_car (accidentals); - if (gh_pair_p (rule)) + SCM rule = scm_car (accidentals); + if (scm_is_pair (rule)) { - SCM type = gh_car (rule); - SCM lazyness = gh_cdr (rule); + SCM type = scm_car (rule); + SCM laziness = scm_cdr (rule); SCM localsig = origin->get_property ("localKeySignature"); - - bool same_octave_b = - gh_eq_p (ly_symbol2scm ("same-octave"), type); - bool any_octave_b = - gh_eq_p (ly_symbol2scm ("any-octave"), type); + + bool same_octave_b + = scm_is_eq (ly_symbol2scm ("same-octave"), type); + bool any_octave_b + = scm_is_eq (ly_symbol2scm ("any-octave"), type); if (same_octave_b || any_octave_b) { + bool d = false; int n = number_accidentals_from_sig - (localsig, note, pitch, curbarnum, lazyness, any_octave_b); - diff = diff || (n < 0); - number = max (number, abs (n)); + (&d, localsig, pitch, bar_number, laziness, any_octave_b); + *different = *different || d; + number = max (number, n); } else - warning (_f ("unknown accidental typesetting: %s. Ignored", - ly_symbol2string (type).to_str0 ())); + warning (_f ("ignoring unknown accidental: %s", + ly_symbol2string (type).c_str ())); } - - /* - if symbol then it is a context name. Scan parent contexts to find it. - */ - else if (gh_symbol_p (rule)) + /* if symbol then it is a context name. Scan parent contexts to + find it. */ + else if (scm_is_symbol (rule)) { - Translator_group * dad = origin; + Context *dad = origin; while (dad && !dad->is_alias (rule)) - dad = dad->daddy_trans_; - + 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 ())); + else + warning (_f ("pair or context-name expected for accidental rule, found %s", + ly_scm2string (rule).c_str ())); } - return diff ? -number : number; + 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; } void -Accidental_engraver::process_acknowledged_grobs () +Accidental_engraver::process_acknowledged () { - if (accidentals_.size () && !accidentals_.top().done_) + if (accidentals_.size () && !accidentals_.back ().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.main_part_get_mus_property ("pitch")); + Pitch *pitch = unsmob_pitch (note->get_property ("pitch")); if (!pitch) continue; - - 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)) + + 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) { num = num_caut; + different = different_caut; cautionary = true; } - if(num==0 && to_boolean (note->get_mus_property ("force-accidental"))) - num=1; - - bool different = num < 0; - num = abs (num); + bool forced = to_boolean (note->get_property ("force-accidental")); + if (num == 0 && forced) + num = 1; - /* 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 */ + /* 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); - Grob *tie_break_reminder = 0; - bool tie_changes = false; - for (int j = 0; j < ties_.size (); j++) - if (support == Tie::head (ties_[j], RIGHT)) - { - tie_changes = different; - /* Enable accidentals for broken tie + if (forced || cautionary) + accidentals_[i].accidental_->set_property ("forced", SCM_BOOL_T); + } + } +} - We only want an accidental on a broken tie, - if the tie changes the accidental. - - Maybe check property noTieBreakForceAccidental? */ - if (different) - tie_break_reminder = ties_[j]; - break; - } +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 (num) - { - Grob * a = make_item ("Accidental"); - a->set_parent (support, Y_AXIS); - - if (!accidental_placement_) - { - accidental_placement_ = make_item ("AccidentalPlacement"); - announce_grob (accidental_placement_, a->self_scm()); - } - - Accidental_placement::add_accidental (accidental_placement_, a); - announce_grob (a, SCM_EOL); - - - SCM accs = gh_cons (scm_int2num (pitch->get_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->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 < 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]); - } - - - /* - 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? - */ - - - int n = pitch->get_notename (); - int o = pitch->get_octave (); - int a = pitch->get_alteration (); - SCM on_s = gh_cons (scm_int2num (o), scm_int2num (n)); - - /* - TODO: Speed this up! - - Perhaps only check translators mentioned in the auto-accidentals? - -rz - - TODO: profile this. - - I'd be surprised if the impact of this would be - measurable. Anyway, it seems localsig doesn't change - every time-step, but a set_property() is done every - time. We could save on that, probably. - - --hwn. - - - */ - - while (origin) - { - SCM localsig = origin->get_property ("localKeySignature"); - if (tie_changes) - { - /* - Remember an alteration that is different both from - that of the tied note and of the key signature. - */ - localsig = ly_assoc_front_x - (localsig, on_s, gh_cons (SCM_BOOL_T, barnum)); - } - else - { - /* - not really really correct if there are more than one - noteheads with the same notename. - */ - localsig = ly_assoc_front_x - (localsig, on_s, gh_cons (scm_int2num (a), barnum)); - } - origin->set_property ("localKeySignature", localsig); - origin = origin->daddy_trans_; - } - } + 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); + } + + /* 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) +{ + + (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,87 +458,153 @@ Accidental_engraver::finalize () void Accidental_engraver::stop_translation_timestep () { - for (int i = 0; i < accidentals_.size(); i++) + for (vsize j = ties_.size (); j--;) { - Grob *a = accidentals_[i].accidental_; - if (a) + Grob *r = Tie::head (ties_[j], RIGHT); + for (vsize i = accidentals_.size (); i--;) + if (accidentals_[i].head_ == r) + { + if (Grob *g = accidentals_[i].accidental_) + { + g->set_object ("tie", ties_[j]->self_scm ()); + accidentals_[i].tied_ = true; + } + ties_.erase (ties_.begin () + j); + break; + } + } + + for (vsize i = accidentals_.size (); i--;) + { + int barnum = get_bar_number (); + + Stream_event *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_from_int (o), scm_from_int (n)); + + SCM localsig = SCM_EOL; + while (origin + && origin->where_defined (ly_symbol2scm ("localKeySignature"), &localsig)) { - typeset_grob (a); + 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_from_int (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_from_int (a), + scm_from_int (barnum))); + change = true; + } + + if (change) + origin->set_property ("localKeySignature", localsig); + + origin = origin->get_parent_context (); } } - if (accidental_placement_) - typeset_grob(accidental_placement_); - accidental_placement_ = 00; - - accidentals_.clear(); + accidental_placement_ = 0; + accidentals_.clear (); left_objects_.clear (); right_objects_.clear (); - ties_.clear (); } 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"))) { - Accidental_entry entry ; - entry.head_ = info.grob_; - entry.origin_ = info.origin_trans_->daddy_trans_; - entry.melodic_ = note; + /* + string harmonics usually don't have accidentals. + */ + if (to_boolean (get_property ("harmonicAccidentals")) + || !ly_is_equal (info.grob ()->get_property ("style"), + ly_symbol2scm ("harmonic"))) + { + Accidental_entry entry; + entry.head_ = info.grob (); + entry.origin_engraver_ = dynamic_cast (info.origin_translator ()); + entry.origin_ = entry.origin_engraver_->context (); + entry.melodic_ = note; - accidentals_.push (entry); - } - else if (Tie::has_interface (info.grob_)) - { - ties_.push (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_); + accidentals_.push_back (entry); + } } } +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 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) - { - Translator_group * trans_ = daddy_trans_; - while (trans_) - { - trans_ -> set_property ("localKeySignature", ly_deep_copy (sig)); - trans_ = trans_->daddy_trans_; - } - set_property_on_children(daddy_trans_,"localKeySignature", sig); - - last_keysig_ = sig; - } + update_local_key_signature (); } - - - - -ENTER_DESCRIPTION (Accidental_engraver, -"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.", - "Accidental", -/* accepts */ "", - "finger-interface rhythmic-head-interface tie-interface arpeggio-interface", - "localKeySignature extraNatural autoAccidentals autoCautionaries", - "localKeySignature"); +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 AccidentalSuggestion", + + "", + + "autoAccidentals " + "autoCautionaries " + "internalBarNumber " + "extraNatural " + "harmonicAccidentals " + "localKeySignature", + "localKeySignature");