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 Jan Nieuwenhuizen <janneke@gnu.org>
   7
   8  */
   9 #include "new-beaming.hh"
  10 #include "auto-beam-engraver.hh"
  11 #include "musical-request.hh"
  12 #include "bar.hh"
  13 #include "beam.hh"
  14 #include "rest.hh"
  15 #include "stem.hh"
  16 #include "debug.hh"
  17 #include "timing-engraver.hh"
  18 #include "engraver-group-engraver.hh"
  19
  20 ADD_THIS_TRANSLATOR (Auto_beam_engraver);
  21
  22 Auto_beam_engraver::Auto_beam_engraver ()
  23 {
  24   stem_l_arr_p_ = 0;
  25   shortest_mom_ = Moment (1, 8);
  26   finished_beam_p_ = 0;
  27   finished_grouping_p_ = 0;
  28   grouping_p_ = 0;
  29   timer_l_ =0;
  30 }
  31
  32 void
  33 Auto_beam_engraver::do_creation_processing ()
  34 {
  35   Translator * t = daddy_grav_l  ()->get_simple_translator ("Timing_engraver");
  36   timer_l_ = dynamic_cast<Timing_engraver*> (t);
  37 }
  38
  39 bool
  40 Auto_beam_engraver::do_try_music (Music* m)
  41 {
  42   /*
  43     Mag dit?  Nu word-i toch maar geswallowed, en
  44     komt er dus ook geen announce...
  45    */
  46   if (Skip_req* s = dynamic_cast <Skip_req*> (m))
  47     {
  48       if (stem_l_arr_p_)
  49         end_beam ();
  50       return true;
  51     }
  52   return false;
  53 }
  54
  55 void
  56 Auto_beam_engraver::do_process_requests ()
  57 {
  58   consider_end_and_begin (shortest_mom_);
  59 }
  60
  61 void
  62 Auto_beam_engraver::consider_end_and_begin (Moment test_mom)
  63 {
  64   if (!timer_l_)
  65       return;
  66
  67   Time_description const *time = &timer_l_->time_;
  68   int num = time->whole_per_measure_ / time->one_beat_;
  69   int den = time->one_beat_.den_i ();
  70   String time_str = String ("time") + to_str (num) + "_" + to_str (den);
  71
  72   String type_str;
  73   if (test_mom.num () != 1)
  74     type_str = to_str (test_mom.num ());
  75   if (test_mom.den () != 1)
  76     type_str = type_str + "_" + to_str (test_mom.den ());
  77
  78   /*
  79     Determine end moment for auto beaming (and begin, mostly 0==anywhere)
  80     In order of increasing priority:
  81
  82     i.   every beat <den>
  83     ii.  time<num>_<den>beamAutoEnd
  84     iii. time<num>_<den>beamAutoEnd<type>
  85     iv.  beamAutoEnd
  86     v.   beamAutoEnd<type>
  87
  88
  89     Rationale:
  90
  91     [to be defined in config file]
  92     i.   easy catch-all rule
  93     ii.  exceptions for time signature
  94     iii. exceptions for time signature, for specific duration type
  95
  96     [user override]
  97     iv.  generic override
  98     v.   override for specific duration type
  99
 100     The user overrides should be required for common cases.
 101    */
 102
 103   /*
 104     first guess: begin beam at any position
 105   */
 106   Moment begin_mom (0);
 107   /*
 108     first guess: end beam at end of beat
 109   */
 110   Moment end_mom = time->one_beat_;
 111
 112   /*
 113     second guess: property generic time exception
 114   */
 115   Scalar begin = get_property (time_str + "beamAutoBegin", 0);
 116   if (begin.length_i ())
 117     begin_mom = begin.to_rat ();
 118
 119   Scalar end = get_property (time_str + "beamAutoEnd", 0);
 120   if (end.length_i ())
 121     end_mom = end.to_rat ();
 122
 123   /*
 124     third guess: property time exception, specific for duration type
 125   */
 126   if (type_str.length_i ())
 127     {
 128       Scalar end_mult = get_property (time_str + "beamAutoEnd" + type_str, 0);
 129       if (end_mult.length_i ())
 130         end_mom = end_mult.to_rat ();
 131       Scalar begin_mult = get_property (time_str + "beamAutoBegin" + type_str, 0);
 132       if (begin_mult.length_i ())
 133         begin_mom = begin_mult.to_rat ();
 134     }
 135
 136   /*
 137     fourth guess [user override]: property plain generic
 138   */
 139   begin = get_property ("beamAutoBegin", 0);
 140   if (begin.length_i ())
 141     begin_mom = begin.to_rat ();
 142
 143   end = get_property ("beamAutoEnd", 0);
 144   if (end.length_i ())
 145     end_mom = end.to_rat ();
 146
 147   /*
 148     fifth guess [user override]: property plain, specific for duration type
 149   */
 150   if (type_str.length_i ())
 151     {
 152       Scalar end_mult = get_property (String ("beamAutoEnd") + type_str, 0);
 153       if (end_mult.length_i ())
 154         end_mom = end_mult.to_rat ();
 155       Scalar begin_mult = get_property (String ("beamAutoBegin") + type_str, 0);
 156       if (begin_mult.length_i ())
 157         begin_mom = begin_mult.to_rat ();
 158     }
 159
 160   Rational r;
 161   if (end_mom)
 162     r = time->whole_in_measure_.mod_rat (end_mom);
 163   else
 164     r = Moment (1);
 165
 166   if (stem_l_arr_p_ && !r)
 167     end_beam ();
 168
 169   /*
 170     Allow already started autobeam to end
 171    */
 172   Scalar on = get_property ("beamAuto", 0);
 173   if (!on.to_bool ())
 174     return;
 175
 176   if (begin_mom)
 177     r = time->whole_in_measure_.mod_rat (begin_mom);
 178   if (!stem_l_arr_p_ && (!begin_mom || !r))
 179     begin_beam ();
 180 }
 181
 182
 183 void
 184 Auto_beam_engraver::begin_beam ()
 185 {
 186   assert (!stem_l_arr_p_);
 187   stem_l_arr_p_ = new Array<Stem*>;
 188   assert (!grouping_p_);
 189   grouping_p_ = new Beaming_info_list;
 190   beam_start_moment_ = now_mom ();
 191   beam_start_location_ = timer_l_->time_.whole_in_measure_;
 192 }
 193
 194 Beam*
 195 Auto_beam_engraver::create_beam_p ()
 196 {
 197   Beam* beam_p = new Beam;
 198
 199   for (int i = 0; i < stem_l_arr_p_->size (); i++)
 200     beam_p->add_stem ((*stem_l_arr_p_)[i]);
 201
 202   /* urg, copied from Beam_engraver */
 203   Scalar prop = get_property ("beamslopedamping", 0);
 204   if (prop.isnum_b ())
 205     beam_p->set_elt_property (damping_scm_sym, gh_int2scm( prop));
 206
 207   prop = get_property ("beamquantisation", 0);
 208   if (prop.isnum_b ())
 209     beam_p->quantisation_ = (Beam::Quantisation)(int)prop;
 210
 211   announce_element (Score_element_info (beam_p, 0));
 212   return beam_p;
 213 }
 214
 215 void
 216 Auto_beam_engraver::end_beam ()
 217 {
 218   if (stem_l_arr_p_->size () < 2)
 219     {
 220       junk_beam ();
 221     }
 222   else
 223     {
 224       finished_beam_p_ = create_beam_p ();
 225       finished_grouping_p_ = grouping_p_;
 226       delete stem_l_arr_p_;
 227       stem_l_arr_p_ = 0;
 228       grouping_p_ = 0;
 229       shortest_mom_ = Moment (1, 8);
 230     }
 231 }
 232
 233 void
 234 Auto_beam_engraver::typeset_beam ()
 235 {
 236   if (finished_beam_p_)
 237     {
 238       finished_grouping_p_->beamify ();
 239       finished_beam_p_->set_beaming (finished_grouping_p_);
 240       typeset_element (finished_beam_p_);
 241       finished_beam_p_ = 0;
 242
 243       delete finished_grouping_p_;
 244       finished_grouping_p_= 0;
 245     }
 246 }
 247
 248 void
 249 Auto_beam_engraver::do_post_move_processing ()
 250 {
 251 }
 252
 253 void
 254 Auto_beam_engraver::do_pre_move_processing ()
 255 {
 256   typeset_beam ();
 257 }
 258
 259 void
 260 Auto_beam_engraver::do_removal_processing ()
 261 {
 262   if (stem_l_arr_p_)
 263     end_beam ();
 264   typeset_beam ();
 265 }
 266
 267 bool
 268 Auto_beam_engraver::same_grace_state_b (Score_element* e)
 269 {
 270   bool gr = (e->get_elt_property (grace_scm_sym) != SCM_BOOL_F) ;
 271
 272   return gr == get_property ("weAreGraceContext",0).to_bool ();
 273 }
 274
 275 void
 276 Auto_beam_engraver::acknowledge_element (Score_element_info info)
 277 {
 278   if (!same_grace_state_b (info.elem_l_) || !timer_l_)
 279     return;
 280
 281   if (stem_l_arr_p_)
 282     {
 283       if (Beam *b = dynamic_cast<Beam *> (info.elem_l_))
 284         {
 285           junk_beam ();
 286         }
 287       else if (Bar *b = dynamic_cast<Bar *> (info.elem_l_))
 288         {
 289           junk_beam ();
 290         }
 291       else if (Rest* rest_l = dynamic_cast<Rest *> (info.elem_l_))
 292         {
 293           end_beam ();
 294         }
 295       else if (Stem* stem_l = dynamic_cast<Stem *> (info.elem_l_))
 296         {
 297           Rhythmic_req *rhythmic_req = dynamic_cast <Rhythmic_req *> (info.req_l_);
 298           if (!rhythmic_req)
 299             {
 300               programming_error ("Stem must have rhythmic structure");
 301               return;
 302             }
 303
 304           if (stem_l->beam_l_)
 305             {
 306               junk_beam ();
 307               return ;
 308             }
 309
 310               /*
 311                 now that we have last_add_mom_, perhaps we can (should) do away
 312                 with these individual junk_beams
 313               */
 314
 315           int durlog  =rhythmic_req->duration_.durlog_i_;
 316           if (durlog <= 2)
 317             end_beam ();
 318           else
 319             {
 320               /*
 321                 if shortest duration would change
 322                 reconsider ending/starting beam first.
 323               */
 324               Moment mom = rhythmic_req->duration_.length_mom ();
 325               consider_end_and_begin (mom);
 326               if (!stem_l_arr_p_)
 327                 return;
 328               if (mom < shortest_mom_)
 329                 {
 330                   if (stem_l_arr_p_->size ())
 331                     {
 332                       shortest_mom_ = mom;
 333                       consider_end_and_begin (shortest_mom_);
 334                       if (!stem_l_arr_p_)
 335                         return;
 336                     }
 337                   shortest_mom_ = mom;
 338                 }
 339               Moment now = now_mom ();
 340
 341               grouping_p_->add_stem (now - beam_start_moment_ + beam_start_location_, durlog - 2);
 342               stem_l_arr_p_->push (stem_l);
 343               last_add_mom_ = now;
 344               extend_mom_ = extend_mom_ >? now + rhythmic_req->length_mom ();
 345             }
 346         }
 347     }
 348 }
 349
 350 void
 351 Auto_beam_engraver::junk_beam ()
 352 {
 353   assert (stem_l_arr_p_);
 354
 355   delete stem_l_arr_p_;
 356   stem_l_arr_p_ = 0;
 357   delete grouping_p_;
 358   grouping_p_ = 0;
 359   shortest_mom_ = Moment (1, 8);
 360 }
 361
 362 void
 363 Auto_beam_engraver::process_acknowledged ()
 364 {
 365   if (stem_l_arr_p_)
 366     {
 367       Moment now = now_mom ();
 368       if ((extend_mom_ < now)
 369           || ((extend_mom_ == now) && (last_add_mom_ != now )))
 370         {
 371           end_beam ();
 372         }
 373       else if (!stem_l_arr_p_->size ())
 374         {
 375           junk_beam ();
 376         }
 377     }
 378 }