lily/completion-note-heads-engraver.cc

   1 /*
   2   completion-note-heads-engraver.cc -- Completion_heads_engraver
   3
   4   (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   5 */
   6
   7 #include <ctype.h>
   8
   9 #include "rhythmic-head.hh"
  10 #include "output-def.hh"
  11 #include "event.hh"
  12 #include "dots.hh"
  13 #include "dot-column.hh"
  14 #include "staff-symbol-referencer.hh"
  15 #include "item.hh"
  16 #include "score-engraver.hh"
  17 #include "warn.hh"
  18 #include "spanner.hh"
  19 #include "tie.hh"
  20 #include "global-context.hh"
  21
  22 /*
  23 TODO: make matching rest engraver.
  24 */
  25
  26 /*
  27
  28   How does this work?
  29
  30   When we catch the note, we predict the end of the note. We keep the
  31   events living until we reach the predicted end-time.
  32
  33   Every time process_music () is called and there are note events, we
  34   figure out how long the note to typeset should be. It should be no
  35   longer than what's specified, than what is left to do and it should
  36   not cross barlines.
  37
  38   We copy the reqs into scratch note reqs, to make sure that we get
  39   all durations exactly right.
  40 */
  41
  42 class Completion_heads_engraver : public Engraver
  43 {
  44   Link_array<Item> notes_;
  45   Link_array<Item> prev_notes_;
  46   Link_array<Grob> ties_;
  47
  48   Link_array<Item> dots_;
  49   Link_array<Music> note_reqs_;
  50   Link_array<Music> scratch_note_reqs_;
  51
  52   Moment note_end_mom_;
  53   bool first_b_;
  54   Rational left_to_do_;
  55   Rational do_nothing_until_;
  56
  57   Moment next_barline_moment ();
  58   Duration find_nearest_duration (Rational length);
  59
  60 public:
  61   TRANSLATOR_DECLARATIONS (Completion_heads_engraver);
  62
  63 protected:
  64   virtual void initialize ();
  65   virtual void start_translation_timestep ();
  66   virtual bool try_music (Music *req) ;
  67   virtual void process_music ();
  68   virtual void stop_translation_timestep ();
  69 };
  70
  71 void
  72 Completion_heads_engraver::initialize ()
  73 {
  74   first_b_ = false;
  75 }
  76
  77 bool
  78 Completion_heads_engraver::try_music (Music *m)
  79 {
  80   if (m->is_mus_type ("note-event"))
  81     {
  82       note_reqs_.push (m);
  83
  84       first_b_ = true;
  85       Moment musiclen = m->get_length ();
  86       Moment now = now_mom ();
  87
  88       if (now_mom ().grace_part_)
  89         {
  90           musiclen.grace_part_ = musiclen.main_part_ ;
  91           musiclen.main_part_ = Rational (0,1);
  92         }
  93       note_end_mom_  = note_end_mom_ >? (now + musiclen);
  94       do_nothing_until_ = Rational (0,0);
  95
  96       return true;
  97     }
  98   else if  (m->is_mus_type ("busy-playing-event"))
  99     {
 100       return note_reqs_.size ();
 101     }
 102
 103   return false;
 104
 105 }
 106
 107 /*
 108   The duration _until_ the next barline.
 109  */
 110 Moment
 111 Completion_heads_engraver::next_barline_moment ( )
 112 {
 113   Moment *e = unsmob_moment (get_property ("measurePosition"));
 114   Moment *l = unsmob_moment (get_property ("measureLength"));
 115   if (!e || !l)
 116     {
 117       programming_error ("No timing props set?");
 118       return Moment (1,1);
 119     }
 120
 121   return (*l - *e);
 122 }
 123
 124 Duration
 125 Completion_heads_engraver::find_nearest_duration (Rational length)
 126 {
 127   int log_limit= 6;
 128
 129   Duration d (0,0);
 130
 131   /*
 132     this could surely be done more efficient. Left to the reader as an
 133     excercise.  */
 134   while (d.get_length () > length && d.duration_log () < log_limit)
 135     {
 136       if (d.dot_count ())
 137         {
 138           d = Duration (d.duration_log (), d.dot_count ()- 1);
 139           continue;
 140         }
 141       else
 142         {
 143           d = Duration (d.duration_log () + 1, 2);
 144         }
 145     }
 146
 147   if (d.duration_log () >= log_limit)
 148     {
 149       // junk the dots.
 150       d = Duration (d.duration_log (), 0);
 151
 152       // scale up.
 153       d = d.compressed (length / d.get_length ());
 154     }
 155
 156   return d;
 157 }
 158
 159 void
 160 Completion_heads_engraver::process_music ()
 161 {
 162   if (!first_b_ && !left_to_do_)
 163     return ;
 164
 165   first_b_ = false;
 166
 167   Moment now =  now_mom ();
 168   if (do_nothing_until_ > now.main_part_)
 169     return ;
 170
 171   Duration note_dur;
 172   Duration *orig = 0;
 173   if (left_to_do_)
 174     {
 175       note_dur = find_nearest_duration (left_to_do_);
 176     }
 177   else
 178     {
 179       orig = unsmob_duration (note_reqs_[0]->get_property ("duration"));
 180       note_dur = *orig;
 181     }
 182   Moment nb = next_barline_moment ();
 183   if (nb < note_dur.get_length ())
 184     {
 185       note_dur = find_nearest_duration (nb.main_part_);
 186
 187       Moment next = now;
 188       next.main_part_ += note_dur.get_length ();
 189
 190       get_global_context ()->add_moment_to_process (next);
 191       do_nothing_until_ = next.main_part_;
 192     }
 193
 194   if (orig)
 195     {
 196       left_to_do_ = orig->get_length ();
 197     }
 198
 199   if (orig && note_dur.get_length () != orig->get_length ())
 200     {
 201       if (!scratch_note_reqs_.size ())
 202         for (int i = 0; i < note_reqs_.size (); i++)
 203           {
 204             Music * m = note_reqs_[i]->clone ();
 205             scratch_note_reqs_.push (m);
 206           }
 207     }
 208
 209
 210   for (int i = 0;
 211        left_to_do_ && i < note_reqs_.size (); i++)
 212     {
 213
 214       Music * req =  note_reqs_[i];
 215       Item *note  = make_item ("NoteHead", req->self_scm ());
 216       if (scratch_note_reqs_.size ())
 217         {
 218           req = scratch_note_reqs_[i];
 219           SCM pits = note_reqs_[i]->get_property ("pitch");
 220           req->set_property ("pitch",pits);
 221         }
 222
 223       req->set_property ("duration", note_dur.smobbed_copy ());
 224       note->set_property ("duration-log",
 225                                  scm_int2num (note_dur.duration_log ()));
 226
 227       int dots= note_dur.dot_count ();
 228       if (dots)
 229         {
 230           Item * d = make_item ("Dots", SCM_EOL);
 231           Rhythmic_head::set_dots (note, d);
 232
 233           /*
 234            measly attempt to save an eeny-weenie bit of memory.
 235           */
 236           if (dots != ly_scm2int (d->get_property ("dot-count")))
 237             d->set_property ("dot-count", scm_int2num (dots));
 238
 239           d->set_parent (note, Y_AXIS);
 240           dots_.push (d);
 241         }
 242
 243       Pitch *pit =unsmob_pitch (req->get_property ("pitch"));
 244
 245       int pos = pit->steps ();
 246       SCM c0 = get_property ("middleCPosition");
 247       if (ly_c_number_p (c0))
 248         pos += ly_scm2int (c0);
 249
 250       note->set_property ("staff-position",   scm_int2num (pos));
 251       notes_.push (note);
 252     }
 253
 254   if (prev_notes_.size () == notes_.size ())
 255     {
 256       for (int i= 0; i < notes_.size (); i++)
 257         {
 258           Grob * p = make_spanner ("Tie", SCM_EOL);
 259           Tie::set_interface (p); // cannot remove yet!
 260
 261           Tie::set_head (p, LEFT, prev_notes_[i]);
 262           Tie::set_head (p, RIGHT, notes_[i]);
 263
 264           ties_.push (p);
 265
 266         }
 267     }
 268
 269   left_to_do_ -= note_dur.get_length ();
 270
 271   /*
 272     don't do complicated arithmetic with grace notes.
 273    */
 274   if (orig
 275       &&  now_mom ().grace_part_ )
 276     {
 277       left_to_do_ = Rational (0,0);
 278     }
 279 }
 280
 281 void
 282 Completion_heads_engraver::stop_translation_timestep ()
 283 {
 284   ties_.clear ();
 285
 286   if (notes_.size ())
 287     prev_notes_ = notes_;
 288   notes_.clear ();
 289
 290   dots_.clear ();
 291
 292   for (int i = scratch_note_reqs_.size (); i--;)
 293     {
 294       scm_gc_unprotect_object (scratch_note_reqs_[i]->self_scm () );
 295     }
 296
 297   scratch_note_reqs_.clear ();
 298 }
 299
 300 void
 301 Completion_heads_engraver::start_translation_timestep ()
 302 {
 303   Moment now = now_mom ();
 304   if (note_end_mom_.main_part_ <= now.main_part_)
 305     {
 306       note_reqs_.clear ();
 307       prev_notes_.clear ();
 308     }
 309 }
 310
 311 Completion_heads_engraver::Completion_heads_engraver ()
 312 {
 313 }
 314
 315 ENTER_DESCRIPTION (Completion_heads_engraver,
 316 /* descr */       "This engraver replaces "
 317 "@code{Note_heads_engraver}. It plays some trickery to "
 318 "break long notes and automatically tie them into the next measure.",
 319 /* creats*/       "NoteHead Dots Tie",
 320 /* accepts */     "busy-playing-event note-event",
 321 /* acks  */      "",
 322 /* reads */       "middleCPosition measurePosition measureLength",
 323 /* write */       "");