/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 2006--2010 Joe Neeman <joeneeman@gmail.com>
+ Copyright (C) 2006--2011 Joe Neeman <joeneeman@gmail.com>
LilyPond is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
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"
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_;
}
->get_broken_system_grobs ();
ret = scm_cons (lines, ret);
}
- else
+ else if (Prob *pb = system_specs_[sys].prob_)
{
- Prob *pb = system_specs_[sys].prob_;
ret = scm_cons (scm_list_1 (pb->self_scm ()), ret);
pb->unprotect ();
}
SCM
Page_breaking::make_pages (vector<vsize> lines_per_page, SCM systems)
{
+ if (scm_is_null (systems))
+ return SCM_EOL;
+
int first_page_number
= robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1);
SCM ret = SCM_EOL;
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;
}
system_specs_.push_back (System_spec (pb));
}
}
+ if (!system_specs_.size ())
+ system_specs_.push_back (System_spec ());
}
void
}
line_breaking_.push_back (Constrained_breaking (system_specs_[i].pscore_, line_breaker_columns));
}
- else
+ 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)
return ret;
}
+// Returns the minimum number of _non-title_ lines.
vsize
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)
{
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<Break_position> const &chunks,
bool min)
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++)
{
div.push_back (line_breaking_[sys].best_solution (start, end).size ());
}
else
- div.push_back (1);
+ div.push_back (0);
system_count_ += div.back ();
}
}
else
{
- assert (div[i] == 1);
- uncompressed_line_details_.push_back (Line_details (system_specs_[sys].prob_, book_->paper_));
+ assert (div[i] == 0);
+ uncompressed_line_details_.push_back (system_specs_[sys].prob_
+ ? Line_details (system_specs_[sys].prob_, book_->paper_)
+ : Line_details ());
}
}
cached_line_details_ = compress_lines (uncompressed_line_details_);
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
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++;
}
calculations that treated it as a non-last page were ok.
*/
- cur_page_height = page_height (first_page_num + ret - 1, true);
- cur_page_height -= min_whitespace_at_top_of_page (cached_line_details_[page_starter]);
- cur_page_height -= min_whitespace_at_bottom_of_page (cached_line_details_.back ());
-
- Real cur_height = cur_rod_height + ((ragged_last () || ragged ()) ? cur_spring_height : 0);
- if (!too_few_lines (line_count - cached_line_details_.back ().compressed_nontitle_lines_count_)
- && cur_height > cur_page_height
- /* don't increase the page count if the last page had only one system */
- && cur_rod_height > cached_line_details_.back ().full_height ())
- ret++;
+ if (is_last ())
+ {
+ cur_page_height = page_height (first_page_num + ret - 1, true);
+ cur_page_height -= min_whitespace_at_top_of_page (cached_line_details_[page_starter]);
+ cur_page_height -= min_whitespace_at_bottom_of_page (cached_line_details_.back ());
+
+ Real cur_height = cur_rod_height + ((ragged_last () || ragged ()) ? cur_spring_height : 0);
+ if (!too_few_lines (line_count - cached_line_details_.back ().compressed_nontitle_lines_count_)
+ && cur_height > cur_page_height
+ /* don't increase the page count if the last page had only one system */
+ && cur_rod_height > cached_line_details_.back ().full_height ())
+ ret++;
+ assert (ret <= cached_line_details_.size ());
+ }
- assert (ret <= cached_line_details_.size ());
return ret;
}
Page_spacing_result
Page_breaking::space_systems_on_best_pages (vsize configuration, vsize first_page_num)
{
+ if (systems_per_page_ > 0)
+ return space_systems_with_fixed_number_per_page (configuration, first_page_num);
+
cache_line_details (configuration);
Page_spacer ps (cached_line_details_, first_page_num, this);
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;
}
projects / lilypond.git / blobdiff