Spacing staves with dynamics between; issue 1668

Distinguish the minimum distances between 'spaceable' staves
from those between lines such as Lyrics.

diff --git a/input/regression/lyrics-bar.ly b/input/regression/lyrics-bar.ly
index d8a596b2e652e6c76b598f9da5d3a385972f1be8..c3f8cdd30258960ce4407596d71f23db98230349 100644 (file)
--- a/input/regression/lyrics-bar.ly
+++ b/input/regression/lyrics-bar.ly
@@ -31,7 +31,7 @@ lyrics do not collide with barlines.
 \layout {
   \context {
     \Lyrics
-      \override VerticalAxisGroup #'nonstaff-nonstaff-spacing #'minimum-distance = #4
+      \override VerticalAxisGroup #'nonstaff-nonstaff-spacing #'minimum-distance = #4.2
       \override LyricText #'Y-offset = #-0.7
       \override BarLine #'bar-extent = #'(-2 . 2)
   }

diff --git a/input/regression/page-spacing-nonstaff-lines-independent.ly b/input/regression/page-spacing-nonstaff-lines-independent.ly
new file mode 100644 (file)
index 0000000..26d7a9d
--- /dev/null
+++ b/input/regression/page-spacing-nonstaff-lines-independent.ly
@@ -0,0 +1,25 @@
+\version "2.13.39"
+
+\header {
+  texidoc = "Spacing rules between Staves coexist with rules affecting
+non-staff lines.  Here, the @code{padding} separating items on different
+staves is larger than the @code{padding} for associated lyrics."
+}
+
+<<
+  \new Staff { c''2 c }
+  \addlyrics { high \skip2 }
+  \new Staff = "bass" \new Voice = "b" { \clef bass c2 c' }
+  \new Lyrics \with {
+    alignAboveContext = "bass"
+  } \lyricsto "b" \lyricmode { bass \skip2 }
+>>
+\layout {
+  \context {
+    \Lyrics
+    \override VerticalAxisGroup #'nonstaff-relatedstaff-spacing = #'((padding . 0.2))
+  } \context {
+    \Staff
+    \override VerticalAxisGroup #'default-staff-staff-spacing = #'((padding . 4))
+  }
+}

diff --git a/lily/align-interface.cc b/lily/align-interface.cc
index bfda43ed43e366a55a95f42206f4f3293cb08816..2fd49f5162a2547c57606d76a5ddd4d0386e5cfd 100644 (file)
--- a/lily/align-interface.cc
+++ b/lily/align-interface.cc
@@ -168,9 +168,11 @@ Align_interface::get_minimum_translations_without_min_dist (Grob *me,
 }
 
 // If include_fixed_spacing is false, the only constraints that will be measured
-// here are those that result from collisions (+ padding).  That is, all
-// minimum-distances, line-break-system-details, basic-distance+stretchable=0
-// constraints will be ignored.
+// here are those that result from collisions (+ padding) and minimum-distance
+// between adjacent staves.
+// If include_fixed_spacing is true, constraints from line-break-system-details,
+// basic-distance+stretchable=0, and staff-staff-spacing of spaceable staves
+// with loose lines in between, are included as well.
 // - If you want to find the minimum height of a system, include_fixed_spacing should be true.
 // - If you're going to actually lay out the page, then it should be false (or
 //   else centered dynamics will break when there is a fixed alignment).
@@ -204,6 +206,7 @@ Align_interface::internal_get_minimum_translations (Grob *me,
   Skyline down_skyline (stacking_dir);
   Real last_spaceable_element_pos = 0;
   Grob *last_spaceable_element = 0;
+  Skyline last_spaceable_skyline (stacking_dir);
   int spaceable_count = 0;
   for (vsize j = 0; j < elems.size (); j++)
     {
@@ -211,25 +214,22 @@ Align_interface::internal_get_minimum_translations (Grob *me,
       Real padding = default_padding;
 
       if (j == 0)
-       dy = skylines[j][-stacking_dir].max_height ();
+       dy = skylines[j][-stacking_dir].max_height () + padding;
       else
        {
-         down_skyline.merge (skylines[j-1][stacking_dir]);
-         dy = down_skyline.distance (skylines[j][-stacking_dir]);
-
          SCM spec = Page_layout_problem::get_spacing_spec (elems[j-1], elems[j], pure, start, end);
          Page_layout_problem::read_spacing_spec (spec, &padding, ly_symbol2scm ("padding"));
 
-         if (include_fixed_spacing)
-           {
-             Real min_distance = 0;
-             if (Page_layout_problem::read_spacing_spec (spec, &min_distance, ly_symbol2scm ("minimum-distance")))
-               dy = max (dy, min_distance);
+         dy = down_skyline.distance (skylines[j][-stacking_dir]) + padding;
 
-             dy = max (dy, Page_layout_problem::get_fixed_spacing (elems[j-1], elems[j], spaceable_count, pure, start, end));
-           }
+         Real min_distance = 0;
+         if (Page_layout_problem::read_spacing_spec (spec, &min_distance, ly_symbol2scm ("minimum-distance")))
+           dy = max (dy, min_distance);
 
-         if (Page_layout_problem::is_spaceable (elems[j]) && last_spaceable_element)
+         if (include_fixed_spacing)
+           dy = max (dy, Page_layout_problem::get_fixed_spacing (elems[j-1], elems[j], spaceable_count, pure, start, end));
+
+         if (include_fixed_spacing && Page_layout_problem::is_spaceable (elems[j]) && last_spaceable_element)
            {
              // Spaceable staves may have
              // constraints coming from the previous spaceable staff
@@ -239,27 +239,26 @@ Align_interface::internal_get_minimum_translations (Grob *me,
              Page_layout_problem::read_spacing_spec (spec,
                                                      &spaceable_padding,
                                                      ly_symbol2scm ("padding"));
-             padding = max (padding, spaceable_padding);
+             dy = max(dy, (last_spaceable_skyline.distance (skylines[j][-stacking_dir])
+                           + stacking_dir*(last_spaceable_element_pos - where) + spaceable_padding));
 
-             if (include_fixed_spacing)
-               {
-                 Real min_distance = 0;
-                 if (Page_layout_problem::read_spacing_spec (spec,
-                                                             &min_distance,
-                                                             ly_symbol2scm ("minimum-distance")))
-                   dy = max (dy, min_distance + stacking_dir*(last_spaceable_element_pos - where));
-
-                 dy = max (dy, Page_layout_problem::get_fixed_spacing (last_spaceable_element, elems[j], spaceable_count,
-                                                                       pure, start, end));
-               }
+             Real spaceable_min_distance = 0;
+             if (Page_layout_problem::read_spacing_spec (spec,
+                                                         &spaceable_min_distance,
+                                                         ly_symbol2scm ("minimum-distance")))
+               dy = max (dy, spaceable_min_distance + stacking_dir*(last_spaceable_element_pos - where));
+
+             dy = max (dy, Page_layout_problem::get_fixed_spacing (last_spaceable_element, elems[j], spaceable_count,
+                                                                   pure, start, end));
            }
        }
 
       if (isinf (dy)) /* if the skyline is empty, maybe max_height is infinity_f */
        dy = 0.0;
 
-      dy = max (0.0, dy + padding);
+      dy = max (0.0, dy);
       down_skyline.raise (-stacking_dir * dy);
+      down_skyline.merge (skylines[j][stacking_dir]);
       where += stacking_dir * dy;
       translates.push_back (where);
 
@@ -268,6 +267,7 @@ Align_interface::internal_get_minimum_translations (Grob *me,
          spaceable_count++;
          last_spaceable_element = elems[j];
          last_spaceable_element_pos = where;
+         last_spaceable_skyline = down_skyline;
        }
     }
 

diff --git a/lily/page-layout-problem.cc b/lily/page-layout-problem.cc
index 4c3e14c7d26e4eb4df23404eebd249085e83deea..9ee2b3fea11b9ae3a22ef74ebb140515b9224fd4 100644 (file)
--- a/lily/page-layout-problem.cc
+++ b/lily/page-layout-problem.cc
@@ -496,7 +496,6 @@ Page_layout_problem::find_system_offsets ()
          Real system_position = first_staff_position + first_staff_min_translation;
 
          // Position the staves within this system.
-         Real translation = 0;
          vector<Real> const& min_offsets = elements_[i].min_offsets;
          bool found_spaceable_staff = false;
          for (vsize staff_idx = 0; staff_idx < elements_[i].staves.size (); ++staff_idx)
@@ -507,8 +506,7 @@ Page_layout_problem::find_system_offsets ()
              if (is_spaceable (staff))
                {
                  // this is relative to the system: negative numbers are down.
-                 translation = system_position - solution_[spring_idx];
-                 spring_idx++;
+                 staff->translate_axis (system_position - solution_[spring_idx], Y_AXIS);
 
                  // Lay out any non-spaceable lines between this line and
                  // the last one.
@@ -521,15 +519,14 @@ Page_layout_problem::find_system_offsets ()
                      loose_lines.push_back (staff);
 
                      distribute_loose_lines (loose_lines, loose_line_min_distances,
-                                             last_spaceable_line_translation, translation - system_position);
+                                             last_spaceable_line_translation, -solution_[spring_idx]);
                      loose_lines.clear ();
                      loose_line_min_distances.clear ();
                    }
                  last_spaceable_line = staff;
-                 last_spaceable_line_translation = -solution_[spring_idx - 1];
-
-                 staff->translate_axis (translation, Y_AXIS);
+                 last_spaceable_line_translation = -solution_[spring_idx];
                  found_spaceable_staff = true;
+                 spring_idx++;
                }
              else
                {