]> git.donarmstrong.com Git - lilypond.git/blob - lily/paper-column.cc
Release: bump Welcome versions.
[lilypond.git] / lily / paper-column.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 "paper-column.hh"
21
22 #include "axis-group-interface.hh"
23 #include "bar-line.hh"
24 #include "break-align-interface.hh"
25 #include "font-interface.hh"
26 #include "grob-array.hh"
27 #include "lookup.hh"
28 #include "moment.hh"
29 #include "output-def.hh"
30 #include "paper-score.hh"
31 #include "pointer-group-interface.hh"
32 #include "rhythmic-head.hh"
33 #include "separation-item.hh"
34 #include "skyline-pair.hh"
35 #include "spaceable-grob.hh"
36 #include "spring.hh"
37 #include "string-convert.hh"
38 #include "system.hh"
39 #include "text-interface.hh"
40 #include "warn.hh"
41
42 Grob *
43 Paper_column::clone () const
44 {
45   return new Paper_column (*this);
46 }
47
48 void
49 Paper_column::do_break_processing ()
50 {
51   Item::do_break_processing ();
52 }
53
54 int
55 Paper_column::get_rank (Grob const *me)
56 {
57   return dynamic_cast<Paper_column const *> (me)->rank_;
58 }
59
60 void
61 Paper_column::set_rank (int rank)
62 {
63   rank_ = rank;
64 }
65
66 System *
67 Paper_column::get_system () const
68 {
69   return system_;
70 }
71
72 void
73 Paper_column::set_system (System *s)
74 {
75   system_ = s;
76 }
77
78 Paper_column *
79 Paper_column::get_column () const
80 {
81   return (Paper_column *) (this);
82 }
83
84 Paper_column::Paper_column (SCM l)
85   : Item (l)
86 {
87   system_ = 0;
88   rank_ = -1;
89 }
90
91 Paper_column::Paper_column (Paper_column const &src)
92   : Item (src)
93 {
94   system_ = 0;
95   rank_ = src.rank_;
96 }
97
98 int
99 Paper_column::compare (Grob *const &a,
100                        Grob *const &b)
101 {
102   return sign (dynamic_cast<Paper_column *> (a)->rank_
103                - dynamic_cast<Paper_column *> (b)->rank_);
104 }
105
106 bool
107 Paper_column::less_than (Grob *const &a,
108                          Grob *const &b)
109 {
110   Paper_column *pa = dynamic_cast<Paper_column *> (a);
111   Paper_column *pb = dynamic_cast<Paper_column *> (b);
112
113   return pa->rank_ < pb->rank_;
114 }
115
116 Moment
117 Paper_column::when_mom (Grob *me)
118 {
119   SCM m = me->get_property ("when");
120   if (Moment *when = unsmob<Moment> (m))
121     return *when;
122   return Moment (0);
123 }
124
125 bool
126 Paper_column::is_musical (Grob *me)
127 {
128   SCM m = me->get_property ("shortest-starter-duration");
129   Moment s (0);
130   if (unsmob<Moment> (m))
131     s = *unsmob<Moment> (m);
132   return s != Moment (0);
133 }
134
135 bool
136 Paper_column::is_used (Grob *me)
137 {
138   extract_grob_set (me, "elements", elts);
139   if (elts.size ())
140     return true;
141
142   extract_grob_set (me, "bounded-by-me", bbm);
143   if (bbm.size ())
144     return true;
145
146   if (Paper_column::is_breakable (me))
147     return true;
148
149   if (to_boolean (me->get_property ("used")))
150     return true;
151
152   if (scm_is_pair (me->get_property ("labels")))
153     return true;
154
155   return false;
156 }
157
158 bool
159 Paper_column::is_breakable (Grob *me)
160 {
161   return scm_is_symbol (me->get_property ("line-break-permission"));
162 }
163
164 Real
165 Paper_column::minimum_distance (Grob *left, Grob *right)
166 {
167   Drul_array<Grob *> cols (left, right);
168   Drul_array<Skyline> skys = Drul_array<Skyline> (Skyline (RIGHT), Skyline (LEFT));
169
170   for (LEFT_and_RIGHT (d))
171     {
172       Skyline_pair *sp = unsmob<Skyline_pair> (cols[d]->get_property ("horizontal-skylines"));
173       if (sp)
174         skys[d] = (*sp)[-d];
175     }
176
177   skys[RIGHT].merge (Separation_item::conditional_skyline (right, left));
178
179   return max (0.0, skys[LEFT].distance (skys[RIGHT]));
180 }
181
182 Interval
183 Paper_column::break_align_width (Grob *me, SCM align_syms)
184 {
185   Grob *p = me->get_parent (X_AXIS);
186
187   if (scm_is_symbol (align_syms))
188     align_syms = scm_list_1 (align_syms);
189
190   if (is_musical (me))
191     {
192       me->programming_error ("tried to get break-align-width of a musical column");
193       return Interval (0, 0) + me->relative_coordinate (p, X_AXIS);
194     }
195
196   Grob *align = 0;
197   for (;!align && scm_is_pair (align_syms); align_syms = scm_cdr (align_syms))
198     {
199       SCM align_sym = scm_car (align_syms);
200       if (scm_is_eq (align_sym, ly_symbol2scm ("staff-bar"))
201           || scm_is_eq (align_sym, ly_symbol2scm ("break-alignment")))
202         align = Pointer_group_interface::find_grob
203           (me, ly_symbol2scm ("elements"),
204            (scm_is_eq (align_sym, ly_symbol2scm ("staff-bar"))
205             ? Bar_line::non_empty_barline
206             : has_interface<Break_alignment_interface>));
207       else
208         {
209           extract_grob_set (me, "elements", elts);
210           for (vsize i = 0; i < elts.size (); i++)
211             {
212               if (elts[i]->get_property ("break-align-symbol") == align_sym
213                   && !elts[i]->extent (elts[i], X_AXIS).is_empty ())
214                 {
215                   align = elts[i];
216                   break;
217                 }
218             }
219         }
220     }
221
222   if (!align)
223     return Interval (0, 0) + me->relative_coordinate (p, X_AXIS);
224
225   return align->extent (p, X_AXIS);
226 }
227
228 /*
229   Loop through elements of a PaperColumn, find all grobs implementing specified
230   interface and return their combined extent.
231 */
232 Interval
233 Paper_column::get_interface_extent (Grob *column, SCM iface, Axis a)
234 {
235   Interval extent = Interval (0, 0);
236   extract_grob_set (column, "elements", elts);
237
238   for (vsize i = 0; i < elts.size (); i++)
239     if (elts[i]->internal_has_interface (iface))
240       extent.unite (robust_relative_extent (elts[i], elts[i], a));
241
242   return extent;
243 }
244
245 /*
246   Print a:
247   - vertical line,
248   - the rank number,
249   - rank moment,
250   - blue arrow representing ideal distance,
251   - red arrow representing minimum distance
252   to aid debugging.  To turn this on, simply add
253   \override Score.PaperColumn #'stencil = #ly:paper-column::print
254   \override Score.NonMusicalPaperColumn #'stencil = #ly:paper-column::print
255   to your score.
256   Also, as of 2013-10-16 there's a switch in Frescobaldi that turns this on.
257 */
258 MAKE_DOCUMENTED_SCHEME_CALLBACK (Paper_column, print, 1,
259                                  "Optional stencil for @code{PaperColumn} or"
260                                  "@code{NonMusicalPaperColumn}.\n"
261                                  "Draws the @code{rank number} of each column,"
262                                  " its moment in time, a blue arrow showing the"
263                                  " ideal distance, and a red arrow showing the"
264                                  " minimum distance between columns.");
265 SCM
266 Paper_column::print (SCM p)
267 {
268   Paper_column *me = unsmob<Paper_column> (p);
269
270   string r = ::to_string (Paper_column::get_rank (me));
271
272   Moment *mom = unsmob<Moment> (me->get_property ("when"));
273   string when = mom ? mom->to_string () : "?/?";
274
275   Font_metric *musfont = Font_interface::get_default_font (me);
276   SCM properties = Font_interface::text_font_alist_chain (me);
277   SCM scm_mol = Text_interface::interpret_markup (me->layout ()->self_scm (),
278                                                   properties,
279                                                   ly_string2scm (r));
280   SCM when_mol = Text_interface::interpret_markup (me->layout ()->self_scm (),
281                                                    properties,
282                                                    ly_string2scm (when));
283   Stencil t = *unsmob<Stencil> (scm_mol);
284   t.scale (1.2, 1.4);
285   t.add_at_edge (Y_AXIS, DOWN, *unsmob<Stencil> (when_mol), 0.1);
286   t.align_to (X_AXIS, LEFT);
287   // compensate for font serifs and half letter-distance
288   t.translate (Offset (-0.1, 0));
289   t.align_to (Y_AXIS, DOWN);
290
291   Stencil l = Lookup::filled_box (Box (Interval (0, 0.02),
292                                        Interval (-8, -1)));
293
294   Real small_pad = 0.15;
295   Real big_pad = 0.35;
296
297   // number of printed arrows from *both* loops
298   int j = 0;
299
300   for (SCM s = me->get_object ("ideal-distances");
301        scm_is_pair (s); s = scm_cdr (s))
302     {
303       Spring *sp = unsmob<Spring> (scm_caar (s));
304       if (!unsmob<Grob> (scm_cdar (s))
305           || !unsmob<Grob> (scm_cdar (s))->get_system ())
306         continue;
307
308       j++;
309
310       Stencil arrowhead (musfont->find_by_name ("arrowheads.open.01"));
311       // initial scaling; it will also scale with font-size.
312       arrowhead.scale (1, 1.66);
313       Real head_len = arrowhead.extent (X_AXIS).length ();
314
315       SCM stil = Text_interface::interpret_markup (me->layout ()->self_scm (),
316                                                    properties,
317                                                    ly_string2scm (String_convert::form_string ("%5.2lf", sp->distance ())));
318       Stencil *number_stc = unsmob<Stencil> (stil);
319       number_stc->scale (1, 1.1);
320       Real num_height = number_stc->extent (Y_AXIS).length ();
321       Real num_len = number_stc->extent (X_AXIS).length ();
322       number_stc->align_to (Y_AXIS, DOWN);
323
324       // arrow's y-coord relative to the top of l stencil:
325       Real y = -2.5;
326       y -= j * (num_height + small_pad + big_pad);
327       // horizontally center number on the arrow, excluding arrowhead.
328       Offset num_off = Offset ((sp->distance () - num_len - head_len) / 2,
329                                y + small_pad);
330
331       vector<Offset> pts;
332       pts.push_back (Offset (0, y));
333
334       Offset p2 (sp->distance (), y);
335       pts.push_back (p2);
336
337       Stencil id_stencil = Lookup::points_to_line_stencil (0.1, pts);
338       id_stencil.add_stencil (arrowhead.translated (p2));
339       id_stencil.add_stencil (number_stc->translated (num_off));
340       // use a lighter shade of blue so it will remain legible on black background.
341       id_stencil = id_stencil.in_color (0.2, 0.4, 1);
342       l.add_stencil (id_stencil);
343     }
344
345   for (SCM s = me->get_object ("minimum-distances");
346        scm_is_pair (s); s = scm_cdr (s))
347     {
348       Real dist = scm_to_double (scm_cdar (s));
349       Grob *other = unsmob<Grob> (scm_caar (s));
350       if (!other || other->get_system () != me->get_system ())
351         continue;
352
353       j++;
354
355       Stencil arrowhead (musfont->find_by_name ("arrowheads.open.01"));
356       // initial scaling; it will also scale with font-size.
357       arrowhead.scale (1, 1.66);
358       Real head_len = arrowhead.extent (X_AXIS).length ();
359
360       SCM stil = Text_interface::interpret_markup (me->layout ()->self_scm (),
361                                                    properties,
362                                                    ly_string2scm (String_convert::form_string ("%5.2lf", dist)));
363       Stencil *number_stc = unsmob<Stencil> (stil);
364       number_stc->scale (1, 1.1);
365       Real num_height = number_stc->extent (Y_AXIS).length ();
366       Real num_len = number_stc->extent (X_AXIS).length ();
367       number_stc->align_to (Y_AXIS, UP);
368
369       // arrow's y-coord relative to the top of l stencil:
370       Real y = -3;
371       y -= j * (num_height + small_pad + big_pad);
372       // horizontally center number on the arrow, excluding arrowhead.
373       Offset num_off = Offset ((dist - num_len - head_len) / 2,
374                                y - small_pad);
375
376       vector<Offset> pts;
377       pts.push_back (Offset (0, y));
378
379       Offset p2 (dist, y);
380       pts.push_back (p2);
381
382       Stencil id_stencil = Lookup::points_to_line_stencil (0.1, pts);
383       id_stencil.add_stencil (arrowhead.translated (p2));
384       id_stencil.add_stencil (number_stc->translated (num_off));
385       // use a lighter shade of red so it will remain legible on black background.
386       id_stencil = id_stencil.in_color (1, 0.25, 0.25);
387       l.add_stencil (id_stencil);
388     }
389   t.add_stencil (l);
390   return t.smobbed_copy ();
391 }
392
393 static bool grob_is_live (const Grob *g)
394 {
395   return g && g->is_live ();
396 }
397
398 /*
399   This is all too hairy. We use bounded-by-me to make sure that some
400   columns are kept "alive". Unfortunately, when spanners are suicided,
401   this falls apart again, because suicided spanners are still in
402   bounded-by-me
403
404   THIS IS BROKEN KLUDGE. WE SHOULD INVENT SOMETHING BETTER.
405 */
406 MAKE_SCHEME_CALLBACK (Paper_column, before_line_breaking, 1);
407 SCM
408 Paper_column::before_line_breaking (SCM grob)
409 {
410   Grob *me = unsmob<Grob> (grob);
411
412   if (Grob_array *ga = unsmob<Grob_array> (me->get_object ("bounded-by-me")))
413     ga->filter (grob_is_live);
414
415   return SCM_UNSPECIFIED;
416 }
417
418 /* FIXME: This is a hack that we use to identify columns that used to
419    contain note-heads but whose note-heads were moved by one of the ligature
420    engravers. Once the ligature engravers are fixed to behave nicely, this
421    function can be removed.
422 */
423 bool
424 Paper_column::is_extraneous_column_from_ligature (Grob *me)
425 {
426   if (!is_musical (me))
427     return false;
428
429   // If all the note-heads that I think are my children actually belong
430   // to another column, then I am extraneous.
431   extract_grob_set (me, "elements", elts);
432   bool has_notehead = false;
433   for (vsize i = 0; i < elts.size (); i++)
434     {
435       if (has_interface<Rhythmic_head> (elts[i]))
436         {
437           has_notehead = true;
438           if (dynamic_cast<Item *> (elts[i])->get_column () == me)
439             return false;
440         }
441     }
442   return has_notehead;
443 }
444
445 ADD_INTERFACE (Paper_column,
446                "@code{Paper_column} objects form the top-most X@tie{}parents"
447                " for items.  There are two types of columns: musical and"
448                " non-musical, to which musical and non-musical objects are"
449                " attached respectively.  The spacing engine determines the"
450                " X@tie{}positions of these objects.\n"
451                "\n"
452                "They are numbered, the first (leftmost) is column@tie{}0."
453                "  Numbering happens before line breaking, and columns are not"
454                " renumbered after line breaking.  Since many columns go"
455                " unused, you should only use the rank field to get ordering"
456                " information.  Two adjacent columns may have non-adjacent"
457                " numbers.",
458
459                /* properties */
460                "between-cols "
461                "bounded-by-me "
462                "full-measure-extra-space "
463                "grace-spacing "
464                "labels "
465                "line-break-system-details "
466                "line-break-penalty "
467                "line-break-permission "
468                "maybe-loose "
469                "page-break-penalty "
470                "page-break-permission "
471                "page-turn-penalty "
472                "page-turn-permission "
473                "rhythmic-location "
474                "shortest-playing-duration "
475                "shortest-starter-duration "
476                "spacing "
477                "used "
478                "when ");
479