DOCS: add warning about slur termination in same voice \

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

diff --git a/lily/page-spacing.cc b/lily/page-spacing.cc
index 3eb4ecfe53021bc6fe021536c0ecdff249d04a96..ab8085c1d59b92900fd46cd7ac72f59f425e3f91 100644 (file)
--- a/lily/page-spacing.cc
+++ b/lily/page-spacing.cc
@@ -16,8 +16,9 @@
 void
 Page_spacing::calc_force ()
 {
-  /* If the first system is a title, we add back in the page-top-space. */
-  Real height = first_line_.title_ ? page_height_ + page_top_space_ : page_height_;
+  Real height = page_height_
+    - breaker_->min_whitespace_at_top_of_page (first_line_)
+    - breaker_->min_whitespace_at_bottom_of_page (last_line_);
 
   if (rod_height_ + last_line_.bottom_padding_ >= height)
     force_ = infinity_f;
@@ -154,17 +155,14 @@ Page_spacer::solve (vsize page_count)
   if (extra_systems)
     {
       ret.systems_per_page_.back () += extra_systems;
-      ret.demerits_ += BAD_SPACING_PENALTY;
+      ret.force_.back () = BAD_SPACING_PENALTY;
     }
   if (extra_pages)
     {
       ret.force_.insert (ret.force_.end (), extra_pages, BAD_SPACING_PENALTY);
       ret.systems_per_page_.insert (ret.systems_per_page_.end (), extra_pages, 0);
-      ret.demerits_ += BAD_SPACING_PENALTY;
     }
 
-
-  ret.demerits_ += ret.penalty_;
   return ret;
 }
 
@@ -185,12 +183,18 @@ Page_spacer::resize (vsize page_count)
   max_page_count_ = page_count;
 }
 
+// Carries out one step in the dynamic programming algorithm for putting systems
+// on a fixed number of pages. One call to this routine calculates the best
+// configuration for putting lines 0 through LINE-1 on PAGE+1 pages, provided that
+// we have previously called calc_subproblem(page-1, k) for every k < LINE.
+//
+// This algorithm is similar to the constrained-breaking algorithm.
 bool
 Page_spacer::calc_subproblem (vsize page, vsize line)
 {
   bool last = line == lines_.size () - 1;
   Page_spacing space (breaker_->page_height (page + first_page_num_, last),
-                     breaker_->page_top_space ());
+                     breaker_);
   Page_spacing_node &cur = state_.at (line, page);
   bool ragged = ragged_ || (ragged_last_ && last);
   int line_count = 0;
@@ -198,17 +202,24 @@ Page_spacer::calc_subproblem (vsize page, vsize line)
   for (vsize page_start = line+1; page_start > page && page_start--;)
     {
       Page_spacing_node const *prev = page > 0 ? &state_.at (page_start-1, page-1) : 0;
-      line_count += lines_[page_start].compressed_nontitle_lines_count_;
 
       space.prepend_system (lines_[page_start]);
-      // FIXME: The following line doesn't respect min-systems-per-page. More
-      // generally, what should we do when respecting min-systems-per-page
-      // would cause a page to be overfull?
-      if (page_start < line && (isinf (space.force_) || (space.force_ < 0 && ragged)))
+
+      // This 'if' statement is a little hard to parse. It won't consider this configuration
+      // if it is overfull unless the current configuration is the first one with this start
+      // point. We also make an exception (and consider this configuration) if the previous
+      // configuration we tried had fewer lines than min-systems-per-page.
+      if (!breaker_->too_few_lines (line_count)
+         && page_start < line
+         && (isinf (space.force_) || (space.force_ < 0 && ragged)))
        break;
 
+      line_count += lines_[page_start].compressed_nontitle_lines_count_;
       if (page > 0 || page_start == 0)
        {
+         // If the last page is ragged, set its force to zero. This way, we will leave
+         // the last page half-empty rather than trying to balance things out
+         // (which only makes sense in non-ragged situations).
          if (line == lines_.size () - 1 && ragged && last && space.force_ > 0)
            space.force_ = 0;
 
@@ -221,7 +232,7 @@ Page_spacer::calc_subproblem (vsize page, vsize line)
 
          Real penalty = breaker_->line_count_penalty (line_count);
          if (page_start > 0)
-           penalty = lines_[page_start-1].page_penalty_
+           penalty += lines_[page_start-1].page_penalty_
              + (page % 2 == 0) ? lines_[page_start-1].turn_penalty_ : 0;
 
          demerits += penalty;
@@ -230,6 +241,8 @@ Page_spacer::calc_subproblem (vsize page, vsize line)
              cur.demerits_ = demerits;
              cur.force_ = space.force_;
              cur.penalty_ = penalty + (prev ? prev->penalty_ : 0);
+             cur.system_count_status_ = breaker_->line_count_status (line_count)
+               | (prev ? prev->system_count_status_ : 0);
              cur.prev_ = page_start - 1;
            }
        }