X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Flocal-key-engraver.cc;h=ed71c533773a215e1f84ec607fced5b9577bc72a;hb=6eb2e2f71f9895b58a01693a94ea84a432bb3766;hp=bfd5390b9c20cef1efc6bf52bf1c36fc4638c8f1;hpb=fbb6d20e9f58d691ffe845284cbb4d8bacf9ca60;p=lilypond.git diff --git a/lily/local-key-engraver.cc b/lily/local-key-engraver.cc index bfd5390b9c..ed71c53377 100644 --- a/lily/local-key-engraver.cc +++ b/lily/local-key-engraver.cc @@ -1,237 +1,290 @@ /* local-key-engraver.cc -- implement Local_key_engraver - (c) 1997--2000 Han-Wen Nienhuys + (c) 1997--2001 Han-Wen Nienhuys */ -// clean up! #include "musical-request.hh" #include "command-request.hh" -#include "local-key-engraver.hh" #include "local-key-item.hh" -#include "key-engraver.hh" -#include "debug.hh" -#include "key-item.hh" +#include "item.hh" #include "tie.hh" -#include "note-head.hh" +#include "rhythmic-head.hh" #include "timing-translator.hh" #include "engraver-group-engraver.hh" -#include "grace-align-item.hh" + #include "staff-symbol-referencer.hh" #include "side-position-interface.hh" #include "engraver.hh" -#include "key.hh" -#include "parray.hh" - +#include "arpeggio.hh" /** - 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). - */ + + + FIXME: should not compute vertical positioning of accidentals, but + get them from the noteheads + + The algorithm for accidentals should be documented, and made + tweakable. + +*/ + + struct Local_key_engraver : Engraver { - Local_key_item *key_item_p_; + Item *key_item_p_; protected: - VIRTUAL_COPY_CONS(Translator); - virtual void do_process_music(); - virtual void acknowledge_element (Score_element_info); - virtual void do_pre_move_processing(); - virtual void do_creation_processing (); - virtual void process_acknowledged (); - virtual void do_removal_processing (); + VIRTUAL_COPY_CONS (Translator); + virtual void process_music (); + virtual void acknowledge_grob (Grob_info); + virtual void stop_translation_timestep (); + virtual void initialize (); + virtual void create_grobs (); + virtual void finalize (); public: - - Key local_key_; - Key_engraver *key_grav_l_; - Array mel_l_arr_; - Array support_l_arr_; - Link_array forced_l_arr_; - Link_array tied_l_arr_; - Local_key_engraver(); - bool self_grace_b_; - Grace_align_item * grace_align_l_; - Timing_translator * time_trans_l_ ; -}; + // 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_; + + Link_array mel_l_arr_; + Link_array support_l_arr_; + Link_array forced_l_arr_; + Link_array tie_l_arr_; + Local_key_engraver (); +}; -Local_key_engraver::Local_key_engraver() +Local_key_engraver::Local_key_engraver () { - key_grav_l_ = 0; key_item_p_ =0; - grace_align_l_ =0; - time_trans_l_ = 0; + + last_keysig_ = SCM_EOL; } void -Local_key_engraver::do_creation_processing () +Local_key_engraver::initialize () { - /* - UGHGUHGUH. - - Breaks if Key_engraver is removed from under us. - */ - Translator * result = - daddy_grav_l()->get_simple_translator ("Key_engraver"); - - key_grav_l_ = dynamic_cast (result); - - if (!key_grav_l_) - { - warning (_ ("out of tune:")); - warning (_f ("Can't find: `%s'", "Key_engraver")); - } - else - { - local_key_ = key_grav_l_->key_; - } - - /* - TODO - (if we are grace) get key info from parent Local_key_engraver - */ - - Translator * tr = daddy_grav_l()->get_simple_translator ("Timing_engraver"); // ugh - time_trans_l_ = dynamic_cast (tr); + last_keysig_ = get_property ("keySignature"); + daddy_trans_l_->set_property ("localKeySignature", last_keysig_); } void -Local_key_engraver::process_acknowledged () +Local_key_engraver::create_grobs () { - if (!key_item_p_ && mel_l_arr_.size()) + if (!key_item_p_ && mel_l_arr_.size ()) { - SCM f = get_property ("forgetAccidentals"); - bool forget = to_boolean (f); - for (int i=0; i < mel_l_arr_.size(); i++) + SCM localsig = get_property ("localKeySignature"); + + for (int i=0; i < mel_l_arr_.size (); i++) { - Item * support_l = support_l_arr_[i]; + Grob * support_l = support_l_arr_[i]; Note_req * note_l = mel_l_arr_[i]; + int n = unsmob_pitch (note_l->get_mus_property ("pitch"))->notename_i_; + int o = unsmob_pitch (note_l->get_mus_property ("pitch"))->octave_i () ; + int a = unsmob_pitch (note_l->get_mus_property ("pitch"))->alteration_i_; + /* 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 */ - bool tie_changes = tied_l_arr_.find_l (support_l) - && !local_key_.different_acc (note_l->pitch_); - - if (!forget - && ((note_l->forceacc_b_ - || !local_key_.different_acc (note_l->pitch_) - || local_key_.internal_forceacc (note_l->pitch_))) - - && !tie_changes) + SCM prev = scm_assoc (gh_cons (gh_int2scm (o), gh_int2scm (n)), localsig); + if (prev == SCM_BOOL_F) + prev = scm_assoc (gh_int2scm (n), localsig); + SCM prev_acc = (prev == SCM_BOOL_F) ? gh_int2scm (0) : gh_cdr (prev); + bool different = !gh_equal_p (prev_acc , gh_int2scm (a)); + int p = gh_number_p (prev_acc) ? gh_scm2int (prev_acc) : 0; + + 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; + } + + /* When do we want accidentals: + + 1. when property force-accidental is set, and not + tie_changes + 2. when different and not tie-changes + 3. maybe when at end of a tie: we must later see if + we're after a line break */ + if (( (to_boolean (note_l->get_mus_property ("force-accidental")) + || different) + && !tie_changes) + || tie_break_reminder) { if (!key_item_p_) { - key_item_p_ = new Local_key_item; - side_position (key_item_p_).set_axis (X_AXIS); - side_position (key_item_p_).set_direction (LEFT); - staff_symbol_referencer(key_item_p_).set_interface (); + 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_element (Score_element_info (key_item_p_, 0)); + announce_grob (key_item_p_, 0); } - key_item_p_->add_pitch (note_l->pitch_, - note_l->cautionary_b_, - local_key_.double_to_single_acc(note_l->pitch_)); - side_position (key_item_p_).add_support (support_l); + + bool extra_natural = + sign (p) * (p - a) == 1 + && abs (p) == 2; + + Local_key_item::add_pitch (key_item_p_, *unsmob_pitch (note_l->get_mus_property ("pitch")), + to_boolean (note_l->get_mus_property ("cautionary")), + extra_natural, + tie_break_reminder); + Side_position_interface::add_support (key_item_p_,support_l); } - if (!forget) + /* + 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? + + */ + bool forget = to_boolean (get_property ("forgetAccidentals")); + if (tie_changes) { - local_key_.set (note_l->pitch_); - if (!tied_l_arr_.find_l (support_l)) - { - local_key_.clear_internal_forceacc (note_l->pitch_); - } - else if (tie_changes) - { - local_key_.set_internal_forceacc (note_l->pitch_); - } + /* + Remember an alteration that is different both from + that of the tied note and of the key signature. + + */ + localsig = scm_assoc_set_x (localsig, gh_cons (gh_int2scm (o), + gh_int2scm (n)), + SCM_BOOL_T); + + } + else if (!forget) + { + /* + not really really correct if there are more than one + noteheads with the same notename. + */ + localsig = scm_assoc_set_x (localsig, gh_cons (gh_int2scm (o), + gh_int2scm (n)), + gh_int2scm (a)); + } } + + + + + daddy_trans_l_->set_property ("localKeySignature", localsig); } - if (key_item_p_ && grace_align_l_) + + + if (key_item_p_) { - side_position (grace_align_l_).add_support (key_item_p_); - grace_align_l_ =0; + /* + Hmm. Which one has to be on the left? + + On which left, code or paper? + + (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_); + + arpeggios_.clear (); } - } void -Local_key_engraver::do_removal_processing () +Local_key_engraver::finalize () { - // TODO: signal accidentals to Local_key_engraver the + } void -Local_key_engraver::do_pre_move_processing() +Local_key_engraver::stop_translation_timestep () { if (key_item_p_) { - for (int i=0; i < support_l_arr_.size(); i++) - side_position (key_item_p_).add_support (support_l_arr_[i]); + for (int i=0; i < support_l_arr_.size (); i++) + Side_position_interface::add_support (key_item_p_,support_l_arr_[i]); - typeset_element (key_item_p_); + typeset_grob (key_item_p_); key_item_p_ =0; } - grace_align_l_ = 0; - mel_l_arr_.clear(); - tied_l_arr_.clear(); - support_l_arr_.clear(); - forced_l_arr_.clear(); + + mel_l_arr_.clear (); + arpeggios_.clear (); + tie_l_arr_.clear (); + support_l_arr_.clear (); + forced_l_arr_.clear (); } void -Local_key_engraver::acknowledge_element (Score_element_info info) +Local_key_engraver::acknowledge_grob (Grob_info info) { - SCM wg= get_property ("weAreGraceContext"); - - bool selfgr = gh_boolean_p (wg) &&gh_scm2bool (wg); - bool he_gr = to_boolean (info.elem_l_->get_elt_property ("grace")); - - Grace_align_item * gai = dynamic_cast (info.elem_l_); - if (he_gr && !selfgr && gai) - { - grace_align_l_ = gai; - } Note_req * note_l = dynamic_cast (info.req_l_); - Note_head * note_head = dynamic_cast (info.elem_l_); - - - if (he_gr != selfgr) - return; - - if (note_l && note_head) + if (note_l && Rhythmic_head::has_interface (info.elem_l_)) { mel_l_arr_.push (note_l); - support_l_arr_.push (note_head); + support_l_arr_.push (info.elem_l_); } - else if (Tie * tie_l = dynamic_cast (info.elem_l_)) + else if (Tie::has_interface (info.elem_l_)) { - tied_l_arr_.push (tie_l->head (RIGHT)); + tie_l_arr_.push (info.elem_l_); } + else if (Arpeggio::has_interface (info.elem_l_)) + { + arpeggios_.push (info.elem_l_); + } + } +/* + ugh. repeated deep_copy generates lots of garbage. + */ void -Local_key_engraver::do_process_music() +Local_key_engraver::process_music () { - if (time_trans_l_ && !time_trans_l_->measure_position ()) + 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) { - if (!to_boolean (get_property ("noResetKey")) && key_grav_l_) - local_key_= key_grav_l_->key_; + daddy_trans_l_->set_property ("localKeySignature", ly_deep_copy (sig)); + last_keysig_ = sig; } - else if (key_grav_l_ && key_grav_l_->key_changed_b ()) + else if (!mp.to_bool () ) { - local_key_ = key_grav_l_->key_; + if (!to_boolean (get_property ("noResetKey"))) + daddy_trans_l_->set_property ("localKeySignature", ly_deep_copy (sig)); } } -ADD_THIS_TRANSLATOR(Local_key_engraver); +ADD_THIS_TRANSLATOR (Local_key_engraver);