lily/piano-pedal-align-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2006--2015 Han-Wen Nienhuys <hanwen@lilypond.org>
   5
   6
   7   LilyPond is free software: you can redistribute it and/or modify
   8   it under the terms of the GNU General Public License as published by
   9   the Free Software Foundation, either version 3 of the License, or
  10   (at your option) any later version.
  11
  12   LilyPond is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "engraver.hh"
  22
  23 #include "spanner.hh"
  24 #include "item.hh"
  25 #include "side-position-interface.hh"
  26 #include "stream-event.hh"
  27 #include "warn.hh"
  28 #include "axis-group-interface.hh"
  29
  30 #include "translator.icc"
  31
  32 using std::vector;
  33
  34 /*
  35   TODO:
  36
  37
  38   * Detach from pedal specifics,
  39
  40   * Also use this engraver for dynamics.
  41 */
  42
  43 struct Pedal_align_info
  44 {
  45   Spanner *line_spanner_;
  46   Grob *carrying_item_;
  47   Spanner *carrying_spanner_;
  48   Spanner *finished_carrying_spanner_;
  49
  50   Pedal_align_info ()
  51   {
  52     clear ();
  53
  54   }
  55   void clear ()
  56   {
  57     line_spanner_ = 0;
  58     carrying_spanner_ = 0;
  59     carrying_item_ = 0;
  60     finished_carrying_spanner_ = 0;
  61   }
  62   bool is_finished ()
  63   {
  64     bool do_continue = carrying_item_;
  65
  66     do_continue |= (carrying_spanner_ && !finished_carrying_spanner_);
  67     do_continue |= (carrying_spanner_ && finished_carrying_spanner_ != carrying_spanner_);
  68
  69     return !do_continue;
  70   }
  71 };
  72
  73 class Piano_pedal_align_engraver : public Engraver
  74 {
  75 public:
  76   TRANSLATOR_DECLARATIONS (Piano_pedal_align_engraver);
  77
  78 protected:
  79   virtual void finalize ();
  80
  81   DECLARE_ACKNOWLEDGER (piano_pedal_script);
  82   DECLARE_ACKNOWLEDGER (piano_pedal_bracket);
  83   DECLARE_ACKNOWLEDGER (note_column);
  84
  85   DECLARE_END_ACKNOWLEDGER (piano_pedal_bracket);
  86
  87   void stop_translation_timestep ();
  88   void start_translation_timestep ();
  89
  90 private:
  91   enum Pedal_type
  92   {
  93     SOSTENUTO,
  94     SUSTAIN,
  95     UNA_CORDA,
  96     NUM_PEDAL_TYPES
  97   };
  98   Pedal_align_info pedal_info_[NUM_PEDAL_TYPES];
  99   vector<Grob *> supports_;
 100
 101   Pedal_type get_grob_pedal_type (Grob_info g);
 102   Spanner *make_line_spanner (Pedal_type t, SCM);
 103 };
 104
 105 Piano_pedal_align_engraver::Piano_pedal_align_engraver ()
 106 {
 107 }
 108
 109 void
 110 Piano_pedal_align_engraver::start_translation_timestep ()
 111 {
 112   supports_.clear ();
 113 }
 114
 115 void
 116 Piano_pedal_align_engraver::stop_translation_timestep ()
 117 {
 118   for (int i = 0; i < NUM_PEDAL_TYPES; i++)
 119     {
 120       if (pedal_info_[i].line_spanner_)
 121         {
 122
 123           if (pedal_info_[i].carrying_item_)
 124             {
 125               if (!pedal_info_[i].line_spanner_->get_bound (LEFT))
 126                 pedal_info_[i].line_spanner_->set_bound (LEFT,
 127                                                          pedal_info_[i].carrying_item_);
 128
 129               pedal_info_[i].line_spanner_->set_bound (RIGHT,
 130                                                        pedal_info_[i].carrying_item_);
 131             }
 132           else if (pedal_info_[i].carrying_spanner_
 133                    || pedal_info_[i].finished_carrying_spanner_
 134                   )
 135             {
 136               if (!pedal_info_[i].line_spanner_->get_bound (LEFT)
 137                   && pedal_info_[i].carrying_spanner_->get_bound (LEFT))
 138                 pedal_info_[i].line_spanner_->set_bound (LEFT,
 139                                                          pedal_info_[i].carrying_spanner_->get_bound (LEFT));
 140
 141               if (pedal_info_[i].finished_carrying_spanner_)
 142                 pedal_info_[i].line_spanner_->set_bound (RIGHT,
 143                                                          pedal_info_[i].finished_carrying_spanner_->get_bound (RIGHT));
 144             }
 145
 146           for (vsize j = 0; j < supports_.size (); j++)
 147             {
 148               Side_position_interface::add_support (pedal_info_[i].line_spanner_, supports_[j]);
 149             }
 150
 151           if (pedal_info_[i].is_finished ())
 152             {
 153               announce_end_grob (pedal_info_[i].line_spanner_, SCM_EOL);
 154               pedal_info_[i].clear ();
 155             }
 156         }
 157
 158       pedal_info_[i].carrying_item_ = 0;
 159     }
 160 }
 161
 162 Piano_pedal_align_engraver::Pedal_type
 163 Piano_pedal_align_engraver::get_grob_pedal_type (Grob_info g)
 164 {
 165   if (g.event_cause ()->in_event_class ("sostenuto-event"))
 166     return SOSTENUTO;
 167   if (g.event_cause ()->in_event_class ("sustain-event"))
 168     return SUSTAIN;
 169   if (g.event_cause ()->in_event_class ("una-corda-event"))
 170     return UNA_CORDA;
 171
 172   programming_error ("Unknown piano pedal type.  Defaulting to sustain");
 173   return SUSTAIN;
 174 }
 175
 176 Spanner *
 177 Piano_pedal_align_engraver::make_line_spanner (Pedal_type t, SCM cause)
 178 {
 179   Spanner *sp = pedal_info_[t].line_spanner_;
 180   if (!sp)
 181     {
 182       switch (t)
 183         {
 184         case (SOSTENUTO):
 185           sp = make_spanner ("SostenutoPedalLineSpanner", cause);
 186           break;
 187         case (SUSTAIN):
 188           sp = make_spanner ("SustainPedalLineSpanner", cause);
 189           break;
 190         case (UNA_CORDA):
 191           sp = make_spanner ("UnaCordaPedalLineSpanner", cause);
 192           break;
 193         default:
 194           programming_error ("No pedal type fonud!");
 195           return sp;
 196         }
 197
 198       pedal_info_[t].line_spanner_ = sp;
 199     }
 200
 201   return sp;
 202 }
 203
 204 void
 205 Piano_pedal_align_engraver::acknowledge_note_column (Grob_info gi)
 206 {
 207   supports_.push_back (gi.grob ());
 208 }
 209
 210 void
 211 Piano_pedal_align_engraver::acknowledge_piano_pedal_bracket (Grob_info gi)
 212 {
 213   Pedal_type type = get_grob_pedal_type (gi);
 214   Grob *sp = make_line_spanner (type, gi.grob ()->self_scm ());
 215
 216   Axis_group_interface::add_element (sp, gi.grob ());
 217   pedal_info_[type].carrying_spanner_ = gi.spanner ();
 218 }
 219
 220 void
 221 Piano_pedal_align_engraver::acknowledge_end_piano_pedal_bracket (Grob_info gi)
 222 {
 223   Pedal_type type = get_grob_pedal_type (gi);
 224   pedal_info_[type].finished_carrying_spanner_ = gi.spanner ();
 225 }
 226
 227 void
 228 Piano_pedal_align_engraver::acknowledge_piano_pedal_script (Grob_info gi)
 229 {
 230   Pedal_type type = get_grob_pedal_type (gi);
 231
 232   Grob *sp = make_line_spanner (type, gi.grob ()->self_scm ());
 233   Axis_group_interface::add_element (sp, gi.grob ());
 234   pedal_info_[type].carrying_item_ = gi.grob ();
 235 }
 236
 237 void
 238 Piano_pedal_align_engraver::finalize ()
 239 {
 240   for (int i = 0; i < NUM_PEDAL_TYPES; i++)
 241     {
 242       if (pedal_info_[i].line_spanner_)
 243         {
 244           SCM cc = get_property ("currentCommandColumn");
 245           Item *c = unsmob<Item> (cc);
 246           pedal_info_[i].line_spanner_->set_bound (RIGHT, c);
 247
 248           pedal_info_[i].clear ();
 249         }
 250     }
 251 }
 252
 253 ADD_ACKNOWLEDGER (Piano_pedal_align_engraver, note_column);
 254 ADD_ACKNOWLEDGER (Piano_pedal_align_engraver, piano_pedal_bracket);
 255 ADD_ACKNOWLEDGER (Piano_pedal_align_engraver, piano_pedal_script);
 256
 257 ADD_END_ACKNOWLEDGER (Piano_pedal_align_engraver, piano_pedal_bracket);
 258
 259 ADD_TRANSLATOR (Piano_pedal_align_engraver,
 260                 /* doc */
 261                 "Align piano pedal symbols and brackets.",
 262
 263                 /* create */
 264                 "SostenutoPedalLineSpanner "
 265                 "SustainPedalLineSpanner "
 266                 "UnaCordaPedalLineSpanner ",
 267
 268                 /* read */
 269                 "currentCommandColumn ",
 270
 271                 /* write */
 272                 ""
 273                );