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       if (factor_.denominator () == 1 && factor_ > Rational (1, 1))
 192         note_dur = Duration (left_to_do_, false);
 193       else
 194         note_dur = Duration (left_to_do_ / factor_, false).compressed (factor_);
 195     }
 196   else
 197     {
 198       orig = unsmob_duration (note_events_[0]->get_property ("duration"));
 199       note_dur = *orig;
 200       factor_ = note_dur.factor ();
 201       left_to_do_ = orig->get_length ();
 202     }
 203   Moment nb = next_moment (note_dur.get_length ());
 204   if (nb.main_part_ && nb < note_dur.get_length ())
 205     {
 206       if (factor_.denominator () == 1 && factor_.numerator () > 1)
 207         note_dur = Duration (nb.main_part_, false);
 208       else
 209         note_dur = Duration (nb.main_part_ / factor_, false).compressed (factor_);
 210     }
 211
 212   do_nothing_until_ = now.main_part_ + note_dur.get_length ();
 213
 214   for (vsize i = 0; left_to_do_ && i < note_events_.size (); i++)
 215     {
 216       bool need_clone = !orig || *orig != note_dur;
 217       Stream_event *event = note_events_[i];
 218
 219       if (need_clone)
 220         event = event->clone ();
 221
 222       SCM pits = note_events_[i]->get_property ("pitch");
 223       event->set_property ("pitch", pits);
 224       event->set_property ("duration", note_dur.smobbed_copy ());
 225       event->set_property ("length", Moment (note_dur.get_length ()).smobbed_copy ());
 226       event->set_property ("duration-log", scm_from_int (note_dur.duration_log ()));
 227
 228       /*
 229         The Completion_heads_engraver splits an event into a group of consecutive events.
 230         For each event in the group, the property "autosplit-end" denotes whether the current event
 231         was truncated during splitting. Based on "autosplit-end", the Tie_engraver decides whether a
 232         tie event should be processed.
 233       */
 234       event->set_property ("autosplit-end",
 235                            ly_bool2scm (left_to_do_ - note_dur.get_length () > Rational (0)));
 236
 237       Item *note = make_note_head (event);
 238       if (need_clone)
 239         event->unprotect ();
 240       notes_.push_back (note);
 241     }
 242
 243   if (prev_notes_.size () == notes_.size ())
 244     {
 245       for (vsize i = 0; i < notes_.size (); i++)
 246         make_tie (prev_notes_[i], notes_[i]);
 247     }
 248
 249   if (ties_.size () && !tie_column_)
 250     tie_column_ = make_spanner ("TieColumn", ties_[0]->self_scm ());
 251
 252   if (tie_column_)
 253     for (vsize i = ties_.size (); i--;)
 254       Tie_column::add_tie (tie_column_, ties_[i]);
 255
 256   left_to_do_ -= note_dur.get_length ();
 257   if (left_to_do_)
 258     get_global_context ()->add_moment_to_process (now.main_part_ + note_dur.get_length ());
 259   /*
 260     don't do complicated arithmetic with grace notes.
 261   */
 262   if (orig && now_mom ().grace_part_)
 263     left_to_do_ = Rational (0, 0);
 264 }
 265
 266 void
 267 Completion_heads_engraver::make_tie (Grob *left, Grob *right)
 268 {
 269   Grob *p = make_spanner ("Tie", SCM_EOL);
 270   Tie::set_head (p, LEFT, left);
 271   Tie::set_head (p, RIGHT, right);
 272   announce_end_grob (p, SCM_EOL);
 273   ties_.push_back (p);
 274 }
 275
 276 void
 277 Completion_heads_engraver::stop_translation_timestep ()
 278 {
 279   ties_.clear ();
 280   tie_column_ = 0;
 281
 282   if (notes_.size ())
 283     prev_notes_ = notes_;
 284   notes_.clear ();
 285 }
 286
 287 void
 288 Completion_heads_engraver::start_translation_timestep ()
 289 {
 290   Moment now = now_mom ();
 291   if (note_end_mom_.main_part_ <= now.main_part_)
 292     {
 293       note_events_.clear ();
 294       prev_notes_.clear ();
 295     }
 296   context ()->set_property ("completionBusy",
 297                             ly_bool2scm (note_events_.size ()));
 298 }
 299
 300 Completion_heads_engraver::Completion_heads_engraver ()
 301 {
 302   tie_column_ = 0;
 303 }
 304
 305 ADD_TRANSLATOR (Completion_heads_engraver,
 306                 /* doc */
 307                 "This engraver replaces @code{Note_heads_engraver}.  It plays"
 308                 " some trickery to break long notes and automatically tie them"
 309                 " into the next measure.",
 310
 311                 /* create */
 312                 "NoteHead "
 313                 "Tie "
 314                 "TieColumn ",
 315
 316                 /* read */
 317                 "completionUnit "
 318                 "measureLength "
 319                 "measurePosition "
 320                 "middleCPosition "
 321                 "timing ",
 322
 323                 /* write */
 324                 "completionBusy "
 325                );