From 9171fc87b5b9693865339578be6ae00d1c536b3b Mon Sep 17 00:00:00 2001 From: Joe Neeman Date: Sun, 24 Oct 2010 12:14:31 -0700 Subject: [PATCH] Fix the usage of min-distance in page breaking. In page breaking, measure min-distance between staff refpoints instead of system refpoints. --- lily/constrained-breaking.cc | 2 +- lily/include/constrained-breaking.hh | 7 ++++-- lily/include/system.hh | 1 + lily/page-breaking.cc | 32 ++++++++++++++++++---------- lily/system.cc | 28 ++++++++++++++++++++++++ 5 files changed, 56 insertions(+), 14 deletions(-) diff --git a/lily/constrained-breaking.cc b/lily/constrained-breaking.cc index 73732ec3ad..e82397f653 100644 --- a/lily/constrained-breaking.cc +++ b/lily/constrained-breaking.cc @@ -508,6 +508,7 @@ Constrained_breaking::fill_line_details (Line_details *const out, vsize start, v || isnan (rest_of_line_extent[RIGHT])) ? Interval (0, 0) : rest_of_line_extent; out->shape_ = Line_shape (begin_of_line_extent, rest_of_line_extent); + out->refpoint_extent_ = sys->pure_refpoint_extent (start_rank, end_rank); out->padding_ = last ? score_system_padding_ : system_system_padding_; out->title_padding_ = score_markup_padding_; out->min_distance_ = last ? score_system_min_distance_ : system_system_min_distance_; @@ -560,7 +561,6 @@ Line_details::Line_details (Prob *pb, Output_def *paper) SCM first_scm = pb->get_property ("first-markup-line"); first_markup_line_ = to_boolean (first_scm); tight_spacing_ = to_boolean (pb->get_property ("tight-spacing")); - first_refpoint_offset_ = 0; } Real diff --git a/lily/include/constrained-breaking.hh b/lily/include/constrained-breaking.hh index ab014cbcc4..f29ee6310f 100644 --- a/lily/include/constrained-breaking.hh +++ b/lily/include/constrained-breaking.hh @@ -44,6 +44,11 @@ struct Line_details { Grob *last_column_; Real force_; Line_shape shape_; + Interval refpoint_extent_; /* The refpoints of the first and last + spaceable staff in this line. min-distance + should be measured from the bottom + refpoint_extent of one line to the + top refpoint_extent of the next. */ Real tallness_; /* Y-extent, adjusted according to begin/rest-of-line*/ Real padding_; /* compulsory space after this system (if we're not @@ -74,7 +79,6 @@ struct Line_details { bool last_markup_line_; bool first_markup_line_; bool tight_spacing_; - Real first_refpoint_offset_; Line_details () { @@ -100,7 +104,6 @@ struct Line_details { last_markup_line_ = false; first_markup_line_ = false; tallness_ = 0; - first_refpoint_offset_ = 0; } Line_details (Prob *pb, Output_def *paper); diff --git a/lily/include/system.hh b/lily/include/system.hh index ee9f82f1e0..3bc7250d6f 100644 --- a/lily/include/system.hh +++ b/lily/include/system.hh @@ -71,6 +71,7 @@ public: Interval begin_of_line_pure_height (vsize start, vsize end); Interval rest_of_line_pure_height (vsize start, vsize end); + Interval pure_refpoint_extent (vsize start, vsize end); protected: virtual void derived_mark () const; diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc index 3fb4d18b0c..22fe336da5 100644 --- a/lily/page-breaking.cc +++ b/lily/page-breaking.cc @@ -109,8 +109,12 @@ compress_lines (const vector &orig) if (!orig[i].tight_spacing_) padding = orig[i].title_ ? old.title_padding_ : old.padding_; + // FIXME: double check these. Doesn't foo.piggyback (bar) mean + // that foo goes on top? + // TODO: break out a Line_details::piggyback from here? compressed.shape_ = old.shape_.piggyback (orig[i].shape_, padding); - compressed.first_refpoint_offset_ += compressed.shape_.rest_[UP] - old.shape_.rest_[UP]; + compressed.refpoint_extent_[UP] = old.refpoint_extent_[UP]; + compressed.refpoint_extent_[DOWN] += compressed.shape_.rest_[UP] - old.shape_.rest_[UP]; compressed.space_ += old.space_; compressed.inverse_hooke_ += old.inverse_hooke_; @@ -889,34 +893,40 @@ Page_breaking::compute_line_heights () Real prev_hanging = 0; Real prev_hanging_begin = 0; Real prev_hanging_rest = 0; + + // refpoint_hanging is the y coordinate of the origin of this system. + // It may not be the same as refpoint_extent[UP], which is the + // refpoint of the first spaceable staff in this system. Real prev_refpoint_hanging = 0; for (vsize i = 0; i < cached_line_details_.size (); i++) { - Line_shape shape = cached_line_details_[i].shape_; + Line_details& cur = cached_line_details_[i]; + Line_shape shape = cur.shape_; Real a = shape.begin_[UP]; Real b = shape.rest_[UP]; - bool title = cached_line_details_[i].title_; + bool title = cur.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_) + Line_details const& prev = cached_line_details_[i-1]; + if (!cur.tight_spacing_) padding = title - ? cached_line_details_[i-1].title_padding_ - : cached_line_details_[i-1].padding_; + ? prev.title_padding_ + : prev.padding_; Real min_dist = title - ? cached_line_details_[i-1].title_min_distance_ - : cached_line_details_[i-1].min_distance_; + ? prev.title_min_distance_ + : prev.min_distance_; refpoint_hanging = max (refpoint_hanging + padding, - prev_refpoint_hanging + min_dist - + cached_line_details_[i].first_refpoint_offset_); + prev_refpoint_hanging - prev.refpoint_extent_[DOWN] + + cur.refpoint_extent_[UP] + min_dist); } 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; + cur.tallness_ = hanging - prev_hanging; prev_hanging = hanging; prev_hanging_begin = hanging_begin; prev_hanging_rest = hanging_rest; diff --git a/lily/system.cc b/lily/system.cc index 3da78689e3..8196736eca 100644 --- a/lily/system.cc +++ b/lily/system.cc @@ -572,6 +572,34 @@ System::get_extremal_staff (Direction dir, Interval const &iv) return 0; } +Interval +System::pure_refpoint_extent (vsize start, vsize end) +{ + Interval ret; + Grob *alignment = get_vertical_alignment (); + if (!alignment) + return Interval (); + + extract_grob_set (alignment, "elements", staves); + vector offsets = Align_interface::get_minimum_translations (alignment, staves, Y_AXIS, true, start, end); + + for (vsize i = 0; i < offsets.size (); ++i) + if (Page_layout_problem::is_spaceable (staves[i])) + { + ret[UP] = offsets[i]; + break; + } + + for (vsize i = offsets.size (); i--;) + if (Page_layout_problem::is_spaceable (staves[i])) + { + ret[DOWN] = offsets[i]; + break; + } + + return ret; +} + Interval System::part_of_line_pure_height (vsize start, vsize end, bool begin) { -- 2.39.2