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
 180           /* backwards compatibility with hairpinToBarline */
 181           if (finished_cresc_->get_property ("to-barline") == SCM_EOL)
 182             {
 183               bool use_bar = to_boolean (get_property ("hairpinToBarline"))
 184                 && scm_is_string (get_property ("whichBar"));
 185
 186               finished_cresc_->set_property ("to-barline", scm_from_bool (use_bar));
 187             }
 188
 189           announce_end_grob (finished_cresc_, SCM_EOL);
 190           cresc_ = 0;
 191           current_cresc_ev_ = 0;
 192         }
 193       else if (accepted_spanevents_drul_[STOP])
 194         {
 195           accepted_spanevents_drul_[STOP]->origin ()->warning (_ ("cannot find start of (de)crescendo"));
 196           stop_ev = 0;
 197         }
 198     }
 199
 200   if (accepted_spanevents_drul_[START])
 201     {
 202       if (current_cresc_ev_)
 203         {
 204           string msg = _ ("already have a decrescendo");
 205           if (current_cresc_ev_->in_event_class ("crescendo-event"))
 206             msg = _ ("already have a crescendo");
 207
 208           accepted_spanevents_drul_[START]->origin ()->warning (msg);
 209           current_cresc_ev_->origin ()->warning (_ ("cresc starts here"));
 210         }
 211       else
 212         {
 213           current_cresc_ev_ = accepted_spanevents_drul_[START];
 214
 215           if (Direction d = to_dir (current_cresc_ev_->get_property ("direction")))
 216             set_grob_direction (line_spanner_, d);
 217
 218           /*
 219             TODO: Use symbols.
 220           */
 221
 222           SCM start_sym = current_cresc_ev_->get_property ("class");
 223           string start_type;
 224
 225           if (start_sym == ly_symbol2scm ("decrescendo-event"))
 226             start_type = "decrescendo";
 227           else if (start_sym == ly_symbol2scm ("crescendo-event"))
 228             start_type = "crescendo";
 229           else
 230             {
 231               programming_error ("unknown dynamic spanner type");
 232               return;
 233             }
 234
 235           /*
 236             UGH. TODO: should read from original event, so appearance
 237             may be altered with \tweak.
 238            */
 239           SCM s = get_property ((start_type + "Spanner").c_str ());
 240           if (!scm_is_symbol (s) || s == ly_symbol2scm ("hairpin"))
 241             {
 242               cresc_ = make_spanner ("Hairpin", accepted_spanevents_drul_[START]->self_scm ());
 243               if (finished_cresc_)
 244                 {
 245                   Pointer_group_interface::add_grob (finished_cresc_,
 246                                                      ly_symbol2scm ("adjacent-hairpins"),
 247                                                      cresc_);
 248
 249                   Pointer_group_interface::add_grob (cresc_,
 250                                                      ly_symbol2scm ("adjacent-hairpins"),
 251                                                      finished_cresc_);
 252                 }
 253             }
 254
 255           /*
 256             This is a convenient (and legacy) interface to TextSpanners
 257             for use in (de)crescendi.
 258             Hmm.
 259           */
 260           else
 261             {
 262               cresc_ = make_spanner ("DynamicTextSpanner", accepted_spanevents_drul_[START]->self_scm ());
 263               cresc_->set_property ("style", s);
 264               context ()->set_property ((start_type
 265                                          + "Spanner").c_str (), SCM_EOL);
 266               s = get_property ((start_type + "Text").c_str ());
 267               if (Text_interface::is_markup (s))
 268                 {
 269                   cresc_->set_property ("text", s);
 270                   context ()->set_property ((start_type + "Text").c_str (),
 271                                             SCM_EOL);
 272                 }
 273
 274               if (script_)
 275                 {
 276                   set_nested_property (cresc_,
 277                                        scm_list_3 (ly_symbol2scm ("bound-details"),
 278                                                    ly_symbol2scm ("left"),
 279                                                    ly_symbol2scm ("attach-dir")
 280                                                    ),
 281                                        scm_from_int (RIGHT));
 282                 }
 283             }
 284
 285           if (script_)
 286             {
 287               cresc_->set_bound (LEFT, script_);
 288               add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
 289             }
 290
 291           Axis_group_interface::add_element (line_spanner_, cresc_);
 292         }
 293     }
 294 }
 295
 296 void
 297 Dynamic_engraver::stop_translation_timestep ()
 298 {
 299   if (!current_cresc_ev_ && line_spanner_)
 300     {
 301       assert (!finished_line_spanner_);
 302       finished_line_spanner_ = line_spanner_;
 303       line_spanner_ = 0;
 304     }
 305
 306   typeset_all ();
 307
 308   if (cresc_ && !cresc_->get_bound (LEFT))
 309     {
 310       cresc_->set_bound (LEFT, unsmob_grob (get_property ("currentMusicalColumn")));
 311       add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
 312     }
 313
 314   script_ev_ = 0;
 315   accepted_spanevents_drul_[START] = 0;
 316   accepted_spanevents_drul_[STOP] = 0;
 317 }
 318
 319 void
 320 Dynamic_engraver::finalize ()
 321 {
 322   typeset_all ();
 323
 324   if (line_spanner_
 325       && !line_spanner_->is_live ())
 326     line_spanner_ = 0;
 327   if (line_spanner_)
 328     {
 329       finished_line_spanner_ = line_spanner_;
 330       typeset_all ();
 331     }
 332
 333   if (cresc_
 334       && !cresc_->is_live ())
 335     cresc_ = 0;
 336   if (cresc_)
 337     {
 338       current_cresc_ev_->origin ()->warning (_ ("unterminated (de)crescendo"));
 339       cresc_->suicide ();
 340       cresc_ = 0;
 341     }
 342 }
 343
 344 void
 345 Dynamic_engraver::typeset_all ()
 346 {
 347   if (finished_cresc_)
 348     {
 349       if (!finished_cresc_->get_bound (RIGHT))
 350         {
 351
 352           Grob *column_bound = unsmob_grob (get_property ("currentMusicalColumn"));
 353
 354           finished_cresc_->set_bound (RIGHT, script_
 355                                       ? script_
 356                                       : column_bound);
 357
 358           if (finished_line_spanner_)
 359             add_bound_item (finished_line_spanner_,
 360                             finished_cresc_->get_bound (RIGHT));
 361         }
 362       finished_cresc_ = 0;
 363     }
 364
 365   script_ = 0;
 366   if (finished_line_spanner_)
 367     {
 368       /*
 369         We used to have
 370
 371         extend-spanner-over-elements (finished_line_spanner_);
 372
 373         but this is rather kludgy, since finished_line_spanner_
 374         typically has a staff-symbol field set , extending it over the
 375         entire staff.
 376
 377       */
 378
 379       Grob *l = finished_line_spanner_->get_bound (LEFT);
 380       Grob *r = finished_line_spanner_->get_bound (RIGHT);
 381       if (!r && l)
 382         finished_line_spanner_->set_bound (RIGHT, l);
 383       else if (!l && r)
 384         finished_line_spanner_->set_bound (LEFT, r);
 385       else if (!r && !l)
 386         {
 387           /*
 388             This is a isolated dynamic apparently, and does not even have
 389             any interesting support item.
 390           */
 391           Grob *cc = unsmob_grob (get_property ("currentMusicalColumn"));
 392           Item *ci = dynamic_cast<Item *> (cc);
 393           finished_line_spanner_->set_bound (RIGHT, ci);
 394           finished_line_spanner_->set_bound (LEFT, ci);
 395         }
 396       finished_line_spanner_ = 0;
 397     }
 398 }
 399
 400 void
 401 Dynamic_engraver::acknowledge_note_column (Grob_info info)
 402 {
 403   if (!line_spanner_)
 404     return;
 405
 406   if (line_spanner_
 407       /* Don't refill killed spanner */
 408       && line_spanner_->is_live ())
 409     {
 410       Side_position_interface::add_support (line_spanner_, info.grob ());
 411       add_bound_item (line_spanner_, dynamic_cast<Item *> (info.grob ()));
 412     }
 413
 414   if (script_ && !script_->get_parent (X_AXIS))
 415     {
 416       extract_grob_set (info.grob (), "note-heads", heads);
 417       if (heads.size ())
 418         {
 419           Grob *head = heads[0];
 420           script_->set_parent (head, X_AXIS);
 421           Self_alignment_interface::set_center_parent (script_, X_AXIS);
 422         }
 423     }
 424
 425   if (cresc_)
 426     {
 427       if (!cresc_->get_bound (LEFT))
 428         {
 429           cresc_->set_bound (LEFT, info.grob ());
 430           add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
 431         }
 432     }
 433
 434   if (finished_cresc_ && !finished_cresc_->get_bound (RIGHT))
 435     finished_cresc_->set_bound (RIGHT, info.grob ());
 436 }
 437
 438 ADD_ACKNOWLEDGER (Dynamic_engraver, note_column);
 439
 440 ADD_TRANSLATOR (Dynamic_engraver,
 441                 /* doc */
 442                 "Create hairpins, dynamic texts, and their vertical"
 443                 " alignments.  The symbols are collected onto a"
 444                 " @code{DynamicLineSpanner} grob which takes care of vertical"
 445                 " positioning.",
 446
 447                 /* create */
 448                 "DynamicLineSpanner "
 449                 "DynamicTextSpanner "
 450                 "DynamicText "
 451                 "Hairpin "
 452                 "TextSpanner ",
 453
 454                 /* read */
 455                 "",
 456
 457                 /* write */
 458                 ""
 459                 );