X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;ds=sidebyside;f=lily%2Fspacing-determine-loose-columns.cc;h=fe072bca0aba3a93097095595e49101faaded388;hb=1d23a8fe3d3abd847bb9199e64241347d836917b;hp=610b96b32081074d8c78ef1db6afd682b42dc2e8;hpb=8097d28e1530571451dc9c73a6fe65b747aa92bd;p=lilypond.git diff --git a/lily/spacing-determine-loose-columns.cc b/lily/spacing-determine-loose-columns.cc index 610b96b320..fe072bca0a 100644 --- a/lily/spacing-determine-loose-columns.cc +++ b/lily/spacing-determine-loose-columns.cc @@ -4,21 +4,23 @@ source file of the GNU LilyPond music typesetter - (c) 2005 Han-Wen Nienhuys - + (c) 2005--2007 Han-Wen Nienhuys */ +#include "staff-spacing.hh" - +#include "spacing-options.hh" #include "system.hh" #include "paper-column.hh" #include "column-x-positions.hh" -#include "staff-spacing.hh" #include "pointer-group-interface.hh" +#include "spacing-interface.hh" #include "spacing-spanner.hh" #include "note-spacing.hh" - +#include "moment.hh" +#include "grob-array.hh" #include "break-align-interface.hh" +#include "warn.hh" /* Return whether COL is fixed to its neighbors by some kind of spacing @@ -31,11 +33,24 @@ (Otherwise, we might risk core dumps, and other weird stuff.) */ static bool -is_loose_column (Grob *l, Grob *c, Grob *r) +is_loose_column (Grob *l, Grob *col, Grob *r, Spacing_options const *options) { - extract_grob_set (c, "right-neighbors", rns); - extract_grob_set (c, "left-neighbors", lns); + if (!to_boolean (col->get_property ("allow-loose-spacing"))) + return false; + + + if ((options->float_nonmusical_columns_ + || options->float_grace_columns_) + && Paper_column::when_mom (col).grace_part_) + { + return true; + } + + if (Paper_column::is_musical (col) + || Paper_column::is_breakable (col)) + return false; + /* If this column doesn't have a proper neighbor, we should really make it loose, but spacing it correctly is more than we can @@ -57,9 +72,14 @@ is_loose_column (Grob *l, Grob *c, Grob *r) such a borderline case.) */ - if (lns.is_empty () || rns.is_empty ()) + + extract_grob_set (col, "right-neighbors", rns); + extract_grob_set (col, "left-neighbors", lns); + + if (lns.empty () || rns.empty ()) return false; + Item *l_neighbor = dynamic_cast (lns[0]); Item *r_neighbor = dynamic_cast (rns[0]); @@ -67,7 +87,7 @@ is_loose_column (Grob *l, Grob *c, Grob *r) return false; l_neighbor = l_neighbor->get_column (); - r_neighbor = dynamic_cast (Note_spacing::right_column (r_neighbor)); + r_neighbor = dynamic_cast (Spacing_interface::right_column (r_neighbor)); if (l == l_neighbor && r == r_neighbor) return false; @@ -80,32 +100,24 @@ is_loose_column (Grob *l, Grob *c, Grob *r) some cases (two isolated, consecutive clef changes) won't be nicely folded, but hey, then don't do that. */ - if (! ((Paper_column::is_musical (l_neighbor) || Item::is_breakable (l_neighbor)) - && (Paper_column::is_musical (r_neighbor) || Item::is_breakable (r_neighbor)))) - { - return false; - } + if (! ((Paper_column::is_musical (l_neighbor) || Paper_column::is_breakable (l_neighbor)) + && (Paper_column::is_musical (r_neighbor) || Paper_column::is_breakable (r_neighbor)))) + return false; /* - A rather hairy check, but we really only want to move around - clefs. (anything else?) - in any case, we don't want to move bar lines. */ - extract_grob_set (c, "elements", elts); - for (int i = elts.size (); i--; ) + extract_grob_set (col, "elements", elts); + for (vsize i = elts.size (); i--;) { Grob *g = elts[i]; - if (g && Break_align_interface::has_interface (g)) + if (g && Break_alignment_interface::has_interface (g)) { extract_grob_set (g, "elements", gelts); - for (int j = gelts.size (); j--; ) + for (vsize j = gelts.size (); j--;) { Grob *h = gelts[j]; - /* - ugh. -- fix staff-bar name? - */ if (h && h->get_property ("break-align-symbol") == ly_symbol2scm ("staff-bar")) return false; } @@ -115,109 +127,126 @@ is_loose_column (Grob *l, Grob *c, Grob *r) return true; } +void +Spacing_spanner::set_distances_for_loose_col (Grob *me, Grob *c, + Drul_array next_door, + Spacing_options const *options) +{ + Direction d = LEFT; + Drul_array dists (0, 0); + + do + { + Item *lc = dynamic_cast ((d == LEFT) ? next_door[LEFT] : c); + Item *rc = dynamic_cast (d == LEFT ? c : next_door[RIGHT]); + + extract_grob_set (lc, "spacing-wishes", wishes); + for (vsize k = wishes.size (); k--;) + { + Grob *sp = wishes[k]; + if (Spacing_interface::left_column (sp) != lc + || Spacing_interface::right_column (sp) != rc) + continue; + + if (Note_spacing::has_interface (sp)) + { + /* + The note spacing should be taken from the musical + columns. + */ + Real base = note_spacing (me, lc, rc, options); + Spring spring = Note_spacing::get_spacing (sp, rc, base, options->increment_); + + dists[d] = max (dists[d], spring.min_distance ()); + } + else if (Staff_spacing::has_interface (sp)) + { + Spring spring = Staff_spacing::get_spacing (sp, rc); + + dists[d] = max (dists[d], spring.min_distance ()); + } + else + programming_error ("Subversive spacing wish"); + } + } + while (flip (&d) != LEFT); + + Rod r; + r.distance_ = dists[LEFT] + dists[RIGHT]; + r.item_drul_ = next_door; + + r.add_to_cols (); +} + + /* Remove columns that are not tightly fitting from COLS. In the removed columns, set 'between-cols to the columns where it is in between. */ void -Spacing_spanner::prune_loose_columns (Grob *me, Link_array *cols, - Spacing_options const *options) +Spacing_spanner::prune_loose_columns (Grob *me, + vector *cols, + Spacing_options *options) { - Link_array newcols; - Real increment = robust_scm2double (me->get_property ("spacing-increment"), 1.2); - for (int i = 0; i < cols->size (); i++) + vector newcols; + + for (vsize i = 0; i < cols->size (); i++) { - if (Item::is_breakable (cols->elem (i)) - || Paper_column::is_musical (cols->elem (i))) - { - newcols.push (cols->elem (i)); - continue; - } + Grob *c = cols->at (i); + + bool loose = (i > 0 && i + 1 < cols->size ()) + && is_loose_column (cols->at (i - 1), c, cols->at (i + 1), options); - Grob *c = cols->elem (i); - if (is_loose_column (cols->elem (i - 1), c, cols->elem (i + 1))) + if (loose) { extract_grob_set (c, "right-neighbors", rns_arr); extract_grob_set (c, "left-neighbors", lns_arr); - - SCM lns = lns_arr.size () ? lns_arr.top()->self_scm () : SCM_BOOL_F; - SCM rns = rns_arr.size () ? rns_arr.top()->self_scm () : SCM_BOOL_F; - + + SCM lns = lns_arr.size () ? lns_arr.back ()->self_scm () : SCM_BOOL_F; + SCM rns = rns_arr.size () ? rns_arr.back ()->self_scm () : SCM_BOOL_F; + /* Either object can be non existent, if the score ends prematurely. */ extract_grob_set (unsmob_grob (rns), "right-items", right_items); - c->set_object ("between-cols", scm_cons (lns, - right_items[0]->self_scm ())); - - /* - Set distance constraints for loose columns - */ - Drul_array next_door; - next_door[LEFT] = cols->elem (i - 1); - next_door[RIGHT] = cols->elem (i + 1); - Direction d = LEFT; - Drul_array dists (0, 0); - - do + if (right_items.size () == 0 || !unsmob_grob (lns)) { - dists[d] = 0.0; - Item *lc = dynamic_cast ((d == LEFT) ? next_door[LEFT] : c); - Item *rc = dynamic_cast (d == LEFT ? c : next_door[RIGHT]); - - - extract_grob_set (lc, "spacing-wishes", wishes); - for (int k = wishes.size(); k--;) + c->programming_error ("Cannot determine neighbors for floating column. "); + c->set_object ("between-cols", scm_cons (cols->at (i-1)->self_scm (), + cols->at (i+1)->self_scm ())); + } + else + { + Grob *min_item = 0; + int min_rank = INT_MAX; + for (vsize j = 0; j < right_items.size (); j ++) { - Grob *sp = wishes[k]; - if (Note_spacing::left_column (sp) != lc - || Note_spacing::right_column (sp) != rc) - continue; - - Real space, fixed; - fixed = 0.0; - bool dummy; - - if (d == LEFT) + int rank = dynamic_cast (right_items[j])->get_column ()->get_rank (); + if (rank < min_rank) { - /* - The note spacing should be taken from the musical - columns. - - */ - Real base = note_spacing (me, lc, rc, options, &dummy); - Note_spacing::get_spacing (sp, rc, base, increment, &space, &fixed); - - space -= increment; - - dists[d] = max (dists[d], space); - } - else - { - Real space, fixed_space; - Staff_spacing::get_spacing_params (sp, - &space, &fixed_space); - - dists[d] = max (dists[d], fixed_space); + min_item = right_items[j]; + min_rank = rank; } } - } - while (flip (&d) != LEFT); + + c->set_object ("between-cols", scm_cons (lns, + min_item->self_scm ())); - Rod r; - r.distance_ = dists[LEFT] + dists[RIGHT]; - r.item_drul_[LEFT] = dynamic_cast (cols->elem (i - 1)); - r.item_drul_[RIGHT] = dynamic_cast (cols->elem (i + 1)); + /* + Set distance constraints for loose columns + */ + Drul_array next_door (dynamic_cast (cols->at (i - 1)), + dynamic_cast (cols->at (i + 1))); - r.add_to_cols (); - } - else - { - newcols.push (c); + set_distances_for_loose_col (me, c, next_door, options); + } } + + if (!loose) + newcols.push_back (c); } *cols = newcols; @@ -227,21 +256,21 @@ Spacing_spanner::prune_loose_columns (Grob *me, Link_array *cols, Set neighboring columns determined by the spacing-wishes grob property. */ void -Spacing_spanner::set_explicit_neighbor_columns (Link_array const &cols) +Spacing_spanner::set_explicit_neighbor_columns (vector const &cols) { - for (int i = 0; i < cols.size (); i++) + for (vsize i = 0; i < cols.size (); i++) { SCM right_neighbors = Grob_array::make_array (); Grob_array *rn_arr = unsmob_grob_array (right_neighbors); - int min_rank = 100000; // inf. + int min_rank = INT_MAX; extract_grob_set (cols[i], "spacing-wishes", wishes); - for (int k = wishes.size(); k--;) + for (vsize k = wishes.size (); k--;) { - Item *wish = dynamic_cast ( wishes[k]); + Item *wish = dynamic_cast (wishes[k]); Item *lc = wish->get_column (); - Grob *right = Note_spacing::right_column (wish); + Grob *right = Spacing_interface::right_column (wish); if (!right) continue; @@ -271,13 +300,13 @@ Spacing_spanner::set_explicit_neighbor_columns (Link_array const &cols) extract_grob_set (rc, "left-neighbors", lns_arr); if (lns_arr.size ()) { - Item *it = dynamic_cast (lns_arr.top()); + Item *it = dynamic_cast (lns_arr.back ()); maxrank = Paper_column::get_rank (it->get_column ()); } if (left_rank >= maxrank) { - + if (left_rank > maxrank) { Grob_array *ga = unsmob_grob_array (rc->get_object ("left-neighbors")); @@ -290,9 +319,7 @@ Spacing_spanner::set_explicit_neighbor_columns (Link_array const &cols) } if (rn_arr->size ()) - { - cols[i]->set_object ("right-neighbors", right_neighbors); - } + cols[i]->set_object ("right-neighbors", right_neighbors); } } @@ -301,33 +328,31 @@ Spacing_spanner::set_explicit_neighbor_columns (Link_array const &cols) yet. Only do breakable non-musical columns, and musical columns. */ void -Spacing_spanner::set_implicit_neighbor_columns (Link_array const &cols) +Spacing_spanner::set_implicit_neighbor_columns (vector const &cols) { - for (int i = 0; i < cols.size (); i++) + for (vsize i = 0; i < cols.size (); i++) { Item *it = dynamic_cast (cols[i]); - if (!Item::is_breakable (it) && !Paper_column::is_musical (it)) + if (!Paper_column::is_breakable (it) && !Paper_column::is_musical (it)) continue; - // it->breakable || it->musical - /* sloppy with typing left/right-neighbors should take list, but paper-column found instead. */ extract_grob_set (cols[i], "left-neighbors", lns); - if (lns.is_empty () && i ) + if (lns.empty () && i) { - SCM ga_scm = Grob_array::make_array(); + SCM ga_scm = Grob_array::make_array (); Grob_array *ga = unsmob_grob_array (ga_scm); - ga->add (cols[i-1]); + ga->add (cols[i - 1]); cols[i]->set_object ("left-neighbors", ga_scm); } extract_grob_set (cols[i], "right-neighbors", rns); - if (rns.is_empty () && i < cols.size () - 1) + if (rns.empty () && i + 1 < cols.size ()) { - SCM ga_scm = Grob_array::make_array(); + SCM ga_scm = Grob_array::make_array (); Grob_array *ga = unsmob_grob_array (ga_scm); - ga->add (cols[i+1]); + ga->add (cols[i + 1]); cols[i]->set_object ("right-neighbors", ga_scm); } }