Revert "spacing-spanner: rods for non-adjacent paper-columns; issue 1700"

This reverts commit ad55b046668fb00a6f80684e4caa4e4de982e399.

diff --git a/input/regression/spacing-non-adjacent-columns3.ly b/input/regression/spacing-non-adjacent-columns3.ly
deleted file mode 100644 (file)
index 4a7c056..0000000
--- a/input/regression/spacing-non-adjacent-columns3.ly
+++ /dev/null
@@ -1,21 +0,0 @@
-\version "2.17.3"
-\header {
-  texidoc = "The spacing engine avoids collisions between non-adjacent columns."
-}
-
-\paper{ragged-right = ##t }
-<<
-  \new ChordNames \chordmode {
-    \set additionalPitchPrefix = #"add"
-    f2:13.15 f2
-  }
-  \new Staff {
-    f'4 f'8 f' f'2 \break
-    \set fingeringOrientations = #'(left)
-    \grace { <d-1-2-3>8[ f a] }
-    <d''-1-2-3-4-5>4 r4
-    \set fingeringOrientations = #'(right)
-    <g'-1-2-3-4-5>4 \grace { d''8[ e'' d'']}
-    g'4
-  }
->>

diff --git a/lily/spacing-spanner.cc b/lily/spacing-spanner.cc
index 51ae51319d2f37d342cfeb9b936ff135b61a2b02..e4035b5d0d1d73d94aceaa1600782285a7e453e8 100644 (file)
--- a/lily/spacing-spanner.cc
+++ b/lily/spacing-spanner.cc
@@ -223,13 +223,11 @@ Spacing_spanner::generate_pair_spacing (Grob *me,
 static void
 set_column_rods (vector<Grob *> const &cols, Real padding)
 {
-  /* distances[i] will be the distance betwen cols[i-1] and cols[i], and
-     overhangs[j] the amount by which cols[0 thru j] extend beyond cols[j]
+  /* distances[i] will be the distance betwen cols[i-1] and cols[i]
      when each column is placed as far to the left as possible. */
   vector<Real> distances (cols.size ());
-  vector<Real> overhangs (cols.size ());
 
-  for (vsize i = 0; i < cols.size (); i++)
+  for (vsize i = 1; i < cols.size (); i++)
     {
       Item *r = dynamic_cast<Item *> (cols[i]);
       Item *rb = r->find_prebroken_piece (LEFT);
@@ -237,15 +235,12 @@ set_column_rods (vector<Grob *> const &cols, Real padding)
       if (Separation_item::is_empty (r) && (!rb || Separation_item::is_empty (rb)))
         continue;
 
-      Interval r_ext = r->extent (r, X_AXIS);
-      overhangs[i] = r_ext[RIGHT];
-
-      if (0 == i) continue;
+      Skyline_pair *skys = Skyline_pair::unsmob (r->get_property ("horizontal-skylines"));
 
-      /* min rather than max because stickout will be negative if the right-hand column
+      /* min rather than max because stickout_i will be negative if the right-hand column
          sticks out a lot to the left */
-      Real stickout = min (r_ext[LEFT],
-                           Separation_item::conditional_skyline (r, cols[i - 1]).max_height ());
+      Real stickout_i = min (skys ? (*skys)[LEFT].max_height () : 0.0,
+                             Separation_item::conditional_skyline (r, cols[i - 1]).max_height ());
 
       Real prev_distances = 0.0;
 
@@ -254,35 +249,35 @@ set_column_rods (vector<Grob *> const &cols, Real padding)
          a constant number of times per iteration of the outer loop. */
       for (vsize j = i; j--;)
         {
-          if (overhangs[j] + padding <= prev_distances + distances[i] + stickout)
-            break; // cols[0 thru j] cannot reach cols[i]
-
           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 stickout_j = skys ? (*skys)[RIGHT].max_height () : 0.0;
 
-          Real dist = Separation_item::set_distance (l, r, padding);
-          distances[i] = max (distances[i], dist - prev_distances);
+          bool touches = stickout_i - stickout_j + prev_distances + distances[i] < 0.0;
+          Real dist = 0.0;
 
-          if (lb)
+          if (touches || j == i - 1)
             {
-              dist = Separation_item::set_distance (lb, r, padding);
-              // The left-broken version might reach more columns to the
-              // right than the unbroken version, by extending farther and/or
-              // nesting more closely;
-              if (j == i - 1) // check this, the first time we see each lb.
-                overhangs[j] = max (overhangs[j],
-                                    lb->extent (lb, X_AXIS)[RIGHT]
-                                    + distances[i] - dist);
+              dist = Separation_item::set_distance (l, r, padding);
+              if (rb)
+                Separation_item::set_distance (l, rb, padding);
             }
-          if (rb)
-            Separation_item::set_distance (l, rb, padding);
+          distances[i] = max (distances[i], dist - prev_distances);
+
+          /* we set a distance for the line-starter column even if its non-broken counterpart
+             doesn't touch the right column. */
+          if (lb)
+            Separation_item::set_distance (lb, r, padding);
           if (lb && rb)
             Separation_item::set_distance (lb, rb, padding);
 
           prev_distances += distances[j];
+          /* we need the empty check for gregorian notation, where there are a lot of
+             extraneous paper-columns that we need to skip over */
+          if (!touches && !Separation_item::is_empty (l))
+            break;
         }
-      overhangs[i] = max (overhangs[i],
-                          overhangs[i - 1] - distances[i]);
     }
 }