lily/tuplet-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1998--2012 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 "beam.hh"
  21 #include "engraver.hh"
  22 #include "international.hh"
  23 #include "note-column.hh"
  24 #include "spanner.hh"
  25 #include "stream-event.hh"
  26 #include "tuplet-bracket.hh"
  27 #include "warn.hh"
  28 #include "item.hh"
  29 #include "moment.hh"
  30
  31 #include "translator.icc"
  32
  33 struct Tuplet_description
  34 {
  35   Stream_event *event_;
  36   Spanner *bracket_;
  37   Spanner *number_;
  38
  39   bool full_length_;
  40   bool full_length_note_;
  41   Moment stop_moment_;
  42   Moment start_moment_;
  43   Moment length_;
  44
  45   Tuplet_description ()
  46   {
  47     event_ = 0;
  48     full_length_note_ = false;
  49     full_length_ = false;
  50     bracket_ = 0;
  51     number_ = 0;
  52   }
  53 };
  54
  55 class Tuplet_engraver : public Engraver
  56 {
  57 public:
  58   TRANSLATOR_DECLARATIONS (Tuplet_engraver);
  59
  60 protected:
  61   vector<Tuplet_description> tuplets_;
  62   vector<Tuplet_description> new_tuplets_;
  63   vector<Tuplet_description> stopped_tuplets_;
  64   vector<Spanner *> last_tuplets_;
  65
  66   DECLARE_ACKNOWLEDGER (note_column);
  67   DECLARE_ACKNOWLEDGER (script);
  68   DECLARE_ACKNOWLEDGER (finger);
  69   DECLARE_ACKNOWLEDGER (string_number);
  70   DECLARE_TRANSLATOR_LISTENER (tuplet_span);
  71   virtual void finalize ();
  72   void start_translation_timestep ();
  73   void process_music ();
  74 };
  75
  76 IMPLEMENT_TRANSLATOR_LISTENER (Tuplet_engraver, tuplet_span);
  77 void
  78 Tuplet_engraver::listen_tuplet_span (Stream_event *ev)
  79 {
  80   Direction dir = to_dir (ev->get_property ("span-direction"));
  81   if (dir == START)
  82     {
  83       Tuplet_description d;
  84       d.event_ = ev;
  85
  86       d.length_ = robust_scm2moment (d.event_->get_property ("length"),
  87                                      Moment (0));
  88       d.start_moment_ = now_mom ();
  89       d.stop_moment_ = now_mom () + d.length_;
  90
  91       for (vsize i = 0; i < new_tuplets_.size (); i++)
  92         {
  93           /*
  94             discard duplicates.
  95           */
  96           if (new_tuplets_[i].stop_moment_ == d.stop_moment_)
  97             return;
  98         }
  99
 100       new_tuplets_.push_back (d);
 101     }
 102   else if (dir == STOP)
 103     {
 104       if (tuplets_.size ())
 105         {
 106           stopped_tuplets_.push_back (tuplets_.back ());
 107           tuplets_.pop_back ();
 108         }
 109       else if (!to_boolean (get_property ("skipTypesetting")))
 110         ev->origin ()->warning (_ ("No tuplet to end"));
 111     }
 112   else
 113     ev->origin ()->programming_error ("direction tuplet-span-event_ invalid.");
 114 }
 115
 116 void
 117 Tuplet_engraver::process_music ()
 118 {
 119   /*
 120     This may happen if the end of a tuplet is part of a quoted voice.
 121    */
 122   Moment now = now_mom ();
 123   for (vsize i = tuplets_.size (); i--;)
 124     {
 125       if (tuplets_[i].stop_moment_ == now)
 126         {
 127           stopped_tuplets_.push_back (tuplets_[i]);
 128           tuplets_.erase (tuplets_.begin () + i);
 129         }
 130     }
 131
 132   for (vsize i = 0; i < stopped_tuplets_.size (); i++)
 133     {
 134       Spanner *bracket = stopped_tuplets_[i].bracket_;
 135       Spanner *number = stopped_tuplets_[i].number_;
 136       if (bracket)
 137         {
 138           if (stopped_tuplets_[i].full_length_)
 139             {
 140               Item *col
 141                 = unsmob_item (stopped_tuplets_[i].full_length_note_
 142                                ? get_property ("currentMusicalColumn")
 143                                : get_property ("currentCommandColumn"));
 144
 145               bracket->set_bound (RIGHT, col);
 146               number->set_bound (RIGHT, col);
 147             }
 148           else if (!bracket->get_bound (RIGHT))
 149             {
 150               if (bracket->get_bound (LEFT))
 151                 {
 152                   bracket->set_bound (RIGHT,
 153                                       bracket->get_bound (LEFT));
 154                   number->set_bound (RIGHT,
 155                                      stopped_tuplets_[i].bracket_->get_bound (LEFT));
 156                 }
 157               else
 158                 programming_error ("stopped tuplet bracket has neither left nor right bound");
 159             }
 160           // todo: scrap last_tuplets_, use stopped_tuplets_ only.
 161           // clear stopped_tuplets_ at start_translation_timestep
 162           last_tuplets_.push_back (bracket);
 163           last_tuplets_.push_back (number);
 164         }
 165     }
 166   stopped_tuplets_.clear ();
 167
 168   concat (tuplets_, new_tuplets_);
 169   new_tuplets_.clear ();
 170   for (vsize j = tuplets_.size (); j > 0; j--)
 171     {
 172       /* i goes from size-1 downto 0, inclusively */
 173       vsize i = j - 1;
 174
 175       if (tuplets_[i].bracket_)
 176         continue;
 177
 178       tuplets_[i].full_length_ = to_boolean (get_property ("tupletFullLength"));
 179       tuplets_[i].full_length_note_
 180         = to_boolean (get_property ("tupletFullLengthNote"));
 181
 182       tuplets_[i].bracket_ = make_spanner ("TupletBracket",
 183                                            tuplets_[i].event_->self_scm ());
 184       tuplets_[i].number_ = make_spanner ("TupletNumber",
 185                                           tuplets_[i].event_->self_scm ());
 186       tuplets_[i].number_->set_object ("bracket", tuplets_[i].bracket_->self_scm ());
 187       tuplets_[i].number_->set_parent (tuplets_[i].bracket_, X_AXIS);
 188       tuplets_[i].number_->set_parent (tuplets_[i].bracket_, Y_AXIS);
 189       tuplets_[i].bracket_->set_object ("tuplet-number", tuplets_[i].number_->self_scm ());
 190       tuplets_[i].stop_moment_.grace_part_ = 0;
 191
 192       if (i + 1 < tuplets_.size () && tuplets_[i + 1].bracket_)
 193         Tuplet_bracket::add_tuplet_bracket (tuplets_[i].bracket_, tuplets_[i + 1].bracket_);
 194
 195       if (i > 0 && tuplets_[i - 1].bracket_)
 196         Tuplet_bracket::add_tuplet_bracket (tuplets_[i - 1].bracket_, tuplets_[i].bracket_);
 197
 198     }
 199 }
 200
 201 void
 202 Tuplet_engraver::acknowledge_note_column (Grob_info inf)
 203 {
 204   for (vsize j = 0; j < tuplets_.size (); j++)
 205     if (tuplets_[j].bracket_)
 206       {
 207         Item *i = dynamic_cast<Item *> (inf.grob ());
 208         Tuplet_bracket::add_column (tuplets_[j].bracket_, i);
 209         add_bound_item (tuplets_[j].number_, i);
 210       }
 211 }
 212
 213 void
 214 Tuplet_engraver::acknowledge_script (Grob_info inf)
 215 {
 216   for (vsize j = 0; j < tuplets_.size (); j++)
 217     if (tuplets_[j].bracket_)
 218       {
 219         Item *i = dynamic_cast<Item *> (inf.grob ());
 220         if (!i->internal_has_interface (ly_symbol2scm ("dynamic-interface")))
 221           Tuplet_bracket::add_script (tuplets_[j].bracket_, i);
 222       }
 223 }
 224
 225 void
 226 Tuplet_engraver::acknowledge_finger (Grob_info inf)
 227 {
 228   for (vsize j = 0; j < tuplets_.size (); j++)
 229     if (tuplets_[j].bracket_)
 230       {
 231         Item *i = dynamic_cast<Item *> (inf.grob ());
 232         Tuplet_bracket::add_script (tuplets_[j].bracket_, i);
 233       }
 234 }
 235
 236 void
 237 Tuplet_engraver::acknowledge_string_number (Grob_info inf)
 238 {
 239   for (vsize j = 0; j < tuplets_.size (); j++)
 240     if (tuplets_[j].bracket_)
 241       {
 242         Item *i = dynamic_cast<Item *> (inf.grob ());
 243         Tuplet_bracket::add_script (tuplets_[j].bracket_, i);
 244       }
 245 }
 246
 247 void
 248 Tuplet_engraver::start_translation_timestep ()
 249 {
 250   last_tuplets_.clear ();
 251   /*
 252     May seem superfluous, but necessary for skipTypesetting.
 253    */
 254   new_tuplets_.clear ();
 255 }
 256
 257 void
 258 Tuplet_engraver::finalize ()
 259 {
 260   if (to_boolean (get_property ("tupletFullLength")))
 261     for (vsize i = 0; i < last_tuplets_.size (); i++)
 262       {
 263         Item *col = unsmob_item (get_property ("currentCommandColumn"));
 264         last_tuplets_[i]->set_bound (RIGHT, col);
 265       }
 266 }
 267
 268 Tuplet_engraver::Tuplet_engraver ()
 269 {
 270 }
 271
 272 ADD_ACKNOWLEDGER (Tuplet_engraver, note_column);
 273 ADD_ACKNOWLEDGER (Tuplet_engraver, script);
 274 ADD_ACKNOWLEDGER (Tuplet_engraver, finger);
 275 ADD_ACKNOWLEDGER (Tuplet_engraver, string_number);
 276 ADD_TRANSLATOR (Tuplet_engraver,
 277                 /* doc */
 278                 "Catch tuplet events and generate appropriate bracket.",
 279
 280                 /* create */
 281                 "TupletBracket "
 282                 "TupletNumber ",
 283
 284                 /* read */
 285                 "tupletFullLength "
 286                 "tupletFullLengthNote ",
 287
 288                 /* write */
 289                 ""
 290                );