]> git.donarmstrong.com Git - lilypond.git/blob - lily/page-turn-engraver.cc
Doc-es: update Vocal.
[lilypond.git] / lily / page-turn-engraver.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 2006--2011 Joe Neeman <joeneeman@gmail.com>
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 "engraver.hh"
21
22 #include "context.hh"
23 #include "duration.hh"
24 #include "grob.hh"
25 #include "international.hh"
26 #include "paper-column.hh"
27 #include "stream-event.hh"
28 #include "warn.hh"
29
30 #include "translator.icc"
31
32 class Page_turn_event
33 {
34 public:
35   SCM permission_;
36   Real penalty_;
37   Interval_t<Rational> duration_;
38
39   Page_turn_event (Rational start, Rational end, SCM perm, Real pen)
40   {
41     duration_[LEFT] = start;
42     duration_[RIGHT] = end;
43     permission_ = perm;
44     penalty_ = pen;
45   }
46
47   /* Suppose we have decided on a possible page turn, only to change
48      out mind later (for example, if there is a volta repeat and it
49      would be difficult to turn the page back). Then we need to
50      re-penalize a region of the piece. Depending on how the events
51      intersect, we may have to split it into as many as 3 pieces.
52   */
53   vector<Page_turn_event> penalize (Page_turn_event const &penalty)
54   {
55     Interval_t<Rational> intersect = intersection (duration_, penalty.duration_);
56     vector<Page_turn_event> ret;
57
58     if (intersect.is_empty ())
59       {
60         ret.push_back (*this);
61         return ret;
62       }
63
64     Real new_pen = max (penalty_, penalty.penalty_);
65
66     if (duration_[LEFT] < penalty.duration_[LEFT])
67       ret.push_back (Page_turn_event (duration_[LEFT], penalty.duration_[LEFT], permission_, penalty_));
68
69     if (penalty.permission_ != SCM_EOL)
70       ret.push_back (Page_turn_event (intersect[LEFT], intersect[RIGHT], permission_, new_pen));
71
72     if (penalty.duration_[RIGHT] < duration_[RIGHT])
73       ret.push_back (Page_turn_event (penalty.duration_[RIGHT], duration_[RIGHT], permission_, penalty_));
74
75     return ret;
76   }
77 };
78
79 class Page_turn_engraver : public Engraver
80 {
81   Moment rest_begin_;
82   Moment repeat_begin_;
83   Moment note_end_;
84   Rational repeat_begin_rest_length_;
85
86   vector<Page_turn_event> forced_breaks_;
87   vector<Page_turn_event> automatic_breaks_;
88   vector<Page_turn_event> repeat_penalties_;
89
90   /* the next 3 are in sync (ie. same number of elements, etc.) */
91   vector<Rational> breakable_moments_;
92   vector<Grob *> breakable_columns_;
93   vector<bool> special_barlines_;
94
95   SCM max_permission (SCM perm1, SCM perm2);
96   Real penalty (Rational rest_len);
97   Grob *breakable_column (Page_turn_event const &);
98
99 protected:
100   DECLARE_TRANSLATOR_LISTENER (break);
101   DECLARE_ACKNOWLEDGER (note_head);
102
103 public:
104   TRANSLATOR_DECLARATIONS (Page_turn_engraver);
105   void stop_translation_timestep ();
106   void start_translation_timestep ();
107   void finalize ();
108 };
109
110 Page_turn_engraver::Page_turn_engraver ()
111 {
112   repeat_begin_ = Moment (-1);
113   repeat_begin_rest_length_ = 0;
114   rest_begin_ = 0;
115   note_end_ = 0;
116 }
117
118 Grob *
119 Page_turn_engraver::breakable_column (Page_turn_event const &brk)
120 {
121   vsize start = lower_bound (breakable_moments_, brk.duration_[LEFT], less<Rational> ());
122   vsize end = upper_bound (breakable_moments_, brk.duration_[RIGHT], less<Rational> ());
123
124   if (start == breakable_moments_.size ())
125     return NULL;
126   if (end == 0)
127     return NULL;
128   end--;
129
130   for (vsize i = end + 1; i-- > start;)
131     if (special_barlines_[i])
132       return breakable_columns_[i];
133
134   return breakable_columns_[end];
135 }
136
137 Real
138 Page_turn_engraver::penalty (Rational rest_len)
139 {
140   Rational min_turn = robust_scm2moment (get_property ("minimumPageTurnLength"), Moment (1)).main_part_;
141
142   return (rest_len < min_turn) ? infinity_f : 0;
143 }
144
145 void
146 Page_turn_engraver::acknowledge_note_head (Grob_info gi)
147 {
148   Stream_event *cause = gi.event_cause ();
149
150   Duration *dur_ptr = cause
151                       ? unsmob_duration (cause->get_property ("duration"))
152                       : 0;
153
154   if (!dur_ptr)
155     return;
156
157   if (rest_begin_ < now_mom ())
158     {
159       Real pen = penalty ((now_mom () - rest_begin_).main_part_);
160       if (!isinf (pen))
161         automatic_breaks_.push_back (Page_turn_event (rest_begin_.main_part_,
162                                                       now_mom ().main_part_,
163                                                       ly_symbol2scm ("allow"), 0));
164     }
165
166   if (rest_begin_ <= repeat_begin_)
167     repeat_begin_rest_length_ = (now_mom () - repeat_begin_).main_part_;
168   note_end_ = now_mom () + dur_ptr->get_length ();
169 }
170
171 IMPLEMENT_TRANSLATOR_LISTENER (Page_turn_engraver, break);
172 void
173 Page_turn_engraver::listen_break (Stream_event *ev)
174 {
175   string name = ly_symbol2string (ev->get_property ("class"));
176
177   if (name == "page-turn-event")
178     {
179       SCM permission = ev->get_property ("break-permission");
180       Real penalty = robust_scm2double (ev->get_property ("break-penalty"), 0);
181       Rational now = now_mom ().main_part_;
182
183       forced_breaks_.push_back (Page_turn_event (now, now, permission, penalty));
184     }
185 }
186
187 void
188 Page_turn_engraver::start_translation_timestep ()
189 {
190   /* What we want to do is to build a list of all the
191      breakable paper columns. In general, paper-columns won't be marked as
192      such until the Paper_column_engraver has done stop_translation_timestep.
193
194      Therefore, we just grab /all/ paper columns (in the
195      stop_translation_timestep, since they're not created here yet)
196      and remove the non-breakable ones at the beginning of the following
197      timestep.
198   */
199
200   if (breakable_columns_.size () && !Paper_column::is_breakable (breakable_columns_.back ()))
201     {
202       breakable_columns_.pop_back ();
203       breakable_moments_.pop_back ();
204       special_barlines_.pop_back ();
205     }
206 }
207
208 void
209 Page_turn_engraver::stop_translation_timestep ()
210 {
211   Grob *pc = unsmob_grob (get_property ("currentCommandColumn"));
212
213   if (pc)
214     {
215       breakable_columns_.push_back (pc);
216       breakable_moments_.push_back (now_mom ().main_part_);
217
218       SCM bar_scm = get_property ("whichBar");
219       string bar = robust_scm2string (bar_scm, "");
220
221       special_barlines_.push_back (bar != "" && bar != "|");
222     }
223
224   /* C&P from Repeat_acknowledge_engraver */
225   SCM cs = get_property ("repeatCommands");
226   bool start = false;
227   bool end = false;
228
229   for (; scm_is_pair (cs); cs = scm_cdr (cs))
230     {
231       SCM command = scm_car (cs);
232       if (command == ly_symbol2scm ("start-repeat"))
233         start = true;
234       else if (command == ly_symbol2scm ("end-repeat"))
235         end = true;
236     }
237
238   if (end && repeat_begin_.main_part_ >= Moment (0))
239     {
240       Rational now = now_mom ().main_part_;
241       Real pen = penalty ((now_mom () - rest_begin_).main_part_ + repeat_begin_rest_length_);
242       Moment *m = unsmob_moment (get_property ("minimumRepeatLengthForPageTurn"));
243       if (m && *m > (now_mom () - repeat_begin_))
244         pen = infinity_f;
245
246       if (pen == infinity_f)
247         repeat_penalties_.push_back (Page_turn_event (repeat_begin_.main_part_, now, SCM_EOL, -infinity_f));
248       else
249         repeat_penalties_.push_back (Page_turn_event (repeat_begin_.main_part_, now, ly_symbol2scm ("allow"), pen));
250
251       repeat_begin_ = Moment (-1);
252     }
253
254   if (start)
255     {
256       repeat_begin_ = now_mom ();
257       repeat_begin_rest_length_ = 0;
258     }
259   rest_begin_ = note_end_;
260 }
261
262 /* return the most permissive symbol (where force is the most permissive and
263    forbid is the least
264 */
265 SCM
266 Page_turn_engraver::max_permission (SCM perm1, SCM perm2)
267 {
268   if (perm1 == SCM_EOL)
269     return perm2;
270   if (perm1 == ly_symbol2scm ("allow") && perm2 == ly_symbol2scm ("force"))
271     return perm2;
272   return perm1;
273 }
274
275 void
276 Page_turn_engraver::finalize ()
277 {
278   vsize rep_index = 0;
279   vector<Page_turn_event> auto_breaks;
280
281   /* filter the automatic breaks through the repeat penalties */
282   for (vsize i = 0; i < automatic_breaks_.size (); i++)
283     {
284       Page_turn_event &brk = automatic_breaks_[i];
285
286       /* find the next applicable repeat penalty */
287       for (;
288            rep_index < repeat_penalties_.size ()
289            && repeat_penalties_[rep_index].duration_[RIGHT] <= brk.duration_[LEFT];
290            rep_index++)
291         ;
292
293       if (rep_index >= repeat_penalties_.size ()
294           || brk.duration_[RIGHT] <= repeat_penalties_[rep_index].duration_[LEFT])
295         auto_breaks.push_back (brk);
296       else
297         {
298           vector<Page_turn_event> split = brk.penalize (repeat_penalties_[rep_index]);
299
300           /* it's possible that the last of my newly-split events overlaps the next repeat_penalty,
301              in which case we need to refilter that event */
302           if (rep_index + 1 < repeat_penalties_.size ()
303               && split.size ()
304               && split.back ().duration_[RIGHT] > repeat_penalties_[rep_index + 1].duration_[LEFT])
305             {
306               automatic_breaks_[i] = split.back ();
307               split.pop_back ();
308               i--;
309             }
310           auto_breaks.insert (auto_breaks.end (), split.begin (), split.end ());
311         }
312     }
313
314   /* apply the automatic breaks */
315   for (vsize i = 0; i < auto_breaks.size (); i++)
316     {
317       Page_turn_event const &brk = auto_breaks[i];
318       Grob *pc = breakable_column (auto_breaks[i]);
319       if (pc)
320         {
321           SCM perm = max_permission (pc->get_property ("page-turn-permission"), brk.permission_);
322           Real pen = min (robust_scm2double (pc->get_property ("page-turn-penalty"), infinity_f), brk.penalty_);
323           pc->set_property ("page-turn-permission", perm);
324           pc->set_property ("page-turn-penalty", scm_from_double (pen));
325         }
326     }
327
328   /* unless a manual break overrides it, allow a page turn at the end of the piece */
329   breakable_columns_.back ()->set_property ("page-turn-permission", ly_symbol2scm ("allow"));
330
331   /* apply the manual breaks */
332   for (vsize i = 0; i < forced_breaks_.size (); i++)
333     {
334       Page_turn_event const &brk = forced_breaks_[i];
335       Grob *pc = breakable_column (forced_breaks_[i]);
336       if (pc)
337         {
338           pc->set_property ("page-turn-permission", brk.permission_);
339           pc->set_property ("page-turn-penalty", scm_from_double (brk.penalty_));
340         }
341     }
342 }
343
344 ADD_ACKNOWLEDGER (Page_turn_engraver, note_head);
345
346 ADD_TRANSLATOR (Page_turn_engraver,
347                 /* doc */
348                 "Decide where page turns are allowed to go.",
349
350                 /* create */
351                 "",
352
353                 /* read */
354                 "minimumPageTurnLength "
355                 "minimumRepeatLengthForPageTurn ",
356
357                 /* write */
358                 ""
359                );