X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fspacing-spanner.cc;h=19739adf6a5ee8ddd520932c33c80750a93f3d99;hb=4063c4f664e044181e416857e999cb07391c3e33;hp=13c2964edba19d063947005f41e6935892a143d0;hpb=2f7b37a5d3482bbda90bea53f98e845c2580512f;p=lilypond.git diff --git a/lily/spacing-spanner.cc b/lily/spacing-spanner.cc index 13c2964edb..19739adf6a 100644 --- a/lily/spacing-spanner.cc +++ b/lily/spacing-spanner.cc @@ -11,8 +11,6 @@ #include #include -using namespace std; - #include "spacing-options.hh" #include "international.hh" #include "main.hh" @@ -22,6 +20,7 @@ using namespace std; #include "paper-column.hh" #include "paper-score.hh" #include "pointer-group-interface.hh" +#include "separation-item.hh" #include "spaceable-grob.hh" #include "spacing-interface.hh" #include "staff-spacing.hh" @@ -209,22 +208,91 @@ Spacing_spanner::generate_pair_spacing (Grob *me, } } +static void +set_column_rods (vector const &cols, Real padding) +{ + /* distances[i] will be the minimum distance between column i and column i+1 */ + vector distances; + + for (vsize i = 1; i < cols.size (); i++) + { + Item *r = dynamic_cast (cols[i]); + Item *rb = r->find_prebroken_piece (LEFT); + + if (Separation_item::is_empty (r) && (!rb || Separation_item::is_empty (rb))) + continue; + + Skyline_pair *skys = Skyline_pair::unsmob (r->get_property ("horizontal-skylines")); + Real right_stickout = skys ? (*skys)[LEFT].max_height () : 0.0; + + Drul_array r_cols (r, rb); + Drul_array cur_dist (0.0, 0.0); + + /* This is an inner loop and hence it is potentially quadratic. However, we only continue + as long as there is a rod to insert. Therefore, this loop will usually only execute + a constant number of times per iteration of the outer loop. */ + for (vsize j = i; j--;) + { + Item *l = dynamic_cast (cols[j]); + Item *lb = l->find_prebroken_piece (RIGHT); + Skyline_pair *skys = Skyline_pair::unsmob (l->get_property ("horizontal-skylines")); + Real left_stickout = skys ? (*skys)[RIGHT].max_height () : 0.0; + bool done = true; + + Direction d = LEFT; + do + { + if (j < i-1) + cur_dist[d] += distances[j]; + + Item *r_col = r_cols[d]; + bool touches = right_stickout - left_stickout + cur_dist[d] < 0.0; + Real dist = 0.0; + + /* we set a distance for the line-starter column even if it's non-broken counterpart + doesn't touch the right column. */ + if (lb) + Separation_item::set_distance (lb, r_col, padding); + + if (touches || j == i-1) + dist = Separation_item::set_distance (l, r_col, padding); + + if (j == i-1 && d == LEFT) + distances.push_back (dist); + + if (j == i-1) + cur_dist[d] = distances[j]; + + done = done && !touches; + } + while (flip (&d) != LEFT && rb); + + /* we need the empty check for gregorian notation, where there are a lot of + extraneous paper-columns that we need to skip over */ + if (done && !Separation_item::is_empty (l)) + break; + } + } +} + + void Spacing_spanner::generate_springs (Grob *me, vector const &cols, Spacing_options const *options) { - Paper_column *prev = 0; - for (vsize i = 0; i < cols.size (); i++) + Paper_column *prev = dynamic_cast (cols[0]); + for (vsize i = 1; i < cols.size (); i++) { Paper_column *col = dynamic_cast (cols[i]); Paper_column *next = (i + 1 < cols.size ()) ? dynamic_cast (cols[i+1]) : 0; - if (i > 0) - generate_pair_spacing (me, prev, col, next, options); + generate_pair_spacing (me, prev, col, next, options); prev = col; } + + set_column_rods (cols, 0.1); // FIXME: padding } /* @@ -237,43 +305,21 @@ Spacing_spanner::musical_column_spacing (Grob *me, Spacing_options const *options) { Real base_note_space = note_spacing (me, left_col, right_col, options); - - Real max_fixed = 0; - Real max_space = 0; - Real compound_note_space = 0.0; - Real compound_fixed_note_space = 0.0; + Spring spring; if (options->stretch_uniformly_) - { - compound_note_space = base_note_space; - - if (!Paper_column::is_musical (right_col)) - { - /* - Crude fix for notes that lead up to barlines and time sigs. - */ - Interval lext = right_col->extent (right_col, X_AXIS); - if (!lext.is_empty ()) - compound_note_space += -lext[LEFT]; - } - } + spring = Spring (base_note_space, 0.0); else { - int wish_count = 0; - + vector springs; extract_grob_set (left_col, "right-neighbors", neighbors); - /* - We adjust the space following a note only if the next note - happens after the current note (this is set in the grob - property SPACING-SEQUENCE. - */ for (vsize i = 0; i < neighbors.size (); i++) { Grob *wish = neighbors[i]; - Item *wish_rcol = Note_spacing::right_column (wish); - if (Note_spacing::left_column (wish) != left_col + Item *wish_rcol = Spacing_interface::right_column (wish); + if (Spacing_interface::left_column (wish) != left_col || (wish_rcol != right_col && wish_rcol != right_col->original ())) continue; @@ -281,32 +327,10 @@ Spacing_spanner::musical_column_spacing (Grob *me, This is probably a waste of time in the case of polyphonic music. */ if (Note_spacing::has_interface (wish)) - { - Real space = 0.0; - Real fixed = 0.0; - - Note_spacing::get_spacing (wish, right_col, base_note_space, options->increment_, &space, &fixed); - - - max_space = max (max_space, space); - max_fixed = max (max_fixed, fixed); - - compound_note_space += space; - compound_fixed_note_space += fixed; - wish_count++; - } + springs.push_back (Note_spacing::get_spacing (wish, right_col, base_note_space, options->increment_)); } - if (Paper_column::when_mom (right_col).grace_part_ - && !Paper_column::when_mom (left_col).grace_part_) - { - /* - Ugh. 0.8 is arbitrary. - */ - compound_note_space *= 0.8; - } - - if (compound_note_space < 0 || wish_count == 0) + if (springs.empty ()) { if (!Paper_column::is_musical (right_col)) @@ -317,9 +341,8 @@ Spacing_spanner::musical_column_spacing (Grob *me, spacing, because the width of s^"text" output is also taken into account here. */ - compound_fixed_note_space = options->increment_; - compound_note_space = max (base_note_space, - options->increment_); + spring = Spring (max (base_note_space, options->increment_), + options->increment_); } else { @@ -327,44 +350,30 @@ Spacing_spanner::musical_column_spacing (Grob *me, Fixed should be 0.0. If there are no spacing wishes, we're likely dealing with polyphonic spacing of hemiolas. - We used to have compound_fixed_note_space = options->increment_ + We used to have min_distance_ = options->increment_ but this can lead to numeric instability problems when we do - inverse_strength = (compound_note_space - compound_fixed_note_space) + inverse_strength = (distance_ - min_distance_) */ - - compound_note_space = base_note_space; - compound_fixed_note_space = 0.0; + spring = Spring (base_note_space, 0.0); } } - else if (to_boolean (me->get_property ("average-spacing-wishes"))) - { - compound_note_space /= wish_count; - compound_fixed_note_space /= wish_count; - } else - { - compound_fixed_note_space = max_fixed; - compound_note_space = max_space; - } + spring = merge_springs (springs); + } + if (Paper_column::when_mom (right_col).grace_part_ + && !Paper_column::when_mom (left_col).grace_part_) + { /* - Whatever we do, the fixed space is smaller than the real - space. - - TODO: this criterion is discontinuous in the derivative. - Maybe it should be continuous? + Ugh. 0.8 is arbitrary. */ - compound_fixed_note_space = min (compound_fixed_note_space, - compound_note_space); + spring *= 0.8; } - Real inverse_strength = 1.0; - Real distance = 1.0; - /* TODO: make sure that the space doesn't exceed the right margin. */ @@ -379,16 +388,11 @@ Spacing_spanner::musical_column_spacing (Grob *me, pack as much bars of music as possible into a line, but the line will then be stretched to fill the whole linewidth. */ - inverse_strength = 1.0; - distance = compound_fixed_note_space; - } - else - { - inverse_strength = (compound_note_space - compound_fixed_note_space); - distance = compound_note_space; + spring.set_distance (spring.min_distance ()); + spring.set_inverse_stretch_strength (1.0); } - Spaceable_grob::add_spring (left_col, right_col, distance, inverse_strength); + Spaceable_grob::add_spring (left_col, right_col, spring); } /* @@ -434,12 +438,8 @@ void Spacing_spanner::breakable_column_spacing (Grob *me, Item *l, Item *r, Spacing_options const *options) { - Real compound_fixed = 0.0; - Real compound_space = 0.0; - Real max_fixed = 0.0; - Real max_space = 0.0; - - int wish_count = 0; + vector springs; + Spring spring; Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l); @@ -454,74 +454,46 @@ Spacing_spanner::breakable_column_spacing (Grob *me, Item *l, Item *r, if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob)) continue; - Real space = 0.; - Real fixed_space = 0.; - /* column for the left one settings should be ok due automatic pointer munging. */ assert (spacing_grob->get_column () == l); - Staff_spacing::get_spacing_params (spacing_grob, - &space, &fixed_space); - - if (Paper_column::when_mom (r).grace_part_) - { - /* - Correct for grace notes. - - Ugh. The 0.8 is arbitrary. - */ - space *= 0.8; - } - - max_space = max (max_space, space); - max_fixed = max (max_fixed, fixed_space); - - compound_space += space; - compound_fixed += fixed_space; - wish_count++; + springs.push_back (Staff_spacing::get_spacing (spacing_grob, r)); } } - if (compound_space <= 0.0 || !wish_count) - { - standard_breakable_column_spacing (me, l, r, &compound_fixed, &compound_space, - options); - wish_count = 1; - } + if (springs.empty ()) + spring = standard_breakable_column_spacing (me, l, r, options); else + spring = merge_springs (springs); + + if (Paper_column::when_mom (r).grace_part_) { - if (to_boolean (me->get_property ("average-spacing-wishes"))) - { - compound_space /= wish_count; - compound_fixed /= wish_count; - } - else - { - compound_fixed = max_fixed; - compound_space = max_space; - } - + /* + Correct for grace notes. + + Ugh. The 0.8 is arbitrary. + */ + spring *= 0.8; } if (Paper_column::is_musical (r) && l->break_status_dir () == CENTER && fills_measure (me, l, r)) { - compound_space += 1.0; + spring.set_distance (spring.distance () + 1.0); + spring.set_default_strength (); } if (options->stretch_uniformly_ && l->break_status_dir () != RIGHT) - compound_fixed = 0.0; - - assert (!isinf (compound_space)); - compound_space = max (compound_space, compound_fixed); + { + spring.set_min_distance (0.0); + spring.set_default_strength (); + } - Real inverse_strength = (compound_space - compound_fixed); - Real distance = compound_space; - Spaceable_grob::add_spring (l, r, distance, inverse_strength); + Spaceable_grob::add_spring (l, r, spring); } ADD_INTERFACE (Spacing_spanner,