X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-engraver.cc;h=003b37ff318f56f11638bb099ffbfffe76efb7fc;hb=750b714488c5af6eae22d07163bba8b554734ac6;hp=73314fb4eac282ab23749a71894b426a525f1540;hpb=08da6e274ea516076699e8e9bbdd48e5919cb526;p=lilypond.git diff --git a/lily/accidental-engraver.cc b/lily/accidental-engraver.cc index 73314fb4ea..003b37ff31 100644 --- a/lily/accidental-engraver.cc +++ b/lily/accidental-engraver.cc @@ -1,32 +1,53 @@ /* - accidental-engraver.cc -- implement accidental_engraver + This file is part of LilyPond, the GNU music typesetter. - (c) 1997--2004 Han-Wen Nienhuys + Copyright (C) 1997--2015 Han-Wen Nienhuys Modified 2001--2002 by Rune Zedeler + + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ -#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 "duration.hh" +#include "engraver.hh" +#include "international.hh" +#include "item.hh" +#include "pitch.hh" #include "protected-scm.hh" +#include "rhythmic-head.hh" +#include "separation-item.hh" +#include "side-position-interface.hh" +#include "spanner.hh" +#include "stream-event.hh" +#include "tie.hh" +#include "warn.hh" +#include "translator.icc" -struct Accidental_entry { +class Accidental_entry +{ +public: bool done_; - Music * melodic_; - Grob * accidental_; + Stream_event *melodic_; + Grob *accidental_; Context *origin_; - Grob* head_; + Engraver *origin_engraver_; + Grob *head_; bool tied_; + Accidental_entry (); }; @@ -34,308 +55,303 @@ Accidental_entry::Accidental_entry () { tied_ = false; done_ = false; - melodic_ =0; + melodic_ = 0; accidental_ = 0; origin_ = 0; + origin_engraver_ = 0; head_ = 0; } -struct Accidental_engraver : Engraver { +class Accidental_engraver : public Engraver +{ + void update_local_key_signature (SCM new_signature); + void create_accidental (Accidental_entry *entry, bool, bool); + Grob *make_standard_accidental (Stream_event *note, Grob *note_head, Engraver *trans, bool); + 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 (); - virtual void initialize (); - virtual void process_acknowledged_grobs (); - virtual void finalize (); -public: + void process_music (); - Protected_scm last_keysig_; + void acknowledge_end_tie (Grob_info); + void acknowledge_arpeggio (Grob_info); + void acknowledge_rhythmic_head (Grob_info); + void acknowledge_finger (Grob_info); + void acknowledge_note_column (Grob_info); - /* - 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_; + void stop_translation_timestep (); + void process_acknowledged (); - Grob * accidental_placement_; + virtual void finalize (); + virtual void derived_mark () const; - Array accidentals_; - Link_array ties_; +public: + SCM last_keysig_; - SCM get_bar_num (); -}; + vector left_objects_; + vector right_objects_; + Grob *accidental_placement_; -static void -set_property_on_children (Context * trans, const char * sym, SCM val) -{ - trans->set_property (sym, val); - for (SCM p = trans->children_contexts (); ly_c_pair_p (p); p = ly_cdr (p)) - { - Context *trg = unsmob_context (ly_car (p)); - set_property_on_children (trg, sym, ly_deep_copy (val)); - } -} + vector accidentals_; + vector ties_; + vector note_columns_; +}; + +/* + localAlterations is changed at runtime, which means that references + in grobs should always store ly_deep_copy ()s of those. +*/ -Accidental_engraver::Accidental_engraver () +Accidental_engraver::Accidental_engraver (Context *c) + : Engraver (c) { accidental_placement_ = 0; last_keysig_ = SCM_EOL; } void -Accidental_engraver::initialize () +Accidental_engraver::derived_mark () const { - last_keysig_ = get_property ("keySignature"); - - Context * trans_ = get_parent_context (); - while (trans_) - { - trans_ -> set_property ("localKeySignature", - ly_deep_copy (last_keysig_)); - trans_ = trans_->get_parent_context (); - } - set_property_on_children (get_parent_context (),"localKeySignature", last_keysig_); + scm_gc_mark (last_keysig_); } -/* - - calculates the number of accidentals on basis of the current local key - sig (passed as argument) +void +Accidental_engraver::update_local_key_signature (SCM new_sig) +{ + last_keysig_ = new_sig; + set_context_property_on_children (context (), + ly_symbol2scm ("localAlterations"), + new_sig); - Returns number of accidentals (0, 1 or 2). + Context *trans = context ()->get_parent_context (); -*/ -static int -number_accidentals_from_sig (bool *different, - SCM sig, Pitch *pitch, SCM curbarnum, SCM lazyness, - 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); + /* + Reset parent contexts so that e.g. piano-accidentals won't remember old + cross-staff accidentals after key-sig-changes. + */ - /* should really be true unless prev == SCM_BOOL_F */ - if (ly_c_pair_p (prev) && ly_c_pair_p (ly_cdr (prev))) + SCM val; + while (trans && trans->here_defined (ly_symbol2scm ("localAlterations"), &val)) { - accbarnum_i = ly_scm2int (ly_cddr (prev)); - prev = scm_cons (ly_car (prev), ly_cadr (prev)); + trans->set_property ("localAlterations", ly_deep_copy (last_keysig_)); + trans = trans->get_parent_context (); } - - /* If an accidental was not found or the accidental was too old */ - if (prev == SCM_BOOL_F || - (ly_c_number_p (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 = ly_c_number_p (prev_acc) ? ly_scm2int (prev_acc) : 0; +struct Accidental_result +{ + bool need_acc; + bool need_restore; + + Accidental_result () + { + need_restore = need_acc = false; + } + + Accidental_result (bool restore, bool acc) + { + need_restore = restore; + need_acc = acc; + } + + Accidental_result (SCM scm) + { + need_restore = to_boolean (scm_car (scm)); + need_acc = to_boolean (scm_cdr (scm)); + } + + int score () const + { + return need_acc ? 1 : 0 + + need_restore ? 1 : 0; + } +}; - int num; - if (a == p && ly_c_number_p (prev_acc)) - num = 0; - else if ( (abs (a)get_property ("localKeySignature"); - - bool same_octave_b = - ly_c_eq_p (ly_symbol2scm ("same-octave"), type); - bool any_octave_b = - ly_c_eq_p (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); - *different = *different || d; - number = max (number, n); - } - else - warning (_f ("ignoring unknown accidental: %s", - ly_symbol2string (type).to_str0 ())); - } - + SCM rule = scm_car (rules); + if (ly_is_procedure (rule)) + { + SCM rule_result_scm = scm_call_4 (rule, origin->self_scm (), + pitch_scm, barnum_scm, measurepos); + Accidental_result rule_result (rule_result_scm); + + result.need_acc |= rule_result.need_acc; + result.need_restore |= rule_result.need_restore; + } /* - 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 (ly_c_symbol_p (rule)) - { - 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 ())); + else if (scm_is_symbol (rule)) + { + Context *dad = find_context_above (origin, rule); + if (dad) + origin = dad; + } + else + warning (_f ("procedure or context-name expected for accidental rule, found %s", + print_scm_val (rule).c_str ())); } - return number; + return result; } -SCM -Accidental_engraver::get_bar_num () +void +Accidental_engraver::process_acknowledged () { - 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) - && ly_c_number_p (barnum)) - barnum = scm_int2num (ly_scm2int (barnum) - 1); - - return barnum ; + if (accidentals_.size () && !accidentals_.back ().done_) + { + SCM accidental_rules = get_property ("autoAccidentals"); + SCM cautionary_rules = get_property ("autoCautionaries"); + SCM measure_position = get_property ("measurePosition"); + int barnum = measure_number (context ()); + + for (vsize i = 0; i < accidentals_.size (); i++) + { + if (accidentals_[i].done_) + continue; + accidentals_[i].done_ = true; + + Stream_event *note = accidentals_[i].melodic_; + Context *origin = accidentals_[i].origin_; + + Pitch *pitch = unsmob (note->get_property ("pitch")); + if (!pitch) + continue; + + Accidental_result acc = check_pitch_against_rules (*pitch, origin, accidental_rules, + barnum, measure_position); + Accidental_result caut = check_pitch_against_rules (*pitch, origin, cautionary_rules, + barnum, measure_position); + + bool cautionary = to_boolean (note->get_property ("cautionary")); + if (caut.score () > acc.score ()) + { + acc.need_acc |= caut.need_acc; + acc.need_restore |= caut.need_restore; + + cautionary = true; + } + + bool forced = to_boolean (note->get_property ("force-accidental")); + if (!acc.need_acc && forced) + acc.need_acc = true; + + /* + Cannot look for ties: it's not guaranteed that they reach + us before the notes. + */ + if (!note->in_event_class ("trill-span-event")) + { + if (acc.need_acc) + create_accidental (&accidentals_[i], acc.need_restore, cautionary); + + if (forced || cautionary) + accidentals_[i].accidental_->set_property ("forced", SCM_BOOL_T); + } + } + } } void -Accidental_engraver::process_acknowledged_grobs () +Accidental_engraver::create_accidental (Accidental_entry *entry, + bool restore_natural, + bool cautionary) { - if (accidentals_.size () && !accidentals_.top ().done_) + Stream_event *note = entry->melodic_; + Grob *support = entry->head_; + 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_, cautionary); + + if (restore_natural) { - SCM accidentals = get_property ("autoAccidentals"); - SCM cautionaries = get_property ("autoCautionaries"); - SCM barnum = get_bar_num (); - - 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) - { - num = num_caut; - different = different_caut; - cautionary = true; - } - - if (num == 0 && to_boolean (note->get_property ("force-accidental"))) - num = 1; - - - /* - Can not look for ties: it's not guaranteed that they reach - us before the notes - */ - - 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 (origin, - ly_symbol2scm ("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 = 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 ()); - - a->set_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]); - } - } + if (to_boolean (get_property ("extraNatural"))) + a->set_property ("restore-first", SCM_BOOL_T); } + + entry->accidental_ = a; } +Grob * +Accidental_engraver::make_standard_accidental (Stream_event * /* note */, + Grob *note_head, + Engraver *trans, + bool cautionary) +{ + /* + We construct the accidentals at the originating Voice + level, so that we get the property settings for + Accidental from the respective Voice. + */ + Grob *a = 0; + if (cautionary) + a = trans->make_item ("AccidentalCautionary", note_head->self_scm ()); + else + 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 (ly_is_equal (left_objects_[i]->get_property ("side-axis"), scm_from_int (X_AXIS))) + Side_position_interface::add_support (left_objects_[i], a); + } + 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, + scm_is_eq (get_property ("accidentalGrouping"), ly_symbol2scm ("voice")), + (long) trans); + + 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) +{ + Grob *a = trans->make_item ("AccidentalSuggestion", note_head->self_scm ()); + + Side_position_interface::add_support (a, note_head); + if (Grob *stem = unsmob (a->get_object ("stem"))) + Side_position_interface::add_support (a, stem); + + a->set_parent (note_head, X_AXIS); + return a; +} void Accidental_engraver::finalize () @@ -346,162 +362,191 @@ 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--;) - 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; - } + Grob *r = Tie::head (ties_[j], RIGHT); + Grob *l = Tie::head (ties_[j], LEFT); + if (l && r) + { + // Don't mark accidentals as "tied" when the pitch is not + // actually the same. This is relevant for enharmonic ties. + Stream_event *le = unsmob (l->get_property ("cause")); + Stream_event *re = unsmob (r->get_property ("cause")); + if (le && re + && !ly_is_equal (le->get_property ("pitch"), re->get_property ("pitch"))) + continue; + } + + 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 (int i = accidentals_.size (); i--;) + for (vsize i = accidentals_.size (); i--;) { - SCM barnum = get_bar_num (); + Stream_event *note = accidentals_[i].melodic_; + Context *origin = accidentals_[i].origin_; - Music * note = accidentals_[i].melodic_; - Context * origin = accidentals_[i].origin_; + int barnum = measure_number (origin); - Pitch * pitch = unsmob_pitch (note->get_property ("pitch")); + Pitch *pitch = unsmob (note->get_property ("pitch")); if (!pitch) - continue; - + 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)); - - while (origin) - { - /* - 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, on_s, scm_cons (SCM_BOOL_T, 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, on_s, scm_cons (scm_int2num (a), barnum)); - - change = true; - } - - if (change) - 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); + Rational a = pitch->get_alteration (); + SCM key = scm_cons (scm_from_int (o), scm_from_int (n)); + + Moment end_mp = measure_position (context (), + unsmob (note->get_property ("duration"))); + SCM position = scm_cons (scm_from_int (barnum), end_mp.smobbed_copy ()); + + SCM localsig = SCM_EOL; + while (origin + && origin->where_defined (ly_symbol2scm ("localAlterations"), &localsig)) + { + bool change = false; + if (accidentals_[i].tied_ + && !(to_boolean (accidentals_[i].accidental_->get_property ("forced")))) + { + /* + Remember an alteration that is different both from + that of the tied note and of the key signature. + */ + localsig = ly_assoc_prepend_x (localsig, key, scm_cons (ly_symbol2scm ("tied"), + position)); + change = true; + } + else + { + /* + not really correct if there is more than one + note head with the same notename. + */ + localsig = ly_assoc_prepend_x (localsig, key, + scm_cons (ly_rational2scm (a), + position)); + change = true; + } + + if (change) + origin->set_property ("localAlterations", localsig); + + origin = origin->get_parent_context (); + } } if (accidental_placement_) - typeset_grob (accidental_placement_); + for (vsize i = 0; i < note_columns_.size (); i++) + Separation_item::add_conditional_item (note_columns_[i], accidental_placement_); accidental_placement_ = 0; - accidentals_.clear (); + note_columns_.clear (); left_objects_.clear (); right_objects_.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_)) - { - 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_ = info.origin_trans_->get_parent_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"))) + && (note->in_event_class ("note-event") + || note->in_event_class ("trill-span-event")) + // option to skip accidentals on string harmonics + && (to_boolean (get_property ("harmonicAccidentals")) + || !scm_is_eq (info.grob ()->get_property ("style"), + ly_symbol2scm ("harmonic"))) + // ignore accidentals in non-printing voices like NullVoice + && !to_boolean (info.context ()->get_property ("nullAccidentals"))) { - left_objects_.push (info.grob_); + 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_back (entry); } } void -Accidental_engraver::process_music () +Accidental_engraver::acknowledge_end_tie (Grob_info info) { - SCM sig = get_property ("keySignature"); + ties_.push_back (dynamic_cast (info.grob ())); +} - /* Detect key sig changes. - 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; - } +void +Accidental_engraver::acknowledge_note_column (Grob_info info) +{ + note_columns_.push_back (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 ("keyAlterations"); + if (!scm_is_eq (last_keysig_, sig)) + update_local_key_signature (sig); +} +void +Accidental_engraver::boot () +{ + ADD_ACKNOWLEDGER (Accidental_engraver, arpeggio); + ADD_ACKNOWLEDGER (Accidental_engraver, finger); + ADD_ACKNOWLEDGER (Accidental_engraver, rhythmic_head); + ADD_END_ACKNOWLEDGER (Accidental_engraver, tie); + ADD_ACKNOWLEDGER (Accidental_engraver, note_column); +} -ENTER_DESCRIPTION (Accidental_engraver, - "Make accidentals. Catches 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"); +ADD_TRANSLATOR (Accidental_engraver, + /* doc */ + "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}.", + + /* create */ + "Accidental " + "AccidentalCautionary " + "AccidentalPlacement " + "AccidentalSuggestion ", + + /* read */ + "autoAccidentals " + "autoCautionaries " + "internalBarNumber " + "extraNatural " + "harmonicAccidentals " + "accidentalGrouping " + "keyAlterations " + "localAlterations ", + + /* write */ + "localAlterations " + );