]> git.donarmstrong.com Git - lilypond.git/blob - lily/hairpin.cc
Web-it: update the website
[lilypond.git] / lily / hairpin.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 1997--2011 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 "hairpin.hh"
21
22 #include "axis-group-interface.hh"
23 #include "bar-line.hh"
24 #include "dimensions.hh"
25 #include "directional-element-interface.hh"
26 #include "international.hh"
27 #include "line-interface.hh"
28 #include "output-def.hh"
29 #include "paper-column.hh"
30 #include "pointer-group-interface.hh"
31 #include "spanner.hh"
32 #include "staff-symbol-referencer.hh"
33 #include "text-interface.hh"
34 #include "note-column.hh"
35 #include "system.hh"
36 #include "warn.hh"
37
38 MAKE_SCHEME_CALLBACK (Hairpin, pure_height, 3);
39 SCM
40 Hairpin::pure_height (SCM smob, SCM, SCM)
41 {
42   Grob *me = unsmob_grob (smob);
43   Real height = robust_scm2double (me->get_property ("height"), 0.0)
44                 * Staff_symbol_referencer::staff_space (me);
45
46   Real thickness = robust_scm2double (me->get_property ("thickness"), 1)
47                    * Staff_symbol_referencer::line_thickness (me);
48
49   height += thickness / 2;
50   return ly_interval2scm (Interval (-height, height));
51 }
52
53 MAKE_SCHEME_CALLBACK (Hairpin, broken_bound_padding, 1);
54 SCM
55 Hairpin::broken_bound_padding (SCM smob)
56 {
57   Spanner *me = unsmob_spanner (smob);
58   Item *r_bound = me->get_bound (RIGHT);
59   if (r_bound->break_status_dir () != -1)
60     {
61       me->warning ("Asking for broken bound padding at a non-broken bound.");
62       return scm_from_double (0.0);
63     }
64
65   System *sys = dynamic_cast<System *> (me->get_system ());
66   Direction dir = get_grob_direction (me->get_parent (Y_AXIS));
67   if (!dir)
68     return scm_from_double (0.0);
69
70   Grob *my_vertical_axis_group = Grob::get_vertical_axis_group (me);
71   Drul_array<Grob *> vertical_axis_groups;
72   Direction d = DOWN;
73   do
74     vertical_axis_groups[d] = d == dir
75                               ? sys->get_neighboring_staff (d, my_vertical_axis_group, Interval_t<int> (me->spanned_rank_interval ()))
76                               : my_vertical_axis_group;
77   while (flip (&d) != DOWN);
78
79   if (!vertical_axis_groups[dir])
80     return scm_from_double (0.0);
81
82   Drul_array<Grob *> span_bars (0, 0);
83   d = DOWN;
84   do
85     {
86       extract_grob_set (vertical_axis_groups[d], "elements", elts);
87       for (vsize i = elts.size (); i--;)
88         if (Bar_line::has_interface (elts[i])
89             && dynamic_cast<Item *> (elts[i])->break_status_dir () == -1)
90           {
91             SCM hsb = elts[i]->get_property ("has-span-bar");
92             if (!scm_is_pair (hsb))
93               break;
94
95             span_bars[d] = unsmob_grob ((d == UP ? scm_car : scm_cdr) (hsb));
96             break;
97           }
98       if (!span_bars[d])
99         return scm_from_double (0.0);
100     }
101   while (flip (&d) != DOWN);
102
103   if (span_bars[DOWN] != span_bars[UP])
104     return scm_from_double (0.0);
105
106   return scm_from_double (0.6);
107 }
108
109 MAKE_SCHEME_CALLBACK (Hairpin, print, 1);
110 SCM
111 Hairpin::print (SCM smob)
112 {
113   Spanner *me = unsmob_spanner (smob);
114
115   SCM s = me->get_property ("grow-direction");
116   if (!is_direction (s))
117     {
118       me->suicide ();
119       return SCM_EOL;
120     }
121
122   Direction grow_dir = to_dir (s);
123   Real padding = robust_scm2double (me->get_property ("bound-padding"), 0.5);
124
125   Drul_array<bool> broken;
126   Drul_array<Item *> bounds;
127   Direction d = LEFT;
128   do
129     {
130       bounds[d] = me->get_bound (d);
131       broken[d] = bounds[d]->break_status_dir () != CENTER;
132     }
133   while (flip (&d) != LEFT);
134
135   broken[RIGHT] = broken[RIGHT] && me->broken_neighbor (RIGHT);
136   broken[RIGHT] = broken[RIGHT] && me->broken_neighbor (RIGHT)->is_live ();
137
138   if (broken[RIGHT])
139     {
140       Spanner *next = me->broken_neighbor (RIGHT);
141       Stencil *s = next->get_stencil ();
142       if (!s || s->is_empty ())
143         broken[RIGHT] = false;
144     }
145
146   Grob *common = bounds[LEFT]->common_refpoint (bounds[RIGHT], X_AXIS);
147   Drul_array<Real> x_points;
148
149   /*
150     Use the height and thickness of the hairpin when making a circled tip
151   */
152   bool circled_tip = ly_scm2bool (me->get_property ("circled-tip"));
153   Real height = robust_scm2double (me->get_property ("height"), 0.2)
154                 * Staff_symbol_referencer::staff_space (me);
155   /*
156     FIXME: 0.525 is still just a guess...
157   */
158   Real rad = height * 0.525;
159   Real thick = 1.0;
160   if (circled_tip)
161     thick = robust_scm2double (me->get_property ("thickness"), 1.0)
162             * Staff_symbol_referencer::line_thickness (me);
163
164   do
165     {
166       Item *b = bounds[d];
167       x_points[d] = b->relative_coordinate (common, X_AXIS);
168       if (broken [d])
169         {
170           if (d == LEFT)
171             x_points[d] = b->extent (common, X_AXIS)[RIGHT];
172         }
173       else
174         {
175           if (Text_interface::has_interface (b))
176             {
177               Interval e = b->extent (common, X_AXIS);
178               if (!e.is_empty ())
179                 x_points[d] = e[-d] - d * padding;
180             }
181           else
182             {
183               bool neighbor_found = false;
184               Spanner *adjacent = NULL;
185               extract_grob_set (me, "adjacent-spanners", neighbors);
186               for (vsize i = 0; i < neighbors.size (); i++)
187                 {
188                   /*
189                     FIXME: this will fuck up in case of polyphonic
190                     notes in other voices. Need to look at note-columns
191                     in the current staff/voice.
192                   */
193                   adjacent = dynamic_cast<Spanner *> (neighbors[i]);
194                   if (adjacent
195                       && (adjacent->get_bound (-d)->get_column ()
196                           == b->get_column ()))
197                     {
198                       neighbor_found = true;
199                       break;
200                     }
201                 }
202
203               Interval e = (Axis_group_interface::has_interface (b)
204                             ? Axis_group_interface::generic_bound_extent (b, common, X_AXIS)
205                             : robust_relative_extent (b, common, X_AXIS));
206               if (neighbor_found)
207                 {
208                   if (Hairpin::has_interface (adjacent))
209                     {
210                       /*
211                         Handle back-to-back hairpins with a circle in the middle
212                       */
213                       if (circled_tip && (grow_dir != d))
214                         x_points[d] = e.center () + d * (rad - thick / 2.0);
215                       /*
216                         If we're hung on a paper column, that means we're not
217                         adjacent to a text-dynamic, and we may move closer. We
218                         make the padding a little smaller, here.
219                       */
220                       else
221                         x_points[d] = e.center () - d * padding / 3;
222                     }
223                   // Our neighbor is a dynamic text spanner, so add the
224                   // same amount of padding as for text dynamics
225                   else
226                     x_points[d] = e[-d] - d * padding;
227                 }
228               else
229                 {
230                   if (Note_column::has_interface (b)
231                       && Note_column::has_rests (b))
232                     x_points[d] = e[-d];
233                   else
234                     x_points[d] = e[d];
235                 }
236             }
237         }
238     }
239   while (flip (&d) != LEFT);
240
241   // here, add padding for barlines that are not at the end of a staff
242   if (Item::is_non_musical (bounds[RIGHT]) && bounds[RIGHT]->break_status_dir () == 0)
243     x_points[RIGHT] -= padding;
244
245   // here, add padding for barlines that are at the end of a staff
246   Real broken_bound_padding = 0.0;
247   if (bounds[RIGHT]->break_status_dir () == -1)
248     {
249       extract_grob_set (me, "concurrent-hairpins", chp);
250       for (vsize i = 0; i < chp.size (); i++)
251         {
252           Spanner *span_elt = dynamic_cast<Spanner *> (chp[i]);
253           if (span_elt->get_bound (RIGHT)->break_status_dir () == -1)
254             broken_bound_padding = max (broken_bound_padding,
255                                          robust_scm2double (span_elt->get_property ("broken-bound-padding"), 0.0));
256         }
257     }
258   x_points[RIGHT] -= broken_bound_padding;
259
260   Real width = x_points[RIGHT] - x_points[LEFT];
261
262   if (width < 0)
263     {
264       me->warning (_ ((grow_dir < 0) ? "decrescendo too small"
265                       : "crescendo too small"));
266       width = 0;
267     }
268
269   bool continued = broken[Direction (-grow_dir)];
270
271   Real starth = 0;
272   Real endh = 0;
273   if (grow_dir < 0)
274     {
275       starth = height;
276       endh = continued ? height / 2 : 0.0;
277     }
278   else
279     {
280       starth = continued ? height / 2 : 0.0;
281       endh = height;
282     }
283
284   /*
285     should do relative to staff-symbol staff-space?
286   */
287   Stencil mol;
288   Real x = 0.0;
289
290   /*
291     Compensate for size of circle
292   */
293   Direction tip_dir = -grow_dir;
294   if (circled_tip && !broken[tip_dir])
295     {
296       if (grow_dir > 0)
297         x = rad * 2.0;
298       else if (grow_dir < 0)
299         width -= rad * 2.0;
300     }
301   mol = Line_interface::line (me, Offset (x, starth), Offset (width, endh));
302   mol.add_stencil (Line_interface::line (me,
303                                          Offset (x, -starth),
304                                          Offset (width, -endh)));
305
306   /*
307     Support al/del niente notation by putting a circle at the
308     tip of the (de)crescendo.
309   */
310   if (circled_tip)
311     {
312       Box extent (Interval (-rad, rad), Interval (-rad, rad));
313
314       /* Hmmm, perhaps we should have a Lookup::circle () method? */
315       Stencil circle (extent,
316                       scm_list_4 (ly_symbol2scm ("circle"),
317                                   scm_from_double (rad),
318                                   scm_from_double (thick),
319                                   SCM_BOOL_F));
320
321       /*
322         don't add another circle if the hairpin is broken
323       */
324       if (!broken[tip_dir])
325         mol.add_at_edge (X_AXIS, tip_dir, Stencil (circle), 0);
326     }
327
328   mol.translate_axis (x_points[LEFT]
329                       - bounds[LEFT]->relative_coordinate (common, X_AXIS),
330                       X_AXIS);
331   return mol.smobbed_copy ();
332 }
333
334 ADD_INTERFACE (Hairpin,
335                "A hairpin crescendo or decrescendo.",
336
337                /* properties */
338                "adjacent-spanners "
339                "circled-tip "
340                "concurrent-hairpins "
341                "broken-bound-padding "
342                "bound-padding "
343                "grow-direction "
344                "height "
345               );