lily/tuplet-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1998--2011 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_TRANSLATOR_LISTENER (tuplet_span);
  69   virtual void finalize ();
  70   void start_translation_timestep ();
  71   void process_music ();
  72 };
  73
  74 IMPLEMENT_TRANSLATOR_LISTENER (Tuplet_engraver, tuplet_span);
  75 void
  76 Tuplet_engraver::listen_tuplet_span (Stream_event *ev)
  77 {
  78   Direction dir = to_dir (ev->get_property ("span-direction"));
  79   if (dir == START)
  80     {
  81       Tuplet_description d;
  82       d.event_ = ev;
  83
  84       d.length_ = robust_scm2moment (d.event_->get_property ("length"),
  85                                      Moment (0));
  86       d.start_moment_ = now_mom ();
  87       d.stop_moment_ = now_mom () + d.length_;
  88
  89       for (vsize i = 0; i < new_tuplets_.size (); i++)
  90         {
  91           /*
  92             discard duplicates.
  93           */
  94           if (new_tuplets_[i].stop_moment_ == d.stop_moment_)
  95             return;
  96         }
  97
  98       new_tuplets_.push_back (d);
  99     }
 100   else if (dir == STOP)
 101     {
 102       if (tuplets_.size ())
 103         {
 104           stopped_tuplets_.push_back (tuplets_.back ());
 105           tuplets_.pop_back ();
 106         }
 107       else if (!to_boolean (get_property ("skipTypesetting")))
 108         ev->origin ()->warning (_ ("No tuplet to end"));
 109     }
 110   else
 111     ev->origin ()->programming_error ("direction tuplet-span-event_ invalid.");
 112 }
 113
 114 void
 115 Tuplet_engraver::process_music ()
 116 {
 117   /*
 118     This may happen if the end of a tuplet is part of a quoted voice.
 119    */
 120   Moment now = now_mom ();
 121   for (vsize i = tuplets_.size (); i--;)
 122     {
 123       if (tuplets_[i].stop_moment_ == now)
 124         {
 125           stopped_tuplets_.push_back (tuplets_[i]);
 126           tuplets_.erase (tuplets_.begin () + i);
 127         }
 128     }
 129
 130   for (vsize i = 0; i < stopped_tuplets_.size (); i++)
 131     {
 132       Spanner *bracket = stopped_tuplets_[i].bracket_;
 133       Spanner *number = stopped_tuplets_[i].number_;
 134       if (bracket)
 135         {
 136           if (stopped_tuplets_[i].full_length_)
 137             {
 138               Item *col
 139                 = unsmob_item (stopped_tuplets_[i].full_length_note_
 140                                ? get_property ("currentMusicalColumn")
 141                                : get_property ("currentCommandColumn"));
 142
 143               bracket->set_bound (RIGHT, col);
 144               number->set_bound (RIGHT, col);
 145             }
 146           else if (!bracket->get_bound (RIGHT))
 147             {
 148               if (bracket->get_bound (LEFT))
 149                 {
 150                   bracket->set_bound (RIGHT,
 151                                       bracket->get_bound (LEFT));
 152                   number->set_bound (RIGHT,
 153                                      stopped_tuplets_[i].bracket_->get_bound (LEFT));
 154                 }
 155               else
 156                 programming_error ("stopped tuplet bracket has neither left nor right bound");
 157             }
 158           // todo: scrap last_tuplets_, use stopped_tuplets_ only.
 159           // clear stopped_tuplets_ at start_translation_timestep
 160           last_tuplets_.push_back (bracket);
 161           last_tuplets_.push_back (number);
 162         }
 163     }
 164   stopped_tuplets_.clear ();
 165
 166   concat (tuplets_, new_tuplets_);
 167   new_tuplets_.clear ();
 168   for (vsize j = tuplets_.size (); j > 0; j--)
 169     {
 170       /* i goes from size-1 downto 0, inclusively */
 171       vsize i = j - 1;
 172
 173       if (tuplets_[i].bracket_)
 174         continue;
 175
 176       tuplets_[i].full_length_ = to_boolean (get_property ("tupletFullLength"));
 177       tuplets_[i].full_length_note_
 178         = to_boolean (get_property ("tupletFullLengthNote"));
 179
 180       tuplets_[i].bracket_ = make_spanner ("TupletBracket",
 181                                            tuplets_[i].event_->self_scm ());
 182       tuplets_[i].number_ = make_spanner ("TupletNumber",
 183                                           tuplets_[i].event_->self_scm ());
 184       tuplets_[i].number_->set_object ("bracket", tuplets_[i].bracket_->self_scm ());
 185       tuplets_[i].number_->set_parent (tuplets_[i].bracket_, X_AXIS);
 186       tuplets_[i].number_->set_parent (tuplets_[i].bracket_, Y_AXIS);
 187       tuplets_[i].bracket_->set_object ("tuplet-number", tuplets_[i].number_->self_scm ());
 188       tuplets_[i].stop_moment_.grace_part_ = 0;
 189
 190       if (i + 1 < tuplets_.size () && tuplets_[i + 1].bracket_)
 191         Tuplet_bracket::add_tuplet_bracket (tuplets_[i].bracket_, tuplets_[i + 1].bracket_);
 192
 193       if (i > 0 && tuplets_[i - 1].bracket_)
 194         Tuplet_bracket::add_tuplet_bracket (tuplets_[i - 1].bracket_, tuplets_[i].bracket_);
 195
 196     }
 197 }
 198
 199 void
 200 Tuplet_engraver::acknowledge_note_column (Grob_info inf)
 201 {
 202   for (vsize j = 0; j < tuplets_.size (); j++)
 203     if (tuplets_[j].bracket_)
 204       {
 205         Item *i = dynamic_cast<Item *> (inf.grob ());
 206         Tuplet_bracket::add_column (tuplets_[j].bracket_, i);
 207         add_bound_item (tuplets_[j].number_, i);
 208       }
 209 }
 210
 211 void
 212 Tuplet_engraver::acknowledge_script (Grob_info inf)
 213 {
 214   for (vsize j = 0; j < tuplets_.size (); j++)
 215     if (tuplets_[j].bracket_)
 216       {
 217         Item *i = dynamic_cast<Item *> (inf.grob ());
 218         Tuplet_bracket::add_script (tuplets_[j].bracket_, i);
 219       }
 220 }
 221
 222 void
 223 Tuplet_engraver::start_translation_timestep ()
 224 {
 225   last_tuplets_.clear ();
 226   /*
 227     May seem superfluous, but necessary for skipTypesetting.
 228    */
 229   new_tuplets_.clear ();
 230 }
 231
 232 void
 233 Tuplet_engraver::finalize ()
 234 {
 235   if (to_boolean (get_property ("tupletFullLength")))
 236     for (vsize i = 0; i < last_tuplets_.size (); i++)
 237       {
 238         Item *col = unsmob_item (get_property ("currentCommandColumn"));
 239         last_tuplets_[i]->set_bound (RIGHT, col);
 240       }
 241 }
 242
 243 Tuplet_engraver::Tuplet_engraver ()
 244 {
 245 }
 246
 247 ADD_ACKNOWLEDGER (Tuplet_engraver, note_column);
 248 ADD_ACKNOWLEDGER (Tuplet_engraver, script);
 249 ADD_TRANSLATOR (Tuplet_engraver,
 250                 /* doc */
 251                 "Catch tuplet events and generate appropriate bracket.",
 252
 253                 /* create */
 254                 "TupletBracket "
 255                 "TupletNumber ",
 256
 257                 /* read */
 258                 "tupletFullLength "
 259                 "tupletFullLengthNote ",
 260
 261                 /* write */
 262                 ""
 263                );