Line_details const &old = ret.back ();
Line_details compressed = orig[i];
/*
- "padding" is the padding below the current line. The padding below
- "old" (taking into account whether "old" is a title) is already
- accounted for in the extent of the compressed line. The padding
- below the compressed line, therefore, should depend on whether its
- bottom-most line is a title or not.
+ 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_;
return sys + 1; /* this page starts with a new System_spec */
}
-Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break)
+Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break, Prob_break_predicate prob_break)
{
book_ = pb;
system_count_ = 0;
+ paper_height_ = robust_scm2double (pb->paper_->c_variable ("paper-height"), 1.0);
ragged_ = to_boolean (pb->paper_->c_variable ("ragged-bottom"));
ragged_last_ = to_boolean (pb->paper_->c_variable ("ragged-last-bottom"));
systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("systems-per-page"), 0));
}
create_system_list ();
- find_chunks_and_breaks (is_break);
+ find_chunks_and_breaks (is_break, prob_break);
}
Page_breaking::~Page_breaking ()
SCM_UNDEFINED));
}
+// Returns the total height of the paper, including margins and
+// space for the header/footer. This is an upper bound on
+// page_height, and it doesn't depend on the current page.
+Real
+Page_breaking::paper_height () const
+{
+ return paper_height_;
+}
+
Real
Page_breaking::page_height (int page_num, bool last) const
{
- 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");
- calc_height = scm_variable_ref (calc_height);
+ // The caches allow us to store the page heights for any
+ // non-negative page numbers. We use a negative value in the
+ // cache to signal that that position has not yet been initialized.
+ // This means that we won't cache properly if page_num is negative or
+ // if calc_height returns a negative number. But that's likely to
+ // be rare, so it shouldn't affect performance.
+ vector<Real>& cache = last ? last_page_height_cache_ : page_height_cache_;
+ if (page_num >= 0 && (int) cache.size () > page_num && cache[page_num] >= 0)
+ return cache[page_num];
+ else
+ {
+ 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");
+ calc_height = scm_variable_ref (calc_height);
- SCM height = scm_apply_1 (calc_height, page, SCM_EOL);
- return scm_to_double (height);
+ SCM height_scm = scm_apply_1 (calc_height, page, SCM_EOL);
+ Real height = scm_to_double (height_scm);
+
+ if (page_num >= 0)
+ {
+ if ((int) cache.size () <= page_num)
+ cache.resize (page_num + 1, -1);
+ cache[page_num] = height;
+ }
+ return height;
+ }
}
SCM
}
void
-Page_breaking::find_chunks_and_breaks (Break_predicate is_break)
+Page_breaking::find_chunks_and_breaks (Break_predicate is_break, Prob_break_predicate prob_is_break)
{
SCM force_sym = ly_symbol2scm ("force");
{
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))
Constrained_breaking breaking (system_specs_[i].pscore_);
vector<Line_details> details = breaking.line_details (0, VPOS, scm_to_int (system_count));
- cols.push_back (system_specs_[i].pscore_->root_system ()->used_columns ()[0]);
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 = 0;
+ 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 break_point = is_break && is_break (cols[j]);
bool chunk_end = cols[j]->get_property ("page-break-permission") == force_sym;
Break_position cur_pos = Break_position (i,
line_breaker_columns.size (),
// 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)
}
else
{
- /* TODO: we want some way of applying Break_p to a prob? */
- if (i == system_specs_.size () - 1)
+ bool break_point = prob_is_break && prob_is_break (system_specs_[i].prob_);
+ if (break_point || i == system_specs_.size () - 1)
breaks_.push_back (Break_position (i));
chunks_.push_back (Break_position (i));
}
}
cached_line_details_ = compress_lines (uncompressed_line_details_);
+ compute_line_heights ();
}
}
Line_division *cur_division)
{
vsize my_index = cur_division->size ();
- vsize others_min = 0;
- vsize others_max = 0;
+ int others_min = 0;
+ int others_max = 0;
for (vsize i = my_index + 1; i < min_sys.size (); i++)
{
others_min += min_sys[i];
others_max += max_sys[i];
}
- others_max = min (others_max, system_count);
- vsize real_min = max (min_sys[my_index], system_count - others_max);
- vsize real_max = min (max_sys[my_index], system_count - others_min);
+ others_max = min (others_max, (int) system_count);
+ 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)
{
return;
}
- for (vsize i = real_min; i <= real_max; i++)
+ for (int i = real_min; i <= real_max; i++)
{
cur_division->push_back (i);
if (my_index == min_sys.size () - 1)
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];
- Real midline_hanging = max (prev_hanging_begin + a, prev_hanging_rest + b);
- Real hanging_begin = midline_hanging - shape.begin_[DOWN];
- Real hanging_rest = midline_hanging - shape.rest_[DOWN];
+ 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;
}
}
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 padding = 0;
Real ext_len;
if (cur_rod_height > 0)
- {
- if (!cached_line_details_[i].tight_spacing_)
- padding = (cached_line_details_[i].title_
- ? cached_line_details_[i - 1].title_padding_
- : cached_line_details_[i - 1].padding_);
- ext_len = cached_line_details_[i].tallness_;
- }
+ 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 + padding;
+ 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]);
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);
- Page_spacing_result best = ps.solve (min_p_count);
- for (vsize i = min_p_count+1; i <= cached_line_details_.size (); i++)
- {
- Page_spacing_result cur = ps.solve (i);
- if (cur.demerits_ < best.demerits_)
- best = cur;
- }
-
- Page_spacing_result ret = finalize_spacing_result (configuration, best);
- return ret;
+ return finalize_spacing_result (configuration, ps.solve ());
}
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;
}