lily/dynamic-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2008--2014 Han-Wen Nienhuys <hanwen@lilypond.org>
   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 #include "hairpin.hh"
  22 #include "international.hh"
  23 #include "item.hh"
  24 #include "note-column.hh"
  25 #include "pointer-group-interface.hh"
  26 #include "self-alignment-interface.hh"
  27 #include "spanner.hh"
  28 #include "stream-event.hh"
  29 #include "text-interface.hh"
  30
  31 #include "translator.icc"
  32
  33 class Dynamic_engraver : public Engraver
  34 {
  35   TRANSLATOR_DECLARATIONS (Dynamic_engraver);
  36   DECLARE_ACKNOWLEDGER (note_column);
  37   DECLARE_TRANSLATOR_LISTENER (absolute_dynamic);
  38   DECLARE_TRANSLATOR_LISTENER (span_dynamic);
  39   DECLARE_TRANSLATOR_LISTENER (break_span);
  40
  41 protected:
  42   virtual void process_music ();
  43   virtual void stop_translation_timestep ();
  44   virtual void finalize ();
  45
  46 private:
  47   SCM get_property_setting (Stream_event *evt, char const *evprop,
  48                             char const *ctxprop);
  49   string get_spanner_type (Stream_event *ev);
  50
  51   Drul_array<Stream_event *> accepted_spanevents_drul_;
  52   Spanner *current_spanner_;
  53   Spanner *finished_spanner_;
  54
  55   Item *script_;
  56   Stream_event *script_event_;
  57   Stream_event *current_span_event_;
  58   bool end_new_spanner_;
  59 };
  60
  61 Dynamic_engraver::Dynamic_engraver ()
  62 {
  63   script_event_ = 0;
  64   current_span_event_ = 0;
  65   script_ = 0;
  66   finished_spanner_ = 0;
  67   current_spanner_ = 0;
  68   accepted_spanevents_drul_.set (0, 0);
  69   end_new_spanner_ = false;
  70 }
  71
  72 IMPLEMENT_TRANSLATOR_LISTENER (Dynamic_engraver, absolute_dynamic);
  73 void
  74 Dynamic_engraver::listen_absolute_dynamic (Stream_event *ev)
  75 {
  76   ASSIGN_EVENT_ONCE (script_event_, ev);
  77 }
  78
  79 IMPLEMENT_TRANSLATOR_LISTENER (Dynamic_engraver, span_dynamic);
  80 void
  81 Dynamic_engraver::listen_span_dynamic (Stream_event *ev)
  82 {
  83   Direction d = to_dir (ev->get_property ("span-direction"));
  84
  85   ASSIGN_EVENT_ONCE (accepted_spanevents_drul_[d], ev);
  86 }
  87
  88 IMPLEMENT_TRANSLATOR_LISTENER (Dynamic_engraver, break_span);
  89 void
  90 Dynamic_engraver::listen_break_span (Stream_event *event)
  91 {
  92   if (event->in_event_class ("break-dynamic-span-event"))
  93     {
  94       // Case 1: Already have a start dynamic event -> break applies to new
  95       //         spanner (created later) -> set a flag
  96       // Case 2: no new spanner, but spanner already active -> break it now
  97       if (accepted_spanevents_drul_[START])
  98         end_new_spanner_ = true;
  99       else if (current_spanner_)
 100         current_spanner_->set_property ("spanner-broken", SCM_BOOL_T);
 101     }
 102 }
 103
 104 SCM
 105 Dynamic_engraver::get_property_setting (Stream_event *evt,
 106                                         char const *evprop,
 107                                         char const *ctxprop)
 108 {
 109   SCM spanner_type = evt->get_property (evprop);
 110   if (spanner_type == SCM_EOL)
 111     spanner_type = get_property (ctxprop);
 112   return spanner_type;
 113 }
 114
 115 void
 116 Dynamic_engraver::process_music ()
 117 {
 118   if (current_spanner_
 119       && (accepted_spanevents_drul_[STOP]
 120           || script_event_
 121           || accepted_spanevents_drul_[START]))
 122     {
 123       Stream_event *ender = accepted_spanevents_drul_[STOP];
 124       if (!ender)
 125         ender = script_event_;
 126
 127       if (!ender)
 128         ender = accepted_spanevents_drul_[START];
 129
 130       finished_spanner_ = current_spanner_;
 131       announce_end_grob (finished_spanner_, ender->self_scm ());
 132       current_spanner_ = 0;
 133       current_span_event_ = 0;
 134     }
 135
 136   if (accepted_spanevents_drul_[START])
 137     {
 138       current_span_event_ = accepted_spanevents_drul_[START];
 139
 140       string start_type = get_spanner_type (current_span_event_);
 141       SCM cresc_type = get_property_setting (current_span_event_, "span-type",
 142                                              (start_type + "Spanner").c_str ());
 143
 144       if (cresc_type == ly_symbol2scm ("text"))
 145         {
 146           current_spanner_
 147             = make_spanner ("DynamicTextSpanner",
 148                             accepted_spanevents_drul_[START]->self_scm ());
 149
 150           SCM text = get_property_setting (current_span_event_, "span-text",
 151                                            (start_type + "Text").c_str ());
 152           if (Text_interface::is_markup (text))
 153             current_spanner_->set_property ("text", text);
 154           /*
 155             If the line of a text spanner is hidden, end the alignment spanner
 156             early: this allows dynamics to be spaced individually instead of
 157             being linked together.
 158           */
 159           if (current_spanner_->get_property ("style") == ly_symbol2scm ("none"))
 160             current_spanner_->set_property ("spanner-broken", SCM_BOOL_T);
 161         }
 162       else
 163         {
 164           if (cresc_type != ly_symbol2scm ("hairpin"))
 165             {
 166               string as_string = ly_scm_write_string (cresc_type);
 167               current_span_event_
 168               ->origin ()->warning (_f ("unknown crescendo style: %s\ndefaulting to hairpin.", as_string.c_str ()));
 169             }
 170           current_spanner_ = make_spanner ("Hairpin",
 171                                            current_span_event_->self_scm ());
 172         }
 173       // if we have a break-dynamic-span event right after the start dynamic, break the new spanner immediately
 174       if (end_new_spanner_)
 175         {
 176           current_spanner_->set_property ("spanner-broken", SCM_BOOL_T);
 177           end_new_spanner_ = false;
 178         }
 179       if (finished_spanner_)
 180         {
 181           if (Hairpin::has_interface (finished_spanner_))
 182             Pointer_group_interface::add_grob (finished_spanner_,
 183                                                ly_symbol2scm ("adjacent-spanners"),
 184                                                current_spanner_);
 185           if (Hairpin::has_interface (current_spanner_))
 186             Pointer_group_interface::add_grob (current_spanner_,
 187                                                ly_symbol2scm ("adjacent-spanners"),
 188                                                finished_spanner_);
 189         }
 190     }
 191
 192   if (script_event_)
 193     {
 194       script_ = make_item ("DynamicText", script_event_->self_scm ());
 195       script_->set_property ("text",
 196                              script_event_->get_property ("text"));
 197
 198       if (finished_spanner_)
 199         finished_spanner_->set_bound (RIGHT, script_);
 200       if (current_spanner_)
 201         current_spanner_->set_bound (LEFT, script_);
 202     }
 203 }
 204
 205 void
 206 Dynamic_engraver::stop_translation_timestep ()
 207 {
 208   if (finished_spanner_ && !finished_spanner_->get_bound (RIGHT))
 209     finished_spanner_
 210     ->set_bound (RIGHT,
 211                  unsmob_grob (get_property ("currentMusicalColumn")));
 212
 213   if (current_spanner_ && !current_spanner_->get_bound (LEFT))
 214     current_spanner_
 215     ->set_bound (LEFT,
 216                  unsmob_grob (get_property ("currentMusicalColumn")));
 217   script_ = 0;
 218   script_event_ = 0;
 219   accepted_spanevents_drul_.set (0, 0);
 220   finished_spanner_ = 0;
 221   end_new_spanner_ = false;
 222 }
 223
 224 void
 225 Dynamic_engraver::finalize ()
 226 {
 227   if (current_spanner_
 228       && !current_spanner_->is_live ())
 229     current_spanner_ = 0;
 230   if (current_spanner_)
 231     {
 232       current_span_event_
 233       ->origin ()->warning (_f ("unterminated %s",
 234                                 get_spanner_type (current_span_event_)
 235                                 .c_str ()));
 236       current_spanner_->suicide ();
 237       current_spanner_ = 0;
 238     }
 239 }
 240
 241 string
 242 Dynamic_engraver::get_spanner_type (Stream_event *ev)
 243 {
 244   string type;
 245   SCM start_sym = scm_car (ev->get_property ("class"));
 246
 247   if (start_sym == ly_symbol2scm ("decrescendo-event"))
 248     type = "decrescendo";
 249   else if (start_sym == ly_symbol2scm ("crescendo-event"))
 250     type = "crescendo";
 251   else
 252     programming_error ("unknown dynamic spanner type");
 253
 254   return type;
 255 }
 256
 257 void
 258 Dynamic_engraver::acknowledge_note_column (Grob_info info)
 259 {
 260   if (script_ && !script_->get_parent (X_AXIS))
 261     {
 262       extract_grob_set (info.grob (), "note-heads", heads);
 263       /*
 264         Spacing constraints may require dynamics to be aligned on rests,
 265         so check for a rest if this note column has no note heads.
 266       */
 267       Grob *x_parent = (heads.size ()
 268                         ? heads[0]
 269                         : unsmob_grob (info.grob ()->get_object ("rest")));
 270       if (x_parent)
 271         {
 272           script_->set_parent (x_parent, X_AXIS);
 273           Self_alignment_interface::set_center_parent (script_, X_AXIS);
 274         }
 275     }
 276
 277   if (current_spanner_ && !current_spanner_->get_bound (LEFT))
 278     current_spanner_->set_bound (LEFT, info.grob ());
 279   if (finished_spanner_ && !finished_spanner_->get_bound (RIGHT))
 280     finished_spanner_->set_bound (RIGHT, info.grob ());
 281 }
 282
 283 ADD_ACKNOWLEDGER (Dynamic_engraver, note_column);
 284 ADD_TRANSLATOR (Dynamic_engraver,
 285                 /* doc */
 286                 "Create hairpins, dynamic texts and dynamic text spanners.",
 287
 288                 /* create */
 289                 "DynamicTextSpanner "
 290                 "DynamicText "
 291                 "Hairpin ",
 292
 293                 /* read */
 294                 "crescendoSpanner "
 295                 "crescendoText "
 296                 "currentMusicalColumn "
 297                 "decrescendoSpanner "
 298                 "decrescendoText ",
 299
 300                 /* write */
 301                 ""
 302                );