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 ()->debug_output (_ ("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                 {
 159                   warning ("omitting tuplet bracket with neither left nor right bound");
 160                   continue;
 161                 }
 162             }
 163           // todo: scrap last_tuplets_, use stopped_tuplets_ only.
 164           // clear stopped_tuplets_ at start_translation_timestep
 165           last_tuplets_.push_back (bracket);
 166           last_tuplets_.push_back (number);
 167         }
 168     }
 169   stopped_tuplets_.clear ();
 170
 171   concat (tuplets_, new_tuplets_);
 172   new_tuplets_.clear ();
 173   for (vsize j = tuplets_.size (); j > 0; j--)
 174     {
 175       /* i goes from size-1 downto 0, inclusively */
 176       vsize i = j - 1;
 177
 178       if (tuplets_[i].bracket_)
 179         continue;
 180
 181       tuplets_[i].full_length_ = to_boolean (get_property ("tupletFullLength"));
 182       tuplets_[i].full_length_note_
 183         = to_boolean (get_property ("tupletFullLengthNote"));
 184
 185       tuplets_[i].bracket_ = make_spanner ("TupletBracket",
 186                                            tuplets_[i].event_->self_scm ());
 187       tuplets_[i].number_ = make_spanner ("TupletNumber",
 188                                           tuplets_[i].event_->self_scm ());
 189       tuplets_[i].number_->set_object ("bracket", tuplets_[i].bracket_->self_scm ());
 190       tuplets_[i].number_->set_parent (tuplets_[i].bracket_, X_AXIS);
 191       tuplets_[i].number_->set_parent (tuplets_[i].bracket_, Y_AXIS);
 192       tuplets_[i].bracket_->set_object ("tuplet-number", tuplets_[i].number_->self_scm ());
 193       tuplets_[i].stop_moment_.grace_part_ = 0;
 194
 195       if (i + 1 < tuplets_.size () && tuplets_[i + 1].bracket_)
 196         Tuplet_bracket::add_tuplet_bracket (tuplets_[i].bracket_, tuplets_[i + 1].bracket_);
 197
 198       if (i > 0 && tuplets_[i - 1].bracket_)
 199         Tuplet_bracket::add_tuplet_bracket (tuplets_[i - 1].bracket_, tuplets_[i].bracket_);
 200
 201     }
 202 }
 203
 204 void
 205 Tuplet_engraver::acknowledge_note_column (Grob_info inf)
 206 {
 207   for (vsize j = 0; j < tuplets_.size (); j++)
 208     if (tuplets_[j].bracket_)
 209       {
 210         Item *i = dynamic_cast<Item *> (inf.grob ());
 211         Tuplet_bracket::add_column (tuplets_[j].bracket_, i);
 212         add_bound_item (tuplets_[j].number_, i);
 213       }
 214 }
 215
 216 void
 217 Tuplet_engraver::acknowledge_script (Grob_info inf)
 218 {
 219   for (vsize j = 0; j < tuplets_.size (); j++)
 220     if (tuplets_[j].bracket_)
 221       {
 222         Item *i = dynamic_cast<Item *> (inf.grob ());
 223         if (!i->internal_has_interface (ly_symbol2scm ("dynamic-interface")))
 224           Tuplet_bracket::add_script (tuplets_[j].bracket_, i);
 225       }
 226 }
 227
 228 void
 229 Tuplet_engraver::acknowledge_finger (Grob_info inf)
 230 {
 231   for (vsize j = 0; j < tuplets_.size (); j++)
 232     if (tuplets_[j].bracket_)
 233       {
 234         Item *i = dynamic_cast<Item *> (inf.grob ());
 235         Tuplet_bracket::add_script (tuplets_[j].bracket_, i);
 236       }
 237 }
 238
 239 void
 240 Tuplet_engraver::acknowledge_string_number (Grob_info inf)
 241 {
 242   for (vsize j = 0; j < tuplets_.size (); j++)
 243     if (tuplets_[j].bracket_)
 244       {
 245         Item *i = dynamic_cast<Item *> (inf.grob ());
 246         Tuplet_bracket::add_script (tuplets_[j].bracket_, i);
 247       }
 248 }
 249
 250 void
 251 Tuplet_engraver::start_translation_timestep ()
 252 {
 253   last_tuplets_.clear ();
 254   /*
 255     May seem superfluous, but necessary for skipTypesetting.
 256    */
 257   new_tuplets_.clear ();
 258 }
 259
 260 void
 261 Tuplet_engraver::finalize ()
 262 {
 263   if (to_boolean (get_property ("tupletFullLength")))
 264     for (vsize i = 0; i < last_tuplets_.size (); i++)
 265       {
 266         Item *col = unsmob_item (get_property ("currentCommandColumn"));
 267         last_tuplets_[i]->set_bound (RIGHT, col);
 268       }
 269 }
 270
 271 Tuplet_engraver::Tuplet_engraver ()
 272 {
 273 }
 274
 275 ADD_ACKNOWLEDGER (Tuplet_engraver, note_column);
 276 ADD_ACKNOWLEDGER (Tuplet_engraver, script);
 277 ADD_ACKNOWLEDGER (Tuplet_engraver, finger);
 278 ADD_ACKNOWLEDGER (Tuplet_engraver, string_number);
 279 ADD_TRANSLATOR (Tuplet_engraver,
 280                 /* doc */
 281                 "Catch tuplet events and generate appropriate bracket.",
 282
 283                 /* create */
 284                 "TupletBracket "
 285                 "TupletNumber ",
 286
 287                 /* read */
 288                 "tupletFullLength "
 289                 "tupletFullLengthNote ",
 290
 291                 /* write */
 292                 ""
 293                );