X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpage-spacing.cc;h=1a3c39cfbf709d88de4725c6238fe8636141eb15;hb=326f7c9d674666df6a8bbfc0883eaf5dfdbaa13e;hp=cc84cfd9432ef19dd3bda51f881dbb79e07705c1;hpb=aa1dc01de16aa8a8e7ac67dab630f3927d56d93e;p=lilypond.git diff --git a/lily/page-spacing.cc b/lily/page-spacing.cc index cc84cfd943..1a3c39cfbf 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 - (c) 2006--2009 Joe Neeman + 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 . */ #include "page-spacing.hh" @@ -16,9 +26,9 @@ void Page_spacing::calc_force () { - /* If the first system contains a title, we add back in the page-top-space. */ - bool starts_with_title = first_line_.compressed_nontitle_lines_count_ < first_line_.compressed_lines_count_; - Real height = starts_with_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; @@ -37,12 +47,16 @@ Page_spacing::resize (Real new_height) void Page_spacing::append_system (const Line_details &line) { - if (!rod_height_) - first_line_ = line; - - rod_height_ += last_line_.padding_; + if (rod_height_) + { + rod_height_ += line.tallness_; + } + else + { + rod_height_ += line.full_height (); + first_line_ = line; + } - rod_height_ += line.extent_.length (); spring_len_ += line.space_; inverse_spring_k_ += line.inverse_hooke_; @@ -54,12 +68,12 @@ Page_spacing::append_system (const Line_details &line) void Page_spacing::prepend_system (const Line_details &line) { - if (rod_height_) - rod_height_ += line.padding_; - else + if (!rod_height_) last_line_ = line; - rod_height_ += line.extent_.length (); + rod_height_ -= first_line_.full_height (); + rod_height_ += first_line_.tallness_; + rod_height_ += line.full_height(); spring_len_ += line.space_; inverse_spring_k_ += line.inverse_hooke_; @@ -86,6 +100,34 @@ Page_spacer::Page_spacer (vector const &lines, vsize first_page_nu ragged_last_ = breaker->is_last () && breaker->ragged_last (); } +Page_spacing_result +Page_spacer::solve () +{ + if (simple_state_.empty ()) + { + simple_state_.resize (lines_.size ()); + for (vsize i = 0; i < lines_.size (); ++i) + calc_subproblem (VPOS, i); + } + + Page_spacing_result ret; + vsize system = lines_.size () - 1; + while (system != VPOS) + { + Page_spacing_node const& cur = simple_state_[system]; + vsize system_count = (cur.prev_ == VPOS) ? system + 1 : system - cur.prev_; + + ret.force_.push_back (cur.force_); + ret.systems_per_page_.push_back (system_count); + ret.demerits_ += cur.force_ * cur.force_; + system = cur.prev_; + } + + reverse (ret.force_); + reverse (ret.systems_per_page_); + return ret; +} + Page_spacing_result Page_spacer::solve (vsize page_count) { @@ -189,19 +231,44 @@ Page_spacer::resize (vsize page_count) // we have previously called calc_subproblem(page-1, k) for every k < LINE. // // This algorithm is similar to the constrained-breaking algorithm. +// +// If page == VPOS, we act on simple_state_ instead of state_. This is useful if +// we don't want to constrain the number of pages that the solution has. In this +// case, the algorithm looks more like the page-turn-page-breaking algorithm. But +// the subproblems look similar for both, so we reuse this method. 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 ()); - Page_spacing_node &cur = state_.at (line, page); + + // Note: if page == VPOS then we don't actually know yet which page number we're + // working on, so we have to recalculate the page height in the loop. In that case, + // the algorithm may not be optimal: if our page has a very large header then perhaps + // we need to look ahead a few systems in order to find the best solution. But + // we won't, because we stop once we overfill the page with the large header. + vsize page_num = page == VPOS ? 0 : page; + Page_spacing space (breaker_->page_height (page_num + first_page_num_, last), + breaker_); + Page_spacing_node &cur = page == VPOS ? simple_state_[line] : state_.at (line, page); bool ragged = ragged_ || (ragged_last_ && last); int line_count = 0; - for (vsize page_start = line+1; page_start > page && page_start--;) + for (vsize page_start = line+1; page_start > page_num && page_start--;) { - Page_spacing_node const *prev = page > 0 ? &state_.at (page_start-1, page-1) : 0; + Page_spacing_node const *prev = 0; + + if (page == VPOS) + { + if (page_start > 0) + { + prev = &simple_state_[page_start-1]; + space.resize (breaker_->page_height (prev->page_ + 1, last)); + } + else + space.resize (breaker_->page_height (first_page_num_, last)); + } + else if (page > 0) + prev = &state_.at (page_start-1, page-1); space.prepend_system (lines_[page_start]); @@ -235,6 +302,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) { @@ -244,6 +323,7 @@ Page_spacer::calc_subproblem (vsize page, vsize line) cur.system_count_status_ = breaker_->line_count_status (line_count) | (prev ? prev->system_count_status_ : 0); cur.prev_ = page_start - 1; + cur.page_ = prev ? prev->page_ + 1 : first_page_num_; } }