X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpage-breaking.cc;h=fe1d163658a548f7a59489c348bf3eadb8ea91cf;hb=d873e86e58792e7d4fc743365338e385677233da;hp=3272e02eefbb3471efab3be5e04a8ed28a11683f;hpb=35d76f132990937989036d9a88f03def876b9600;p=lilypond.git diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc index 3272e02eef..fe1d163658 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" @@ -124,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 @@ -189,6 +250,21 @@ 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) + { + 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); + 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")); @@ -229,12 +305,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_; } @@ -244,6 +324,24 @@ 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_; +} + bool Page_breaking::too_many_lines (int line_count) const { @@ -456,6 +554,12 @@ 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")); + SCM footnotes = Page_layout_problem::get_footnotes_from_lines (systems, footnote_padding ()); + Page_layout_problem::add_footnotes_to_footer (footnotes, foot, unsmob_paper_book (p->get_property ("paper-book"))); + + p->set_property ("foot-stencil", foot->smobbed_copy ()); scm_apply_1 (page_stencil, page, SCM_EOL); return page; @@ -501,6 +605,7 @@ Page_breaking::make_pages (vector lines_per_page, SCM systems) { 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); @@ -525,6 +630,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; } @@ -667,6 +777,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) { @@ -679,6 +790,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) { @@ -691,6 +803,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) @@ -698,7 +813,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++) { @@ -798,7 +913,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 (); } @@ -835,7 +950,7 @@ Page_breaking::cache_line_details (vsize configuration_index) } else { - assert (div[i] == 1); + assert (div[i] == 0); uncompressed_line_details_.push_back (system_specs_[sys].prob_ ? Line_details (system_specs_[sys].prob_, book_->paper_) : Line_details ()); @@ -873,7 +988,7 @@ Page_breaking::line_divisions_rec (vsize 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 @@ -957,30 +1072,32 @@ 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; Real ext_len; if (cur_rod_height > 0) - ext_len = cached_line_details_[i].tallness_; + ext_len = cur.tallness_; else - ext_len = cached_line_details_[i].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 + cached_line_details_[i].space_; + 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++; } @@ -1182,7 +1299,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; }