lily/completion-note-heads-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1997--2012 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 "rhythmic-head.hh"
  31 #include "score-engraver.hh"
  32 #include "spanner.hh"
  33 #include "staff-symbol-referencer.hh"
  34 #include "stream-event.hh"
  35 #include "tie.hh"
  36 #include "tie-column.hh"
  37 #include "warn.hh"
  38 #include "misc.hh"
  39
  40 #include "translator.icc"
  41
  42 /*
  43   How does this work?
  44
  45   When we catch the note, we predict the end of the note. We keep the
  46   events living until we reach the predicted end-time.
  47
  48   Every time process_music () is called and there are note events, we
  49   figure out how long the note to typeset should be. It should be no
  50   longer than what's specified, than what is left to do and it should
  51   not cross barlines or sub-bar units.
  52
  53   We copy the events into scratch note events, to make sure that we get
  54   all durations exactly right.
  55 */
  56
  57 class Completion_heads_engraver : public Engraver
  58 {
  59   vector<Item *> notes_;
  60   vector<Item *> prev_notes_;
  61   // Must remember notes for explicit ties.
  62   vector<Grob *> ties_;
  63   vector<Stream_event *> note_events_;
  64   Spanner *tie_column_;
  65   Moment note_end_mom_;
  66   bool is_first_;
  67   Rational left_to_do_;
  68   Rational do_nothing_until_;
  69   Rational factor_;
  70
  71   Moment next_moment (Rational const &);
  72   Item *make_note_head (Stream_event *);
  73
  74 public:
  75   TRANSLATOR_DECLARATIONS (Completion_heads_engraver);
  76
  77 protected:
  78   virtual void initialize ();
  79   void make_tie (Grob *, Grob *);
  80   void start_translation_timestep ();
  81   void process_music ();
  82   void stop_translation_timestep ();
  83   DECLARE_TRANSLATOR_LISTENER (note);
  84 };
  85
  86 void
  87 Completion_heads_engraver::initialize ()
  88 {
  89   is_first_ = false;
  90 }
  91
  92 IMPLEMENT_TRANSLATOR_LISTENER (Completion_heads_engraver, note);
  93 void
  94 Completion_heads_engraver::listen_note (Stream_event *ev)
  95 {
  96   note_events_.push_back (ev);
  97
  98   is_first_ = true;
  99   Moment now = now_mom ();
 100   Moment musiclen = get_event_length (ev, now);
 101
 102   note_end_mom_ = max (note_end_mom_, (now + musiclen));
 103   do_nothing_until_ = Rational (0, 0);
 104 }
 105
 106 /*
 107   The duration _until_ the next bar line or completion unit
 108 */
 109 Moment
 110 Completion_heads_engraver::next_moment (Rational const &note_len)
 111 {
 112   Moment *e = unsmob_moment (get_property ("measurePosition"));
 113   Moment *l = unsmob_moment (get_property ("measureLength"));
 114   if (!e || !l || !to_boolean (get_property ("timing")))
 115     {
 116       return Moment (0, 0);
 117     }
 118
 119   Moment result = *l - *e;
 120   Moment const *unit = unsmob_moment (get_property ("completionUnit"));
 121
 122   if (unit)
 123     {
 124       Rational const now_unit = e->main_part_ / unit->main_part_;
 125       if (now_unit.den () > 1)
 126         {
 127           /*
 128             within a unit - go to the end of that
 129           */
 130           result = unit->main_part_
 131                    * (Rational (1) - (now_unit - now_unit.trunc_rat ()));
 132         }
 133       else
 134         {
 135           /*
 136             at the beginning of a unit:
 137             take a power-of-two number of units, but not more than required,
 138             since then the Duration constructor destroys the unit structure
 139           */
 140           if (note_len < result.main_part_)
 141             result.main_part_ = note_len;
 142           Rational const step_unit = result.main_part_ / unit->main_part_;
 143           if (step_unit.den () < step_unit.num ())
 144             {
 145               int const log2
 146                 = intlog2 (int (step_unit.num () / step_unit.den ()));
 147               result.main_part_ = unit->main_part_ * Rational (1 << log2);
 148             }
 149         }
 150     }
 151
 152   return result;
 153 }
 154
 155 Item *
 156 Completion_heads_engraver::make_note_head (Stream_event *ev)
 157 {
 158   Item *note = make_item ("NoteHead", ev->self_scm ());
 159   Pitch *pit = unsmob_pitch (ev->get_property ("pitch"));
 160
 161   int pos = pit->steps ();
 162   SCM c0 = get_property ("middleCPosition");
 163   if (scm_is_number (c0))
 164     pos += scm_to_int (c0);
 165
 166   note->set_property ("staff-position", scm_from_int (pos));
 167
 168   return note;
 169 }
 170
 171 void
 172 Completion_heads_engraver::process_music ()
 173 {
 174   if (!is_first_ && !left_to_do_)
 175     return;
 176
 177   is_first_ = false;
 178
 179   Moment now = now_mom ();
 180   if (do_nothing_until_ > now.main_part_)
 181     return;
 182
 183   Duration note_dur;
 184   Duration *orig = 0;
 185   if (left_to_do_)
 186     {
 187       /*
 188         note that note_dur may be strictly less than left_to_do_
 189         (say, if left_to_do_ == 5/8)
 190       */
 191       note_dur = Duration (left_to_do_ / factor_, false).compressed (factor_);
 192     }
 193   else
 194     {
 195       orig = unsmob_duration (note_events_[0]->get_property ("duration"));
 196       note_dur = *orig;
 197       SCM factor = get_property ("completionFactor");
 198       if (ly_is_procedure (factor))
 199         factor = scm_call_2 (factor,
 200                              context ()->self_scm (),
 201                              note_dur.smobbed_copy ());
 202       factor_ = robust_scm2rational (factor, note_dur.factor ());
 203       left_to_do_ = orig->get_length ();
 204     }
 205   Moment nb = next_moment (note_dur.get_length ());
 206   if (nb.main_part_ && nb < note_dur.get_length ())
 207     {
 208       note_dur = Duration (nb.main_part_ / factor_, false).compressed (factor_);
 209     }
 210
 211   do_nothing_until_ = now.main_part_ + note_dur.get_length ();
 212
 213   for (vsize i = 0; left_to_do_ && i < note_events_.size (); i++)
 214     {
 215       bool need_clone = !orig || *orig != note_dur;
 216       Stream_event *event = note_events_[i];
 217
 218       if (need_clone)
 219         event = event->clone ();
 220
 221       SCM pits = note_events_[i]->get_property ("pitch");
 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       /*
 228         The Completion_heads_engraver splits an event into a group of consecutive events.
 229         For each event in the group, the property "autosplit-end" denotes whether the current event
 230         was truncated during splitting. Based on "autosplit-end", the Tie_engraver decides whether a
 231         tie event should be processed.
 232       */
 233       event->set_property ("autosplit-end",
 234                            ly_bool2scm (left_to_do_ - note_dur.get_length () > Rational (0)));
 235
 236       Item *note = make_note_head (event);
 237       if (need_clone)
 238         event->unprotect ();
 239       notes_.push_back (note);
 240     }
 241
 242   if (prev_notes_.size () == notes_.size ())
 243     {
 244       for (vsize i = 0; i < notes_.size (); i++)
 245         make_tie (prev_notes_[i], notes_[i]);
 246     }
 247
 248   if (ties_.size () && !tie_column_)
 249     tie_column_ = make_spanner ("TieColumn", ties_[0]->self_scm ());
 250
 251   if (tie_column_)
 252     for (vsize i = ties_.size (); i--;)
 253       Tie_column::add_tie (tie_column_, ties_[i]);
 254
 255   left_to_do_ -= note_dur.get_length ();
 256   if (left_to_do_)
 257     get_global_context ()->add_moment_to_process (now.main_part_ + note_dur.get_length ());
 258   /*
 259     don't do complicated arithmetic with grace notes.
 260   */
 261   if (orig && now_mom ().grace_part_)
 262     left_to_do_ = Rational (0, 0);
 263 }
 264
 265 void
 266 Completion_heads_engraver::make_tie (Grob *left, Grob *right)
 267 {
 268   Grob *p = make_spanner ("Tie", SCM_EOL);
 269   Tie::set_head (p, LEFT, left);
 270   Tie::set_head (p, RIGHT, right);
 271   announce_end_grob (p, SCM_EOL);
 272   ties_.push_back (p);
 273 }
 274
 275 void
 276 Completion_heads_engraver::stop_translation_timestep ()
 277 {
 278   ties_.clear ();
 279   tie_column_ = 0;
 280
 281   if (notes_.size ())
 282     prev_notes_ = notes_;
 283   notes_.clear ();
 284 }
 285
 286 void
 287 Completion_heads_engraver::start_translation_timestep ()
 288 {
 289   Moment now = now_mom ();
 290   if (note_end_mom_.main_part_ <= now.main_part_)
 291     {
 292       note_events_.clear ();
 293       prev_notes_.clear ();
 294     }
 295   context ()->set_property ("completionBusy",
 296                             ly_bool2scm (note_events_.size ()));
 297 }
 298
 299 Completion_heads_engraver::Completion_heads_engraver ()
 300 {
 301   tie_column_ = 0;
 302 }
 303
 304 ADD_TRANSLATOR (Completion_heads_engraver,
 305                 /* doc */
 306                 "This engraver replaces @code{Note_heads_engraver}.  It plays"
 307                 " some trickery to break long notes and automatically tie them"
 308                 " into the next measure.",
 309
 310                 /* create */
 311                 "NoteHead "
 312                 "Tie "
 313                 "TieColumn ",
 314
 315                 /* read */
 316                 "completionFactor "
 317                 "completionUnit "
 318                 "measureLength "
 319                 "measurePosition "
 320                 "middleCPosition "
 321                 "timing ",
 322
 323                 /* write */
 324                 "completionBusy "
 325                );