/*
local-key-engraver.cc -- implement Local_key_engraver
- (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+ (c) 1997--2001 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
#include "musical-request.hh"
#include "staff-symbol-referencer.hh"
#include "side-position-interface.hh"
#include "engraver.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
+
+*/
+
+
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 ();
+ 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:
// 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<Grob> arpeggios_;
Link_array<Note_req> mel_l_arr_;
- Link_array<Score_element> support_l_arr_;
+ Link_array<Grob> support_l_arr_;
Link_array<Item> forced_l_arr_;
- Link_array<Score_element> tied_l_arr_;
+ Link_array<Grob> tied_l_arr_;
Local_key_engraver();
Item * grace_align_l_;
}
void
-Local_key_engraver::do_creation_processing ()
+Local_key_engraver::initialize ()
{
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())
{
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++)
{
- Score_element * support_l = support_l_arr_[i];
+ Grob * support_l = support_l_arr_[i];
Note_req * note_l = mel_l_arr_[i];
- int n = note_l->pitch_.notename_i_;
- int o = note_l->pitch_.octave_i_;
- int a = note_l->pitch_.accidental_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
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;
-
+ 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;
+
bool tie_changes = tied_l_arr_.find_l (support_l) && different;
- if (!forget
- && (note_l->forceacc_b_ || different)
- && !tie_changes)
+ if ((to_boolean (note_l->get_mus_property ("force-accidental"))
+ || different) && !tie_changes)
{
if (!key_item_p_)
{
- key_item_p_ = new Item(get_property ("basicLocalKeyProperties"));
+ 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);
+ announce_grob (key_item_p_, 0);
}
bool extra_natural =
- sign (prev_acc) * (prev_acc - a) == 1
- && abs(prev_acc) == 2;
+ sign (p) * (p - a) == 1
+ && abs(p) == 2;
- Local_key_item::add_pitch (key_item_p_, note_l->pitch_,
- note_l->cautionary_b_,
+ 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);
Side_position::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)
+ {
+ /*
+ 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
gh_int2scm (n)),
gh_int2scm (a));
-#if 0
- /*
- TESTME!
- */
- 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_);
- }
-#endif
}
}
Side_position::add_support (grace_align_l_,key_item_p_);
grace_align_l_ =0;
}
-
+
+ if (key_item_p_)
+ {
+ /*
+ 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::add_support (arpeggios_[i], key_item_p_);
+
+ arpeggios_.clear ();
+ }
}
void
-Local_key_engraver::do_removal_processing ()
+Local_key_engraver::finalize ()
{
// TODO: if grace ? 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::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();
+ arpeggios_.clear ();
tied_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"));
+ bool he_gr = to_boolean (info.elem_l_->get_grob_property ("grace"));
Item * item = dynamic_cast<Item*> (info.elem_l_);
if (he_gr && !selfgr && item && Grace_align_item::has_interface (item))
{
tied_l_arr_.push (Tie::head (info.elem_l_, RIGHT));
}
+ 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()
{
SCM smp = get_property ("measurePosition");
Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
projects / lilypond.git / blobdiff