X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpage-breaking.cc;h=543665f97bb4d53b7ff3e74940b796b75190602d;hb=abef60a562c5337a87ad7b38874a446ce4fef863;hp=0ef1a309e9e5531b904fed613b4f583ac128323d;hpb=d3032e8908ee5b68d2ab58e6ff594e8e4fed5277;p=lilypond.git diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc index 0ef1a309e9..543665f97b 100644 --- a/lily/page-breaking.cc +++ b/lily/page-breaking.cc @@ -99,9 +99,18 @@ compress_lines (const vector &orig) { Line_details const &old = ret.back (); Line_details compressed = orig[i]; - Real padding = orig[i].title_ ? old.title_padding_ : 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_; @@ -164,10 +173,11 @@ Page_breaking::next_system (Break_position const &break_pos) const 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)); @@ -187,7 +197,7 @@ Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break) } create_system_list (); - find_chunks_and_breaks (is_break); + find_chunks_and_breaks (is_break, prob_break); } Page_breaking::~Page_breaking () @@ -356,16 +366,45 @@ Page_breaking::make_page (int page_num, bool last) const 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& 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 @@ -514,7 +553,7 @@ Page_breaking::create_system_list () } 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"); @@ -525,7 +564,8 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break) { if (system_specs_[i].pscore_) { - vector cols; + vector cols = system_specs_[i].pscore_->root_system ()->used_columns (); + vector forced_line_break_cols; SCM system_count = system_specs_[i].pscore_->layout ()->c_variable ("system-count"); if (scm_is_number (system_count)) @@ -536,21 +576,28 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break) Constrained_breaking breaking (system_specs_[i].pscore_); vector 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 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 (), @@ -564,14 +611,14 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break) // 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) @@ -581,8 +628,8 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break) } 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)); @@ -785,6 +832,7 @@ Page_breaking::cache_line_details (vsize configuration_index) } } cached_line_details_ = compress_lines (uncompressed_line_details_); + compute_line_heights (); } } @@ -803,17 +851,17 @@ Page_breaking::line_divisions_rec (vsize system_count, 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) { @@ -824,7 +872,7 @@ Page_breaking::line_divisions_rec (vsize system_count, 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) @@ -841,19 +889,38 @@ 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]; - 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; } } @@ -868,27 +935,19 @@ 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 padding = 0; Real ext_len; if (cur_rod_height > 0) - { - 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]); @@ -1059,21 +1118,10 @@ Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize 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 @@ -1276,6 +1324,7 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n 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; }