/*
- 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/>.
*/
/*
{
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_;
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_))
{
{
if (system_specs_[i].pscore_)
{
- vector<Grob*> cols;
+ 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))
vector<Line_details> details = breaking.line_details (0, VPOS, scm_to_int (system_count));
for (vsize j = 0; j < details.size (); j++)
- cols.push_back (details[j].last_column_);
+ forced_line_break_cols.push_back (details[j].last_column_);
}
- else
- cols = system_specs_[i].pscore_->root_system ()->used_columns ();
- int last_chunk_idx = -1;
+ 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;
// since it mixes Break_positions from breaks_ and
// chunks_.
if (scm_is_number (system_count))
- cur_pos.forced_line_count_ = j - last_chunk_idx;
+ 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_chunk_idx = j;
+ last_forced_line_break_idx = forced_line_break_idx;
}
if ((break_point || chunk_end) && !last)
if (cached_configuration_index_ != configuration_index)
{
cached_configuration_index_ = configuration_index;
- Real padding = 0;
- SCM spacing_spec = book_->paper_->c_variable ("between-system-spacing");
- SCM page_breaking_spacing_spec = book_->paper_->c_variable ("page-breaking-between-system-spacing");
- Page_layout_problem::read_spacing_spec (spacing_spec, &padding, ly_symbol2scm ("padding"));
- Page_layout_problem::read_spacing_spec (page_breaking_spacing_spec, &padding, ly_symbol2scm ("padding"));
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)
{
int line_count = 0;
cache_line_details (configuration);
+ compute_line_heights ();
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)
+ min_whitespace_at_bottom_of_page (cached_line_details_[i]);
&& 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;
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
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_;
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;
}
ly_symbol2scm ("padding"));
// FIXME: take into account the height of the header
- return max (0.0, max (padding, min_distance - line.extent_[UP]));
+ Real translate = max (line.shape_.begin_[UP], line.shape_.rest_[UP]);
+ return max (0.0, max (padding, min_distance - translate));
}
Real
ly_symbol2scm ("padding"));
// FIXME: take into account the height of the footer
- return max (0.0, max (padding, min_distance + line.extent_[DOWN]));
+ 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