X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpage-breaking.cc;h=5d55c7a9f41e26114d796dd8e22fa0c84136afcc;hb=54b02666750062788185bd3f99e644d621e348c2;hp=cf483bdcb3488e49fe22c1335dbc41a611feace1;hpb=8860a7700be8348848bba7972ad86ef46721c544;p=lilypond.git diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc index cf483bdcb3..5d55c7a9f4 100644 --- a/lily/page-breaking.cc +++ b/lily/page-breaking.cc @@ -1,7 +1,7 @@ /* This file is part of LilyPond, the GNU music typesetter. - Copyright (C) 2006--2010 Joe Neeman + Copyright (C) 2006--2011 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 @@ -71,18 +71,74 @@ discarded after a call to set_current_breakpoints, since that Line_division refers to a subset of chunks which might be different from the current subset of chunks under consideration. + + HOW TO WRITE A PAGE BREAKING ALGORITHM + All page breakers supported by this class work more-or-less in the same way. + First, they request a particular number of systems by saying + set_current_breakpoints (0, last_break_position (), system_count) + (never mind what the first two arguments do, I'll get to them later). + Alternatively, you can do + set_to_ideal_line_configuration (0, last_break_position ()), + and the number of systems will be automatically chosen according to what + the line breaker wants. + + If there are multiple scores, there will be many different ways to achieve + a certain number of lines. You can see how many alternatives are available + with current_configuration_count (). For every i from 0 to + current_configuration_count ()-1, you can see the line division of the + corresponding configuration with current_configuration (i), or you can try + out various page configurations with one of the space_systems_xxx or + pack_systems_xxx functions. The first argument to each of these functions + is the configuration index. + + When you're done trying out configurations and you've picked the one + you want, do + break_into_pieces (0, last_break_position (), line_division_that_you_want); + return make_pages (systems_per_page, systems ()); + where systems_per_page is a vector of numbers telling how many systems are + on each page. You can get your systems_per_page vector by looking inside + the Page_spacing_results that are returned by space_systems_xxx or + pack_systems_xxx. + + A note on performance: set_current_breakpoints is EXPONENTIALLY SLOW unless + you constrain it by giving it a lower or an upper bound on the configurations + it looks for. Optimal_page_breaking, for example, works by trying + out a bunch of configurations, increasing the system count by one, trying + again and so on. Each time we increase the system count, we assume that the + best new configurations are going to be elementwise larger than the + best configuration for the previous system count (in other words, we're going + to get a new configuration just by adding an extra line to sone score + and leaving the rest the same). Therefore, we pass the best previous line + division as an lower bound to set_current_breakpoints. + + Now you should be in a position to understand Optimal_page_breaking::solve. + Go ahead and read that before finding out, in the next paragraph, + what the first two arguments to set_current_breakpoints do. + + "BREAKS" + Sometimes, it's useful to run this whole page-breaking machinery on a subset + of the book. To do this, you can mark certain "breaks" in the book (a poor + choice of name, perhaps, since a "break" here is different from a page break) + and you can run page breaking between any two breaks. You mark your breaks + by providing a Break_predicate (and, if you want, a Prob_break_predicate) + to Page_breaking's constructor. You then choose a subset of your book + by passing the starting and ending breaks to set_current_breakpoints. You + can see an example of this in Page_turn_page_breaking, where there is a break + everywhere that a page turn is allowed. */ #include "page-breaking.hh" #include "international.hh" #include "item.hh" +#include "line-interface.hh" #include "output-def.hh" #include "page-layout-problem.hh" #include "page-spacing.hh" #include "paper-book.hh" #include "paper-score.hh" #include "paper-system.hh" +#include "text-interface.hh" #include "system.hh" #include "warn.hh" @@ -100,17 +156,21 @@ compress_lines (const vector &orig) Line_details const &old = ret.back (); Line_details compressed = orig[i]; /* - "padding" is the padding below the current line. The padding below - "old" (taking into account whether "old" is a title) is already - accounted for in the extent of the compressed line. The padding - below the compressed line, therefore, should depend on whether its - bottom-most line is a title or not. + We must account for the padding between the lines that we are compressing. + The padding values come from "old," which is the upper system here. Note + the meaning of tight-spacing: if a system has tight-spacing, then the padding + _before_ it is ignored. */ Real padding = 0; if (!orig[i].tight_spacing_) padding = orig[i].title_ ? old.title_padding_ : old.padding_; + // FIXME: double check these. Doesn't foo.piggyback (bar) mean + // that foo goes on top? + // TODO: break out a Line_details::piggyback from here? compressed.shape_ = old.shape_.piggyback (orig[i].shape_, padding); + compressed.refpoint_extent_[UP] = old.refpoint_extent_[UP]; + compressed.refpoint_extent_[DOWN] += compressed.shape_.rest_[UP] - old.shape_.rest_[UP]; compressed.space_ += old.space_; compressed.inverse_hooke_ += old.inverse_hooke_; @@ -120,7 +180,12 @@ compress_lines (const vector &orig) // compressed.title_ is true if and only if the first of its // compressed lines was a title. - compressed.title_ = old.title_; + compressed.title_ = old.title_; + + // adds footnotes of one line to the footnotes of another + compressed.footnotes_.insert (compressed.footnotes_.begin (), + old.footnotes_.begin (), old.footnotes_.end ()); + ret.back () = compressed; } else @@ -173,10 +238,11 @@ Page_breaking::next_system (Break_position const &break_pos) const return sys + 1; /* this page starts with a new System_spec */ } -Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break) +Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break, Prob_break_predicate prob_break) { book_ = pb; system_count_ = 0; + paper_height_ = robust_scm2double (pb->paper_->c_variable ("paper-height"), 1.0); ragged_ = to_boolean (pb->paper_->c_variable ("ragged-bottom")); ragged_last_ = to_boolean (pb->paper_->c_variable ("ragged-last-bottom")); systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("systems-per-page"), 0)); @@ -184,6 +250,25 @@ Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break) min_systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("min-systems-per-page"), 0)); orphan_penalty_ = robust_scm2int (pb->paper_->c_variable ("orphan-penalty"), 100000); + Stencil *footnote_separator = Page_layout_problem::get_footnote_separator_stencil (pb->paper_); + + if (footnote_separator) + { + Interval separator_extent = footnote_separator->extent (Y_AXIS); + Real separator_span = separator_extent.length (); + + footnote_separator_stencil_height_ = separator_span; + } + else + footnote_separator_stencil_height_ = 0.0; + + footnote_padding_ = robust_scm2double (pb->paper_->c_variable ("footnote-padding"), 0.0); + footnote_footer_padding_ = robust_scm2double (pb->paper_->c_variable ("footnote-footer-padding"), 0.0); + + footnote_number_raise_ = (to_boolean (pb->paper_->c_variable ("footnote-auto-numbering")) + ? robust_scm2double (pb->paper_->c_variable ("footnote-number-raise"), 0.0) + : 0.0); + if (systems_per_page_ && (max_systems_per_page_ || min_systems_per_page_)) { warning (_f ("ignoring min-systems-per-page and max-systems-per-page because systems-per-page was set")); @@ -196,7 +281,7 @@ Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break) } create_system_list (); - find_chunks_and_breaks (is_break); + find_chunks_and_breaks (is_break, prob_break); } Page_breaking::~Page_breaking () @@ -224,12 +309,16 @@ Page_breaking::systems_per_page () const int Page_breaking::max_systems_per_page () const { + if (systems_per_page_) + return systems_per_page_; return max_systems_per_page_; } int Page_breaking::min_systems_per_page () const { + if (systems_per_page_) + return systems_per_page_; return min_systems_per_page_; } @@ -239,6 +328,30 @@ Page_breaking::system_count () const return system_count_; } +Real +Page_breaking::footnote_separator_stencil_height () const +{ + return footnote_separator_stencil_height_; +} + +Real +Page_breaking::footnote_padding () const +{ + return footnote_padding_; +} + +Real +Page_breaking::footnote_footer_padding () const +{ + return footnote_footer_padding_; +} + +Real +Page_breaking::footnote_number_raise () const +{ + return footnote_number_raise_; +} + bool Page_breaking::too_many_lines (int line_count) const { @@ -338,9 +451,8 @@ Page_breaking::systems () ->get_broken_system_grobs (); ret = scm_cons (lines, ret); } - else + else if (Prob *pb = system_specs_[sys].prob_) { - Prob *pb = system_specs_[sys].prob_; ret = scm_cons (scm_list_1 (pb->self_scm ()), ret); pb->unprotect (); } @@ -365,16 +477,45 @@ Page_breaking::make_page (int page_num, bool last) const SCM_UNDEFINED)); } +// Returns the total height of the paper, including margins and +// space for the header/footer. This is an upper bound on +// page_height, and it doesn't depend on the current page. +Real +Page_breaking::paper_height () const +{ + return paper_height_; +} + Real Page_breaking::page_height (int page_num, bool last) const { - SCM mod = scm_c_resolve_module ("scm page"); - SCM page = make_page (page_num, last); - SCM calc_height = scm_c_module_lookup (mod, "calc-printable-height"); - calc_height = scm_variable_ref (calc_height); + // The caches allow us to store the page heights for any + // non-negative page numbers. We use a negative value in the + // cache to signal that that position has not yet been initialized. + // This means that we won't cache properly if page_num is negative or + // if calc_height returns a negative number. But that's likely to + // be rare, so it shouldn't affect performance. + vector& cache = last ? last_page_height_cache_ : page_height_cache_; + if (page_num >= 0 && (int) cache.size () > page_num && cache[page_num] >= 0) + return cache[page_num]; + else + { + SCM mod = scm_c_resolve_module ("scm page"); + SCM page = make_page (page_num, last); + SCM calc_height = scm_c_module_lookup (mod, "calc-printable-height"); + calc_height = scm_variable_ref (calc_height); - SCM height = scm_apply_1 (calc_height, page, SCM_EOL); - return scm_to_double (height); + SCM height_scm = scm_apply_1 (calc_height, page, SCM_EOL); + Real height = scm_to_double (height_scm); + + if (page_num >= 0) + { + if ((int) cache.size () <= page_num) + cache.resize (page_num + 1, -1); + cache[page_num] = height; + } + return height; + } } SCM @@ -390,15 +531,15 @@ Page_breaking::breakpoint_property (vsize breakpoint, char const *str) } SCM -Page_breaking::get_page_configuration (SCM systems, int page_num, bool ragged, bool last) +Page_breaking::get_page_configuration (SCM systems, int page_num, int footnote_count, bool ragged, bool last) { SCM dummy_page = make_page (page_num, last); - Page_layout_problem layout (book_, dummy_page, systems); + Page_layout_problem layout (book_, dummy_page, systems, footnote_count); return scm_is_pair (systems) ? layout.solution (ragged) : SCM_EOL; } SCM -Page_breaking::draw_page (SCM systems, SCM configuration, int page_num, bool last) +Page_breaking::draw_page (SCM systems, SCM configuration, int page_num, int footnote_num, bool last) { // Create a stencil for each system. SCM paper_systems = SCM_EOL; @@ -423,6 +564,20 @@ Page_breaking::draw_page (SCM systems, SCM configuration, int page_num, bool las Prob *p = unsmob_prob (page); p->set_property ("lines", paper_systems); p->set_property ("configuration", configuration); + + Stencil *foot = unsmob_stencil (p->get_property ("foot-stencil")); + + footnote_num = (to_boolean (book_->paper_->c_variable ("reset-footnotes-on-new-page")) + ? 0 + : footnote_num); + + SCM footnotes = Page_layout_problem::get_footnotes_from_lines (systems, + footnote_num, + book_); + + Page_layout_problem::add_footnotes_to_footer (footnotes, foot, book_); + + p->set_property ("foot-stencil", foot->smobbed_copy ()); scm_apply_1 (page_stencil, page, SCM_EOL); return page; @@ -431,6 +586,9 @@ Page_breaking::draw_page (SCM systems, SCM configuration, int page_num, bool las SCM Page_breaking::make_pages (vector lines_per_page, SCM systems) { + if (scm_is_null (systems)) + return SCM_EOL; + int first_page_number = robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1); SCM ret = SCM_EOL; @@ -444,8 +602,9 @@ Page_breaking::make_pages (vector lines_per_page, SCM systems) // themselves. If this happens before the neighbouring staves have // been laid out, bad side-effects could happen (in particular, // Align_interface::align_to_ideal_distances might be called). - SCM systems_and_configs = SCM_EOL; - + SCM systems_configs_fncounts = SCM_EOL; + vsize footnote_count = 0; + for (vsize i = 0; i < lines_per_page.size (); i++) { int page_num = i + first_page_number; @@ -453,21 +612,24 @@ Page_breaking::make_pages (vector lines_per_page, SCM systems) bool rag = ragged () || (bookpart_last_page && ragged_last ()); SCM line_count = scm_from_int (lines_per_page[i]); SCM lines = scm_list_head (systems, line_count); - SCM config = get_page_configuration (lines, page_num, rag, bookpart_last_page); - - systems_and_configs = scm_cons (scm_cons (lines, config), systems_and_configs); + int fn_lines = Page_layout_problem::get_footnote_count (lines); + SCM config = get_page_configuration (lines, page_num, footnote_count, rag, bookpart_last_page); + + systems_configs_fncounts = scm_cons (scm_list_3 (lines, config, scm_from_int ((int)footnote_count)), systems_configs_fncounts); + footnote_count += fn_lines; systems = scm_list_tail (systems, line_count); } // Now it's safe to make the pages. int page_num = first_page_number + lines_per_page.size () - 1; - for (SCM s = systems_and_configs; scm_is_pair (s); s = scm_cdr (s)) + for (SCM s = systems_configs_fncounts; scm_is_pair (s); s = scm_cdr (s)) { SCM lines = scm_caar (s); - SCM config = scm_cdar (s); - bool bookpart_last_page = (s == systems_and_configs); - SCM page = draw_page (lines, config, page_num, bookpart_last_page); + SCM config = scm_cadar (s); + int footnote_num = scm_to_int (scm_caddar (s)); + bool bookpart_last_page = (s == systems_configs_fncounts); + SCM page = draw_page (lines, config, page_num, footnote_num, bookpart_last_page); /* collect labels */ SCM page_num_scm = scm_from_int (page_num); for (SCM l = lines ; scm_is_pair (l) ; l = scm_cdr (l)) @@ -489,6 +651,11 @@ Page_breaking::make_pages (vector lines_per_page, SCM systems) ret = scm_cons (page, ret); --page_num; } + + // By reversing the table, we ensure that duplicated labels (eg. those + // straddling a page turn) will appear in the table with their last + // occurence first. + label_page_table = scm_reverse_x (label_page_table, SCM_EOL); book_->top_paper ()->set_variable (ly_symbol2scm ("label-page-table"), label_page_table); return ret; } @@ -520,10 +687,12 @@ Page_breaking::create_system_list () system_specs_.push_back (System_spec (pb)); } } + if (!system_specs_.size ()) + system_specs_.push_back (System_spec ()); } void -Page_breaking::find_chunks_and_breaks (Break_predicate is_break) +Page_breaking::find_chunks_and_breaks (Break_predicate is_break, Prob_break_predicate prob_is_break) { SCM force_sym = ly_symbol2scm ("force"); @@ -534,7 +703,8 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break) { if (system_specs_[i].pscore_) { - vector cols; + vector cols = system_specs_[i].pscore_->root_system ()->used_columns (); + vector forced_line_break_cols; SCM system_count = system_specs_[i].pscore_->layout ()->c_variable ("system-count"); if (scm_is_number (system_count)) @@ -545,21 +715,28 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break) Constrained_breaking breaking (system_specs_[i].pscore_); vector details = breaking.line_details (0, VPOS, scm_to_int (system_count)); - cols.push_back (system_specs_[i].pscore_->root_system ()->used_columns ()[0]); for (vsize j = 0; j < details.size (); j++) - cols.push_back (details[j].last_column_); + forced_line_break_cols.push_back (details[j].last_column_); } - else - cols = system_specs_[i].pscore_->root_system ()->used_columns (); - int last_chunk_idx = 0; + int last_forced_line_break_idx = 0; + vsize forced_line_break_idx = 0; vector line_breaker_columns; line_breaker_columns.push_back (0); for (vsize j = 1; j < cols.size (); j++) { + if (forced_line_break_cols.size ()) + { + if (forced_line_break_idx >= forced_line_break_cols.size () + || forced_line_break_cols[forced_line_break_idx] != cols[j]) + continue; + else + forced_line_break_idx++; + } + bool last = (j == cols.size () - 1); - bool break_point = is_break (cols[j]); + bool break_point = is_break && is_break (cols[j]); bool chunk_end = cols[j]->get_property ("page-break-permission") == force_sym; Break_position cur_pos = Break_position (i, line_breaker_columns.size (), @@ -573,14 +750,14 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break) // since it mixes Break_positions from breaks_ and // chunks_. if (scm_is_number (system_count)) - cur_pos.forced_line_count_ = j - last_chunk_idx; + cur_pos.forced_line_count_ = forced_line_break_idx - last_forced_line_break_idx; if (break_point || (i == system_specs_.size () - 1 && last)) breaks_.push_back (cur_pos); if (chunk_end || last) { chunks_.push_back (cur_pos); - last_chunk_idx = j; + last_forced_line_break_idx = forced_line_break_idx; } if ((break_point || chunk_end) && !last) @@ -588,10 +765,10 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break) } line_breaking_.push_back (Constrained_breaking (system_specs_[i].pscore_, line_breaker_columns)); } - else + else if (system_specs_[i].prob_) { - /* TODO: we want some way of applying Break_p to a prob? */ - if (i == system_specs_.size () - 1) + bool break_point = prob_is_break && prob_is_break (system_specs_[i].prob_); + if (break_point || i == system_specs_.size () - 1) breaks_.push_back (Break_position (i)); chunks_.push_back (Break_position (i)); @@ -621,6 +798,7 @@ Page_breaking::chunk_list (vsize start_index, vsize end_index) return ret; } +// Returns the minimum number of _non-title_ lines. vsize Page_breaking::min_system_count (vsize start, vsize end) { @@ -633,6 +811,7 @@ Page_breaking::min_system_count (vsize start, vsize end) return ret; } +// Returns the maximum number of _non-title_ lines. vsize Page_breaking::max_system_count (vsize start, vsize end) { @@ -645,6 +824,9 @@ Page_breaking::max_system_count (vsize start, vsize end) return ret; } +// The numbers returned by this function represent either +// the maximum or minimum number of _non-title_ lines +// per chunk. Page_breaking::Line_division Page_breaking::system_count_bounds (vector const &chunks, bool min) @@ -652,7 +834,7 @@ Page_breaking::system_count_bounds (vector const &chunks, assert (chunks.size () >= 2); Line_division ret; - ret.resize (chunks.size () - 1, 1); + ret.resize (chunks.size () - 1, 0); for (vsize i = 0; i + 1 < chunks.size (); i++) { @@ -752,7 +934,7 @@ Page_breaking::set_to_ideal_line_configuration (vsize start, vsize end) div.push_back (line_breaking_[sys].best_solution (start, end).size ()); } else - div.push_back (1); + div.push_back (0); system_count_ += div.back (); } @@ -789,11 +971,14 @@ Page_breaking::cache_line_details (vsize configuration_index) } else { - assert (div[i] == 1); - uncompressed_line_details_.push_back (Line_details (system_specs_[sys].prob_, book_->paper_)); + assert (div[i] == 0); + uncompressed_line_details_.push_back (system_specs_[sys].prob_ + ? Line_details (system_specs_[sys].prob_, book_->paper_) + : Line_details ()); } } cached_line_details_ = compress_lines (uncompressed_line_details_); + compute_line_heights (); } } @@ -812,19 +997,19 @@ Page_breaking::line_divisions_rec (vsize system_count, Line_division *cur_division) { vsize my_index = cur_division->size (); - vsize others_min = 0; - vsize others_max = 0; + int others_min = 0; + int others_max = 0; for (vsize i = my_index + 1; i < min_sys.size (); i++) { others_min += min_sys[i]; others_max += max_sys[i]; } - others_max = min (others_max, system_count); - vsize real_min = max (min_sys[my_index], system_count - others_max); - vsize real_max = min (max_sys[my_index], system_count - others_min); + others_max = min (others_max, (int) system_count); + int real_min = max ((int) min_sys[my_index], (int) system_count - others_max); + int real_max = min ((int) max_sys[my_index], (int) system_count - others_min); - if (real_min > real_max || real_min <= 0) + if (real_min > real_max || real_min < 0) { /* this should never happen within a recursive call. If it happens at all, it means that we were called with an unsolvable problem @@ -833,7 +1018,7 @@ Page_breaking::line_divisions_rec (vsize system_count, return; } - for (vsize i = real_min; i <= real_max; i++) + for (int i = real_min; i <= real_max; i++) { cur_division->push_back (i); if (my_index == min_sys.size () - 1) @@ -850,19 +1035,44 @@ Page_breaking::compute_line_heights () Real prev_hanging = 0; Real prev_hanging_begin = 0; Real prev_hanging_rest = 0; + + // refpoint_hanging is the y coordinate of the origin of this system. + // It may not be the same as refpoint_extent[UP], which is the + // refpoint of the first spaceable staff in this system. + Real prev_refpoint_hanging = 0; for (vsize i = 0; i < cached_line_details_.size (); i++) { - Line_shape shape = cached_line_details_[i].shape_; + Line_details& cur = cached_line_details_[i]; + Line_shape shape = cur.shape_; Real a = shape.begin_[UP]; Real b = shape.rest_[UP]; - Real midline_hanging = max (prev_hanging_begin + a, prev_hanging_rest + b); - Real hanging_begin = midline_hanging - shape.begin_[DOWN]; - Real hanging_rest = midline_hanging - shape.rest_[DOWN]; + bool title = cur.title_; + Real refpoint_hanging = max (prev_hanging_begin + a, prev_hanging_rest + b); + + if (i > 0) + { + Real padding = 0; + Line_details const& prev = cached_line_details_[i-1]; + if (!cur.tight_spacing_) + padding = title + ? prev.title_padding_ + : prev.padding_; + Real min_dist = title + ? prev.title_min_distance_ + : prev.min_distance_; + refpoint_hanging = max (refpoint_hanging + padding, + prev_refpoint_hanging - prev.refpoint_extent_[DOWN] + + cur.refpoint_extent_[UP] + min_dist); + } + + Real hanging_begin = refpoint_hanging - shape.begin_[DOWN]; + Real hanging_rest = refpoint_hanging - shape.rest_[DOWN]; Real hanging = max (hanging_begin, hanging_rest); - cached_line_details_[i].tallness_ = hanging - prev_hanging; + cur.tallness_ = hanging - prev_hanging; prev_hanging = hanging; prev_hanging_begin = hanging_begin; prev_hanging_rest = hanging_rest; + prev_refpoint_hanging = refpoint_hanging; } } @@ -877,45 +1087,38 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) int line_count = 0; cache_line_details (configuration); - compute_line_heights (); if (cached_line_details_.size ()) cur_page_height -= min_whitespace_at_top_of_page (cached_line_details_[0]); for (vsize i = 0; i < cached_line_details_.size (); i++) { - Real padding = 0; + Line_details const &cur = cached_line_details_[i]; + Line_details const *const prev = (i > 0) ? &cached_line_details_[i-1] : 0; Real ext_len; if (cur_rod_height > 0) - { - if (!cached_line_details_[i].tight_spacing_) - padding = (cached_line_details_[i].title_ - ? cached_line_details_[i - 1].title_padding_ - : cached_line_details_[i - 1].padding_); - ext_len = cached_line_details_[i].tallness_; - } + ext_len = cur.tallness_; else - { - ext_len = cached_line_details_[i].full_height(); - } - Real next_rod_height = cur_rod_height + ext_len + padding; - Real next_spring_height = cur_spring_height + cached_line_details_[i].space_; + ext_len = cur.full_height(); + + Real spring_len = (i > 0) ? prev->spring_length (cur) : 0; + Real next_rod_height = cur_rod_height + ext_len; + Real next_spring_height = cur_spring_height + spring_len; Real next_height = next_rod_height + (ragged () ? next_spring_height : 0) - + min_whitespace_at_bottom_of_page (cached_line_details_[i]); - int next_line_count = line_count + cached_line_details_[i].compressed_nontitle_lines_count_; + + min_whitespace_at_bottom_of_page (cur); + int next_line_count = line_count + cur.compressed_nontitle_lines_count_; if ((!too_few_lines (line_count) && (next_height > cur_page_height && cur_rod_height > 0)) || too_many_lines (next_line_count) - || (i > 0 - && cached_line_details_[i-1].page_permission_ == ly_symbol2scm ("force"))) + || (prev && prev->page_permission_ == ly_symbol2scm ("force"))) { - line_count = cached_line_details_[i].compressed_nontitle_lines_count_; - cur_rod_height = cached_line_details_[i].full_height(); - cur_spring_height = cached_line_details_[i].space_; + line_count = cur.compressed_nontitle_lines_count_; + cur_rod_height = cur.full_height(); + cur_spring_height = 0; page_starter = i; cur_page_height = page_height (first_page_num + ret, false); - cur_page_height -= min_whitespace_at_top_of_page (cached_line_details_[i]); + cur_page_height -= min_whitespace_at_top_of_page (cur); ret++; } @@ -940,18 +1143,21 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) calculations that treated it as a non-last page were ok. */ - cur_page_height = page_height (first_page_num + ret - 1, true); - cur_page_height -= min_whitespace_at_top_of_page (cached_line_details_[page_starter]); - cur_page_height -= min_whitespace_at_bottom_of_page (cached_line_details_.back ()); - - Real cur_height = cur_rod_height + ((ragged_last () || ragged ()) ? cur_spring_height : 0); - if (!too_few_lines (line_count - cached_line_details_.back ().compressed_nontitle_lines_count_) - && cur_height > cur_page_height - /* don't increase the page count if the last page had only one system */ - && cur_rod_height > cached_line_details_.back ().full_height ()) - ret++; + if (is_last ()) + { + cur_page_height = page_height (first_page_num + ret - 1, true); + cur_page_height -= min_whitespace_at_top_of_page (cached_line_details_[page_starter]); + cur_page_height -= min_whitespace_at_bottom_of_page (cached_line_details_.back ()); + + Real cur_height = cur_rod_height + ((ragged_last () || ragged ()) ? cur_spring_height : 0); + if (!too_few_lines (line_count - cached_line_details_.back ().compressed_nontitle_lines_count_) + && cur_height > cur_page_height + /* don't increase the page count if the last page had only one system */ + && cur_rod_height > cached_line_details_.back ().full_height ()) + ret++; + assert (ret <= cached_line_details_.size ()); + } - assert (ret <= cached_line_details_.size ()); return ret; } @@ -1069,21 +1275,13 @@ Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize Page_spacing_result Page_breaking::space_systems_on_best_pages (vsize configuration, vsize first_page_num) { - vsize min_p_count = min_page_count (configuration, first_page_num); + if (systems_per_page_ > 0) + return space_systems_with_fixed_number_per_page (configuration, first_page_num); cache_line_details (configuration); Page_spacer ps (cached_line_details_, first_page_num, this); - Page_spacing_result best = ps.solve (min_p_count); - for (vsize i = min_p_count+1; i <= cached_line_details_.size (); i++) - { - Page_spacing_result cur = ps.solve (i); - if (cur.demerits_ < best.demerits_) - best = cur; - } - - Page_spacing_result ret = finalize_spacing_result (configuration, best); - return ret; + return finalize_spacing_result (configuration, ps.solve ()); } Page_spacing_result @@ -1122,7 +1320,7 @@ Page_breaking::space_systems_with_fixed_number_per_page (vsize configuration, res.penalty_ += cached_line_details_[line-1].page_penalty_; if (system_count_on_this_page != systems_per_page_) { - res.penalty_ += TERRIBLE_SPACING_PENALTY; + res.penalty_ += abs (system_count_on_this_page - systems_per_page_) * TERRIBLE_SPACING_PENALTY; res.system_count_status_ |= ((system_count_on_this_page < systems_per_page_)) ? SYSTEM_COUNT_TOO_FEW : SYSTEM_COUNT_TOO_MANY; } @@ -1147,7 +1345,6 @@ Page_breaking::pack_systems_on_least_pages (vsize configuration, vsize first_pag Page_spacing space (page_height (first_page_num, false), this); cache_line_details (configuration); - compute_line_heights (); for (vsize line = 0; line < cached_line_details_.size (); line++) { Real prev_force = space.force_; @@ -1287,6 +1484,7 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n p1.systems_per_page_.push_back (p2.systems_per_page_[0]); p1.force_.push_back (p2.force_[0]); p1.penalty_ += p2.penalty_ - cached_line_details_[i].turn_penalty_; + p1.system_count_status_ |= p2.system_count_status_; return p1; } @@ -1415,7 +1613,7 @@ Page_breaking::min_whitespace_at_top_of_page (Line_details const &line) const { SCM first_system_spacing = book_->paper_->c_variable ("top-system-spacing"); if (line.title_) - first_system_spacing = book_->paper_->c_variable ("top-title-spacing"); + first_system_spacing = book_->paper_->c_variable ("top-markup-spacing"); Real min_distance = -infinity_f; Real padding = 0; @@ -1435,7 +1633,7 @@ Page_breaking::min_whitespace_at_top_of_page (Line_details const &line) const Real Page_breaking::min_whitespace_at_bottom_of_page (Line_details const &line) const { - SCM last_system_spacing = book_->paper_->c_variable ("bottom-system-spacing"); + SCM last_system_spacing = book_->paper_->c_variable ("last-bottom-spacing"); Real min_distance = -infinity_f; Real padding = 0;