Fix 399 again.

[lilypond.git] / lily / spacing-spanner.cc

diff --git a/lily/spacing-spanner.cc b/lily/spacing-spanner.cc
index a61bffb98a3aa41d7a417ee493a17e7412e127b0..19739adf6a5ee8ddd520932c33c80750a93f3d99 100644 (file)
--- a/lily/spacing-spanner.cc
+++ b/lily/spacing-spanner.cc
@@ -11,8 +11,6 @@
 #include <math.h>
 #include <cstdio>
 
 #include <math.h>
 #include <cstdio>
 

-using namespace std;
-

 #include "spacing-options.hh"
 #include "international.hh"
 #include "main.hh"
 #include "spacing-options.hh"
 #include "international.hh"
 #include "main.hh"


@@ -22,6 +20,7 @@ using namespace std;
 #include "paper-column.hh"
 #include "paper-score.hh"
 #include "pointer-group-interface.hh"
 #include "paper-column.hh"
 #include "paper-score.hh"
 #include "pointer-group-interface.hh"

+#include "separation-item.hh"

 #include "spaceable-grob.hh"
 #include "spacing-interface.hh"
 #include "staff-spacing.hh"
 #include "spaceable-grob.hh"
 #include "spacing-interface.hh"
 #include "staff-spacing.hh"


