(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-// clean up!
#include "musical-request.hh"
#include "command-request.hh"
#include "local-key-item.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 "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
+
+*/
+
+
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 do_removal_processing ();
public:
- SCM last_accs_;
- Key_engraver *key_grav_l_;
- Array<Note_req* > mel_l_arr_;
- Array<Item*> support_l_arr_;
- Link_array<Item > forced_l_arr_;
- Link_array<Item > tied_l_arr_;
- Local_key_engraver();
- bool self_grace_b_;
- Grace_align_item * grace_align_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<Score_element> arpeggios_;
+
+ 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_grav_l_ = 0;
key_item_p_ =0;
grace_align_l_ =0;
- last_accs_ = SCM_EOL;
+ last_keysig_ = SCM_EOL;
}
-
void
Local_key_engraver::do_creation_processing ()
{
- last_accs_ = get_property ("keySignature");
+ last_keysig_ = get_property ("keySignature");
+ daddy_trans_l_->set_property ("localKeySignature", last_keysig_);
}
void
Local_key_engraver::process_acknowledged ()
{
- SCM localsig = get_property ("localKeySignature");
-
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];
int n = note_l->pitch_.notename_i_;
{
if (!key_item_p_)
{
- key_item_p_ = new Local_key_item (get_property ("basicLocalKeyProperties"));
- Side_position_interface (key_item_p_).set_axis (X_AXIS);
- Side_position_interface (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_);
- announce_element (Score_element_info (key_item_p_, 0));
+ announce_element (key_item_p_, 0);
}
sign (prev_acc) * (prev_acc - a) == 1
&& abs(prev_acc) == 2;
- key_item_p_->add_pitch (note_l->pitch_,
- note_l->cautionary_b_,
- extra_natural);
- Side_position_interface (key_item_p_).add_support (support_l);
+ 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);
}
- 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?
+
+ */
+ if (!forget && !tie_changes)
{
+ /*
+ 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));
-#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
}
}
+
+
+
+
+ daddy_trans_l_->set_property ("localKeySignature", localsig);
}
+
if (key_item_p_ && grace_align_l_)
{
- Side_position_interface (grace_align_l_).add_support (key_item_p_);
+ 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?
+ */
+ for (int i=0; i < arpeggios_.size (); i++)
+ Side_position::add_support (arpeggios_[i], key_item_p_);
+
+ arpeggios_.clear ();
+ }
}
void
if (key_item_p_)
{
for (int i=0; i < support_l_arr_.size(); i++)
- Side_position_interface (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();
+ arpeggios_.clear ();
tied_l_arr_.clear();
support_l_arr_.clear();
forced_l_arr_.clear();
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<Grace_align_item*> (info.elem_l_);
- if (he_gr && !selfgr && gai)
+ Item * item = dynamic_cast<Item*> (info.elem_l_);
+ if (he_gr && !selfgr && item && Grace_align_item::has_interface (item))
{
- grace_align_l_ = gai;
+ grace_align_l_ = item;
}
- Note_req * note_l = dynamic_cast <Note_req *> (info.req_l_);
- Note_head * note_head = dynamic_cast<Note_head *> (info.elem_l_);
-
-
-
if (he_gr != selfgr)
return;
- if (note_l && note_head)
+ Note_req * note_l = dynamic_cast <Note_req *> (info.req_l_);
+
+ 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<Tie *> (info.elem_l_))
+ else if (Tie::has_interface (info.elem_l_))
{
- tied_l_arr_.push (tie_l->head (RIGHT));
+ 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()
{
-
SCM smp = get_property ("measurePosition");
Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
SCM sig = get_property ("keySignature");
- if (!mp)
+
+ /*
+ 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")))
- daddy_trans_l_->set_property ("localKeySignature", sig);
+ daddy_trans_l_->set_property ("localKeySignature", ly_deep_copy (sig));
+ last_keysig_ = sig;
}
- else if (last_accs_ != sig)
+ else if (!mp)
{
- daddy_trans_l_->set_property ("localKeySignature", sig);
+ if (!to_boolean (get_property ("noResetKey")))
+ daddy_trans_l_->set_property ("localKeySignature", ly_deep_copy (sig));
}
}
projects / lilypond.git / blobdiff