]> git.donarmstrong.com Git - lilypond.git/blob - lily/dynamic-engraver.cc
2f66955d446317d3ad5682d633b992c579ee0c06
[lilypond.git] / lily / dynamic-engraver.cc
1 /*
2   dynamic-engraver.cc -- implement Dynamic_engraver
3
4   source file of the GNU LilyPond music typesetter
5
6   (c) 1997--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
7 */
8
9 #include "axis-group-interface.hh"
10 #include "context.hh"
11 #include "dimensions.hh"
12 #include "directional-element-interface.hh"
13 #include "engraver.hh"
14 #include "hairpin.hh"
15 #include "international.hh"
16 #include "interval.hh"
17 #include "note-column.hh"
18 #include "paper-column.hh"
19 #include "pointer-group-interface.hh"
20 #include "script-interface.hh"
21 #include "self-alignment-interface.hh"
22 #include "side-position-interface.hh"
23 #include "staff-symbol-referencer.hh"
24 #include "stream-event.hh"
25 #include "warn.hh"
26 #include "spanner.hh"
27 #include "text-interface.hh"
28
29 #include "translator.icc"
30
31 /*
32   TODO:
33
34   * direction of text-dynamic-event if not equal to direction of
35   line-spanner
36
37   - TODO: this engraver is too complicated. We should split it into
38   the handling of the basic grobs and the linespanner
39
40   - TODO: the line-spanner is not killed after the (de)crescs are
41   finished.
42 */
43
44 /**
45    print text & hairpin dynamics.
46 */
47 class Dynamic_engraver : public Engraver
48 {
49   Item *script_;
50   Spanner *line_spanner_;
51   Spanner *cresc_;
52
53   Spanner *finished_line_spanner_;
54   Spanner *finished_cresc_;
55
56   Stream_event *script_ev_;
57   Stream_event *current_cresc_ev_;
58
59   Drul_array<Stream_event *> accepted_spanevents_drul_;
60
61   vector<Note_column*> pending_columns_;
62   vector<Grob*> pending_elements_;
63
64   void typeset_all ();
65
66   TRANSLATOR_DECLARATIONS (Dynamic_engraver);
67   DECLARE_ACKNOWLEDGER (note_column);
68   DECLARE_TRANSLATOR_LISTENER (absolute_dynamic);
69   DECLARE_TRANSLATOR_LISTENER (span_dynamic);
70
71 protected:
72   virtual void finalize ();
73   void stop_translation_timestep ();
74   void process_music ();
75 };
76
77 Dynamic_engraver::Dynamic_engraver ()
78 {
79   script_ = 0;
80   finished_cresc_ = 0;
81   line_spanner_ = 0;
82   finished_line_spanner_ = 0;
83   current_cresc_ev_ = 0;
84   cresc_ = 0;
85
86   script_ev_ = 0;
87   accepted_spanevents_drul_[START] = 0;
88   accepted_spanevents_drul_[STOP] = 0;
89 }
90
91 IMPLEMENT_TRANSLATOR_LISTENER (Dynamic_engraver, absolute_dynamic);
92 void
93 Dynamic_engraver::listen_absolute_dynamic (Stream_event *ev)
94 {
95   /*
96     TODO: probably broken.
97   */
98   ASSIGN_EVENT_ONCE (script_ev_, ev);
99 }
100
101 IMPLEMENT_TRANSLATOR_LISTENER (Dynamic_engraver, span_dynamic);
102 void
103 Dynamic_engraver::listen_span_dynamic (Stream_event *ev)
104 {
105   Direction d = to_dir (ev->get_property ("span-direction"));
106
107   if (d == START)
108     ASSIGN_EVENT_ONCE (accepted_spanevents_drul_[START], ev);
109   
110   /* Cancel any ongoing crescendo, either explicitly by \! or
111      implicitly by a new crescendo. Also avoid warning if cresc is
112      cancelled both implicitly and explicitly. */
113   if ((d == STOP || current_cresc_ev_) && !accepted_spanevents_drul_[STOP])
114     ASSIGN_EVENT_ONCE (accepted_spanevents_drul_[STOP], ev);
115 }
116
117 void
118 Dynamic_engraver::process_music ()
119 {
120   if (accepted_spanevents_drul_[START] || accepted_spanevents_drul_[STOP] || script_ev_)
121     {
122       if (!line_spanner_)
123         {
124           Stream_event *rq = accepted_spanevents_drul_[START];
125           line_spanner_ = make_spanner ("DynamicLineSpanner", rq ? rq->self_scm () : SCM_EOL);
126           if (script_ev_)
127             rq = script_ev_;
128         }
129     }
130
131   /*
132     During a (de)crescendo, pending event will not be cleared,
133     and a line-spanner will always be created, as \< \! are already
134     two events.
135
136     Note: line-spanner must always have at least same duration
137     as (de)crecsendo, b.o. line-breaking.
138   */
139
140   /*
141     maybe we should leave dynamic texts to the text-engraver and
142     simply acknowledge them?
143   */
144   if (script_ev_)
145     {
146       script_ = make_item ("DynamicText", script_ev_->self_scm ());
147       script_->set_property ("text",
148                              script_ev_->get_property ("text"));
149
150       if (Direction d = to_dir (script_ev_->get_property ("direction")))
151         set_grob_direction (line_spanner_, d);
152       else if (Direction d = to_dir (line_spanner_->get_property ("direction")))
153         set_grob_direction (script_, d);
154
155       Axis_group_interface::add_element (line_spanner_, script_);
156     }
157
158   Stream_event *stop_ev = accepted_spanevents_drul_ [STOP]
159     ? accepted_spanevents_drul_[STOP] : script_ev_;
160
161   if (accepted_spanevents_drul_[STOP] || script_ev_)
162     {
163       /*
164         finish side position alignment if the (de)cresc ends here, and
165         there are no new dynamics.
166       */
167
168       if (cresc_)
169         {
170           assert (!finished_cresc_ && cresc_);
171
172           if (script_)
173             {
174               cresc_->set_bound (RIGHT, script_);
175               add_bound_item (line_spanner_, script_);
176             }
177
178           finished_cresc_ = cresc_;
179           announce_end_grob (finished_cresc_, SCM_EOL);
180           cresc_ = 0;
181           current_cresc_ev_ = 0;
182         }
183       else if (accepted_spanevents_drul_[STOP])
184         {
185           accepted_spanevents_drul_[STOP]->origin ()->warning (_ ("cannot find start of (de)crescendo"));
186           stop_ev = 0;
187         }
188     }
189
190   if (accepted_spanevents_drul_[START])
191     {
192       if (current_cresc_ev_)
193         {
194           string msg = _ ("already have a decrescendo");
195           if (current_cresc_ev_->in_event_class ("crescendo-event"))
196             msg = _ ("already have a crescendo");
197
198           accepted_spanevents_drul_[START]->origin ()->warning (msg);
199           current_cresc_ev_->origin ()->warning (_ ("cresc starts here"));
200         }
201       else
202         {
203           current_cresc_ev_ = accepted_spanevents_drul_[START];
204
205           if (Direction d = to_dir (current_cresc_ev_->get_property ("direction")))
206             set_grob_direction (line_spanner_, d);
207
208           /*
209             TODO: Use symbols.
210           */
211           
212           SCM start_sym = current_cresc_ev_->get_property ("class");
213           string start_type;
214           
215           if (start_sym == ly_symbol2scm ("decrescendo-event"))
216             start_type = "decrescendo";
217           else if (start_sym == ly_symbol2scm ("crescendo-event"))
218             start_type = "crescendo";
219           else
220             {
221               programming_error ("unknown dynamic spanner type");
222               return;
223             }
224
225           /*
226             UGH. TODO: should read from original event, so appearance
227             may be altered with \tweak.
228            */
229           SCM s = get_property ((start_type + "Spanner").c_str ());
230           if (!scm_is_symbol (s) || s == ly_symbol2scm ("hairpin"))
231             {
232               cresc_ = make_spanner ("Hairpin", accepted_spanevents_drul_[START]->self_scm ());
233               if (finished_cresc_)
234                 {
235                   Pointer_group_interface::add_grob (finished_cresc_,
236                                                      ly_symbol2scm ("adjacent-hairpins"),
237                                                      cresc_);
238
239                   Pointer_group_interface::add_grob (cresc_,
240                                                      ly_symbol2scm ("adjacent-hairpins"),
241                                                      finished_cresc_);
242                 }
243             }
244
245           /*
246             This is a convenient (and legacy) interface to TextSpanners
247             for use in (de)crescendi.
248             Hmm.
249           */
250           else
251             {
252               cresc_ = make_spanner ("DynamicTextSpanner", accepted_spanevents_drul_[START]->self_scm ());
253               cresc_->set_property ("style", s);
254               context ()->set_property ((start_type
255                                          + "Spanner").c_str (), SCM_EOL);
256               s = get_property ((start_type + "Text").c_str ());
257               if (Text_interface::is_markup (s))
258                 {
259                   cresc_->set_property ("text", s);
260                   context ()->set_property ((start_type + "Text").c_str (),
261                                             SCM_EOL);
262                 }
263
264               if (script_)
265                 {
266                   set_nested_property (cresc_,
267                                        scm_list_3 (ly_symbol2scm ("bound-details"),
268                                                    ly_symbol2scm ("left"),
269                                                    ly_symbol2scm ("attach-dir")
270                                                    ),
271                                        scm_from_int (RIGHT));
272                 }
273             }
274
275           if (script_)
276             {
277               cresc_->set_bound (LEFT, script_);
278               add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
279             }
280
281           Axis_group_interface::add_element (line_spanner_, cresc_);
282         }
283     }
284 }
285
286 void
287 Dynamic_engraver::stop_translation_timestep ()
288 {
289   if (!current_cresc_ev_ && line_spanner_)
290     {
291       assert (!finished_line_spanner_);
292       finished_line_spanner_ = line_spanner_;
293       line_spanner_ = 0;
294     }
295
296   typeset_all ();
297
298   if (cresc_ && !cresc_->get_bound (LEFT))
299     {
300       cresc_->set_bound (LEFT, unsmob_grob (get_property ("currentMusicalColumn")));
301       add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
302     }
303
304   script_ev_ = 0;
305   accepted_spanevents_drul_[START] = 0;
306   accepted_spanevents_drul_[STOP] = 0;
307 }
308
309 void
310 Dynamic_engraver::finalize ()
311 {
312   typeset_all ();
313
314   if (line_spanner_
315       && !line_spanner_->is_live ())
316     line_spanner_ = 0;
317   if (line_spanner_)
318     {
319       finished_line_spanner_ = line_spanner_;
320       typeset_all ();
321     }
322
323   if (cresc_
324       && !cresc_->is_live ())
325     cresc_ = 0;
326   if (cresc_)
327     {
328       current_cresc_ev_->origin ()->warning (_ ("unterminated (de)crescendo"));
329       cresc_->suicide ();
330       cresc_ = 0;
331     }
332 }
333
334 void
335 Dynamic_engraver::typeset_all ()
336 {
337   if (finished_cresc_)
338     {
339       if (!finished_cresc_->get_bound (RIGHT))
340         {
341                   
342           Grob *column_bound = unsmob_grob (get_property ("currentMusicalColumn"));
343           
344           finished_cresc_->set_bound (RIGHT, script_
345                                       ? script_
346                                       : column_bound);
347
348           if (finished_line_spanner_)
349             add_bound_item (finished_line_spanner_,
350                             finished_cresc_->get_bound (RIGHT));
351         }
352       finished_cresc_ = 0;
353     }
354
355   script_ = 0;
356   if (finished_line_spanner_)
357     {
358       /*
359         We used to have
360
361         extend-spanner-over-elements (finished_line_spanner_);
362
363         but this is rather kludgy, since finished_line_spanner_
364         typically has a staff-symbol field set , extending it over the
365         entire staff.
366
367       */
368
369       Grob *l = finished_line_spanner_->get_bound (LEFT);
370       Grob *r = finished_line_spanner_->get_bound (RIGHT);
371       if (!r && l)
372         finished_line_spanner_->set_bound (RIGHT, l);
373       else if (!l && r)
374         finished_line_spanner_->set_bound (LEFT, r);
375       else if (!r && !l)
376         {
377           /*
378             This is a isolated dynamic apparently, and does not even have
379             any interesting support item.
380           */
381           Grob *cc = unsmob_grob (get_property ("currentMusicalColumn"));
382           Item *ci = dynamic_cast<Item *> (cc);
383           finished_line_spanner_->set_bound (RIGHT, ci);
384           finished_line_spanner_->set_bound (LEFT, ci);
385         }
386       finished_line_spanner_ = 0;
387     }
388 }
389
390 void
391 Dynamic_engraver::acknowledge_note_column (Grob_info info)
392 {
393   if (!line_spanner_)
394     return;
395
396   if (line_spanner_
397       /* Don't refill killed spanner */
398       && line_spanner_->is_live ())
399     {
400       Side_position_interface::add_support (line_spanner_, info.grob ());
401       add_bound_item (line_spanner_, dynamic_cast<Item *> (info.grob ()));
402     }
403
404   if (script_ && !script_->get_parent (X_AXIS))
405     {
406       extract_grob_set (info.grob (), "note-heads", heads);
407       if (heads.size ())
408         {
409           Grob *head = heads[0];
410           script_->set_parent (head, X_AXIS);
411           Self_alignment_interface::set_center_parent (script_, X_AXIS);
412         }
413     }
414
415   if (cresc_)
416     {
417       if (!cresc_->get_bound (LEFT))
418         {
419           cresc_->set_bound (LEFT, info.grob ());
420           add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
421         }
422     }
423
424   if (finished_cresc_ && !finished_cresc_->get_bound (RIGHT))
425     finished_cresc_->set_bound (RIGHT, info.grob ());
426 }
427
428 ADD_ACKNOWLEDGER (Dynamic_engraver, note_column);
429
430 ADD_TRANSLATOR (Dynamic_engraver,
431                 /* doc */
432                 "Create hairpins, dynamic texts, and their vertical"
433                 " alignments.  The symbols are collected onto a"
434                 " @code{DynamicLineSpanner} grob which takes care of vertical"
435                 " positioning.",
436
437                 /* create */
438                 "DynamicLineSpanner "
439                 "DynamicTextSpanner "
440                 "DynamicText "
441                 "Hairpin "
442                 "TextSpanner ",
443
444                 /* read */
445                 "",
446
447                 /* write */
448                 ""
449                 );