lily/auto-beam-engraver.cc

   1 /*
   2   auto-beam-engraver.cc -- implement Auto_beam_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1999--2007 Jan Nieuwenhuizen <janneke@gnu.org>
   7 */
   8
   9 #include "bar-line.hh"
  10 #include "beaming-pattern.hh"
  11 #include "beam.hh"
  12 #include "context.hh"
  13 #include "duration.hh"
  14 #include "engraver.hh"
  15 #include "item.hh"
  16 #include "rest.hh"
  17 #include "spanner.hh"
  18 #include "stream-event.hh"
  19 #include "stem.hh"
  20 #include "warn.hh"
  21
  22 #include "translator.icc"
  23
  24 class Auto_beam_engraver : public Engraver
  25 {
  26   TRANSLATOR_DECLARATIONS (Auto_beam_engraver);
  27
  28 protected:
  29   void stop_translation_timestep ();
  30   void start_translation_timestep ();
  31   void process_music ();
  32   virtual void finalize ();
  33   virtual void derived_mark () const;
  34
  35   DECLARE_ACKNOWLEDGER (rest);
  36   DECLARE_ACKNOWLEDGER (beam);
  37   DECLARE_ACKNOWLEDGER (bar_line);
  38   DECLARE_ACKNOWLEDGER (stem);
  39   DECLARE_TRANSLATOR_LISTENER (beam_forbid);
  40
  41   void process_acknowledged ();
  42
  43 private:
  44   bool test_moment (Direction, Moment);
  45   void consider_begin (Moment);
  46   void consider_end (Moment);
  47   Spanner *create_beam ();
  48   void begin_beam ();
  49   void end_beam ();
  50   void junk_beam ();
  51   bool is_same_grace_state (Grob *e);
  52   void typeset_beam ();
  53
  54   Stream_event *forbid_;
  55   /*
  56     shortest_mom is the shortest note in the beam.
  57   */
  58   Moment shortest_mom_;
  59   Spanner *finished_beam_;
  60   vector<Item*> *stems_;
  61
  62   int process_acknowledged_count_;
  63   Moment last_add_mom_;
  64   /*
  65     Projected ending of the  beam we're working on.
  66   */
  67   Moment extend_mom_;
  68   Moment beam_start_moment_;
  69   Moment beam_start_location_;
  70
  71   bool subdivide_beams_;
  72   Moment beat_length_;
  73
  74   // We act as if beam were created, and start a grouping anyway.
  75   Beaming_pattern *grouping_;
  76   SCM beam_settings_;
  77
  78   Beaming_pattern *finished_grouping_;
  79
  80   void check_bar_property ();
  81 };
  82
  83 void
  84 Auto_beam_engraver::derived_mark () const
  85 {
  86   scm_gc_mark (beam_settings_);
  87 }
  88
  89 void
  90 Auto_beam_engraver::check_bar_property ()
  91 {
  92   /* Duplicated from process_music (), since
  93      Repeat_acknowledge_engraver::process_music () may also set whichBar.  */
  94
  95   Moment now = now_mom ();
  96   if (scm_is_string (get_property ("whichBar"))
  97       && beam_start_moment_ < now)
  98     {
  99       consider_end (shortest_mom_);
 100       junk_beam ();
 101     }
 102 }
 103
 104 void
 105 Auto_beam_engraver::process_music ()
 106 {
 107   if (scm_is_string (get_property ("whichBar")))
 108     {
 109       consider_end (shortest_mom_);
 110       junk_beam ();
 111     }
 112
 113   if (forbid_)
 114     {
 115       consider_end (shortest_mom_);
 116       junk_beam ();
 117     }
 118 }
 119
 120 Auto_beam_engraver::Auto_beam_engraver ()
 121 {
 122   forbid_ = 0;
 123   process_acknowledged_count_ = 0;
 124   stems_ = 0;
 125   shortest_mom_ = Moment (Rational (1, 8));
 126   finished_beam_ = 0;
 127   finished_grouping_ = 0;
 128   grouping_ = 0;
 129   beam_settings_ = SCM_EOL;
 130 }
 131
 132 IMPLEMENT_TRANSLATOR_LISTENER (Auto_beam_engraver, beam_forbid);
 133 void
 134 Auto_beam_engraver::listen_beam_forbid (Stream_event *ev)
 135 {
 136   ASSIGN_EVENT_ONCE (forbid_, ev);
 137 }
 138
 139 bool
 140 Auto_beam_engraver::test_moment (Direction dir, Moment test)
 141 {
 142   return scm_call_3 (get_property ("autoBeamCheck"),
 143                      context ()->self_scm (),
 144                      scm_from_int (dir),
 145                      test.smobbed_copy ())
 146     != SCM_BOOL_F;
 147 }
 148
 149 void
 150 Auto_beam_engraver::consider_begin (Moment test_mom)
 151 {
 152   bool on = to_boolean (get_property ("autoBeaming"));
 153   if (!stems_ && on
 154       && !forbid_)
 155     {
 156       bool b = test_moment (START, test_mom);
 157       if (b)
 158         begin_beam ();
 159     }
 160 }
 161
 162 void
 163 Auto_beam_engraver::consider_end (Moment test_mom)
 164 {
 165   if (stems_)
 166     {
 167       /* Allow already started autobeam to end:
 168          don't check for autoBeaming */
 169       bool b = test_moment (STOP, test_mom);
 170       if (b)
 171         end_beam ();
 172     }
 173 }
 174
 175 Spanner *
 176 Auto_beam_engraver::create_beam ()
 177 {
 178   if (to_boolean (get_property ("skipTypesetting")))
 179     return 0;
 180
 181   for (vsize i = 0; i < stems_->size (); i++)
 182     if (Stem::get_beam ((*stems_)[i]))
 183       return 0;
 184
 185   /*
 186     Can't use make_spanner_from_properties() because we have to use
 187     beam_settings_.
 188   */
 189   Spanner *beam = new Spanner (beam_settings_);
 190
 191   for (vsize i = 0; i < stems_->size (); i++)
 192     Beam::add_stem (beam, (*stems_)[i]);
 193
 194   announce_grob (beam, (*stems_)[0]->self_scm ());
 195
 196   return beam;
 197 }
 198
 199 void
 200 Auto_beam_engraver::begin_beam ()
 201 {
 202   if (stems_ || grouping_)
 203     {
 204       programming_error ("already have autobeam");
 205       return;
 206     }
 207
 208   stems_ = new vector<Item*>;
 209   grouping_ = new Beaming_pattern ();
 210   beam_settings_ = updated_grob_properties (context (), ly_symbol2scm ("Beam"));
 211
 212   beam_start_moment_ = now_mom ();
 213   beam_start_location_
 214     = robust_scm2moment (get_property ("measurePosition"), Moment (0));
 215 }
 216
 217 void
 218 Auto_beam_engraver::junk_beam ()
 219 {
 220   if (!stems_)
 221     return;
 222
 223   delete stems_;
 224   stems_ = 0;
 225   delete grouping_;
 226   grouping_ = 0;
 227   beam_settings_ = SCM_EOL;
 228
 229   shortest_mom_ = Moment (Rational (1, 8));
 230 }
 231
 232 void
 233 Auto_beam_engraver::end_beam ()
 234 {
 235   if (stems_->size () < 2)
 236     junk_beam ();
 237   else
 238     {
 239       finished_beam_ = create_beam ();
 240
 241       if (finished_beam_)
 242         {
 243           announce_end_grob (finished_beam_, SCM_EOL);
 244           finished_grouping_ = grouping_;
 245         }
 246       delete stems_;
 247       stems_ = 0;
 248       grouping_ = 0;
 249       beam_settings_ = SCM_EOL;
 250     }
 251
 252   shortest_mom_ = Moment (Rational (1, 8));
 253 }
 254
 255 void
 256 Auto_beam_engraver::typeset_beam ()
 257 {
 258   if (finished_beam_)
 259     {
 260       if (!finished_beam_->get_bound (RIGHT))
 261         finished_beam_->set_bound (RIGHT, finished_beam_->get_bound (LEFT));
 262
 263       finished_grouping_->beamify (context ());
 264       Beam::set_beaming (finished_beam_, finished_grouping_);
 265       finished_beam_ = 0;
 266
 267       delete finished_grouping_;
 268       finished_grouping_ = 0;
 269     }
 270 }
 271
 272 void
 273 Auto_beam_engraver::start_translation_timestep ()
 274 {
 275   process_acknowledged_count_ = 0;
 276   /*
 277     don't beam over skips
 278   */
 279   if (stems_)
 280     {
 281       Moment now = now_mom ();
 282       if (extend_mom_ < now)
 283         end_beam ();
 284     }
 285   forbid_ = 0;
 286 }
 287
 288 void
 289 Auto_beam_engraver::stop_translation_timestep ()
 290 {
 291   typeset_beam ();
 292 }
 293
 294 void
 295 Auto_beam_engraver::finalize ()
 296 {
 297   /* finished beams may be typeset */
 298   typeset_beam ();
 299   /* but unfinished may need another announce/acknowledge pass */
 300   if (stems_)
 301     junk_beam ();
 302 }
 303
 304
 305 void
 306 Auto_beam_engraver::acknowledge_beam (Grob_info info)
 307 {
 308   (void)info;
 309   check_bar_property ();
 310   if (stems_)
 311     end_beam ();
 312 }
 313
 314 void
 315 Auto_beam_engraver::acknowledge_bar_line (Grob_info info)
 316 {
 317   (void)info;
 318   check_bar_property ();
 319   if (stems_)
 320     end_beam ();
 321 }
 322
 323 void
 324 Auto_beam_engraver::acknowledge_rest (Grob_info info)
 325 {
 326   (void)info;
 327   check_bar_property ();
 328   if (stems_)
 329     end_beam ();
 330 }
 331
 332 void
 333 Auto_beam_engraver::acknowledge_stem (Grob_info info)
 334 {
 335   check_bar_property ();
 336   Item *stem = dynamic_cast<Item *> (info.grob ());
 337   Stream_event *ev = info.ultimate_event_cause ();
 338   if (!ev->in_event_class ("rhythmic-event"))
 339     {
 340       programming_error ("stem must have rhythmic structure");
 341       return;
 342     }
 343
 344   /*
 345     Don't (start) auto-beam over empty stems; skips or rests
 346   */
 347   if (!Stem::head_count (stem))
 348     {
 349       if (stems_)
 350         end_beam ();
 351       return;
 352     }
 353
 354   if (Stem::get_beam (stem))
 355     {
 356       if (stems_)
 357         junk_beam ();
 358       return;
 359     }
 360
 361   int durlog = unsmob_duration (ev->get_property ("duration"))->duration_log ();
 362
 363   if (durlog <= 2)
 364     {
 365       if (stems_)
 366         end_beam ();
 367       return;
 368     }
 369
 370   /*
 371     ignore grace notes.
 372   */
 373   Moment now = now_mom ();
 374   if (bool (beam_start_location_.grace_part_) != bool (now.grace_part_))
 375     return;
 376
 377   Moment dur = unsmob_duration (ev->get_property ("duration"))->get_length ();
 378
 379   consider_end (dur);
 380   consider_begin (dur);
 381
 382   if (dur < shortest_mom_)
 383     shortest_mom_ = dur;
 384
 385   if (!stems_)
 386     return;
 387
 388   grouping_->add_stem (now - beam_start_moment_ + beam_start_location_,
 389                        durlog - 2);
 390   stems_->push_back (stem);
 391   last_add_mom_ = now;
 392   extend_mom_ = max (extend_mom_, now) + get_event_length (ev);
 393 }
 394
 395 void
 396 Auto_beam_engraver::process_acknowledged ()
 397 {
 398   if (extend_mom_ > now_mom ())
 399     return;
 400
 401   if (!process_acknowledged_count_)
 402     {
 403       consider_end (shortest_mom_);
 404       consider_begin (shortest_mom_);
 405     }
 406   else if (process_acknowledged_count_ > 1)
 407     {
 408       if (stems_)
 409         {
 410           Moment now = now_mom ();
 411           if ((extend_mom_ < now)
 412               || ((extend_mom_ == now) && (last_add_mom_ != now)))
 413             end_beam ();
 414           else if (!stems_->size ())
 415             junk_beam ();
 416         }
 417     }
 418
 419   process_acknowledged_count_++;
 420 }
 421
 422 ADD_ACKNOWLEDGER (Auto_beam_engraver, stem);
 423 ADD_ACKNOWLEDGER (Auto_beam_engraver, bar_line);
 424 ADD_ACKNOWLEDGER (Auto_beam_engraver, beam);
 425 ADD_ACKNOWLEDGER (Auto_beam_engraver, rest);
 426 ADD_TRANSLATOR (Auto_beam_engraver,
 427                 /* doc */ "Generate beams based on measure characteristics and observed "
 428                 "Stems.  Uses beatLength, measureLength and measurePosition to decide "
 429                 "when to start and stop a beam.  Overriding beaming is done through "
 430                 "@ref{Stem_engraver} properties @code{stemLeftBeamCount} and "
 431                 "@code{stemRightBeamCount}. ",
 432                 /* create */ "Beam",
 433
 434                 /* read */
 435                 "autoBeaming "
 436                 "autoBeamSettings "
 437                 "beatLength "
 438                 "subdivideBeams ",
 439
 440                 /* write */ "");