]> git.donarmstrong.com Git - lilypond.git/blob - lily/completion-note-heads-engraver.cc
Release: bump VERSION_DEVEL.
[lilypond.git] / lily / completion-note-heads-engraver.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 1997--2015 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<Spanner *> 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   void listen_note (Stream_event *);
84 };
85
86 void
87 Completion_heads_engraver::initialize ()
88 {
89   is_first_ = false;
90 }
91
92 void
93 Completion_heads_engraver::listen_note (Stream_event *ev)
94 {
95   note_events_.push_back (ev);
96
97   is_first_ = true;
98   Moment now = now_mom ();
99   Moment musiclen = get_event_length (ev, now);
100
101   note_end_mom_ = max (note_end_mom_, (now + musiclen));
102   do_nothing_until_ = Rational (0, 0);
103 }
104
105 /*
106   The duration _until_ the next bar line or completion unit
107 */
108 Moment
109 Completion_heads_engraver::next_moment (Rational const &note_len)
110 {
111   Moment *e = unsmob<Moment> (get_property ("measurePosition"));
112   Moment *l = unsmob<Moment> (get_property ("measureLength"));
113   if (!e || !l || !to_boolean (get_property ("timing")))
114     {
115       return Moment (0, 0);
116     }
117
118   Moment result = *l - *e;
119   if (result < 0)
120     {
121       programming_error ("invalid measure position: "
122                          + e->to_string () + " of " + l->to_string ());
123       return 0;
124     }
125   Moment const *unit = unsmob<Moment> (get_property ("completionUnit"));
126
127   if (unit)
128     {
129       Rational const now_unit = e->main_part_ / unit->main_part_;
130       if (now_unit.den () > 1)
131         {
132           /*
133             within a unit - go to the end of that
134           */
135           result = unit->main_part_
136                    * (Rational (1) - (now_unit - now_unit.trunc_rat ()));
137         }
138       else
139         {
140           /*
141             at the beginning of a unit:
142             take a power-of-two number of units, but not more than required,
143             since then the Duration constructor destroys the unit structure
144           */
145           if (note_len < result.main_part_)
146             result.main_part_ = note_len;
147           Rational const step_unit = result.main_part_ / unit->main_part_;
148           if (step_unit.den () < step_unit.num ())
149             {
150               int const log2
151                 = intlog2 (int (step_unit.num () / step_unit.den ()));
152               result.main_part_ = unit->main_part_ * Rational (1 << log2);
153             }
154         }
155     }
156
157   return result;
158 }
159
160 Item *
161 Completion_heads_engraver::make_note_head (Stream_event *ev)
162 {
163   Item *note = make_item ("NoteHead", ev->self_scm ());
164   Pitch *pit = unsmob<Pitch> (ev->get_property ("pitch"));
165
166   int pos = pit ? pit->steps () : 0;
167   SCM c0 = get_property ("middleCPosition");
168   if (scm_is_number (c0))
169     pos += scm_to_int (c0);
170
171   note->set_property ("staff-position", scm_from_int (pos));
172
173   return note;
174 }
175
176 void
177 Completion_heads_engraver::process_music ()
178 {
179   if (!is_first_ && !left_to_do_)
180     return;
181
182   is_first_ = false;
183
184   Moment now = now_mom ();
185   if (do_nothing_until_ > now.main_part_)
186     return;
187
188   Duration note_dur;
189   Duration *orig = 0;
190   if (left_to_do_)
191     {
192       /*
193         note that note_dur may be strictly less than left_to_do_
194         (say, if left_to_do_ == 5/8)
195       */
196       note_dur = Duration (left_to_do_ / factor_, false).compressed (factor_);
197     }
198   else
199     {
200       orig = unsmob<Duration> (note_events_[0]->get_property ("duration"));
201       note_dur = *orig;
202       SCM factor = get_property ("completionFactor");
203       if (ly_is_procedure (factor))
204         factor = scm_call_2 (factor,
205                              context ()->self_scm (),
206                              note_dur.smobbed_copy ());
207       factor_ = robust_scm2rational (factor, note_dur.factor ());
208       left_to_do_ = orig->get_length ();
209     }
210   Moment nb = next_moment (note_dur.get_length ());
211   if (nb.main_part_ && nb < note_dur.get_length ())
212     {
213       note_dur = Duration (nb.main_part_ / factor_, false).compressed (factor_);
214     }
215
216   do_nothing_until_ = now.main_part_ + note_dur.get_length ();
217
218   for (vsize i = 0; left_to_do_ && i < note_events_.size (); i++)
219     {
220       bool need_clone = !orig || *orig != note_dur;
221       Stream_event *event = note_events_[i];
222
223       if (need_clone)
224         event = event->clone ();
225
226       SCM pits = note_events_[i]->get_property ("pitch");
227       event->set_property ("pitch", pits);
228       event->set_property ("duration", note_dur.smobbed_copy ());
229       event->set_property ("length", Moment (note_dur.get_length ()).smobbed_copy ());
230       event->set_property ("duration-log", scm_from_int (note_dur.duration_log ()));
231
232       /*
233         The Completion_heads_engraver splits an event into a group of consecutive events.
234         For each event in the group, the property "autosplit-end" denotes whether the current event
235         was truncated during splitting. Based on "autosplit-end", the Tie_engraver decides whether a
236         tie event should be processed.
237       */
238       event->set_property ("autosplit-end",
239                            ly_bool2scm (left_to_do_ - note_dur.get_length () > Rational (0)));
240
241       Item *note = make_note_head (event);
242       if (need_clone)
243         event->unprotect ();
244       notes_.push_back (note);
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   if (ties_.size () && !tie_column_)
254     tie_column_ = make_spanner ("TieColumn", ties_[0]->self_scm ());
255
256   if (tie_column_)
257     for (vsize i = ties_.size (); i--;)
258       Tie_column::add_tie (tie_column_, ties_[i]);
259
260   left_to_do_ -= note_dur.get_length ();
261   if (left_to_do_)
262     get_global_context ()->add_moment_to_process (now.main_part_ + note_dur.get_length ());
263   /*
264     don't do complicated arithmetic with grace notes.
265   */
266   if (orig && now_mom ().grace_part_)
267     left_to_do_ = Rational (0, 0);
268 }
269
270 void
271 Completion_heads_engraver::make_tie (Grob *left, Grob *right)
272 {
273   Spanner *p = make_spanner ("Tie", SCM_EOL);
274   Tie::set_head (p, LEFT, left);
275   Tie::set_head (p, RIGHT, right);
276   announce_end_grob (p, SCM_EOL);
277   ties_.push_back (p);
278 }
279
280 void
281 Completion_heads_engraver::stop_translation_timestep ()
282 {
283   ties_.clear ();
284   tie_column_ = 0;
285
286   if (notes_.size ())
287     prev_notes_ = notes_;
288   notes_.clear ();
289 }
290
291 void
292 Completion_heads_engraver::start_translation_timestep ()
293 {
294   Moment now = now_mom ();
295   if (note_end_mom_.main_part_ <= now.main_part_)
296     {
297       note_events_.clear ();
298       prev_notes_.clear ();
299     }
300   context ()->set_property ("completionBusy",
301                             ly_bool2scm (note_events_.size ()));
302 }
303
304 Completion_heads_engraver::Completion_heads_engraver (Context *c)
305   : Engraver (c)
306 {
307   tie_column_ = 0;
308 }
309
310 void
311 Completion_heads_engraver::boot ()
312 {
313   ADD_LISTENER (Completion_heads_engraver, note);
314 }
315
316 ADD_TRANSLATOR (Completion_heads_engraver,
317                 /* doc */
318                 "This engraver replaces @code{Note_heads_engraver}.  It plays"
319                 " some trickery to break long notes and automatically tie them"
320                 " into the next measure.",
321
322                 /* create */
323                 "NoteHead "
324                 "Tie "
325                 "TieColumn ",
326
327                 /* read */
328                 "completionFactor "
329                 "completionUnit "
330                 "measureLength "
331                 "measurePosition "
332                 "middleCPosition "
333                 "timing ",
334
335                 /* write */
336                 "completionBusy "
337                );