Run grand replace for 2015.

[lilypond.git] / lily / beaming-pattern.cc

diff --git a/lily/beaming-pattern.cc b/lily/beaming-pattern.cc
index 2db441ef690d347f4436efeec704e0a6e2cdc2a5..5ffbcfb9d9047ef558213bcc3293b117c9443c37 100644 (file)
--- a/lily/beaming-pattern.cc
+++ b/lily/beaming-pattern.cc
@@ -1,7 +1,7 @@
 /*
   This file is part of LilyPond, the GNU music typesetter.
 
-  Copyright (C) 1999--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
+  Copyright (C) 1999--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
   LilyPond is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -40,10 +40,11 @@ Beam_rhythmic_element::Beam_rhythmic_element ()
   beam_count_drul_[RIGHT] = 0;
   invisible_ = false;
   factor_ = Rational (1);
-
+  tuplet_start_ = false;
 }
 
-Beam_rhythmic_element::Beam_rhythmic_element (Moment m, int i, bool inv, Rational factor)
+Beam_rhythmic_element::Beam_rhythmic_element (Moment m, int i, bool inv,
+                                              Rational factor, bool tuplet_start)
 {
   start_moment_ = m;
   rhythmic_importance_ = 0;
@@ -51,6 +52,7 @@ Beam_rhythmic_element::Beam_rhythmic_element (Moment m, int i, bool inv, Rationa
   beam_count_drul_[RIGHT] = i;
   invisible_ = inv;
   factor_ = factor;
+  tuplet_start_ = tuplet_start;
 }
 
 void
@@ -99,6 +101,15 @@ Beaming_pattern::flag_direction (Beaming_options const &options, vsize i) const
 
   if (count <= left_count && count <= right_count)
     return CENTER;
+  else if (!options.strict_beat_beaming_)
+    {
+      // Try to avoid sticking-out flags as much as possible by pointing
+      // my flags at the neighbor with the most flags.
+      if (right_count > left_count)
+        return RIGHT;
+      else if (left_count > right_count)
+        return LEFT;
+    }
 
   // If all else fails, point the beamlet away from the important moment.
   return (infos_[i].rhythmic_importance_ < infos_[i + 1].rhythmic_importance_)
@@ -174,11 +185,10 @@ update_tuplet (Moment start_moment, Rational factor, Moment *tuplet_start_moment
   int tuplet_number = (int) factor.den ();
   if ((tuplet_number > 1) && (tuplet_start_moment->num () < 0))
     *tuplet_start_moment = start_moment;
-  else if (tuplet_number == 1) 
-    *tuplet_start_moment = Moment (-1, 1); 
+  else if (tuplet_number == 1)
+    *tuplet_start_moment = Moment (-1, 1);
 }
 
-
 /*
    Get the group start position, the next group starting position, and the
    next beat starting position, given start_moment, base_moment,
@@ -198,7 +208,7 @@ find_location (SCM grouping, Moment base_moment, Moment start_moment,
 
   while (*next_group_pos < *next_beat_pos)
     {
-      int group_count = 1;  //default -- 1 base moments in a beam
+      I64 group_count = 1;  //default -- 1 base moments in a beam
       if (scm_is_pair (grouping))
         {
           group_count = scm_to_int (scm_car (grouping));
@@ -207,17 +217,17 @@ find_location (SCM grouping, Moment base_moment, Moment start_moment,
 
       // If we have a tuplet, the count should be determined from
       // the maximum tuplet size for beamed tuplets.
-      int tuplet_number = factor.den ();
-      if (tuplet_number > 1)
+      U64 tuplet_number = factor.den ();
+      if (tuplet_number > 1U)
         {
           // We use 1/8 as the base moment for the tuplet because it's
           // the largest beamed value.  If the tuplet is shorter, it's
           // OK, the code still works
-          int test_count = ( Moment (Rational (1, 8) / factor ) / base_moment).num ();
+          I64 test_count = ( Moment (Rational (1, 8) / factor) / base_moment).num ();
           if (test_count > group_count) group_count = test_count;
         }
       *group_pos = *next_group_pos;
-      *next_group_pos = *group_pos + group_count * base_moment;
+      *next_group_pos = *group_pos + Rational(group_count) * base_moment;
     }
 }
 
@@ -228,7 +238,7 @@ Beaming_pattern::find_rhythmic_importance (Beaming_options const &options)
   Moment next_group_pos (0);
   Moment next_beat_pos (options.base_moment_);
   Moment tuplet_start_moment (-1, 1);
-  int tuplet_number = 1;
+  I64 tuplet_number = 1;
 
   SCM grouping = options.grouping_;
   vsize i = 0;
@@ -259,8 +269,8 @@ Beaming_pattern::find_rhythmic_importance (Beaming_options const &options)
           Moment tuplet_moment (tuplet);
           Moment tuplet_dt = infos_[i].start_moment_ - tuplet_start_moment;
           tuplet_number = tuplet.den ();
-          // set the beat end (if not in a tuplet) and increment the next beat
-          if (tuplet_number == 1 && infos_[i].start_moment_ == next_beat_pos)
+          // set the beat end and increment the next beat
+          if (infos_[i].start_moment_ == next_beat_pos)
             {
               infos_[i].rhythmic_importance_ = -1;
               next_beat_pos += options.base_moment_;
@@ -270,9 +280,9 @@ Beaming_pattern::find_rhythmic_importance (Beaming_options const &options)
           // important.  For tuplets, we need to make sure that we use
           // the fraction of the tuplet, instead of the fraction of
           // a beat.
-          Moment ratio = (tuplet_number == 1) 
-                           ? dt / options.base_moment_ 
-                           : tuplet_dt / Moment (1, 8)  / tuplet_moment;
+          Moment ratio = (tuplet_number == 1)
+                         ? dt / options.base_moment_
+                         : tuplet_dt / Moment (1, 8) / tuplet_moment;
           if (infos_[i].rhythmic_importance_ >= 0)
             infos_[i].rhythmic_importance_ = (int) ratio.den ();
 
@@ -317,9 +327,9 @@ Beaming_pattern::unbeam_invisible_stems ()
 }
 
 void
-Beaming_pattern::add_stem (Moment m, int b, bool invisible, Rational factor)
+Beaming_pattern::add_stem (Moment m, int b, bool invisible, Rational factor, bool tuplet_start)
 {
-  infos_.push_back (Beam_rhythmic_element (m, b, invisible, factor));
+  infos_.push_back (Beam_rhythmic_element (m, b, invisible, factor, tuplet_start));
 }
 
 Beaming_pattern::Beaming_pattern ()
@@ -341,11 +351,12 @@ Beaming_pattern::start_moment (int i) const
 Moment
 Beaming_pattern::end_moment (int i) const
 {
-  Duration *dur = new Duration (2 + max (beamlet_count (i, LEFT),
-                                         beamlet_count (i, RIGHT)),
-                                0);
+  Duration dur (2 + max (beamlet_count (i, LEFT),
+                         beamlet_count (i, RIGHT)),
+                0);
 
-  return infos_.at (i).start_moment_ + dur->get_length ();
+  return infos_.at (i).start_moment_
+         + infos_.at (i).factor_ * dur.get_length ();
 }
 
 bool
@@ -360,6 +371,12 @@ Beaming_pattern::factor (int i) const
   return infos_.at (i).factor_;
 }
 
+bool
+Beaming_pattern::tuplet_start (int i) const
+{
+  return infos_.at (i).tuplet_start_;
+}
+
 /*
     Split a beaming pattern at index i and return a new
     Beaming_pattern containing the removed elements
@@ -377,7 +394,8 @@ Beaming_pattern::split_pattern (int i)
       new_pattern->add_stem (start_moment (j),
                              count,
                              invisibility (j),
-                             factor (j));
+                             factor (j),
+                             tuplet_start (j));
     }
   for (vsize j = i + 1; j < infos_.size ();)
     infos_.pop_back ();
@@ -389,6 +407,7 @@ Beaming_options::from_context (Context *context)
 {
   grouping_ = context->get_property ("beatStructure");
   subdivide_beams_ = to_boolean (context->get_property ("subdivideBeams"));
+  strict_beat_beaming_ = to_boolean (context->get_property ("strictBeatBeaming"));
   base_moment_ = robust_scm2moment (context->get_property ("baseMoment"),
                                     Moment (1, 4));
   measure_length_ = robust_scm2moment (context->get_property ("measureLength"),
@@ -399,4 +418,5 @@ Beaming_options::Beaming_options ()
 {
   grouping_ = SCM_EOL;
   subdivide_beams_ = false;
+  strict_beat_beaming_ = false;
 }