X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpage-breaking.cc;h=252e24c5df61c2685d2b5ac415cc2292c4d7b9d5;hb=5bbfc22fce036b9b69df5e420de93e11da23c05e;hp=d5f71297b8390f4219969660a39c348c45f6c22b;hpb=55ac733b69643a6bc6a83b706c65cb56efd388ef;p=lilypond.git diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc index d5f71297b8..252e24c5df 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--2011 Joe Neeman + Copyright (C) 2006--2014 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" @@ -96,42 +152,50 @@ compress_lines (const vector &orig) for (vsize i = 0; i < orig.size (); i++) { if (ret.size () && !scm_is_symbol (ret.back ().page_permission_)) - { - Line_details const &old = ret.back (); - Line_details compressed = orig[i]; - /* - 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_; - - compressed.compressed_lines_count_ = old.compressed_lines_count_ + 1; - compressed.compressed_nontitle_lines_count_ = - old.compressed_nontitle_lines_count_ + (compressed.title_ ? 0 : 1); - - // compressed.title_ is true if and only if the first of its - // compressed lines was a title. - compressed.title_ = old.title_; - ret.back () = compressed; - } + { + Line_details const &old = ret.back (); + Line_details compressed = orig[i]; + /* + 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_; + + compressed.compressed_lines_count_ = old.compressed_lines_count_ + 1; + compressed.compressed_nontitle_lines_count_ + = old.compressed_nontitle_lines_count_ + (compressed.title_ ? 0 : 1); + + // compressed.title_ is true if and only if the first of its + // compressed lines was a title. + compressed.title_ = old.title_; + + // adds footnotes of one line to the footnotes of another + compressed.footnote_heights_.insert (compressed.footnote_heights_.begin (), + old.footnote_heights_.begin (), + old.footnote_heights_.end ()); + compressed.in_note_heights_.insert (compressed.in_note_heights_.begin (), + old.in_note_heights_.begin (), + old.in_note_heights_.end ()); + + ret.back () = compressed; + } else - { - ret.push_back (orig[i]); - ret.back ().force_ = 0; - } + { + ret.push_back (orig[i]); + } } return ret; } @@ -141,7 +205,7 @@ compress_lines (const vector &orig) */ static vector uncompress_solution (vector const &systems_per_page, - vector const &compressed) + vector const &compressed) { vector ret; vsize start_sys = 0; @@ -150,7 +214,7 @@ uncompress_solution (vector const &systems_per_page, { int compressed_count = 0; for (vsize j = start_sys; j < start_sys + systems_per_page[i]; j++) - compressed_count += compressed[j].compressed_lines_count_ - 1; + compressed_count += compressed[j].compressed_lines_count_ - 1; ret.push_back (systems_per_page[i] + compressed_count); start_sys += systems_per_page[i]; @@ -189,6 +253,24 @@ Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break, Prob_bre 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.is_empty ()) + { + 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); + in_note_padding_ = robust_scm2double (pb->paper_->c_variable ("in-note-padding"), 0.0); + footnote_footer_padding_ = robust_scm2double (pb->paper_->c_variable ("footnote-footer-padding"), 0.0); + + footnote_number_raise_ = robust_scm2double (pb->paper_->c_variable ("footnote-number-raise"), 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")); @@ -248,6 +330,36 @@ Page_breaking::system_count () const return system_count_; } +Real +Page_breaking::footnote_separator_stencil_height () const +{ + return footnote_separator_stencil_height_; +} + +Real +Page_breaking::in_note_padding () const +{ + return in_note_padding_; +} + +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 { @@ -285,10 +397,10 @@ Page_breaking::line_count_status (int line_count) const /* translate indices into breaks_ into start-end parameters for the line breaker */ void Page_breaking::line_breaker_args (vsize sys, - Break_position const &start, - Break_position const &end, - vsize *line_breaker_start, - vsize *line_breaker_end) + Break_position const &start, + Break_position const &end, + vsize *line_breaker_start, + vsize *line_breaker_end) { assert (system_specs_[sys].pscore_); assert (next_system (start) <= sys && sys <= end.system_spec_index_); @@ -306,7 +418,7 @@ Page_breaking::line_breaker_args (vsize sys, void Page_breaking::break_into_pieces (vsize start_break, vsize end_break, - Line_division const &div) + Line_division const &div) { vector chunks = chunk_list (start_break, end_break); bool ignore_div = false; @@ -320,16 +432,16 @@ Page_breaking::break_into_pieces (vsize start_break, vsize end_break, { vsize sys = next_system (chunks[i]); if (system_specs_[sys].pscore_) - { - vsize start; - vsize end; - line_breaker_args (sys, chunks[i], chunks[i+1], &start, &end); - - vector pos = ignore_div - ? line_breaking_[sys].best_solution (start, end) - : line_breaking_[sys].solve (start, end, div[i]); - system_specs_[sys].pscore_->root_system ()->break_into_pieces (pos); - } + { + vsize start; + vsize end; + line_breaker_args (sys, chunks[i], chunks[i + 1], &start, &end); + + vector pos = ignore_div + ? line_breaking_[sys].best_solution (start, end) + : line_breaking_[sys].solve (start, end, div[i]); + system_specs_[sys].pscore_->root_system ()->break_into_pieces (pos); + } } } @@ -340,20 +452,20 @@ Page_breaking::systems () for (vsize sys = 0; sys < system_specs_.size (); sys++) { if (system_specs_[sys].pscore_) - { - system_specs_[sys].pscore_->root_system () - ->do_break_substitution_and_fixup_refpoints (); - SCM lines = system_specs_[sys].pscore_->root_system () - ->get_broken_system_grobs (); - ret = scm_cons (lines, ret); - } + { + system_specs_[sys].pscore_->root_system () + ->do_break_substitution_and_fixup_refpoints (); + SCM lines = system_specs_[sys].pscore_->root_system () + ->get_broken_system_grobs (); + ret = scm_cons (lines, ret); + } else if (Prob *pb = system_specs_[sys].prob_) - { - ret = scm_cons (scm_list_1 (pb->self_scm ()), ret); - pb->unprotect (); - } + { + ret = scm_cons (scm_list_1 (pb->self_scm ()), ret); + pb->unprotect (); + } } - return scm_append (scm_reverse (ret)); + return scm_append (scm_reverse_x (ret, SCM_EOL)); } SCM @@ -366,11 +478,11 @@ Page_breaking::make_page (int page_num, bool last) const make_page_scm = scm_variable_ref (make_page_scm); return scm_apply_0 (make_page_scm, - scm_list_n (book_->self_scm (), - ly_symbol2scm ("page-number"), scm_from_int (page_num), - ly_symbol2scm ("is-last-bookpart"), scm_from_bool (last_part), - ly_symbol2scm ("is-bookpart-last-page"), scm_from_bool (last), - SCM_UNDEFINED)); + scm_list_n (book_->self_scm (), + ly_symbol2scm ("page-number"), scm_from_int (page_num), + ly_symbol2scm ("is-last-bookpart"), scm_from_bool (last_part), + ly_symbol2scm ("is-bookpart-last-page"), scm_from_bool (last), + SCM_UNDEFINED)); } // Returns the total height of the paper, including margins and @@ -391,7 +503,7 @@ Page_breaking::page_height (int page_num, bool last) const // 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_; + 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 @@ -405,11 +517,11 @@ Page_breaking::page_height (int page_num, bool last) const 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; - } + { + if ((int) cache.size () <= page_num) + cache.resize (page_num + 1, -1); + cache[page_num] = height; + } return height; } } @@ -439,28 +551,34 @@ Page_breaking::draw_page (SCM systems, SCM configuration, int page_num, bool las { // Create a stencil for each system. SCM paper_systems = SCM_EOL; - for (SCM s = scm_reverse (systems); scm_is_pair (s); s = scm_cdr (s)) + for (SCM s = systems; scm_is_pair (s); s = scm_cdr (s)) { SCM paper_system = scm_car (s); - if (Grob *g = unsmob_grob (scm_car (s))) - { - System *sys = dynamic_cast (g); - paper_system = sys->get_paper_system (); - } + if (Grob *g = Grob::unsmob (scm_car (s))) + { + System *sys = dynamic_cast (g); + paper_system = sys->get_paper_system (); + } paper_systems = scm_cons (paper_system, paper_systems); } + paper_systems = scm_reverse_x (paper_systems, SCM_EOL); // Create the page and draw it. SCM page = make_page (page_num, last); - SCM page_module = scm_c_resolve_module ("scm page"); - SCM page_stencil = scm_c_module_lookup (page_module, "page-stencil"); - page_stencil = scm_variable_ref (page_stencil); - Prob *p = unsmob_prob (page); + Prob *p = Prob::unsmob (page); p->set_property ("lines", paper_systems); p->set_property ("configuration", configuration); - scm_apply_1 (page_stencil, page, SCM_EOL); + + Stencil *foot_p = Stencil::unsmob (p->get_property ("foot-stencil")); + Stencil foot = foot_p ? *foot_p : Stencil (); + + SCM footnotes = Page_layout_problem::get_footnotes_from_lines (systems); + + foot = Page_layout_problem::add_footnotes_to_footer (footnotes, foot, book_); + + p->set_property ("foot-stencil", foot.smobbed_copy ()); return page; } @@ -474,17 +592,22 @@ Page_breaking::make_pages (vector lines_per_page, SCM systems) int first_page_number = robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1); SCM ret = SCM_EOL; + bool reset_footnotes_on_new_page = to_boolean (book_->top_paper ()->c_variable ("reset-footnotes-on-new-page")); SCM label_page_table = book_->top_paper ()->c_variable ("label-page-table"); if (label_page_table == SCM_UNDEFINED) label_page_table = SCM_EOL; - // Build a list of (systems . configuration) pairs. Note that we lay out - // the staves and find the configurations before drawing anything. Some + // Build a list of (systems configuration . footnote-count) triples. + // Note that we lay out the staves and find the configurations, + // but we do not draw anything in this function. It is important + // that all staves are laid out vertically before any are drawn; some // grobs (like tuplet brackets) look at their neighbours while drawing - // themselves. If this happens before the neighbouring staves have + // 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; + Real last_page_force = 0; for (vsize i = 0; i < lines_per_page.size (); i++) { @@ -493,38 +616,60 @@ 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); + int fn_lines = Page_layout_problem::get_footnote_count (lines); + Page_layout_problem::add_footnotes_to_lines (lines, reset_footnotes_on_new_page ? 0 : footnote_count, book_); + + SCM config = SCM_EOL; + SCM dummy_page = make_page (page_num, bookpart_last_page); + Page_layout_problem layout (book_, dummy_page, lines); + if (!scm_is_pair (systems)) + config = SCM_EOL; + else if (rag && !ragged ()) + // If we're ragged-last but not ragged, make the last page + // have the same force as the previous page. + config = layout.fixed_force_solution (last_page_force); + else + config = layout.solution (rag); + + if ((ragged () && layout.force () < 0.0) + || isinf (layout.force ())) + warning (_f ("page %d has been compressed", page_num)); + else + last_page_force = layout.force (); - systems_and_configs = scm_cons (scm_cons (lines, config), systems_and_configs); + systems_configs_fncounts = scm_cons (scm_cons (lines, config), systems_configs_fncounts); + footnote_count += fn_lines; systems = scm_list_tail (systems, line_count); } - // Now it's safe to make the pages. + // TODO: previously, the following loop caused the systems to be + // drawn. Now that we no longer draw anything in Page_breaking, + // it is safe to merge these two loops. 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); + bool bookpart_last_page = (s == systems_configs_fncounts); + SCM page = draw_page (lines, config, page_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)) - { - SCM labels = SCM_EOL; - if (Grob * line = unsmob_grob (scm_car (l))) - { - System *system = dynamic_cast (line); - labels = system->get_property ("labels"); - } - else if (Prob *prob = unsmob_prob (scm_car (l))) - labels = prob->get_property ("labels"); - - for (SCM lbls = labels ; scm_is_pair (lbls) ; lbls = scm_cdr (lbls)) - label_page_table = scm_cons (scm_cons (scm_car (lbls), page_num_scm), - label_page_table); - } + for (SCM l = lines; scm_is_pair (l); l = scm_cdr (l)) + { + SCM labels = SCM_EOL; + if (Grob *line = Grob::unsmob (scm_car (l))) + { + System *system = dynamic_cast (line); + labels = system->get_property ("labels"); + } + else if (Prob *prob = Prob::unsmob (scm_car (l))) + labels = prob->get_property ("labels"); + + for (SCM lbls = labels; scm_is_pair (lbls); lbls = scm_cdr (lbls)) + label_page_table = scm_cons (scm_cons (scm_car (lbls), page_num_scm), + label_page_table); + } ret = scm_cons (page, ret); --page_num; @@ -538,27 +683,19 @@ Page_breaking::make_pages (vector lines_per_page, SCM systems) return ret; } -/* The page-turn-page-breaker needs to have a line-breaker between any two - columns with non-NULL page-turn-permission. - - The optimal-breaker needs to have a line-breaker between any two columns - with page-break-permission = 'force. - - By using a grob predicate, we can accommodate both of these uses. -*/ void Page_breaking::create_system_list () { SCM specs = book_->get_system_specs (); for (SCM s = specs; scm_is_pair (s); s = scm_cdr (s)) { - if (Paper_score *ps = dynamic_cast (unsmob_music_output (scm_car (s)))) - { - system_specs_.push_back (System_spec (ps)); - } + if (Paper_score *ps = dynamic_cast (Music_output::unsmob (scm_car (s)))) + { + system_specs_.push_back (System_spec (ps)); + } else { - Prob *pb = unsmob_prob (scm_car (s)); + Prob *pb = Prob::unsmob (scm_car (s)); assert (pb); pb->protect (); @@ -569,6 +706,14 @@ Page_breaking::create_system_list () system_specs_.push_back (System_spec ()); } +/* The page-turn-page-breaker needs to have a line-breaker between any two + columns with non-NULL page-turn-permission. + + The optimal-breaker needs to have a line-breaker between any two columns + with page-break-permission = 'force. + + By using a grob predicate, we can accommodate both of these uses. +*/ void Page_breaking::find_chunks_and_breaks (Break_predicate is_break, Prob_break_predicate prob_is_break) { @@ -580,81 +725,81 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break, Prob_break_pred for (vsize i = 0; i < system_specs_.size (); i++) { if (system_specs_[i].pscore_) - { - 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)) - { - // With system-count given, the line configuration for - // this score is fixed. We need to ensure that chunk - // boundaries only occur at line breaks. - Constrained_breaking breaking (system_specs_[i].pscore_); - vector details = breaking.line_details (0, VPOS, scm_to_int (system_count)); - - for (vsize j = 0; j < details.size (); j++) - forced_line_break_cols.push_back (details[j].last_column_); - } - - 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 && 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 (), - cols[j], - last); - - // NOTE: even in the breaks_ list, forced_line_count_ - // refers to the number of lines between a - // Break_position and the start of that /chunk/. This - // is needed for system_count_bounds to work correctly, - // since it mixes Break_positions from breaks_ and - // chunks_. - if (scm_is_number (system_count)) - 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_forced_line_break_idx = forced_line_break_idx; - } - - if ((break_point || chunk_end) && !last) - line_breaker_columns.push_back (j); - } - line_breaking_.push_back (Constrained_breaking (system_specs_[i].pscore_, line_breaker_columns)); - } + { + 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)) + { + // With system-count given, the line configuration for + // this score is fixed. We need to ensure that chunk + // boundaries only occur at line breaks. + Constrained_breaking breaking (system_specs_[i].pscore_); + vector details = breaking.line_details (0, VPOS, scm_to_int (system_count)); + + for (vsize j = 0; j < details.size (); j++) + forced_line_break_cols.push_back (details[j].last_column_); + } + + 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 && 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 (), + cols[j], + last); + + // NOTE: even in the breaks_ list, forced_line_count_ + // refers to the number of lines between a + // Break_position and the start of that /chunk/. This + // is needed for system_count_bounds to work correctly, + // since it mixes Break_positions from breaks_ and + // chunks_. + if (scm_is_number (system_count)) + 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_forced_line_break_idx = forced_line_break_idx; + } + + if ((break_point || chunk_end) && !last) + line_breaker_columns.push_back (j); + } + line_breaking_.push_back (Constrained_breaking (system_specs_[i].pscore_, line_breaker_columns)); + } else if (system_specs_[i].prob_) - { - 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)); + { + 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)); + chunks_.push_back (Break_position (i)); - /* FIXME: shouldn't we push a Null_breaker or similar dummy - class? --hwn */ - line_breaking_.push_back (Constrained_breaking (NULL)); - } + /* FIXME: shouldn't we push a Null_breaker or similar dummy + class? --hwn */ + line_breaking_.push_back (Constrained_breaking (NULL)); + } } } @@ -707,7 +852,7 @@ Page_breaking::max_system_count (vsize start, vsize end) // per chunk. Page_breaking::Line_division Page_breaking::system_count_bounds (vector const &chunks, - bool min) + bool min) { assert (chunks.size () >= 2); @@ -718,17 +863,17 @@ Page_breaking::system_count_bounds (vector const &chunks, { vsize sys = next_system (chunks[i]); - if (chunks[i+1].forced_line_count_) - ret[i] = chunks[i+1].forced_line_count_; + if (chunks[i + 1].forced_line_count_) + ret[i] = chunks[i + 1].forced_line_count_; else if (system_specs_[sys].pscore_) - { - vsize start; - vsize end; - line_breaker_args (sys, chunks[i], chunks[i+1], &start, &end); - ret[i] = min - ? line_breaking_[sys].min_system_count (start, end) - : line_breaking_[sys].max_system_count (start, end); - } + { + vsize start; + vsize end; + line_breaker_args (sys, chunks[i], chunks[i + 1], &start, &end); + ret[i] = min + ? line_breaking_[sys].min_system_count (start, end) + : line_breaking_[sys].max_system_count (start, end); + } } return ret; @@ -736,10 +881,10 @@ Page_breaking::system_count_bounds (vector const &chunks, void Page_breaking::set_current_breakpoints (vsize start, - vsize end, - vsize system_count, - Line_division lower_bound, - Line_division upper_bound) + vsize end, + vsize system_count, + Line_division lower_bound, + Line_division upper_bound) { system_count_ = system_count; current_chunks_ = chunk_list (start, end); @@ -758,32 +903,32 @@ Page_breaking::set_current_breakpoints (vsize start, Line_division work_in_progress; current_configurations_.clear (); line_divisions_rec (system_count, - lower_bound, - upper_bound, - &work_in_progress); + lower_bound, + upper_bound, + &work_in_progress); /* we only consider a constant number of configurations. Otherwise, this becomes slow when there are many small scores. The constant 5 is somewhat arbitrary. */ if (current_configurations_.size () > 5) { - vector > dems_and_indices; + vector > dems_and_indices; for (vsize i = 0; i < current_configurations_.size (); i++) - { - cache_line_details (i); - Real dem = 0; - for (vsize j = 0; j < cached_line_details_.size (); j++) - dem += cached_line_details_[j].force_ * cached_line_details_[j].force_ - + cached_line_details_[j].break_penalty_; + { + cache_line_details (i); + Real dem = 0; + for (vsize j = 0; j < cached_line_details_.size (); j++) + dem += cached_line_details_[j].force_ * cached_line_details_[j].force_ + + cached_line_details_[j].break_penalty_; - dems_and_indices.push_back (pair (dem, i)); - } - vector_sort (dems_and_indices, less > ()); + dems_and_indices.push_back (pair (dem, i)); + } + vector_sort (dems_and_indices, less > ()); vector best_5_configurations; for (vsize i = 0; i < 5; i++) - best_5_configurations.push_back (current_configurations_[dems_and_indices[i].second]); + best_5_configurations.push_back (current_configurations_[dems_and_indices[i].second]); clear_line_details_cache (); current_configurations_ = best_5_configurations; @@ -800,19 +945,19 @@ Page_breaking::set_to_ideal_line_configuration (vsize start, vsize end) system_count_ = 0; Line_division div; - for (vsize i = 0; i+1 < current_chunks_.size (); i++) + for (vsize i = 0; i + 1 < current_chunks_.size (); i++) { vsize sys = next_system (current_chunks_[i]); - if (current_chunks_[i+1].forced_line_count_) - div.push_back (current_chunks_[i+1].forced_line_count_); + if (current_chunks_[i + 1].forced_line_count_) + div.push_back (current_chunks_[i + 1].forced_line_count_); else if (system_specs_[sys].pscore_) - { - line_breaker_args (sys, current_chunks_[i], current_chunks_[i+1], &start, &end); - div.push_back (line_breaking_[sys].best_solution (start, end).size ()); - } + { + line_breaker_args (sys, current_chunks_[i], current_chunks_[i + 1], &start, &end); + div.push_back (line_breaking_[sys].best_solution (start, end).size ()); + } else - div.push_back (0); + div.push_back (0); system_count_ += div.back (); } @@ -836,25 +981,25 @@ Page_breaking::cache_line_details (vsize configuration_index) Line_division &div = current_configurations_[configuration_index]; uncompressed_line_details_.clear (); for (vsize i = 0; i + 1 < current_chunks_.size (); i++) - { - vsize sys = next_system (current_chunks_[i]); - if (system_specs_[sys].pscore_) - { - vsize start; - vsize end; - line_breaker_args (sys, current_chunks_[i], current_chunks_[i+1], &start, &end); - - vector details = line_breaking_[sys].line_details (start, end, div[i]); - uncompressed_line_details_.insert (uncompressed_line_details_.end (), details.begin (), details.end ()); - } - else - { - assert (div[i] == 0); - uncompressed_line_details_.push_back (system_specs_[sys].prob_ - ? Line_details (system_specs_[sys].prob_, book_->paper_) - : Line_details ()); - } - } + { + vsize sys = next_system (current_chunks_[i]); + if (system_specs_[sys].pscore_) + { + vsize start; + vsize end; + line_breaker_args (sys, current_chunks_[i], current_chunks_[i + 1], &start, &end); + + vector details = line_breaking_[sys].line_details (start, end, div[i]); + uncompressed_line_details_.insert (uncompressed_line_details_.end (), details.begin (), details.end ()); + } + else + { + 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 (); } @@ -870,9 +1015,9 @@ Page_breaking::clear_line_details_cache () void Page_breaking::line_divisions_rec (vsize system_count, - Line_division const &min_sys, - Line_division const &max_sys, - Line_division *cur_division) + Line_division const &min_sys, + Line_division const &max_sys, + Line_division *cur_division) { vsize my_index = cur_division->size (); int others_min = 0; @@ -890,8 +1035,8 @@ Page_breaking::line_divisions_rec (vsize system_count, 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 - and we should return an empty result */ + at all, it means that we were called with an unsolvable problem + and we should return an empty result */ assert (my_index == 0); return; } @@ -900,7 +1045,7 @@ Page_breaking::line_divisions_rec (vsize system_count, { cur_division->push_back (i); if (my_index == min_sys.size () - 1) - current_configurations_.push_back (*cur_division); + current_configurations_.push_back (*cur_division); else line_divisions_rec (system_count - i, min_sys, max_sys, cur_division); cur_division->pop_back (); @@ -920,7 +1065,7 @@ Page_breaking::compute_line_heights () Real prev_refpoint_hanging = 0; for (vsize i = 0; i < cached_line_details_.size (); i++) { - Line_details& cur = cached_line_details_[i]; + Line_details &cur = cached_line_details_[i]; Line_shape shape = cur.shape_; Real a = shape.begin_[UP]; Real b = shape.rest_[UP]; @@ -928,20 +1073,20 @@ Page_breaking::compute_line_heights () 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 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]; @@ -972,40 +1117,40 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) for (vsize i = 0; i < cached_line_details_.size (); i++) { Line_details const &cur = cached_line_details_[i]; - Line_details const *const prev = (i > 0) ? &cached_line_details_[i-1] : 0; + Line_details const *const prev = (i > 0) ? &cached_line_details_[i - 1] : 0; Real ext_len; if (cur_rod_height > 0) - ext_len = cur.tallness_; + ext_len = cur.tallness_; else - ext_len = cur.full_height(); + 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 (cur); + + 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) - || (prev && prev->page_permission_ == ly_symbol2scm ("force"))) - { - 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 (cur); - - ret++; - } + || too_many_lines (next_line_count) + || (prev && prev->page_permission_ == ly_symbol2scm ("force"))) + { + 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 (cur); + + ret++; + } else - { - cur_rod_height = next_rod_height; - cur_spring_height = next_spring_height; - line_count = next_line_count; - } + { + cur_rod_height = next_rod_height; + cur_spring_height = next_spring_height; + line_count = next_line_count; + } } /* there are two potential problems with the last page (because we didn't know @@ -1027,12 +1172,11 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num) 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++; + && cur_rod_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 ()); } @@ -1056,15 +1200,15 @@ Page_breaking::space_systems_on_n_pages (vsize configuration, vsize n, vsize fir cache_line_details (configuration); bool valid_n = (n >= min_page_count (configuration, first_page_num) - && n <= cached_line_details_.size ()); + && n <= cached_line_details_.size ()); if (!valid_n) programming_error ("number of pages is out of bounds"); if (n == 1 && valid_n) ret = space_systems_on_1_page (cached_line_details_, - page_height (first_page_num, is_last ()), - ragged () || (is_last () && ragged_last ())); + page_height (first_page_num, is_last ()), + ragged () || (is_last () && ragged_last ())); else if (n == 2 && valid_n) ret = space_systems_on_2_pages (configuration, first_page_num); else @@ -1082,11 +1226,11 @@ Page_breaking::blank_page_penalty () const SCM penalty_sym; if (is_last ()) - penalty_sym = ly_symbol2scm ("blank-last-page-force"); + penalty_sym = ly_symbol2scm ("blank-last-page-penalty"); else if (ends_score ()) - penalty_sym = ly_symbol2scm ("blank-after-score-page-force"); + penalty_sym = ly_symbol2scm ("blank-after-score-page-penalty"); else - penalty_sym = ly_symbol2scm ("blank-page-force"); + penalty_sym = ly_symbol2scm ("blank-page-penalty"); Break_position const &pos = breaks_[current_end_breakpoint_]; if (Paper_score *ps = system_specs_[pos.system_spec_index_].pscore_) @@ -1099,7 +1243,7 @@ Page_breaking::blank_page_penalty () const // or N+1 pages; see the comment to space_systems_on_n_pages. Page_spacing_result Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize n, vsize first_page_num, - Real penalty_for_fewer_pages) + Real penalty_for_fewer_pages) { Page_spacing_result n_res; Page_spacing_result m_res; @@ -1107,7 +1251,7 @@ Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize if (systems_per_page_ > 0) { Page_spacing_result ret = space_systems_with_fixed_number_per_page (configuration, first_page_num); - ret.demerits_ += (ret.force_.size () == n || ret.force_.size () == (n-1)) ? 0 : BAD_SPACING_PENALTY; + ret.demerits_ += (ret.force_.size () == n || ret.force_.size () == (n - 1)) ? 0 : BAD_SPACING_PENALTY; return ret; } @@ -1124,18 +1268,18 @@ Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize Real height = page_height (first_page_num, is_last ()); if (1 >= min_p_count) - n_res = space_systems_on_1_page (cached_line_details_, height, rag); + n_res = space_systems_on_1_page (cached_line_details_, height, rag); if (1 < cached_line_details_.size ()) - m_res = space_systems_on_2_pages (configuration, first_page_num); + m_res = space_systems_on_2_pages (configuration, first_page_num); } else { Page_spacer ps (cached_line_details_, first_page_num, this); - + if (n >= min_p_count || !valid_n) - n_res = ps.solve (n); + n_res = ps.solve (n); if (n < cached_line_details_.size () || !valid_n) - m_res = ps.solve (n+1); + m_res = ps.solve (n + 1); } m_res = finalize_spacing_result (configuration, m_res); @@ -1164,7 +1308,7 @@ Page_breaking::space_systems_on_best_pages (vsize configuration, vsize first_pag Page_spacing_result Page_breaking::space_systems_with_fixed_number_per_page (vsize configuration, - vsize first_page_num) + vsize first_page_num) { Page_spacing_result res; Page_spacing space (page_height (first_page_num, false), this); @@ -1181,27 +1325,27 @@ Page_breaking::space_systems_with_fixed_number_per_page (vsize configuration, int system_count_on_this_page = 0; while (system_count_on_this_page < systems_per_page_ - && line < cached_line_details_.size ()) - { - Line_details const &cur_line = cached_line_details_[line]; - space.append_system (cur_line); - system_count_on_this_page += cur_line.compressed_nontitle_lines_count_; - line++; + && line < cached_line_details_.size ()) + { + Line_details const &cur_line = cached_line_details_[line]; + space.append_system (cur_line); + system_count_on_this_page += cur_line.compressed_nontitle_lines_count_; + line++; - if (cur_line.page_permission_ == ly_symbol2scm ("force")) - break; - } + if (cur_line.page_permission_ == ly_symbol2scm ("force")) + break; + } res.systems_per_page_.push_back (line - page_first_line); res.force_.push_back (space.force_); - res.penalty_ += cached_line_details_[line-1].page_penalty_; + res.penalty_ += cached_line_details_[line - 1].page_penalty_; if (system_count_on_this_page != systems_per_page_) - { - 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; - } + { + 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; + } page_first_line = line; } @@ -1228,47 +1372,47 @@ Page_breaking::pack_systems_on_least_pages (vsize configuration, vsize first_pag Real prev_force = space.force_; space.append_system (cached_line_details_[line]); if ((line > page_first_line) - && (isinf (space.force_) - || ((line > 0) - && (cached_line_details_[line-1].page_permission_ == ly_symbol2scm ("force"))))) - { - res.systems_per_page_.push_back (line - page_first_line); - res.force_.push_back (prev_force); - res.penalty_ += cached_line_details_[line-1].page_penalty_; - page++; - space.resize (page_height (first_page_num + page, false)); - space.clear (); + && (isinf (space.force_) + || ((line > 0) + && (cached_line_details_[line - 1].page_permission_ == ly_symbol2scm ("force"))))) + { + res.systems_per_page_.push_back (line - page_first_line); + res.force_.push_back (prev_force); + res.penalty_ += cached_line_details_[line - 1].page_penalty_; + page++; + space.resize (page_height (first_page_num + page, false)); + space.clear (); space.append_system (cached_line_details_[line]); - page_first_line = line; - } + page_first_line = line; + } if (line == cached_line_details_.size () - 1) - { - /* This is the last line */ - /* When the last page height was computed, we did not know yet that it - * was the last one. If the systems put on it don't fit anymore, the last - * system is moved to a new page */ - space.resize (page_height (first_page_num + page, true)); - if ((line > page_first_line) && (isinf (space.force_))) - { - res.systems_per_page_.push_back (line - page_first_line); - res.force_.push_back (prev_force); - /* the last page containing the last line */ - space.resize (page_height (first_page_num + page + 1, true)); - space.clear (); - space.append_system (cached_line_details_[line]); - res.systems_per_page_.push_back (1); - res.force_.push_back (space.force_); - res.penalty_ += cached_line_details_[line-1].page_penalty_; + { + /* This is the last line */ + /* When the last page height was computed, we did not know yet that it + * was the last one. If the systems put on it don't fit anymore, the last + * system is moved to a new page */ + space.resize (page_height (first_page_num + page, true)); + if ((line > page_first_line) && (isinf (space.force_))) + { + res.systems_per_page_.push_back (line - page_first_line); + res.force_.push_back (prev_force); + /* the last page containing the last line */ + space.resize (page_height (first_page_num + page + 1, true)); + space.clear (); + space.append_system (cached_line_details_[line]); + res.systems_per_page_.push_back (1); + res.force_.push_back (space.force_); + res.penalty_ += cached_line_details_[line - 1].page_penalty_; res.penalty_ += cached_line_details_[line].page_penalty_; - } - else - { - res.systems_per_page_.push_back (line + 1 - page_first_line); - res.force_.push_back (space.force_); + } + else + { + res.systems_per_page_.push_back (line + 1 - page_first_line); + res.force_.push_back (space.force_); res.penalty_ += cached_line_details_[line].page_penalty_; - } - } + } + } } return finalize_spacing_result (configuration, res); } @@ -1295,11 +1439,13 @@ Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result line_penalty += uncompressed_line_details_[i].break_penalty_; } - for (vsize i = 0; i < res.force_.size (); i++) + for (vsize i = ragged () ? res.force_.size () - 1 : 0; + i < res.force_.size () - ragged_last (); + i++) { Real f = res.force_[i]; - page_demerits += min(f*f, BAD_SPACING_PENALTY); + page_demerits += min (f * f, BAD_SPACING_PENALTY); } /* for a while we tried averaging page and line forces across pages instead @@ -1354,16 +1500,16 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n for (vsize i = 0; i + 1 < cached_line_details_.size (); i++) if (cached_line_details_[i].page_permission_ == ly_symbol2scm ("force")) { - vector lines1 (cached_line_details_.begin (), cached_line_details_.begin () + i + 1); - vector lines2 (cached_line_details_.begin () + i + 1, cached_line_details_.end ()); - Page_spacing_result p1 = space_systems_on_1_page (lines1, page1_height, ragged1); - Page_spacing_result p2 = space_systems_on_1_page (lines2, page2_height, ragged2); - - 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; + vector lines1 (cached_line_details_.begin (), cached_line_details_.begin () + i + 1); + vector lines2 (cached_line_details_.begin () + i + 1, cached_line_details_.end ()); + Page_spacing_result p1 = space_systems_on_1_page (lines1, page1_height, ragged1); + Page_spacing_result p2 = space_systems_on_1_page (lines2, page2_height, ragged2); + + 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; } vector page1_force; @@ -1403,11 +1549,13 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n page1_penalty[i] = line_count_penalty (page1_line_count); page1_status[i] = line_count_status (page1_line_count); - if (ragged2) - page2_force[page2_force.size () - 1 - i] = - (page2.force_ < 0 && i + 1 < page1_force.size ()) ? infinity_f : 0; + if (ragged1) + page2_force[page2_force.size () - 1 - i] + = (page2.force_ < 0 && i + 1 < page1_force.size ()) ? infinity_f : 0; + else if (ragged2 && page2.force_ > 0) + page2_force[page2_force.size () - 1 - i] = 0.0; else - page2_force[page2_force.size () - 1 - i] = page2.force_; + page2_force[page2_force.size () - 1 - i] = page2.force_; page2_penalty[page2_penalty.size () - 1 - i] = line_count_penalty (page2_line_count); page2_status[page2_penalty.size () - 1 - i] = line_count_status (page2_line_count); } @@ -1423,26 +1571,26 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n // constraints. That is, we penalize harshly when they don't happen // but we don't completely reject. Real dem = f - + page1_penalty[i] + page2_penalty[i] - + cached_line_details_[i+1].page_penalty_ - + cached_line_details_.back ().page_penalty_ + cached_line_details_.back ().turn_penalty_; + + page1_penalty[i] + page2_penalty[i] + + cached_line_details_[i + 1].page_penalty_ + + cached_line_details_.back ().page_penalty_ + cached_line_details_.back ().turn_penalty_; if (dem < best_demerits) - { - best_demerits = dem; - best_sys_count = i+1; - } + { + best_demerits = dem; + best_sys_count = i + 1; + } } Page_spacing_result ret; ret.systems_per_page_.push_back (best_sys_count); ret.systems_per_page_.push_back (cached_line_details_.size () - best_sys_count); - ret.force_.push_back (page1_force[best_sys_count-1]); - ret.force_.push_back (page2_force[best_sys_count-1]); - ret.system_count_status_ = page1_status[best_sys_count-1] | page2_status[best_sys_count-1]; - ret.penalty_ = cached_line_details_[best_sys_count-1].page_penalty_ - + cached_line_details_.back ().page_penalty_ - + cached_line_details_.back ().turn_penalty_ - + page1_penalty[best_sys_count-1] + page2_penalty[best_sys_count-1]; + ret.force_.push_back (page1_force[best_sys_count - 1]); + ret.force_.push_back (page2_force[best_sys_count - 1]); + ret.system_count_status_ = page1_status[best_sys_count - 1] | page2_status[best_sys_count - 1]; + ret.penalty_ = cached_line_details_[best_sys_count - 1].page_penalty_ + + cached_line_details_.back ().page_penalty_ + + cached_line_details_.back ().turn_penalty_ + + page1_penalty[best_sys_count - 1] + page2_penalty[best_sys_count - 1]; /* don't do finalize_spacing_result () because we are only an internal function */ return ret; @@ -1480,7 +1628,7 @@ Page_breaking::ends_score () const vsize Page_breaking::last_break_position () const { - return breaks_.size () - 1; + return breaks_.size () - 1; } // This gives the minimum distance between the top of the @@ -1497,11 +1645,11 @@ Page_breaking::min_whitespace_at_top_of_page (Line_details const &line) const Real padding = 0; Page_layout_problem::read_spacing_spec (first_system_spacing, - &min_distance, - ly_symbol2scm ("minimum-distance")); + &min_distance, + ly_symbol2scm ("minimum-distance")); Page_layout_problem::read_spacing_spec (first_system_spacing, - &padding, - ly_symbol2scm ("padding")); + &padding, + ly_symbol2scm ("padding")); // FIXME: take into account the height of the header Real translate = max (line.shape_.begin_[UP], line.shape_.rest_[UP]); @@ -1516,11 +1664,11 @@ Page_breaking::min_whitespace_at_bottom_of_page (Line_details const &line) const Real padding = 0; Page_layout_problem::read_spacing_spec (last_system_spacing, - &min_distance, - ly_symbol2scm ("minimum-distance")); + &min_distance, + ly_symbol2scm ("minimum-distance")); Page_layout_problem::read_spacing_spec (last_system_spacing, - &padding, - ly_symbol2scm ("padding")); + &padding, + ly_symbol2scm ("padding")); // FIXME: take into account the height of the footer Real translate = min (line.shape_.begin_[DOWN], line.shape_.rest_[DOWN]);