/*
- local-key-reg.cc -- implement Local_key_engraver
+ local-key-engraver.cc -- implement Local_key_engraver
- (c) 1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+ (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
#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 "time-description.hh"
-#include "engraver-group.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"
+/**
+ 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
+
+*/
+
+
+struct Local_key_engraver : Engraver {
+ 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 ();
+public:
+
+ // todo -> property
+ SCM last_keysig_;
+
+ Link_array<Note_req> mel_l_arr_;
+ Link_array<Score_element> support_l_arr_;
+ Link_array<Item> forced_l_arr_;
+ Link_array<Score_element> tied_l_arr_;
+ Local_key_engraver();
+
+ Item * grace_align_l_;
+};
+
Local_key_engraver::Local_key_engraver()
{
- key_C_ = 0;
key_item_p_ =0;
+ grace_align_l_ =0;
+ last_keysig_ = SCM_EOL;
}
void
Local_key_engraver::do_creation_processing ()
{
- /*
- UGHGUHGUH.
-
- Breaks if Key_engraver is removed from under us.
- */
- Translator * result =
- daddy_grav_l()->get_simple_translator (Key_engraver::static_name());
-
- if (!result)
- {
- warning (_ ("out of tune") + "! " + _ ("can't find") + " Key_engraver");
- }
- else
- {
- key_C_ = &((Key_engraver*)result->access_Engraver ())->key_;
- local_key_ = *key_C_;
- }
+ last_keysig_ = get_property ("keySignature");
+ daddy_trans_l_->set_property ("localKeySignature", last_keysig_);
}
void
{
if (!key_item_p_ && mel_l_arr_.size())
{
+ SCM localsig = get_property ("localKeySignature");
+
+ SCM f = get_property ("forgetAccidentals");
+ bool forget = to_boolean (f);
for (int i=0; i < mel_l_arr_.size(); i++)
{
- Item * support_l = support_l_arr_[i];
+ Score_element * support_l = support_l_arr_[i];
Note_req * note_l = mel_l_arr_[i];
- if (tied_l_arr_.find_l (support_l) &&
- !note_l->forceacc_b_)
- continue;
-
- if (!note_l->forceacc_b_
- && local_key_.different_acc (note_l->pitch_))
- continue;
- if (!key_item_p_)
+ int n = note_l->pitch_.notename_i_;
+ int o = note_l->pitch_.octave_i_;
+ int a = note_l->pitch_.accidental_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 */
+
+ 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);
+ int prev_acc = (prev == SCM_BOOL_F) ? 0 : gh_scm2int (gh_cdr (prev));
+ bool different = prev_acc != a;
+
+ bool tie_changes = tied_l_arr_.find_l (support_l) && different;
+ if (!forget
+ && (note_l->forceacc_b_ || different)
+ && !tie_changes)
+ {
+ if (!key_item_p_)
+ {
+ key_item_p_ = new Item(get_property ("Accidentals"));
+ Local_key_item::set_interface (key_item_p_);
+ Side_position::set_axis (key_item_p_, X_AXIS);
+ Side_position::set_direction (key_item_p_, LEFT);
+ Staff_symbol_referencer::set_interface (key_item_p_);
+
+ announce_element (key_item_p_, 0);
+ }
+
+
+ bool extra_natural =
+ sign (prev_acc) * (prev_acc - a) == 1
+ && abs(prev_acc) == 2;
+
+ Local_key_item::add_pitch (key_item_p_, note_l->pitch_,
+ note_l->cautionary_b_,
+ extra_natural);
+ Side_position::add_support (key_item_p_,support_l);
+ }
+
+ /*
+ 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?
+
+ */
+ if (!forget && !tie_changes)
{
- key_item_p_ = new Local_key_item;
- announce_element (Score_element_info (key_item_p_, 0));
+ /*
+ 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));
+
}
- key_item_p_->add (note_l->pitch_);
- key_item_p_->add_support (support_l);
- local_key_.set (note_l->pitch_);
- }
-
+ }
+
+
+
+
+ daddy_trans_l_->set_property ("localKeySignature", localsig);
}
+
+ if (key_item_p_ && grace_align_l_)
+ {
+ Side_position::add_support (grace_align_l_,key_item_p_);
+ grace_align_l_ =0;
+ }
+
+}
+
+void
+Local_key_engraver::do_removal_processing ()
+{
+ // TODO: if grace ? signal accidentals to Local_key_engraver the
}
void
if (key_item_p_)
{
for (int i=0; i < support_l_arr_.size(); i++)
- key_item_p_->add_support (support_l_arr_[i]);
+ Side_position::add_support (key_item_p_,support_l_arr_[i]);
typeset_element (key_item_p_);
key_item_p_ =0;
}
-
+
+ grace_align_l_ = 0;
mel_l_arr_.clear();
tied_l_arr_.clear();
support_l_arr_.clear();
void
Local_key_engraver::acknowledge_element (Score_element_info info)
-{
- Score_element * elem_l = info.elem_l_;
- Item * item_l = elem_l->access_Item();
-
- Note_req * note_l = (info.req_l_->access_Musical_req ())
- ? info.req_l_->access_Musical_req ()->access_Note_req () : 0;
+{
+ 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"));
- if (note_l && item_l && item_l->is_type_b (Note_head::static_name ()))
+ Item * item = dynamic_cast<Item*> (info.elem_l_);
+ if (he_gr && !selfgr && item && Grace_align_item::has_interface (item))
{
- mel_l_arr_.push (note_l);
- support_l_arr_.push (item_l);
+ grace_align_l_ = item;
}
- else if (info.req_l_->access_Command_req ()
- && info.req_l_->access_Command_req ()->access_Key_change_req () && key_C_)
+ if (he_gr != selfgr)
+ return;
+
+ Note_req * note_l = dynamic_cast <Note_req *> (info.req_l_);
+
+ if (note_l && Rhythmic_head::has_interface (info.elem_l_))
{
- local_key_ = *key_C_;
+ mel_l_arr_.push (note_l);
+ support_l_arr_.push (info.elem_l_);
}
- else if (elem_l->is_type_b (Tie::static_name ()))
+ else if (Tie::has_interface (info.elem_l_))
{
- Tie * tie_l = (Tie*)elem_l->access_Spanner ();
- if (tie_l->same_pitch_b_)
- tied_l_arr_.push (tie_l-> head_l_drul_[RIGHT]);
+ tied_l_arr_.push (Tie::head (info.elem_l_, RIGHT));
}
}
+/*
+ ugh. repeated deep_copy generates lots of garbage.
+ */
void
-Local_key_engraver::do_process_requests()
+Local_key_engraver::do_process_music()
{
- Time_description const * time_C_ = get_staff_info().time_C_;
- if (time_C_ && !time_C_->whole_in_measure_)
+ 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));
+ last_keysig_ = sig;
+ }
+ else if (!mp)
{
- if (key_C_)
- local_key_= *key_C_;
+ if (!to_boolean (get_property ("noResetKey")))
+ daddy_trans_l_->set_property ("localKeySignature", ly_deep_copy (sig));
}
}
-IMPLEMENT_IS_TYPE_B1(Local_key_engraver,Engraver);
+
ADD_THIS_TRANSLATOR(Local_key_engraver);
+
projects / lilypond.git / blobdiff