lily/completion-note-heads-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1997--2010 Han-Wen Nienhuys <hanwen@xs4all.nl>
   5
   6   LilyPond is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   LilyPond is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include <cctype>
  21 using namespace std;
  22
  23 #include "dot-column.hh"
  24 #include "dots.hh"
  25 #include "duration.hh"
  26 #include "global-context.hh"
  27 #include "item.hh"
  28 #include "output-def.hh"
  29 #include "pitch.hh"
  30 #include "pqueue.hh"
  31 #include "rhythmic-head.hh"
  32 #include "score-engraver.hh"
  33 #include "spanner.hh"
  34 #include "staff-symbol-referencer.hh"
  35 #include "stream-event.hh"
  36 #include "tie.hh"
  37 #include "warn.hh"
  38
  39 #include "translator.icc"
  40
  41 /*
  42   TODO: make matching rest engraver.
  43 */
  44 struct Pending_tie
  45 {
  46   Moment when_;
  47   Stream_event* tie_event_;
  48   Pending_tie() { tie_event_ = 0; }
  49 };
  50
  51 int compare(Pending_tie const &a, Pending_tie const &b)
  52 {
  53   return compare(a.when_, b.when_);
  54 }
  55
  56
  57 /*
  58   How does this work?
  59
  60   When we catch the note, we predict the end of the note. We keep the
  61   events living until we reach the predicted end-time.
  62
  63   Every time process_music () is called and there are note events, we
  64   figure out how long the note to typeset should be. It should be no
  65   longer than what's specified, than what is left to do and it should
  66   not cross barlines.
  67
  68   We copy the events into scratch note events, to make sure that we get
  69   all durations exactly right.
  70 */
  71
  72 class Completion_heads_engraver : public Engraver
  73 {
  74   vector<Item*> notes_;
  75   vector<Item*> prev_notes_;
  76
  77   // Must remember notes for explicit ties.
  78   vector<Item*> tie_note_candidates_;
  79   vector<Stream_event*> tie_note_candidate_events_;
  80   vector<Grob*> ties_;
  81   PQueue<Pending_tie> pending_ties_;
  82   vector<Stream_event*> note_events_;
  83
  84   Stream_event *current_tie_event_;
  85   Moment note_end_mom_;
  86   bool is_first_;
  87   Rational left_to_do_;
  88   Rational do_nothing_until_;
  89
  90   Rational factor_;
  91
  92   Moment next_barline_moment ();
  93   Item *make_note_head (Stream_event*);
  94
  95 public:
  96   TRANSLATOR_DECLARATIONS (Completion_heads_engraver);
  97
  98 protected:
  99   virtual void initialize ();
 100   void make_tie (Grob *, Grob *);
 101   void start_translation_timestep ();
 102   void process_music ();
 103   void stop_translation_timestep ();
 104   DECLARE_TRANSLATOR_LISTENER (note);
 105   DECLARE_TRANSLATOR_LISTENER (tie);
 106 };
 107
 108 void
 109 Completion_heads_engraver::initialize ()
 110 {
 111   is_first_ = false;
 112   current_tie_event_ = 0;
 113 }
 114
 115 IMPLEMENT_TRANSLATOR_LISTENER (Completion_heads_engraver, note);
 116 void
 117 Completion_heads_engraver::listen_note (Stream_event *ev)
 118 {
 119   note_events_.push_back (ev);
 120
 121   is_first_ = true;
 122   Moment now = now_mom ();
 123   Moment musiclen = get_event_length (ev, now);
 124
 125   note_end_mom_ = max (note_end_mom_, (now + musiclen));
 126   do_nothing_until_ = Rational (0, 0);
 127 }
 128
 129 IMPLEMENT_TRANSLATOR_LISTENER (Completion_heads_engraver, tie);
 130 void
 131 Completion_heads_engraver::listen_tie (Stream_event *ev)
 132 {
 133   is_first_ = true;
 134   current_tie_event_ = ev;
 135 }
 136
 137 /*
 138   The duration _until_ the next barline.
 139 */
 140 Moment
 141 Completion_heads_engraver::next_barline_moment ()
 142 {
 143   Moment *e = unsmob_moment (get_property ("measurePosition"));
 144   Moment *l = unsmob_moment (get_property ("measureLength"));
 145   if (!e || !l || !to_boolean (get_property ("timing")))
 146     {
 147       return Moment (0, 0);
 148     }
 149
 150   return (*l - *e);
 151 }
 152
 153 Item*
 154 Completion_heads_engraver::make_note_head (Stream_event *ev)
 155 {
 156   Item *note = make_item ("NoteHead", ev->self_scm ());
 157   Pitch *pit = unsmob_pitch (ev->get_property ("pitch"));
 158
 159   int pos = pit->steps ();
 160   SCM c0 = get_property ("middleCPosition");
 161   if (scm_is_number (c0))
 162     pos += scm_to_int (c0);
 163
 164   note->set_property ("staff-position", scm_from_int (pos));
 165
 166   return note;
 167 }
 168
 169 void
 170 Completion_heads_engraver::process_music ()
 171 {
 172   if (!is_first_ && !left_to_do_)
 173     return;
 174
 175   if (current_tie_event_)
 176     {
 177       Pending_tie pending;
 178       pending.when_ = note_end_mom_;
 179       pending.tie_event_ = current_tie_event_;
 180       pending_ties_.insert (pending);
 181     }
 182
 183   is_first_ = false;
 184
 185   Moment now = now_mom ();
 186   if (do_nothing_until_ > now.main_part_)
 187     return;
 188
 189   Duration note_dur;
 190   Duration *orig = 0;
 191   if (left_to_do_)
 192     {
 193       /*
 194         note that note_dur may be strictly less than left_to_do_
 195         (say, if left_to_do_ == 5/8)
 196       */
 197       note_dur = Duration (left_to_do_ / factor_, false).compressed (factor_);
 198     }
 199   else
 200     {
 201       orig = unsmob_duration (note_events_[0]->get_property ("duration"));
 202       note_dur = *orig;
 203       factor_ = note_dur.factor ();
 204       left_to_do_ = orig->get_length ();
 205     }
 206   Moment nb = next_barline_moment ();
 207   if (nb.main_part_ && nb < note_dur.get_length ())
 208     note_dur = Duration (nb.main_part_ / factor_, false).compressed (factor_);
 209
 210   do_nothing_until_ = now.main_part_ + note_dur.get_length ();
 211
 212   for (vsize i = 0; left_to_do_ && i < note_events_.size (); i++)
 213     {
 214       bool need_clone = !orig || *orig != note_dur;
 215       Stream_event *event = note_events_[i];
 216
 217       if (need_clone)
 218         event = event->clone ();
 219
 220       SCM pits = note_events_[i]->get_property ("pitch");
 221
 222       event->set_property ("pitch", pits);
 223       event->set_property ("duration", note_dur.smobbed_copy ());
 224       event->set_property ("length", Moment (note_dur.get_length ()).smobbed_copy ());
 225       event->set_property ("duration-log", scm_from_int (note_dur.duration_log ()));
 226
 227       Item *note = make_note_head (event);
 228       if (need_clone)
 229         event->unprotect ();
 230       notes_.push_back (note);
 231     }
 232
 233   if (pending_ties_.size ()
 234       && pending_ties_.front().when_ == now_mom())
 235     {
 236       for (vsize i = 0; i < tie_note_candidate_events_.size(); i++)
 237         for (vsize j = 0; j < note_events_.size(); j++)
 238           {
 239             Pitch *p =  unsmob_pitch (note_events_[j]->get_property ("pitch"));
 240             Pitch *p_last
 241               = unsmob_pitch (tie_note_candidate_events_[j]->get_property ("pitch"));
 242             if (p && p_last && *p == *p_last)
 243               make_tie (tie_note_candidates_[i], notes_[j]);
 244           }
 245     }
 246
 247   if (prev_notes_.size () == notes_.size ())
 248     {
 249       for (vsize i = 0; i < notes_.size (); i++)
 250         make_tie (prev_notes_[i], notes_[i]);
 251     }
 252
 253   left_to_do_ -= note_dur.get_length ();
 254   if (left_to_do_)
 255     get_global_context ()->add_moment_to_process (now.main_part_ + note_dur.get_length());
 256   /*
 257     don't do complicated arithmetic with grace notes.
 258   */
 259   if (orig && now_mom ().grace_part_)
 260     left_to_do_ = Rational (0, 0);
 261 }
 262
 263 void
 264 Completion_heads_engraver::make_tie (Grob *left, Grob *right)
 265 {
 266   Grob *p = make_spanner ("Tie", SCM_EOL);
 267   Tie::set_head (p, LEFT, left);
 268   Tie::set_head (p, RIGHT, right);
 269   ties_.push_back (p);
 270 }
 271
 272 void
 273 Completion_heads_engraver::stop_translation_timestep ()
 274 {
 275   ties_.clear ();
 276
 277   if (notes_.size ())
 278     prev_notes_ = notes_;
 279   notes_.clear ();
 280 }
 281
 282 void
 283 Completion_heads_engraver::start_translation_timestep ()
 284 {
 285   Moment now = now_mom ();
 286   while (pending_ties_.size() && pending_ties_.front().when_ < now)
 287     {
 288       pending_ties_.delmin();
 289     }
 290   current_tie_event_ = 0;
 291   if (note_end_mom_.main_part_ <= now.main_part_)
 292     {
 293       tie_note_candidate_events_ = note_events_;
 294       tie_note_candidates_ = prev_notes_;
 295
 296       note_events_.clear ();
 297       prev_notes_.clear ();
 298     }
 299   context ()->set_property ("completionBusy",
 300                             ly_bool2scm (note_events_.size ()));
 301 }
 302
 303 Completion_heads_engraver::Completion_heads_engraver ()
 304 {
 305 }
 306
 307 ADD_TRANSLATOR (Completion_heads_engraver,
 308                 /* doc */
 309                 "This engraver replaces @code{Note_heads_engraver}.  It plays"
 310                 " some trickery to break long notes and automatically tie them"
 311                 " into the next measure.",
 312
 313                 /* create */
 314                 "NoteHead "
 315                 "Dots "
 316                 "Tie ",
 317
 318                 /* read */
 319                 "middleCPosition "
 320                 "measurePosition "
 321                 "measureLength ",
 322
 323                 /* write */
 324                 "completionBusy "
 325                 );