/*
- page-breaking.cc -- implement a superclass and utility
- functions shared by various page-breaking algorithms
+ This file is part of LilyPond, the GNU music typesetter.
- source file of the GNU LilyPond music typesetter
+ Copyright (C) 2006--2010 Joe Neeman <joeneeman@gmail.com>
- (c) 2006--2009 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ LilyPond is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
*/
/*
#include "international.hh"
#include "item.hh"
#include "output-def.hh"
+#include "page-layout-problem.hh"
#include "page-spacing.hh"
#include "paper-book.hh"
#include "paper-score.hh"
{
Line_details const &old = ret.back ();
Line_details compressed = orig[i];
- compressed.extent_[DOWN] = old.extent_[DOWN];
- compressed.extent_[UP] = old.extent_[UP] + orig[i].extent_.length () + old.padding_;
+ /*
+ 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_;
+
+ compressed.shape_ = old.shape_.piggyback (orig[i].shape_, padding);
+ compressed.first_refpoint_offset_ += compressed.shape_.rest_[UP] - old.shape_.rest_[UP];
compressed.space_ += old.space_;
compressed.inverse_hooke_ += old.inverse_hooke_;
compressed.compressed_nontitle_lines_count_ =
old.compressed_nontitle_lines_count_ + (compressed.title_ ? 0 : 1);
- compressed.title_ = compressed.title_ && old.title_;
+ // compressed.title_ is true if and only if the first of its
+ // compressed lines was a title.
+ compressed.title_ = old.title_;
ret.back () = compressed;
}
else
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));
+ orphan_penalty_ = robust_scm2int (pb->paper_->c_variable ("orphan-penalty"), 100000);
if (systems_per_page_ && (max_systems_per_page_ || min_systems_per_page_))
{
return min_systems_per_page_;
}
-Real
-Page_breaking::page_top_space () const
-{
- return page_top_space_;
-}
-
vsize
Page_breaking::system_count () const
{
return scm_append (scm_reverse (ret));
}
+SCM
+Page_breaking::make_page (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 make_page_scm = scm_c_module_lookup (mod, "make-page");
+
+ 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));
+}
+
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 page = make_page (page_num, last);
SCM calc_height = scm_c_module_lookup (mod, "calc-printable-height");
- SCM make_page = scm_c_module_lookup (mod, "make-page");
-
calc_height = scm_variable_ref (calc_height);
- make_page = scm_variable_ref (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-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) - page_top_space_;
+ return scm_to_double (height);
}
SCM
}
SCM
-Page_breaking::make_pages (vector<vsize> lines_per_page, SCM systems)
+Page_breaking::get_page_configuration (SCM systems, int page_num, bool ragged, bool last)
{
- SCM layout_module = scm_c_resolve_module ("scm layout-page-layout");
- SCM page_module = scm_c_resolve_module ("scm page");
+ SCM dummy_page = make_page (page_num, last);
+ Page_layout_problem layout (book_, dummy_page, systems);
+ return scm_is_pair (systems) ? layout.solution (ragged) : SCM_EOL;
+}
- SCM make_page = scm_c_module_lookup (layout_module, "stretch-and-draw-page");
+SCM
+Page_breaking::draw_page (SCM systems, SCM configuration, int page_num, bool last)
+{
+ // 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))
+ {
+ SCM paper_system = scm_car (s);
+ if (Grob *g = unsmob_grob (scm_car (s)))
+ {
+ System *sys = dynamic_cast<System*> (g);
+ paper_system = sys->get_paper_system ();
+ }
+
+ paper_systems = scm_cons (paper_system, paper_systems);
+ }
+
+ // 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");
- make_page = scm_variable_ref (make_page);
page_stencil = scm_variable_ref (page_stencil);
- SCM book = book_->self_scm ();
+ Prob *p = unsmob_prob (page);
+ p->set_property ("lines", paper_systems);
+ p->set_property ("configuration", configuration);
+ scm_apply_1 (page_stencil, page, SCM_EOL);
+
+ return page;
+}
+
+SCM
+Page_breaking::make_pages (vector<vsize> lines_per_page, SCM systems)
+{
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;
+ // Build a list of (systems . configuration) pairs. Note that we lay out
+ // the staves and find the configurations before drawing anything. Some
+ // grobs (like tuplet brackets) look at their neighbours while drawing
+ // 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;
+
for (vsize i = 0; i < lines_per_page.size (); i++)
{
- SCM page_num = scm_from_int (i + first_page_number);
- bool partbook_last_page = (i == lines_per_page.size () - 1);
- SCM rag = scm_from_bool (ragged () || ( partbook_last_page && ragged_last ()));
+ int page_num = i + first_page_number;
+ bool bookpart_last_page = (i == lines_per_page.size () - 1);
+ 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 page = scm_apply_0 (make_page,
- scm_list_n (book, lines, page_num, rag,
- scm_from_bool (last_bookpart),
- scm_from_bool (partbook_last_page),
- SCM_UNDEFINED));
+ SCM config = get_page_configuration (lines, page_num, rag, bookpart_last_page);
+
+ systems_and_configs = scm_cons (scm_cons (lines, config), systems_and_configs);
+ systems = scm_list_tail (systems, line_count);
+ }
+
+ // Now it's safe to make the pages.
+ int page_num = first_page_number + lines_per_page.size () - 1;
+ for (SCM s = systems_and_configs; scm_is_pair (s); s = scm_cdr (s))
+ {
+ 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);
+
/* 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;
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_cons (scm_cons (scm_car (lbls), page_num_scm),
label_page_table);
}
- scm_apply_1 (page_stencil, page, SCM_EOL);
ret = scm_cons (page, ret);
- systems = scm_list_tail (systems, line_count);
+ --page_num;
}
book_->top_paper ()->set_variable (ly_symbol2scm ("label-page-table"), label_page_table);
- ret = scm_reverse (ret);
return ret;
}
{
if (Paper_score *ps = dynamic_cast<Paper_score*> (unsmob_music_output (scm_car (s))))
{
- SCM system_count = ps->layout ()->c_variable ("system-count");
-
- if (scm_is_number (system_count))
- s = scm_append (scm_list_3 (scm_list_1 (scm_car (s)),
- scm_vector_to_list (ps->get_paper_systems ()),
- scm_cdr (s)));
- else
- system_specs_.push_back (System_spec (ps));
+ system_specs_.push_back (System_spec (ps));
}
else
{
{
if (system_specs_[i].pscore_)
{
- vector<Grob*> cols
- = system_specs_[i].pscore_->root_system ()->used_columns ();
+ vector<Grob*> cols = system_specs_[i].pscore_->root_system ()->used_columns ();
+ vector<Grob*> 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<Line_details> 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<vsize> line_breaker_columns;
line_breaker_columns.push_back (0);
for (vsize j = 1; j < cols.size (); j++)
{
+ if (forced_line_break_cols.size ())
+ {
+ if (forced_line_break_idx >= forced_line_break_cols.size ()
+ || forced_line_break_cols[forced_line_break_idx] != cols[j])
+ continue;
+ else
+ forced_line_break_idx++;
+ }
+
bool last = (j == cols.size () - 1);
bool break_point = is_break (cols[j]);
bool chunk_end = cols[j]->get_property ("page-break-permission") == force_sym;
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);
+ {
+ 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);
for (vsize i = 0; i + 1 < chunks.size (); i++)
{
vsize sys = next_system (chunks[i]);
- if (system_specs_[sys].pscore_)
+
+ 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;
for (vsize i = 0; i+1 < current_chunks_.size (); i++)
{
vsize sys = next_system (current_chunks_[i]);
- if (system_specs_[sys].pscore_)
+
+ 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 ());
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");
- Real padding = robust_scm2double (padding_scm, 0.0);
Line_division &div = current_configurations_[configuration_index];
uncompressed_line_details_.clear ();
else
{
assert (div[i] == 1);
- 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);
+ uncompressed_line_details_.push_back (Line_details (system_specs_[sys].prob_, book_->paper_));
}
}
cached_line_details_ = compress_lines (uncompressed_line_details_);
}
}
+void
+Page_breaking::compute_line_heights ()
+{
+ Real prev_hanging = 0;
+ Real prev_hanging_begin = 0;
+ Real prev_hanging_rest = 0;
+ Real prev_refpoint_hanging = 0;
+ for (vsize i = 0; i < cached_line_details_.size (); i++)
+ {
+ Line_shape shape = cached_line_details_[i].shape_;
+ Real a = shape.begin_[UP];
+ Real b = shape.rest_[UP];
+ bool title = cached_line_details_[i].title_;
+ Real refpoint_hanging = max (prev_hanging_begin + a, prev_hanging_rest + b);
+
+ if (i > 0)
+ {
+ Real padding = 0;
+ if (!cached_line_details_[i].tight_spacing_)
+ padding = title
+ ? cached_line_details_[i-1].title_padding_
+ : cached_line_details_[i-1].padding_;
+ Real min_dist = title
+ ? cached_line_details_[i-1].title_min_distance_
+ : cached_line_details_[i-1].min_distance_;
+ refpoint_hanging = max (refpoint_hanging + padding,
+ prev_refpoint_hanging + min_dist
+ + cached_line_details_[i].first_refpoint_offset_);
+ }
+
+ Real hanging_begin = refpoint_hanging - shape.begin_[DOWN];
+ Real hanging_rest = refpoint_hanging - shape.rest_[DOWN];
+ Real hanging = max (hanging_begin, hanging_rest);
+ cached_line_details_[i].tallness_ = hanging - prev_hanging;
+ prev_hanging = hanging;
+ prev_hanging_begin = hanging_begin;
+ prev_hanging_rest = hanging_rest;
+ prev_refpoint_hanging = refpoint_hanging;
+ }
+}
+
vsize
Page_breaking::min_page_count (vsize configuration, vsize first_page_num)
{
vsize ret = 1;
+ vsize page_starter = 0;
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);
+ compute_line_heights ();
- // If the first line on a page has titles, allow them some extra space.
- if (cached_line_details_.size ()
- && cached_line_details_[0].compressed_nontitle_lines_count_ < cached_line_details_[0].compressed_lines_count_)
- cur_page_height += page_top_space ();
+ if (cached_line_details_.size ())
+ cur_page_height -= min_whitespace_at_top_of_page (cached_line_details_[0]);
for (vsize i = 0; i < cached_line_details_.size (); i++)
{
- Real 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 ext_len;
+ if (cur_rod_height > 0)
+ ext_len = cached_line_details_[i].tallness_;
+ else
+ ext_len = cached_line_details_[i].full_height();
+
+ Real next_rod_height = cur_rod_height + ext_len;
Real next_spring_height = cur_spring_height + cached_line_details_[i].space_;
- Real next_height = next_rod_height + (ragged () ? next_spring_height : 0);
+ 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_;
if ((!too_few_lines (line_count) && (next_height > cur_page_height && cur_rod_height > 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_rod_height = cached_line_details_[i].full_height();
cur_spring_height = cached_line_details_[i].space_;
+ 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]);
- if (cached_line_details_[i].compressed_nontitle_lines_count_ < cached_line_details_[i].compressed_lines_count_)
- cur_page_height += page_top_space ();
ret++;
}
else
*/
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 ().extent_.length ())
+ && cur_rod_height > cached_line_details_.back ().full_height ())
ret++;
assert (ret <= cached_line_details_.size ());
// 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)
+Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize n, vsize first_page_num,
+ Real penalty_for_fewer_pages)
{
Page_spacing_result n_res;
Page_spacing_result m_res;
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;
+ Real page_spacing_weight = robust_scm2double (book_->paper_->c_variable ("page-spacing-weight"), 10);
+ n_res.demerits_ += penalty_for_fewer_pages * page_spacing_weight;
if (n_res.force_.size ())
- n_res.force_.back () += penalty;
+ n_res.force_.back () += penalty_for_fewer_pages;
return (m_res.demerits_ < n_res.demerits_) ? m_res : n_res;
}
Page_breaking::space_systems_on_best_pages (vsize configuration, vsize first_page_num)
{
vsize min_p_count = min_page_count (configuration, first_page_num);
- Real odd_pages_penalty = blank_page_penalty ();
cache_line_details (configuration);
Page_spacer ps (cached_line_details_, first_page_num, this);
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++)
{
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 ret = finalize_spacing_result (configuration, best);
+ return ret;
}
Page_spacing_result
vsize first_page_num)
{
Page_spacing_result res;
- Page_spacing space (page_height (first_page_num, false), page_top_space_);
+ Page_spacing space (page_height (first_page_num, false), this);
vsize line = 0;
vsize page = 0;
vsize page_first_line = 0;
Page_spacing_result res;
vsize page = 0;
vsize page_first_line = 0;
- Page_spacing space (page_height (first_page_num, false), page_top_space_);
+ Page_spacing space (page_height (first_page_num, false), this);
cache_line_details (configuration);
+ compute_line_heights ();
for (vsize line = 0; line < cached_line_details_.size (); line++)
{
Real prev_force = space.force_;
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, page_top_space_);
+ Page_spacing space (page_height, this);
Page_spacing_result ret;
int line_count = 0;
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<int> page1_status;
vector<int> page2_status;
- Page_spacing page1 (page1_height, page_top_space_);
- Page_spacing page2 (page2_height, page_top_space_);
+ Page_spacing page1 (page1_height, this);
+ Page_spacing page2 (page2_height, this);
int page1_line_count = 0;
int page2_line_count = 0;
{
return breaks_.size () - 1;
}
+
+// This gives the minimum distance between the top of the
+// printable area (ie. the bottom of the top-margin) and
+// the extent box of the topmost system.
+Real
+Page_breaking::min_whitespace_at_top_of_page (Line_details const &line) const
+{
+ SCM first_system_spacing = book_->paper_->c_variable ("top-system-spacing");
+ if (line.title_)
+ first_system_spacing = book_->paper_->c_variable ("top-title-spacing");
+
+ Real min_distance = -infinity_f;
+ Real padding = 0;
+
+ Page_layout_problem::read_spacing_spec (first_system_spacing,
+ &min_distance,
+ ly_symbol2scm ("minimum-distance"));
+ Page_layout_problem::read_spacing_spec (first_system_spacing,
+ &padding,
+ ly_symbol2scm ("padding"));
+
+ // FIXME: take into account the height of the header
+ Real translate = max (line.shape_.begin_[UP], line.shape_.rest_[UP]);
+ return max (0.0, max (padding, min_distance - translate));
+}
+
+Real
+Page_breaking::min_whitespace_at_bottom_of_page (Line_details const &line) const
+{
+ SCM last_system_spacing = book_->paper_->c_variable ("bottom-system-spacing");
+ Real min_distance = -infinity_f;
+ Real padding = 0;
+
+ Page_layout_problem::read_spacing_spec (last_system_spacing,
+ &min_distance,
+ ly_symbol2scm ("minimum-distance"));
+ Page_layout_problem::read_spacing_spec (last_system_spacing,
+ &padding,
+ ly_symbol2scm ("padding"));
+
+ // FIXME: take into account the height of the footer
+ Real translate = min (line.shape_.begin_[DOWN], line.shape_.rest_[DOWN]);
+ return max (0.0, max (padding, min_distance + translate));
+}
+
+int
+Page_breaking::orphan_penalty () const
+{
+ return orphan_penalty_;
+}
projects / lilypond.git / blobdiff