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