X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpage-spacing.cc;h=f78cc1795aef00d30b5811557d5269c1846fab25;hb=0bf11a427a6ba669fa2d2ad709ca1d257bb5afd2;hp=c60f0d88b1d171d3df4608169575ea7cf6331cfa;hpb=0361762a1cf6d15590bad1419051bc59de3ef7fd;p=lilypond.git

diff --git a/lily/page-spacing.cc b/lily/page-spacing.cc
index c60f0d88b1..f78cc1795a 100644
--- a/lily/page-spacing.cc
+++ b/lily/page-spacing.cc
@@ -1,10 +1,20 @@
 /*
-  page-spacing.cc - implement routines for spacing
-  systems vertically on pages
+  This file is part of LilyPond, the GNU music typesetter.
 
-  source file of the GNU LilyPond music typesetter
+  Copyright (C) 2006--2010 Joe Neeman <joeneeman@gmail.com>
 
-  (c) 2006--2009 Joe Neeman <joeneeman@gmail.com>
+  LilyPond is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LilyPond is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "page-spacing.hh"
@@ -16,8 +26,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;
@@ -39,7 +50,7 @@ Page_spacing::append_system (const Line_details &line)
   if (!rod_height_)
     first_line_ = line;
 
-  rod_height_ += last_line_.padding_;
+  rod_height_ += line.title_ ? last_line_.title_padding_ : last_line_.padding_;
 
   rod_height_ += line.extent_.length ();
   spring_len_ += line.space_;
@@ -54,7 +65,7 @@ void
 Page_spacing::prepend_system (const Line_details &line)
 {
   if (rod_height_)
-    rod_height_ += line.padding_;
+    rod_height_ += first_line_.title_ ? line.title_padding_ : line.padding_;
   else
     last_line_ = line;
 
@@ -154,17 +165,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 +193,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;
@@ -213,6 +227,9 @@ Page_spacer::calc_subproblem (vsize page, vsize line)
       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;
 
@@ -228,6 +245,18 @@ Page_spacer::calc_subproblem (vsize page, vsize line)
 	    penalty += lines_[page_start-1].page_penalty_
 	      + (page % 2 == 0) ? lines_[page_start-1].turn_penalty_ : 0;
 
+	  /* Deal with widow/orphan lines */
+	  /* Last line of paragraph is first line on the new page */
+	  if ((page_start > 0) &&
+	      (page_start < lines_.size ()) &&
+	      (lines_[page_start].last_markup_line_))
+		  penalty += breaker_->orphan_penalty ();
+	  /* First line of paragraph is last line on the previous page */
+	  if ((page_start > 0) &&
+	      (page_start < lines_.size ()) &&
+	      (lines_[page_start-1].first_markup_line_))
+		  penalty += breaker_->orphan_penalty ();
+
 	  demerits += penalty;
 	  if (demerits < cur.demerits_ || page_start == line)
 	    {