source file of the GNU LilyPond music typesetter
- (c) 2006--2007 Joe Neeman <joeneeman@gmail.com>
+ (c) 2006--2009 Joe Neeman <joeneeman@gmail.com>
*/
#include "page-breaking.hh"
#include "system.hh"
#include "warn.hh"
-/* for each forbidden page break, merge the systems around it into one system. */
+/* for each forbidden page break, merge the systems around it into one
+ system. */
static vector<Line_details>
compress_lines (const vector<Line_details> &orig)
{
compressed.space_ += old.space_;
compressed.inverse_hooke_ += old.inverse_hooke_;
- /* we don't need the force_ field for the vertical spacing,
- so we use force_ = n to signal that the line was compressed,
- reducing the number of lines by n (and force_ = 0 otherwise).
- This makes uncompression much easier. */
- compressed.force_ = old.force_ + 1;
+ 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_ = compressed.title_ && old.title_;
ret.back () = compressed;
}
else
{
int compressed_count = 0;
for (vsize j = start_sys; j < start_sys + systems_per_page[i]; j++)
- compressed_count += (int)compressed[j].force_;
+ compressed_count += compressed[j].compressed_lines_count_ - 1;
ret.push_back (systems_per_page[i] + compressed_count);
start_sys += systems_per_page[i];
vsize
Page_breaking::next_system (Break_position const &break_pos) const
{
- vsize sys = break_pos.sys_;
+ vsize sys = break_pos.system_spec_index_;
if (sys == VPOS) /* beginning of the book */
return 0;
- if (all_[sys].pscore_ && !break_pos.score_ender_)
+ if (system_specs_[sys].pscore_ && !break_pos.score_ender_)
return sys; /* the score overflows the previous page */
- return sys + 1; /* this page starts with a new sys */
+ return sys + 1; /* this page starts with a new System_spec */
}
Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break)
{
book_ = pb;
- ragged_ = to_boolean (pb->paper_->c_variable ("ragged"));
- ragged_last_ = to_boolean (pb->paper_->c_variable ("ragged-last"));
+ system_count_ = 0;
+ ragged_ = to_boolean (pb->paper_->c_variable ("ragged-bottom"));
+ ragged_last_ = to_boolean (pb->paper_->c_variable ("ragged-last-bottom"));
+ page_top_space_ = robust_scm2double (pb->paper_->c_variable ("page-top-space"), 0);
+ systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("systems-per-page"), 0));
+ max_systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("max-systems-per-page"), 0));
+ min_systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("min-systems-per-page"), 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"));
+ min_systems_per_page_ = max_systems_per_page_ = 0;
+ }
+ if (max_systems_per_page_ && min_systems_per_page_ > max_systems_per_page_)
+ {
+ warning (_f ("min-systems-per-page is larger than max-systems-per-page, ignoring both values"));
+ min_systems_per_page_ = max_systems_per_page_ = 0;
+ }
+
create_system_list ();
find_chunks_and_breaks (is_break);
}
return ragged_last_;
}
+int
+Page_breaking::systems_per_page () const
+{
+ return systems_per_page_;
+}
+
+int
+Page_breaking::max_systems_per_page () const
+{
+ return max_systems_per_page_;
+}
+
+int
+Page_breaking::min_systems_per_page () const
+{
+ return min_systems_per_page_;
+}
+
+Real
+Page_breaking::page_top_space () const
+{
+ return page_top_space_;
+}
+
+vsize
+Page_breaking::system_count () const
+{
+ return system_count_;
+}
+
+bool
+Page_breaking::too_many_lines (int line_count) const
+{
+ return max_systems_per_page () > 0 && line_count > max_systems_per_page ();
+}
+
+bool
+Page_breaking::too_few_lines (int line_count) const
+{
+ return line_count < min_systems_per_page ();
+}
+
+Real
+Page_breaking::line_count_penalty (int line_count) const
+{
+ if (too_many_lines (line_count))
+ return (line_count - max_systems_per_page ()) * TERRIBLE_SPACING_PENALTY;
+ if (too_few_lines (line_count))
+ return (min_systems_per_page () - line_count) * TERRIBLE_SPACING_PENALTY;
+
+ return 0;
+}
+
+int
+Page_breaking::line_count_status (int line_count) const
+{
+ if (too_many_lines (line_count))
+ return SYSTEM_COUNT_TOO_MANY;
+ if (too_few_lines (line_count))
+ return SYSTEM_COUNT_TOO_FEW;
+
+ return SYSTEM_COUNT_OK;
+}
+
/* translate indices into breaks_ into start-end parameters for the line breaker */
void
Page_breaking::line_breaker_args (vsize sys,
vsize *line_breaker_start,
vsize *line_breaker_end)
{
- assert (all_[sys].pscore_);
- assert (next_system (start) <= sys && sys <= end.sys_);
+ assert (system_specs_[sys].pscore_);
+ assert (next_system (start) <= sys && sys <= end.system_spec_index_);
- if (start.sys_ == sys)
+ if (start.system_spec_index_ == sys)
*line_breaker_start = start.score_break_;
else
*line_breaker_start = 0;
- if (end.sys_ == sys)
+ if (end.system_spec_index_ == sys)
*line_breaker_end = end.score_break_;
else
*line_breaker_end = VPOS;
}
void
-Page_breaking::break_into_pieces (vsize start_break, vsize end_break, Line_division const &div)
+Page_breaking::break_into_pieces (vsize start_break, vsize end_break,
+ Line_division const &div)
{
vector<Break_position> chunks = chunk_list (start_break, end_break);
bool ignore_div = false;
for (vsize i = 0; i + 1 < chunks.size (); i++)
{
vsize sys = next_system (chunks[i]);
- if (all_[sys].pscore_)
+ if (system_specs_[sys].pscore_)
{
vsize start;
vsize end;
vector<Column_x_positions> pos = ignore_div
? line_breaking_[sys].best_solution (start, end)
: line_breaking_[sys].solve (start, end, div[i]);
- all_[sys].pscore_->root_system ()->break_into_pieces (pos);
+ system_specs_[sys].pscore_->root_system ()->break_into_pieces (pos);
}
}
}
Page_breaking::systems ()
{
SCM ret = SCM_EOL;
- for (vsize sys = 0; sys < all_.size (); sys++)
+ for (vsize sys = 0; sys < system_specs_.size (); sys++)
{
- if (all_[sys].pscore_)
+ if (system_specs_[sys].pscore_)
{
- all_[sys].pscore_->root_system ()->do_break_substitution_and_fixup_refpoints ();
- SCM lines = all_[sys].pscore_->root_system ()->get_broken_system_grobs ();
+ 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
{
- Prob *pb = all_[sys].prob_;
+ Prob *pb = system_specs_[sys].prob_;
ret = scm_cons (scm_list_1 (pb->self_scm ()), ret);
pb->unprotect ();
}
Real
Page_breaking::page_height (int page_num, bool last) const
{
+ bool last_part = ly_scm2bool (book_->paper_->c_variable ("is-last-bookpart"));
SCM mod = scm_c_resolve_module ("scm page");
SCM calc_height = scm_c_module_lookup (mod, "calc-printable-height");
SCM make_page = scm_c_module_lookup (mod, "make-page");
SCM page = scm_apply_0 (make_page, scm_list_n (
book_->self_scm (),
ly_symbol2scm ("page-number"), scm_from_int (page_num),
- ly_symbol2scm ("is-last"), scm_from_bool (last),
+ ly_symbol2scm ("is-last-bookpart"), scm_from_bool (last_part),
+ ly_symbol2scm ("is-bookpart-last-page"), scm_from_bool (last),
SCM_UNDEFINED));
SCM height = scm_apply_1 (calc_height, page, SCM_EOL);
- return scm_to_double (height) - scm_to_double (book_->paper_->c_variable ("page-top-space"));
+ return scm_to_double (height) - page_top_space_;
}
SCM
{
Break_position const &pos = breaks_[breakpoint];
- if (pos.sys_ == VPOS)
+ if (pos.system_spec_index_ == VPOS)
return SCM_EOL;
- if (all_[pos.sys_].pscore_)
+ if (system_specs_[pos.system_spec_index_].pscore_)
return pos.col_->get_property (str);
- return all_[pos.sys_].prob_->get_property (str);
+ return system_specs_[pos.system_spec_index_].prob_->get_property (str);
}
SCM
page_stencil = scm_variable_ref (page_stencil);
SCM book = book_->self_scm ();
- bool ragged_all = to_boolean (book_->paper_->c_variable ("ragged-bottom"));
- bool ragged_last = to_boolean (book_->paper_->c_variable ("ragged-last-bottom"));
- int first_page_number = robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1);
+ int first_page_number
+ = robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1);
+ bool last_bookpart = ly_scm2bool (book_->paper_->c_variable ("is-last-bookpart"));
SCM ret = SCM_EOL;
+ SCM label_page_table = book_->top_paper ()->c_variable ("label-page-table");
+ if (label_page_table == SCM_UNDEFINED)
+ label_page_table = SCM_EOL;
for (vsize i = 0; i < lines_per_page.size (); i++)
{
SCM page_num = scm_from_int (i + first_page_number);
- SCM last = scm_from_bool (i == lines_per_page.size () - 1);
- SCM ragged = scm_from_bool (ragged_all || (to_boolean (last) && ragged_last));
+ bool partbook_last_page = (i == lines_per_page.size () - 1);
+ SCM rag = scm_from_bool (ragged () || ( partbook_last_page && ragged_last ()));
SCM line_count = scm_from_int (lines_per_page[i]);
SCM lines = scm_list_head (systems, line_count);
SCM page = scm_apply_0 (make_page,
- scm_list_n (book, lines, page_num, ragged, last, SCM_UNDEFINED));
+ scm_list_n (book, lines, page_num, rag,
+ scm_from_bool (last_bookpart),
+ scm_from_bool (partbook_last_page),
+ SCM_UNDEFINED));
+ /* collect labels */
+ 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<System*> (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),
+ label_page_table);
+ }
scm_apply_1 (page_stencil, page, SCM_EOL);
ret = scm_cons (page, ret);
systems = scm_list_tail (systems, line_count);
}
+ book_->top_paper ()->set_variable (ly_symbol2scm ("label-page-table"), label_page_table);
ret = scm_reverse (ret);
return ret;
}
scm_vector_to_list (ps->get_paper_systems ()),
scm_cdr (s)));
else
- all_.push_back (System_spec (ps));
+ system_specs_.push_back (System_spec (ps));
}
else
{
assert (pb);
pb->protect ();
- all_.push_back (System_spec (pb));
+ system_specs_.push_back (System_spec (pb));
}
}
}
chunks_.push_back (Break_position ());
breaks_.push_back (Break_position ());
- for (vsize i = 0; i < all_.size (); i++)
+ for (vsize i = 0; i < system_specs_.size (); i++)
{
- if (all_[i].pscore_)
+ if (system_specs_[i].pscore_)
{
- vector<Grob*> cols = all_[i].pscore_->root_system ()->used_columns ();
+ vector<Grob*> cols
+ = system_specs_[i].pscore_->root_system ()->used_columns ();
vector<vsize> line_breaker_columns;
line_breaker_columns.push_back (0);
for (vsize j = 1; j < cols.size (); j++)
{
- bool last = j == cols.size () - 1;
+ bool last = (j == cols.size () - 1);
bool break_point = is_break (cols[j]);
bool chunk_end = cols[j]->get_property ("page-break-permission") == force_sym;
Break_position cur_pos = Break_position (i,
cols[j],
last);
- if (break_point || (i == all_.size () - 1 && last))
+ if (break_point || (i == system_specs_.size () - 1 && last))
breaks_.push_back (cur_pos);
if (chunk_end || last)
chunks_.push_back (cur_pos);
if ((break_point || chunk_end) && !last)
line_breaker_columns.push_back (j);
}
- line_breaking_.push_back (Constrained_breaking (all_[i].pscore_, line_breaker_columns));
+ line_breaking_.push_back (Constrained_breaking (system_specs_[i].pscore_, line_breaker_columns));
}
else
{
/* TODO: we want some way of applying Break_p to a prob? */
- if (i == all_.size () - 1)
+ if (i == system_specs_.size () - 1)
breaks_.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));
}
}
Break_position start = breaks_[start_index];
Break_position end = breaks_[end_index];
- vsize i;
- for (i = 0; i < chunks_.size () && chunks_[i] <= start; i++)
+ vsize i = 0;
+ for (; i < chunks_.size () && chunks_[i] <= start; i++)
;
vector<Break_position> ret;
}
Page_breaking::Line_division
-Page_breaking::system_count_bounds (vector<Break_position> const &chunks, bool min)
+Page_breaking::system_count_bounds (vector<Break_position> const &chunks,
+ bool min)
{
assert (chunks.size () >= 2);
for (vsize i = 0; i + 1 < chunks.size (); i++)
{
vsize sys = next_system (chunks[i]);
- if (all_[sys].pscore_)
+ if (system_specs_[sys].pscore_)
{
vsize start;
vsize end;
Line_division lower_bound,
Line_division upper_bound)
{
+ system_count_ = system_count;
current_chunks_ = chunk_list (start, end);
current_start_breakpoint_ = start;
current_end_breakpoint_ = end;
current_start_breakpoint_ = start;
current_end_breakpoint_ = end;
clear_line_details_cache ();
+ system_count_ = 0;
Line_division div;
for (vsize i = 0; i+1 < current_chunks_.size (); i++)
{
vsize sys = next_system (current_chunks_[i]);
- if (all_[sys].pscore_)
+ 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 ());
}
else
div.push_back (1);
+
+ system_count_ += div.back ();
}
current_configurations_.clear ();
current_configurations_.push_back (div);
{
if (cached_configuration_index_ != configuration_index)
{
+ cached_configuration_index_ = configuration_index;
SCM padding_scm = book_->paper_->c_variable ("page-breaking-between-system-padding");
if (!scm_is_number (padding_scm))
padding_scm = book_->paper_->c_variable ("between-system-padding");
for (vsize i = 0; i + 1 < current_chunks_.size (); i++)
{
vsize sys = next_system (current_chunks_[i]);
- if (all_[sys].pscore_)
+ if (system_specs_[sys].pscore_)
{
vsize start;
vsize end;
else
{
assert (div[i] == 1);
- uncompressed_line_details_.push_back (Line_details (all_[sys].prob_));
- uncompressed_line_details_.back ().padding_ = padding;
+ uncompressed_line_details_.push_back (Line_details (system_specs_[sys].prob_));
+ uncompressed_line_details_.back ().padding_ =
+ robust_scm2double (system_specs_[sys].prob_->get_property ("next-padding"),
+ padding);
}
}
cached_line_details_ = compress_lines (uncompressed_line_details_);
Real cur_rod_height = 0;
Real cur_spring_height = 0;
Real cur_page_height = page_height (first_page_num, false);
+ int line_count = 0;
cache_line_details (configuration);
for (vsize i = 0; i < cached_line_details_.size (); i++)
Real ext_len = cached_line_details_[i].extent_.length ();
Real next_rod_height = cur_rod_height + ext_len
+ ((cur_rod_height > 0) ? cached_line_details_[i].padding_: 0);
- Real next_spring_height = cur_spring_height + line_space (cached_line_details_[i]);
+ Real next_spring_height = cur_spring_height + cached_line_details_[i].space_;
Real next_height = next_rod_height + (ragged () ? next_spring_height : 0);
+ int next_line_count = line_count + cached_line_details_[i].compressed_nontitle_lines_count_;
-
- if ((next_height > cur_page_height && cur_rod_height > 0)
+ 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")))
{
+ line_count = cached_line_details_[i].compressed_nontitle_lines_count_;
cur_rod_height = ext_len;
- cur_spring_height = line_space (cached_line_details_[i]);
+ cur_spring_height = cached_line_details_[i].space_;
cur_page_height = page_height (first_page_num + ret, false);
ret++;
}
{
cur_rod_height = next_rod_height;
cur_spring_height = next_spring_height;
+ line_count = next_line_count;
}
}
cur_page_height = page_height (first_page_num + ret - 1, true);
Real cur_height = cur_rod_height + ((ragged_last () || ragged ()) ? cur_spring_height : 0);
- if (cur_height > cur_page_height
+ 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 ().extent_.length ())
ret++;
return ret;
}
-Spacing_result
+// If systems_per_page_ is positive, we don't really try to space on N pages;
+// we just put the requested number of systems on each page and penalize
+// if the result doesn't have N pages.
+Page_spacing_result
Page_breaking::space_systems_on_n_pages (vsize configuration, vsize n, vsize first_page_num)
{
- Spacing_result ret;
- assert (n >= min_page_count (configuration, first_page_num));
+ Page_spacing_result ret;
+
+ 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) ? 0 : BAD_SPACING_PENALTY;
+ return ret;
+ }
cache_line_details (configuration);
- if (n > cached_line_details_.size ())
- return Spacing_result ();
- if (n == 1)
+ bool valid_n = (n >= min_page_count (configuration, first_page_num)
+ && 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, last ()),
- ragged () || (last () && ragged_last ()));
- else if (n == 2)
+ 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
{
Real
Page_breaking::blank_page_penalty () const
{
- SCM penalty_sym = last () ? ly_symbol2scm ("blank-last-page-force") : ly_symbol2scm ("blank-page-force");
+ SCM penalty_sym;
+
+ if (is_last ())
+ penalty_sym = ly_symbol2scm ("blank-last-page-force");
+ else if (ends_score ())
+ penalty_sym = ly_symbol2scm ("blank-after-score-page-force");
+ else
+ penalty_sym = ly_symbol2scm ("blank-page-force");
+
+ Break_position const &pos = breaks_[current_end_breakpoint_];
+ if (Paper_score *ps = system_specs_[pos.system_spec_index_].pscore_)
+ return robust_scm2double (ps->layout ()->lookup_variable (penalty_sym), 0.0);
+
return robust_scm2double (book_->paper_->lookup_variable (penalty_sym), 0.0);
}
-Spacing_result
+// If systems_per_page_ is positive, we don't really try to space on N
+// 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)
{
- Spacing_result n_res;
- Spacing_result m_res;
+ Page_spacing_result n_res;
+ Page_spacing_result m_res;
- if (n <= 2)
+ if (systems_per_page_ > 0)
{
- n_res = space_systems_on_n_pages (configuration, n, first_page_num);
- m_res = space_systems_on_n_pages (configuration, n+1, first_page_num);
+ 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;
+ return ret;
}
- else
+
+ cache_line_details (configuration);
+ vsize min_p_count = min_page_count (configuration, first_page_num);
+ bool valid_n = n >= min_p_count || n <= cached_line_details_.size ();
+
+ if (!valid_n)
+ programming_error ("both page counts are out of bounds");
+
+ if (n == 1 && valid_n)
{
- cache_line_details (configuration);
+ bool rag = ragged () || (is_last () && ragged_last ());
+ Real height = page_height (first_page_num, is_last ());
- vsize min_p_count = min_page_count (configuration, first_page_num);
+ if (1 >= min_p_count)
+ 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);
+ }
+ else
+ {
Page_spacer ps (cached_line_details_, first_page_num, this);
- if (n >= min_p_count)
+
+ if (n >= min_p_count || !valid_n)
n_res = ps.solve (n);
- if (n < cached_line_details_.size ())
+ if (n < cached_line_details_.size () || !valid_n)
m_res = ps.solve (n+1);
}
+ m_res = finalize_spacing_result (configuration, m_res);
+ n_res = finalize_spacing_result (configuration, n_res);
+
Real penalty = blank_page_penalty ();
n_res.demerits_ += penalty;
- n_res.force_.back () += penalty;
- if (m_res.demerits_ < n_res.demerits_)
- return m_res;
- return n_res;
+ if (n_res.force_.size ())
+ n_res.force_.back () += penalty;
+
+ return (m_res.demerits_ < n_res.demerits_) ? m_res : n_res;
}
-Spacing_result
+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);
cache_line_details (configuration);
Page_spacer ps (cached_line_details_, first_page_num, this);
- Spacing_result best = ps.solve (min_p_count);
+ Page_spacing_result best = ps.solve (min_p_count);
best.force_.back () += (min_p_count % 2) ? odd_pages_penalty : 0;
best.demerits_ += (min_p_count % 2) ? odd_pages_penalty : 0;
for (vsize i = min_p_count+1; i <= cached_line_details_.size (); i++)
{
- Spacing_result cur = ps.solve (i);
+ Page_spacing_result cur = ps.solve (i);
cur.demerits_ += (i % 2) ? odd_pages_penalty : 0;
if (cur.demerits_ < best.demerits_)
best = cur;
return finalize_spacing_result (configuration, best);
}
+Page_spacing_result
+Page_breaking::space_systems_with_fixed_number_per_page (vsize configuration,
+ vsize first_page_num)
+{
+ Page_spacing_result res;
+ Page_spacing space (page_height (first_page_num, false), page_top_space_);
+ vsize line = 0;
+ vsize page = 0;
+ vsize page_first_line = 0;
+
+ cache_line_details (configuration);
+ while (line < cached_line_details_.size ())
+ {
+ page++;
+ space.clear ();
+ space.resize (page_height (first_page_num + page, false));
+
+ 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++;
+
+ 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_;
+ if (system_count_on_this_page != systems_per_page_)
+ {
+ res.penalty_ += 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;
+ }
+
+ /* Recalculate forces for the last page because we know now that is
+ really the last page. */
+ space.resize (page_height (first_page_num + page, true));
+ res.force_.back () = space.force_;
+ return finalize_spacing_result (configuration, res);
+}
+
+Page_spacing_result
+Page_breaking::pack_systems_on_least_pages (vsize configuration, vsize first_page_num)
+{
+ // TODO: add support for min/max-systems-per-page.
+ Page_spacing_result res;
+ vsize page = 0;
+ vsize page_first_line = 0;
+ Page_spacing space (page_height (first_page_num, false), page_top_space_);
+
+ cache_line_details (configuration);
+ for (vsize line = 0; line < cached_line_details_.size (); line++)
+ {
+ 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 ();
+ space.append_system (cached_line_details_[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_;
+ 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_);
+ res.penalty_ += cached_line_details_[line].page_penalty_;
+ }
+ }
+ }
+ return finalize_spacing_result (configuration, res);
+}
+
/* Calculate demerits and fix res.systems_per_page_ so that
it refers to the original line numbers, not the ones given by compress_lines (). */
-Spacing_result
-Page_breaking::finalize_spacing_result (vsize configuration, Spacing_result res)
+Page_spacing_result
+Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result res)
{
+ if (res.force_.empty ())
+ return res;
+
cache_line_details (configuration);
res.systems_per_page_ = uncompress_solution (res.systems_per_page_, cached_line_details_);
Real line_force = 0;
Real line_penalty = 0;
- Real page_force = 0;
+ Real page_demerits = res.penalty_;
Real page_weighting = robust_scm2double (book_->paper_->c_variable ("page-spacing-weight"), 10);
for (vsize i = 0; i < uncompressed_line_details_.size (); i++)
for (vsize i = 0; i < res.force_.size (); i++)
{
Real f = res.force_[i];
- if (isinf (f) && res.systems_per_page_[i] == 1)
- f = 20000;
- page_force += f * f;
+ page_demerits += min(f*f, BAD_SPACING_PENALTY);
}
/* for a while we tried averaging page and line forces across pages instead
with a very bad page force (for example because of a forced page break),
the page breaker will put in a _lot_ of pages so that the bad force
becomes averaged out over many pages. */
- res.demerits_ = line_force + line_penalty + (page_force + res.penalty_) * page_weighting;
+ res.demerits_ = line_force + line_penalty + page_demerits * page_weighting;
return res;
}
space_systems functions. This is because space_systems_on_1_page is (unlike
the other space_systems functions) sometimes called on subsets of a full
configuration. */
-Spacing_result
+Page_spacing_result
Page_breaking::space_systems_on_1_page (vector<Line_details> const &lines, Real page_height, bool ragged)
{
- Page_spacing space (page_height);
- Spacing_result ret;
+ Page_spacing space (page_height, page_top_space_);
+ Page_spacing_result ret;
+ int line_count = 0;
for (vsize i = 0; i < lines.size (); i++)
- space.append_system (lines[i]);
+ {
+ space.append_system (lines[i]);
+ line_count += lines[i].compressed_nontitle_lines_count_;
+ }
ret.systems_per_page_.push_back (lines.size ());
ret.force_.push_back (ragged ? min (space.force_, 0.0) : space.force_);
- ret.penalty_ = lines.back ().page_penalty_ + lines.back ().turn_penalty_;
+ ret.penalty_ = line_count_penalty (line_count) + lines.back ().page_penalty_ + lines.back ().turn_penalty_;
+ ret.system_count_status_ |= line_count_status (line_count);
/* don't do finalize_spacing_result () because we are only an internal function */
return ret;
}
-Spacing_result
+Page_spacing_result
Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_num)
{
Real page1_height = page_height (first_page_num, false);
- Real page2_height = page_height (first_page_num+1, last ());
+ Real page2_height = page_height (first_page_num + 1, is_last ());
bool ragged1 = ragged ();
- bool ragged2 = ragged () || (last () && ragged_last ());
+ bool ragged2 = ragged () || (is_last () && ragged_last ());
/* if there is a forced break, this reduces to 2 1-page problems */
cache_line_details (configuration);
{
vector<Line_details> lines1 (cached_line_details_.begin (), cached_line_details_.begin () + i + 1);
vector<Line_details> lines2 (cached_line_details_.begin () + i + 1, cached_line_details_.end ());
- Spacing_result p1 = space_systems_on_1_page (lines1, page1_height, ragged1);
- Spacing_result p2 = space_systems_on_1_page (lines2, page2_height, ragged2);
+ 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]);
vector<Real> page1_force;
vector<Real> page2_force;
- Page_spacing page1 (page1_height);
- Page_spacing page2 (page2_height);
+
+ // page1_penalty and page2_penalty store the penalties based
+ // on min-systems-per-page and max-systems-per-page.
+ vector<Real> page1_penalty;
+ vector<Real> page2_penalty;
+
+ // page1_status and page2_status keep track of whether the min-systems-per-page
+ // and max-systems-per-page constraints are satisfied.
+ vector<int> page1_status;
+ vector<int> page2_status;
+
+ Page_spacing page1 (page1_height, page_top_space_);
+ Page_spacing page2 (page2_height, page_top_space_);
+ int page1_line_count = 0;
+ int page2_line_count = 0;
page1_force.resize (cached_line_details_.size () - 1, infinity_f);
page2_force.resize (cached_line_details_.size () - 1, infinity_f);
+ page1_penalty.resize (cached_line_details_.size () - 1, infinity_f);
+ page2_penalty.resize (cached_line_details_.size () - 1, infinity_f);
+ page1_status.resize (cached_line_details_.size () - 1, 0);
+ page2_status.resize (cached_line_details_.size () - 1, 0);
/* find the page 1 and page 2 forces for each page-breaking position */
for (vsize i = 0; i < page1_force.size (); i++)
{
page1.append_system (cached_line_details_[i]);
page2.prepend_system (cached_line_details_[cached_line_details_.size () - 1 - i]);
+ page1_line_count += cached_line_details_[i].compressed_nontitle_lines_count_;
+ page2_line_count += cached_line_details_[cached_line_details_.size () - 1 - i].compressed_nontitle_lines_count_;
+
page1_force[i] = (ragged1 && page1.force_ < 0 && i > 0) ? infinity_f : page1.force_;
+ 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;
else
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);
}
/* find the position that minimises the sum of the page forces */
Real best_demerits = infinity_f;
for (vsize i = 0; i < page1_force.size (); i++)
{
- Real dem = page1_force[i] * page1_force[i]
- + page2_force[i] * page2_force[i]
+ Real f = page1_force[i] * page1_force[i] + page2_force[i] * page2_force[i];
+
+ // NOTE: we treat max-systems-per-page and min-systems-per-page as soft
+ // 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_;
if (dem < best_demerits)
}
}
- Spacing_result ret;
+ 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_;
+ + 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;
return current_configurations_[configuration_index];
}
-bool Page_breaking::last () const
+bool
+Page_breaking::is_last () const
+{
+ return current_end_breakpoint_ == last_break_position ();
+}
+
+bool
+Page_breaking::ends_score () const
+{
+ return breaks_[current_end_breakpoint_].score_ender_;
+}
+
+vsize
+Page_breaking::last_break_position () const
{
- return current_end_breakpoint_ == breaks_.size () - 1;
+ return breaks_.size () - 1;
}