compressed.extent_[UP] = old.extent_[UP] + orig[i].extent_.length () + old.padding_;
compressed.space_ += old.space_;
compressed.inverse_hooke_ += old.inverse_hooke_;
+ compressed.title_ = old.title_;
/* we don't need the force_ field for the vertical spacing,
so we use force_ = n to signal that the line was compressed,
Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break)
{
book_ = pb;
+ 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);
create_system_list ();
find_chunks_and_breaks (is_break);
}
return ragged_last_;
}
+Real
+Page_breaking::page_top_space () const
+{
+ return page_top_space_;
+}
+
+vsize
+Page_breaking::system_count () const
+{
+ return system_count_;
+}
+
/* translate indices into breaks_ into start-end parameters for the line breaker */
void
Page_breaking::line_breaker_args (vsize sys,
ly_symbol2scm ("is-last"), 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
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++)
}
else
div.push_back (1);
+
+ system_count_ += div.back ();
}
current_configurations_.clear ();
current_configurations_.push_back (div);
Page_breaking::space_systems_on_n_pages (vsize configuration, vsize n, vsize first_page_num)
{
Page_spacing_result ret;
- assert (n >= min_page_count (configuration, first_page_num));
cache_line_details (configuration);
- if (n > cached_line_details_.size ())
- return Page_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, is_last ()),
ragged () || (is_last () && ragged_last ()));
- else if (n == 2)
+ 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 = is_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);
}
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 (n == 1)
+ if (!valid_n)
+ programming_error ("both page counts are out of bounds");
+
+ if (n == 1 && valid_n)
{
bool rag = ragged () || (is_last () && ragged_last ());
Real height = page_height (first_page_num, is_last ());
{
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);
}
Page_spacing_result res;
vsize page = 0;
vsize page_first_line = 0;
- Page_spacing space (page_height (first_page_num, false));
+ 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++)
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_spacing space (page_height, page_top_space_);
Page_spacing_result ret;
for (vsize i = 0; i < lines.size (); i++)
vector<Real> page1_force;
vector<Real> page2_force;
- Page_spacing page1 (page1_height);
- Page_spacing page2 (page2_height);
+ Page_spacing page1 (page1_height, page_top_space_);
+ Page_spacing page2 (page2_height, page_top_space_);
page1_force.resize (cached_line_details_.size () - 1, infinity_f);
page2_force.resize (cached_line_details_.size () - 1, infinity_f);
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
{