@@ -167,15 +166,10 @@ Spacing_spanner::generate_pair_spacing (Grob *me,
 {
   if (Paper_column::is_musical (left_col))
     {
 {
   if (Paper_column::is_musical (left_col))
     {

-      bool skip_unbroken_right = false;
-

       if (!Paper_column::is_musical (right_col)
          && options->float_nonmusical_columns_
          && after_right_col
          && Paper_column::is_musical (after_right_col))
       if (!Paper_column::is_musical (right_col)
          && options->float_nonmusical_columns_
          && after_right_col
          && Paper_column::is_musical (after_right_col))

-       skip_unbroken_right = true;
-
-      if (skip_unbroken_right)

        {
          /*
            TODO: should generate rods to prevent collisions.
        {
          /*
            TODO: should generate rods to prevent collisions.


@@ -214,27 +208,95 @@ Spacing_spanner::generate_pair_spacing (Grob *me,
     }
 }
 
     }
 }
 

+static void
+set_column_rods (vector<Grob*> const &cols, Real padding)
+{
+  /* distances[i] will be the minimum distance between column i and column i+1 */
+  vector<Real> distances;
+
+  for (vsize i = 1; i < cols.size (); i++)
+    {
+      Item *r = dynamic_cast<Item*> (cols[i]);
+      Item *rb = r->find_prebroken_piece (LEFT);
+
+      if (Separation_item::is_empty (r) && (!rb || Separation_item::is_empty (rb)))
+       continue;
+
+      Skyline_pair *skys = Skyline_pair::unsmob (r->get_property ("horizontal-skylines"));
+      Real right_stickout = skys ? (*skys)[LEFT].max_height () : 0.0;
+
+      Drul_array<Item*> r_cols (r, rb);
+      Drul_array<Real> cur_dist (0.0, 0.0);
+
+      /* This is an inner loop and hence it is potentially quadratic. However, we only continue
+        as long as there is a rod to insert. Therefore, this loop will usually only execute
+        a constant number of times per iteration of the outer loop. */
+      for (vsize j = i; j--;)
+       {
+         Item *l = dynamic_cast<Item*> (cols[j]);
+         Item *lb = l->find_prebroken_piece (RIGHT);
+         Skyline_pair *skys = Skyline_pair::unsmob (l->get_property ("horizontal-skylines"));
+         Real left_stickout = skys ? (*skys)[RIGHT].max_height () : 0.0;
+         bool done = true;
+
+         Direction d = LEFT;
+         do
+           {
+             if (j < i-1)
+               cur_dist[d] += distances[j];
+
+             Item *r_col = r_cols[d];
+             bool touches = right_stickout - left_stickout + cur_dist[d] < 0.0;
+             Real dist = 0.0;
+
+             /* we set a distance for the line-starter column even if it's non-broken counterpart
+                doesn't touch the right column. */
+             if (lb)
+               Separation_item::set_distance (lb, r_col, padding);
+
+             if (touches || j == i-1)
+               dist = Separation_item::set_distance (l, r_col, padding);
+
+             if (j == i-1 && d == LEFT)
+               distances.push_back (dist);
+
+             if (j == i-1)
+               cur_dist[d] = distances[j];
+
+             done = done && !touches;
+           }
+         while (flip (&d) != LEFT && rb);
+
+         /* we need the empty check for gregorian notation, where there are a lot of
+            extraneous paper-columns that we need to skip over */
+         if (done && !Separation_item::is_empty (l))
+           break;
+       }
+    }
+}
+
+

 void
 Spacing_spanner::generate_springs (Grob *me,
                                   vector<Grob*> const &cols,
                                   Spacing_options const *options)
 {
 void
 Spacing_spanner::generate_springs (Grob *me,
                                   vector<Grob*> const &cols,
                                   Spacing_options const *options)
 {

-  Paper_column *prev = 0;
-  for (vsize i = 0; i < cols.size (); i++)
+  Paper_column *prev = dynamic_cast<Paper_column*> (cols[0]);
+  for (vsize i = 1; i < cols.size (); i++)

     {
       Paper_column *col = dynamic_cast<Paper_column *> (cols[i]);
       Paper_column *next = (i + 1 < cols.size ()) ? dynamic_cast<Paper_column *> (cols[i+1]) : 0;
       
     {
       Paper_column *col = dynamic_cast<Paper_column *> (cols[i]);
       Paper_column *next = (i + 1 < cols.size ()) ? dynamic_cast<Paper_column *> (cols[i+1]) : 0;
       

-      if (i > 0)
-       generate_pair_spacing (me, prev, col, next, options);
+      generate_pair_spacing (me, prev, col, next, options);

 
       prev = col;
     }
 
       prev = col;
     }

+
+  set_column_rods (cols, 0.1); // FIXME: padding

 }
 
 /*
 }
 
 /*

-  Generate the space between two musical columns LEFT_COL and RIGHT_COL, given
-  spacing parameters INCR and SHORTEST.
+  Generate the space between two musical columns LEFT_COL and RIGHT_COL.

 */
 void
 Spacing_spanner::musical_column_spacing (Grob *me,
 */
 void
 Spacing_spanner::musical_column_spacing (Grob *me,


@@ -242,45 +304,22 @@ Spacing_spanner::musical_column_spacing (Grob *me,
                                         Item *right_col,
                                         Spacing_options const *options)
 {
                                         Item *right_col,
                                         Spacing_options const *options)
 {

-  bool expand_only = false;
-  Real base_note_space = note_spacing (me, left_col, right_col, options, &expand_only);
-
-  Real max_fixed = 0;
-  Real max_space = 0;
-  Real compound_note_space = 0.0;
-  Real compound_fixed_note_space = 0.0;
+  Real base_note_space = note_spacing (me, left_col, right_col, options);
+  Spring spring;

 
   if (options->stretch_uniformly_)
 
   if (options->stretch_uniformly_)

-    {
-      compound_note_space = base_note_space;
-            
-      if (!Paper_column::is_musical (right_col))
-       {
-         /*
-           Crude fix for notes that lead up to barlines and time sigs.
-         */
-         Interval lext = right_col->extent (right_col, X_AXIS);
-         if (!lext.is_empty ())
-           compound_note_space += -lext[LEFT];
-       }
-    }
+    spring = Spring (base_note_space, 0.0);

   else
     {
   else
     {

-      int wish_count = 0;
-      
+      vector<Spring> springs;

       extract_grob_set (left_col, "right-neighbors", neighbors);
 
       extract_grob_set (left_col, "right-neighbors", neighbors);
 

-      /*
-       We adjust the space following a note only if the next note
-       happens after the current note (this is set in the grob
-       property SPACING-SEQUENCE.
-      */

       for (vsize i = 0; i < neighbors.size (); i++)
        {
          Grob *wish = neighbors[i];
 
       for (vsize i = 0; i < neighbors.size (); i++)
        {
          Grob *wish = neighbors[i];
 

-         Item *wish_rcol = Note_spacing::right_column (wish);
-         if (Note_spacing::left_column (wish) != left_col
+         Item *wish_rcol = Spacing_interface::right_column (wish);
+         if (Spacing_interface::left_column (wish) != left_col

              || (wish_rcol != right_col && wish_rcol != right_col->original ()))
            continue;
 
              || (wish_rcol != right_col && wish_rcol != right_col->original ()))
            continue;
 


@@ -288,32 +327,10 @@ Spacing_spanner::musical_column_spacing (Grob *me,
            This is probably a waste of time in the case of polyphonic
            music.  */
          if (Note_spacing::has_interface (wish))
            This is probably a waste of time in the case of polyphonic
            music.  */
          if (Note_spacing::has_interface (wish))

-           {
-             Real space = 0.0;
-             Real fixed = 0.0;
-
-             Note_spacing::get_spacing (wish, right_col, base_note_space, options->increment_, &space, &fixed);
-
-
-             max_space = max (max_space, space);
-             max_fixed = max (max_fixed, fixed);
-             
-             compound_note_space += space;
-             compound_fixed_note_space += fixed;
-             wish_count++;
-           }
-       }
-
-      if (Paper_column::when_mom (right_col).grace_part_
-         && !Paper_column::when_mom (left_col).grace_part_)
-       {
-         /*
-           Ugh. 0.8 is arbitrary.
-         */
-         compound_note_space *= 0.8;
+           springs.push_back (Note_spacing::get_spacing (wish, right_col, base_note_space, options->increment_));

        }
 
        }
 

-      if (compound_note_space < 0 || wish_count == 0)
+      if (springs.empty ())

        {
 
          if (!Paper_column::is_musical (right_col))
        {
 
          if (!Paper_column::is_musical (right_col))


@@ -324,9 +341,8 @@ Spacing_spanner::musical_column_spacing (Grob *me,
                spacing, because the width of s^"text" output is also
                taken into account here.
               */
                spacing, because the width of s^"text" output is also
                taken into account here.
               */

-             compound_fixed_note_space = options->increment_;
-             compound_note_space = max (base_note_space,
-                                        options->increment_);
+             spring = Spring (max (base_note_space, options->increment_),
+                              options->increment_);

            }
          else
            {
            }
          else
            {


@@ -334,44 +350,30 @@ Spacing_spanner::musical_column_spacing (Grob *me,
                Fixed should be 0.0. If there are no spacing wishes, we're
                likely dealing with polyphonic spacing of hemiolas.
            
                Fixed should be 0.0. If there are no spacing wishes, we're
                likely dealing with polyphonic spacing of hemiolas.
            

-               We used to have compound_fixed_note_space = options->increment_
+               We used to have min_distance_ = options->increment_

 
                but this can lead to numeric instability problems when we
                do
            
 
                but this can lead to numeric instability problems when we
                do
            

-               inverse_strength = (compound_note_space - compound_fixed_note_space)
+               inverse_strength = (distance_ - min_distance_)

       
              */
       
              */

-
-             compound_note_space = base_note_space;
-             compound_fixed_note_space = 0.0;
+             spring = Spring (base_note_space, 0.0);

            }
        }
            }
        }

-      else if (to_boolean (me->get_property ("average-spacing-wishes")))
-       {
-         compound_note_space /= wish_count;
-         compound_fixed_note_space /= wish_count;
-       }

       else
       else

-       {
-         compound_fixed_note_space = max_fixed;
-         compound_note_space = max_space;
-       }
+       spring = merge_springs (springs);
+    }

 
 

+  if (Paper_column::when_mom (right_col).grace_part_
+      && !Paper_column::when_mom (left_col).grace_part_)
+    {

       /*
       /*

-       Whatever we do, the fixed space is smaller than the real
-       space.
-
-       TODO: this criterion is discontinuous in the derivative.
-       Maybe it should be continuous?
+       Ugh. 0.8 is arbitrary.

       */
       */

-      compound_fixed_note_space = min (compound_fixed_note_space,
-                                      compound_note_space);
+      spring *= 0.8;

     }
 
     }
 

-  Real inverse_strength = 1.0;
-  Real distance = 1.0;
-

   /*
     TODO: make sure that the space doesn't exceed the right margin.
   */
   /*
     TODO: make sure that the space doesn't exceed the right margin.
   */


@@ -386,16 +388,11 @@ Spacing_spanner::musical_column_spacing (Grob *me,
        pack as much bars of music as possible into a line, but the
        line will then be stretched to fill the whole linewidth.
       */
        pack as much bars of music as possible into a line, but the
        line will then be stretched to fill the whole linewidth.
       */

-      inverse_strength = 1.0;
-      distance = compound_fixed_note_space;
-    }
-  else
-    {
-      inverse_strength = (compound_note_space - compound_fixed_note_space);
-      distance = compound_note_space;
+      spring.set_distance (spring.min_distance ());
+      spring.set_inverse_stretch_strength (1.0);

     }
 
     }
 

-  Spaceable_grob::add_spring (left_col, right_col, distance, inverse_strength);
+  Spaceable_grob::add_spring (left_col, right_col, spring);

 }
 
 /*
 }
 
 /*


@@ -441,12 +438,8 @@ void
 Spacing_spanner::breakable_column_spacing (Grob *me, Item *l, Item *r,
                                           Spacing_options const *options)
 {
 Spacing_spanner::breakable_column_spacing (Grob *me, Item *l, Item *r,
                                           Spacing_options const *options)
 {

-  Real compound_fixed = 0.0;
-  Real compound_space = 0.0;
-  Real max_fixed = 0.0;
-  Real max_space = 0.0;
-  
-  int wish_count = 0;
+  vector<Spring> springs;
+  Spring spring;

 
   Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
 
 
   Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
 


@@ -461,74 +454,46 @@ Spacing_spanner::breakable_column_spacing (Grob *me, Item *l, Item *r,
          if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
            continue;
 
          if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
            continue;
 

-         Real space = 0.;
-         Real fixed_space = 0.;
-

          /*
            column for the left one settings should be ok due automatic
            pointer munging.
          */
          assert (spacing_grob->get_column () == l);
 
          /*
            column for the left one settings should be ok due automatic
            pointer munging.
          */
          assert (spacing_grob->get_column () == l);
 

-         Staff_spacing::get_spacing_params (spacing_grob,
-                                            &space, &fixed_space);
-
-         if (Paper_column::when_mom (r).grace_part_)
-           {
-             /*
-               Correct for grace notes.
-
-               Ugh. The 0.8 is arbitrary.
-             */
-             space *= 0.8;
-           }
-
-         max_space = max (max_space, space);
-         max_fixed = max (max_fixed, fixed_space);
-         
-         compound_space += space;
-         compound_fixed += fixed_space;
-         wish_count++;
+         springs.push_back (Staff_spacing::get_spacing (spacing_grob, r));

        }
     }
 
        }
     }
 

-  if (compound_space <= 0.0 || !wish_count)
-    {
-      standard_breakable_column_spacing (me, l, r, &compound_fixed, &compound_space,
-                                        options);
-      wish_count = 1;
-    }
+  if (springs.empty ())
+    spring = standard_breakable_column_spacing (me, l, r, options);

   else
   else

+    spring = merge_springs (springs);
+
+  if (Paper_column::when_mom (r).grace_part_)

     {
     {

-      if (to_boolean (me->get_property ("average-spacing-wishes")))
-       {
-         compound_space /= wish_count;
-         compound_fixed /= wish_count;
-       }
-      else
-       {
-         compound_fixed = max_fixed;
-         compound_space = max_space;
-       }
-      
+      /*
+       Correct for grace notes.
+       
+       Ugh. The 0.8 is arbitrary.
+      */
+      spring *= 0.8;

     }
 
   if (Paper_column::is_musical (r)
       && l->break_status_dir () == CENTER
       && fills_measure (me, l, r))
     {
     }
 
   if (Paper_column::is_musical (r)
       && l->break_status_dir () == CENTER
       && fills_measure (me, l, r))
     {

-      compound_space += 1.0; 
+      spring.set_distance (spring.distance () + 1.0);
+      spring.set_default_strength ();

     }
   
   if (options->stretch_uniformly_ && l->break_status_dir () != RIGHT)
     }
   
   if (options->stretch_uniformly_ && l->break_status_dir () != RIGHT)

-    compound_fixed = 0.0;
-
-  assert (!isinf (compound_space));
-  compound_space = max (compound_space, compound_fixed);
+    {
+      spring.set_min_distance (0.0);
+      spring.set_default_strength ();
+    }

 
 

-  Real inverse_strength = (compound_space - compound_fixed);
-  Real distance = compound_space;
-  Spaceable_grob::add_spring (l, r, distance, inverse_strength);
+  Spaceable_grob::add_spring (l, r, spring);

 }
 
 ADD_INTERFACE (Spacing_spanner,
 }
 
 ADD_INTERFACE (Spacing_spanner,