lily/beam-engraver.cc

   1 /*
   2   beam-engraver.cc -- implement Beam_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1998--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 #include "beam.hh"
  10 #include "beaming.hh"
  11 #include "context.hh"
  12 #include "drul-array.hh"
  13 #include "duration.hh"
  14 #include "engraver.hh"
  15 #include "international.hh"
  16 #include "item.hh"
  17 #include "rest.hh"
  18 #include "score-engraver.hh"
  19 #include "spanner.hh"
  20 #include "stem.hh"
  21 #include "warn.hh"
  22
  23 #include "translator.icc"
  24
  25 class Beam_engraver : public Engraver
  26 {
  27 public:
  28   DECLARE_ACKNOWLEDGER (stem);
  29   DECLARE_ACKNOWLEDGER (rest);
  30 protected:
  31   Music *start_ev_;
  32
  33   Spanner *finished_beam_;
  34   Spanner *beam_;
  35   Music *prev_start_ev_;
  36
  37   Music *now_stop_ev_;
  38
  39   Beaming_info_list *beam_info_;
  40   Beaming_info_list *finished_beam_info_;
  41
  42   /// location  within measure where beam started.
  43   Moment beam_start_location_;
  44
  45   /// moment (global time) where beam started.
  46   Moment beam_start_mom_;
  47
  48   bool subdivide_beams_;
  49   Moment beat_length_;
  50
  51   void typeset_beam ();
  52   void set_melisma (bool);
  53
  54   Moment last_stem_added_at_;
  55   void stop_translation_timestep ();
  56   void start_translation_timestep ();
  57   virtual void finalize ();
  58
  59   virtual bool try_music (Music *);
  60   void process_music ();
  61
  62   virtual bool valid_start_point ();
  63   virtual bool valid_end_point ();
  64
  65 public:
  66   TRANSLATOR_DECLARATIONS (Beam_engraver);
  67 };
  68
  69 /*
  70   Hmm. this isn't necessary, since grace beams and normal beams are
  71   always nested.
  72 */
  73 bool
  74 Beam_engraver::valid_start_point ()
  75 {
  76   Moment n = now_mom ();
  77
  78   return n.grace_part_ == Rational (0);
  79 }
  80
  81 bool
  82 Beam_engraver::valid_end_point ()
  83 {
  84   return valid_start_point ();
  85 }
  86
  87 Beam_engraver::Beam_engraver ()
  88 {
  89   beam_ = 0;
  90   finished_beam_ = 0;
  91   finished_beam_info_ = 0;
  92   beam_info_ = 0;
  93   now_stop_ev_ = 0;
  94   start_ev_ = 0;
  95   prev_start_ev_ = 0;
  96 }
  97
  98 bool
  99 Beam_engraver::try_music (Music *m)
 100 {
 101   if (m->is_mus_type ("beam-event"))
 102     {
 103       Direction d = to_dir (m->get_property ("span-direction"));
 104       if (d == START && !valid_start_point ())
 105         return false;
 106       if (d == STOP && !valid_end_point ())
 107         return false;
 108
 109       if (d == START)
 110         start_ev_ = m;
 111       else if (d == STOP)
 112         now_stop_ev_ = m;
 113       return true;
 114     }
 115   return false;
 116 }
 117
 118 void
 119 Beam_engraver::set_melisma (bool ml)
 120 {
 121   SCM b = get_property ("autoBeaming");
 122   if (!to_boolean (b))
 123     context ()->set_property ("beamMelismaBusy", ml ? SCM_BOOL_T : SCM_BOOL_F);
 124 }
 125
 126 void
 127 Beam_engraver::process_music ()
 128 {
 129   if (beam_ && !to_boolean (get_property ("allowBeamBreak")))
 130     get_score_engraver ()->forbid_breaks ();
 131
 132   if (start_ev_)
 133     {
 134       if (beam_)
 135         {
 136           start_ev_->origin ()->warning (_ ("already have a beam"));
 137           return;
 138         }
 139
 140       set_melisma (true);
 141       prev_start_ev_ = start_ev_;
 142       beam_ = make_spanner ("Beam", start_ev_->self_scm ());
 143       Moment mp (robust_scm2moment (get_property ("measurePosition"), Moment (0)));
 144
 145       beam_start_location_ = mp;
 146       beam_start_mom_ = now_mom ();
 147
 148       beam_info_ = new Beaming_info_list;
 149
 150       /* urg, must copy to Auto_beam_engraver too */
 151     }
 152 }
 153
 154 void
 155 Beam_engraver::typeset_beam ()
 156 {
 157   if (finished_beam_)
 158     {
 159       finished_beam_info_->beamify (beat_length_, subdivide_beams_);
 160       Beam::set_beaming (finished_beam_, finished_beam_info_);
 161
 162       delete finished_beam_info_;
 163       finished_beam_info_ = 0;
 164       finished_beam_ = 0;
 165     }
 166 }
 167
 168 void
 169 Beam_engraver::start_translation_timestep ()
 170 {
 171   start_ev_ = 0;
 172
 173   if (beam_)
 174     {
 175       set_melisma (true);
 176
 177       subdivide_beams_ = to_boolean (get_property ("subdivideBeams"));
 178       beat_length_ = robust_scm2moment (get_property ("beatLength"), Moment (1, 4));
 179     }
 180 }
 181
 182 void
 183 Beam_engraver::stop_translation_timestep ()
 184 {
 185   typeset_beam ();
 186   if (now_stop_ev_)
 187     {
 188       finished_beam_ = beam_;
 189       finished_beam_info_ = beam_info_;
 190
 191       now_stop_ev_ = 0;
 192       beam_ = 0;
 193       beam_info_ = 0;
 194       typeset_beam ();
 195       set_melisma (false);
 196     }
 197 }
 198
 199 void
 200 Beam_engraver::finalize ()
 201 {
 202   typeset_beam ();
 203   if (beam_)
 204     {
 205       prev_start_ev_->origin ()->warning (_ ("unterminated beam"));
 206
 207       /*
 208         we don't typeset it, (we used to, but it was commented
 209         out. Reason unknown) */
 210       beam_->suicide ();
 211       delete beam_info_;
 212     }
 213 }
 214
 215 void
 216 Beam_engraver::acknowledge_rest (Grob_info info)
 217 {
 218   if (beam_)
 219     {
 220       chain_offset_callback (info.grob(),
 221                              Beam::rest_collision_callback_proc, Y_AXIS);
 222     }
 223 }
 224
 225
 226
 227 void
 228 Beam_engraver::acknowledge_stem (Grob_info info)
 229 {
 230   if (!beam_)
 231     return;
 232
 233   Moment now = now_mom ();
 234   if (!valid_start_point ())
 235     return;
 236
 237   Item *stem = dynamic_cast<Item *> (info.grob ());
 238   if (Stem::get_beam (stem))
 239     return;
 240
 241
 242
 243   Music *m = info.ultimate_music_cause ();
 244   if (!m->is_mus_type ("rhythmic-event"))
 245     {
 246       string s = _ ("stem must have Rhythmic structure");
 247       if (info.music_cause ())
 248         info.music_cause ()->origin ()->warning (s);
 249       else
 250         ::warning (s);
 251
 252       return;
 253     }
 254
 255   last_stem_added_at_ = now;
 256   int durlog = unsmob_duration (m->get_property ("duration"))->duration_log ();
 257   if (durlog <= 2)
 258     {
 259       m->origin ()->warning (_ ("stem doesn't fit in beam"));
 260       prev_start_ev_->origin ()->warning (_ ("beam was started here"));
 261       /*
 262         don't return, since
 263
 264         [r4 c8] can just as well be modern notation.
 265       */
 266     }
 267
 268   stem->set_property ("duration-log",
 269                       scm_from_int (durlog));
 270   Moment stem_location = now - beam_start_mom_ + beam_start_location_;
 271   beam_info_->add_stem (stem_location,
 272                         max (durlog- 2, 0));
 273   Beam::add_stem (beam_, stem);
 274 }
 275
 276 ADD_ACKNOWLEDGER (Beam_engraver, stem);
 277 ADD_ACKNOWLEDGER (Beam_engraver, rest);
 278
 279 ADD_TRANSLATOR (Beam_engraver,
 280                 /* doc */ "Handles Beam events by engraving Beams.    If omitted, then notes will be "
 281                 "printed with flags instead of beams.",
 282                 /* create */ "Beam",
 283                 /* accept */ "beam-event",
 284                 /* read */ "beamMelismaBusy beatLength subdivideBeams",
 285                 /* write */ "");
 286
 287 class Grace_beam_engraver : public Beam_engraver
 288 {
 289 public:
 290   TRANSLATOR_DECLARATIONS (Grace_beam_engraver);
 291
 292 protected:
 293   virtual bool valid_start_point ();
 294   virtual bool valid_end_point ();
 295 };
 296
 297 Grace_beam_engraver::Grace_beam_engraver ()
 298 {
 299 }
 300
 301 bool
 302 Grace_beam_engraver::valid_start_point ()
 303 {
 304   Moment n = now_mom ();
 305
 306   return n.grace_part_ != Rational (0);
 307 }
 308
 309 bool
 310 Grace_beam_engraver::valid_end_point ()
 311 {
 312   return beam_ && valid_start_point ();
 313 }
 314
 315 ADD_ACKNOWLEDGER (Grace_beam_engraver, stem);
 316 ADD_ACKNOWLEDGER (Grace_beam_engraver, rest);
 317 ADD_TRANSLATOR (Grace_beam_engraver,
 318                 /* doc */ "Handles Beam events by engraving Beams.  If omitted, then notes will "
 319                 "be printed with flags instead of beams. Only engraves beams when we "
 320                 " are at grace points in time. ",
 321                 /* create */ "Beam",
 322                 /* accept */ "beam-event",
 323                 /* read */ "beamMelismaBusy beatLength allowBeamBreak subdivideBeams",
 324                 /* write */ "");
 325