lily/local-key-engraver.cc

   1 /*
   2   local-key-engraver.cc -- implement Local_key_engraver
   3
   4   (c)  1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   5 */
   6
   7 #include "musical-request.hh"
   8 #include "command-request.hh"
   9 #include "local-key-item.hh"
  10 #include "item.hh"
  11 #include "tie.hh"
  12 #include "rhythmic-head.hh"
  13 #include "timing-translator.hh"
  14 #include "engraver-group-engraver.hh"
  15 #include "grace-align-item.hh"
  16 #include "staff-symbol-referencer.hh"
  17 #include "side-position-interface.hh"
  18 #include "engraver.hh"
  19
  20
  21 /**
  22    Make accidentals.  Catches note heads, ties and notices key-change
  23    events.  Due to interaction with ties (which don't come together
  24    with note heads), this needs to be in a context higher than Tie_engraver.
  25    (FIXME).
  26  */
  27 struct Local_key_engraver : Engraver {
  28   Item *key_item_p_;
  29 protected:
  30   VIRTUAL_COPY_CONS(Translator);
  31   virtual void do_process_music();
  32   virtual void acknowledge_element (Score_element_info);
  33   virtual void do_pre_move_processing();
  34   virtual void do_creation_processing ();
  35   virtual void process_acknowledged ();
  36   virtual void do_removal_processing ();
  37 public:
  38
  39   // todo -> property
  40   SCM last_keysig_;
  41
  42   Link_array<Note_req> mel_l_arr_;
  43   Link_array<Score_element> support_l_arr_;
  44   Link_array<Item> forced_l_arr_;
  45   Link_array<Score_element> tied_l_arr_;
  46   Local_key_engraver();
  47
  48   Item * grace_align_l_;
  49 };
  50
  51 Local_key_engraver::Local_key_engraver()
  52 {
  53   key_item_p_ =0;
  54   grace_align_l_ =0;
  55   last_keysig_ = SCM_EOL;
  56 }
  57
  58 void
  59 Local_key_engraver::do_creation_processing ()
  60 {
  61   last_keysig_ = get_property ("keySignature");
  62   daddy_trans_l_->set_property ("localKeySignature",  last_keysig_);
  63 }
  64
  65 void
  66 Local_key_engraver::process_acknowledged ()
  67 {
  68   if (!key_item_p_ && mel_l_arr_.size())
  69     {
  70       SCM localsig = get_property ("localKeySignature");
  71
  72       SCM f = get_property ("forgetAccidentals");
  73       bool forget = to_boolean (f);
  74       for (int i=0; i  < mel_l_arr_.size(); i++)
  75         {
  76           Score_element * support_l = support_l_arr_[i];
  77           Note_req * note_l = mel_l_arr_[i];
  78
  79           int n = note_l->pitch_.notename_i_;
  80           int o = note_l->pitch_.octave_i_;
  81           int a = note_l->pitch_.accidental_i_;
  82
  83           /* see if there's a tie that "changes" the accidental */
  84           /* works because if there's a tie, the note to the left
  85              is of the same pitch as the actual note */
  86
  87           SCM prev = scm_assoc (gh_cons (gh_int2scm (o), gh_int2scm (n)), localsig);
  88           if (prev == SCM_BOOL_F)
  89             prev = scm_assoc (gh_int2scm (n), localsig);
  90           int prev_acc = (prev == SCM_BOOL_F) ? 0 : gh_scm2int (gh_cdr (prev));
  91           bool different = prev_acc != a;
  92
  93           bool tie_changes = tied_l_arr_.find_l (support_l) && different;
  94           if (!forget
  95               && (note_l->forceacc_b_ || different)
  96               && !tie_changes)
  97             {
  98               if (!key_item_p_)
  99                 {
 100                   key_item_p_ = new Item(get_property ("basicLocalKeyProperties"));
 101                   Local_key_item::set_interface (key_item_p_);
 102                   Side_position::set_axis (key_item_p_, X_AXIS);
 103                   Side_position::set_direction (key_item_p_, LEFT);
 104                   Staff_symbol_referencer::set_interface (key_item_p_);
 105
 106                   announce_element (key_item_p_, 0);
 107                 }
 108
 109
 110               bool extra_natural =
 111                 sign (prev_acc) * (prev_acc - a) == 1
 112                 && abs(prev_acc) == 2;
 113
 114               Local_key_item::add_pitch (key_item_p_, note_l->pitch_,
 115                                          note_l->cautionary_b_,
 116                                          extra_natural);
 117               Side_position::add_support (key_item_p_,support_l);
 118             }
 119
 120           if (!forget)
 121             {
 122               /*
 123                 not really really correct if there are more than one
 124                 noteheads with the same notename.
 125                */
 126               localsig = scm_assoc_set_x (localsig, gh_cons (gh_int2scm (o),
 127                                                              gh_int2scm (n)),
 128                                           gh_int2scm (a));
 129
 130 #if 0
 131               /*
 132                 TESTME!
 133                */
 134               if (!tied_l_arr_.find_l (support_l))
 135                 {
 136                   local_key_.clear_internal_forceacc (note_l->pitch_);
 137                 }
 138               else if (tie_changes)
 139                 {
 140                   local_key_.set_internal_forceacc (note_l->pitch_);
 141                 }
 142 #endif
 143             }
 144         }
 145
 146
 147
 148
 149       daddy_trans_l_->set_property ("localKeySignature",  localsig);
 150     }
 151
 152   if (key_item_p_ && grace_align_l_)
 153     {
 154       Side_position::add_support (grace_align_l_,key_item_p_);
 155       grace_align_l_ =0;
 156     }
 157
 158 }
 159
 160 void
 161 Local_key_engraver::do_removal_processing ()
 162 {
 163   // TODO: if grace ? signal accidentals to Local_key_engraver the
 164 }
 165
 166 void
 167 Local_key_engraver::do_pre_move_processing()
 168 {
 169   if (key_item_p_)
 170     {
 171       for (int i=0; i < support_l_arr_.size(); i++)
 172         Side_position::add_support (key_item_p_,support_l_arr_[i]);
 173
 174       typeset_element (key_item_p_);
 175       key_item_p_ =0;
 176     }
 177
 178   grace_align_l_ = 0;
 179   mel_l_arr_.clear();
 180   tied_l_arr_.clear();
 181   support_l_arr_.clear();
 182   forced_l_arr_.clear();
 183 }
 184
 185 void
 186 Local_key_engraver::acknowledge_element (Score_element_info info)
 187 {
 188   SCM wg= get_property ("weAreGraceContext");
 189
 190   bool selfgr = gh_boolean_p (wg) &&gh_scm2bool (wg);
 191   bool he_gr = to_boolean (info.elem_l_->get_elt_property ("grace"));
 192
 193   Item * item = dynamic_cast<Item*> (info.elem_l_);
 194   if (he_gr && !selfgr && item && Grace_align_item::has_interface (item))
 195     {
 196       grace_align_l_ = item;
 197     }
 198   if (he_gr != selfgr)
 199     return;
 200
 201   Note_req * note_l =  dynamic_cast <Note_req *> (info.req_l_);
 202
 203   if (note_l && Rhythmic_head::has_interface (info.elem_l_))
 204     {
 205       mel_l_arr_.push (note_l);
 206       support_l_arr_.push (info.elem_l_);
 207     }
 208   else if (Tie::has_interface (info.elem_l_))
 209     {
 210       tied_l_arr_.push (Tie::head (info.elem_l_, RIGHT));
 211     }
 212 }
 213
 214 /*
 215   ugh. repeated deep_copy generates lots of garbage.
 216  */
 217 void
 218 Local_key_engraver::do_process_music()
 219 {
 220   SCM smp = get_property ("measurePosition");
 221   Moment mp =  (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
 222
 223   SCM sig = get_property ("keySignature");
 224
 225   /*
 226     Detect key sig changes. If we haven't found any, check if at start
 227     of measure, and set localKeySignature anyhow.  */
 228   if (last_keysig_ != sig)
 229     {
 230       daddy_trans_l_->set_property ("localKeySignature",  ly_deep_copy (sig));
 231       last_keysig_ = sig;
 232     }
 233   else if (!mp)
 234     {
 235       if (!to_boolean (get_property ("noResetKey")))
 236         daddy_trans_l_->set_property ("localKeySignature",  ly_deep_copy (sig));
 237     }
 238 }
 239
 240
 241
 242 ADD_THIS_TRANSLATOR(Local_key_engraver);
 243