-/*
- spacing-spanner.cc -- implement Spacing_spanner
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1999--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
- */
-
-#include <math.h>
-#include <stdio.h>
-
-#include "line-of-score.hh"
-#include "paper-score.hh"
-#include "paper-column.hh"
-#include "item.hh"
-#include "moment.hh"
-#include "note-spacing.hh"
-#include "misc.hh"
-#include "warn.hh"
-#include "staff-spacing.hh"
-#include "spring.hh"
-#include "paper-column.hh"
-#include "spaceable-grob.hh"
-
/*
- paper-column:
-
- Don't be confused by right-items: each spacing wish can also contain
- a number of items, with which a spacing constraint may be kept. It's
- a little baroque, but it might come in handy later on?
-
- */
-class Spacing_spanner
-{
-public:
- static void standard_breakable_column_spacing (Grob * me, Item*l, Item*r,
- Real * fixed, Real * space, Moment);
-
-
- static Real default_bar_spacing (Grob*,Grob*,Grob*,Moment);
- static Real note_spacing (Grob*,Grob*,Grob*,Moment, bool*);
- static Real get_duration_space (Grob*,Moment dur, Rational shortest, bool*);
- static Rational find_shortest (Link_array<Grob> const &);
- static void breakable_column_spacing (Grob*, Item* l, Item *r, Moment);
- static void find_loose_columns () {}
- static void prune_loose_colunms (Grob*,Link_array<Grob> *cols, Rational);
- static void find_loose_columns (Link_array<Grob> cols);
- static void set_explicit_neighbor_columns (Link_array<Grob> cols);
- static void set_implicit_neighbor_columns (Link_array<Grob> cols);
- static void do_measure (Rational, Grob*me,Link_array<Grob> *cols);
- static void musical_column_spacing (Grob*,Item*,Item*, Real, Rational);
- DECLARE_SCHEME_CALLBACK (set_springs, (SCM ));
-};
-
-/*
- Return whether COL is fixed to its neighbors by some kind of spacing
- constraint.
-*/
-static bool
-loose_column (Grob *l, Grob *c, Grob *r)
-{
- SCM rns = c->get_grob_property ("right-neighbors");
- SCM lns = c->get_grob_property ("left-neighbors");
-
- /*
- If this column doesn't have a proper neighbor, we should really
- make it loose, but spacing it correctly is more than we can
- currently can handle.
-
- (this happens in the following situation:
-
- |
- | clef G
- *
-
- | | ||
- | | ||
- O O ||
-
-
- the column containing the clef is really loose, and should be
- attached right to the first column, but that is a lot of work for
- such a borderline case.)
-
- */
- if (!gh_pair_p (lns) || !gh_pair_p (rns))
- return false;
+ This file is part of LilyPond, the GNU music typesetter.
- Item * l_neighbor = dynamic_cast<Item*> (unsmob_grob (gh_car (lns)));
- Item * r_neighbor = dynamic_cast<Item*> (unsmob_grob (gh_car (rns)));
+ Copyright (C) 1999--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
- if (!l_neighbor || !r_neighbor)
- return false;
-
- l_neighbor = l_neighbor->column_l();
- r_neighbor = dynamic_cast<Item*> (Note_spacing::right_column (r_neighbor));
-
- if (l == l_neighbor && r == r_neighbor)
- return false;
-
- if (!l_neighbor || !r_neighbor)
- return false;
-
- /*
- Only declare loose if the bounds make a little sense. This means
- some cases (two isolated, consecutive clef changes) won't be
- nicely folded, but hey, then don't do that.
- */
- if ((Paper_column::musical_b (l_neighbor) || Item::breakable_b (l_neighbor))
- && (Paper_column::musical_b (r_neighbor) || Item::breakable_b (r_neighbor)))
- {
- return true;
- }
-
-
- /*
- If in doubt: we're not loose; the spacing engine should space for
- it, risking suboptimal spacing.
+ LilyPond is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
- (Otherwise, we might risk core dumps, and other weird stuff.)
+ LilyPond is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
- */
- return false;
-}
-
-/*
- Remove columns that are not tightly fitting from COLS. In the
- removed columns, set 'between-cols to the columns where it is in
- between.
+ You should have received a copy of the GNU General Public License
+ along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
*/
-void
-Spacing_spanner::prune_loose_colunms (Grob*me,Link_array<Grob> *cols, Rational shortest)
-{
- Link_array<Grob> newcols;
- Real increment = gh_scm2double (me->get_grob_property ("spacing-increment"));
- for (int i=0; i < cols->size (); i++)
- {
- if (Item::breakable_b (cols->elem(i)) || Paper_column::musical_b (cols->elem (i)))
- {
- newcols.push (cols->elem(i));
- continue;
- }
-
- Grob *c = cols->elem(i);
- if (loose_column (cols->elem (i-1), c, cols->elem (i+1)))
- {
- SCM lns = c->get_grob_property ("left-neighbors");
- lns = gh_pair_p (lns) ? gh_car (lns) : SCM_BOOL_F;
-
- SCM rns = c->get_grob_property ("right-neighbors");
- rns = gh_pair_p (rns) ? gh_car (rns) : SCM_BOOL_F;
-
- /*
- Either object can be non existent, if the score ends
- prematurely.
- */
- rns = gh_car (unsmob_grob (rns)->get_grob_property ("right-items"));
- c->set_grob_property ("between-cols", gh_cons (lns,
- rns));
-
- /*
- Set distance constraints for loose columns
- */
- Drul_array<Grob*> next_door;
- next_door[LEFT] =cols->elem (i - 1);
- next_door[RIGHT] =cols->elem (i + 1);
- Direction d = LEFT;
- Drul_array<Real> dists(0,0);
-
- do
- {
- dists[d] = 0.0;
- Item *lc = dynamic_cast<Item*> ((d == LEFT) ? next_door[LEFT] : c);
- Item *rc = dynamic_cast<Item*> (d == LEFT ? c : next_door[RIGHT]);
-
- for (SCM s = lc->get_grob_property ("spacing-wishes");
- gh_pair_p (s); s = gh_cdr (s))
- {
- Grob *sp = unsmob_grob (gh_car (s));
- 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)
- {
- /*
- The note spacing should be taken from the musical
- columns.
-
- */
- Real base = note_spacing (me, lc, rc, shortest, &dummy);
- Note_spacing::get_spacing (sp, rc, base, increment, &space, &fixed);
-
- space -= increment;
-
- dists[d] = dists[d] >? space;
- }
- else
- {
- Real space, fixed_space;
- Staff_spacing::get_spacing_params (sp,
- &space, &fixed_space);
-
- dists[d] = dists[d] >? fixed_space;
- }
-
- }
- }
- while (flip (&d) != LEFT);
-
- Rod r;
- r.distance_f_ = dists[LEFT] + dists[RIGHT];
- r.item_l_drul_[LEFT] = dynamic_cast<Item*> (cols->elem(i-1));
- r.item_l_drul_[RIGHT] = dynamic_cast<Item*> (cols->elem (i+1));
-
- r.add_to_cols ();
- }
- else
- {
- newcols.push (c);
- }
- }
- *cols = newcols;
-}
+#include "spacing-spanner.hh"
-/*
- Set neighboring columns determined by the spacing-wishes grob property.
-*/
-void
-Spacing_spanner::set_explicit_neighbor_columns (Link_array<Grob> cols)
-{
- for (int i=0; i < cols.size(); i++)
- {
- SCM right_neighbors = SCM_EOL;
- int min_rank = 100000; // inf.
-
-
- SCM wishes= cols[i]->get_grob_property ("spacing-wishes");
- for (SCM s =wishes; gh_pair_p (s); s = gh_cdr (s))
- {
- Item * wish = dynamic_cast<Item*> (unsmob_grob (gh_car (s)));
-
- Item * lc = wish->column_l ();
- Grob * right = Note_spacing::right_column (wish);
-
- if (!right)
- continue;
-
- Item * rc = dynamic_cast<Item*> (right);
-
- int right_rank = Paper_column::rank_i (rc);
- int left_rank = Paper_column::rank_i (lc);
-
- /*
- update the left column.
- */
- if (right_rank <= min_rank)
- {
- if (right_rank < min_rank)
- right_neighbors =SCM_EOL;
-
- min_rank = right_rank;
- right_neighbors = gh_cons (wish->self_scm (), right_neighbors);
- }
-
- /*
- update the right column of the wish.
- */
- int maxrank = 0;
- SCM left_neighs = rc->get_grob_property ("left-neighbors");
- if (gh_pair_p (left_neighs)
- && unsmob_grob (gh_car (left_neighs)))
- {
- Item * it = dynamic_cast<Item*> (unsmob_grob (gh_car (left_neighs)));
- maxrank = Paper_column::rank_i (it->column_l());
- }
-
- if (left_rank >= maxrank)
- {
- if (left_rank > maxrank)
- left_neighs = SCM_EOL;
-
- left_neighs = gh_cons (wish->self_scm (), left_neighs);
- rc->set_grob_property ("left-neighbors", right_neighbors);
- }
- }
-
- if (gh_pair_p (right_neighbors))
- {
- cols[i]->set_grob_property ("right-neighbors", right_neighbors);
- }
- }
-}
-
-/*
- Set neighboring columns that have no left/right-neighbor set
- yet. Only do breakable non-musical columns, and musical columns.
-*/
-void
-Spacing_spanner::set_implicit_neighbor_columns (Link_array<Grob> cols)
-{
- for (int i = 0; i < cols.size (); i++)
- {
- Item * it = dynamic_cast<Item*>(cols[i]);
- if (!Item::breakable_b (it) && !Paper_column::musical_b (it))
- continue;
+#include <math.h>
+#include <cstdio>
- // it->breakable || it->musical
+#include "spacing-options.hh"
+#include "international.hh"
+#include "main.hh"
+#include "moment.hh"
+#include "note-spacing.hh"
+#include "output-def.hh"
+#include "paper-column.hh"
+#include "paper-score.hh"
+#include "pointer-group-interface.hh"
+#include "separation-item.hh"
+#include "skyline-pair.hh"
+#include "spaceable-grob.hh"
+#include "spacing-interface.hh"
+#include "staff-spacing.hh"
+#include "system.hh"
+#include "warn.hh"
- /*
- sloppy with typnig left/right-neighbors should take list, but paper-column found instead.
- */
- SCM ln = cols[i] ->get_grob_property ("left-neighbors");
- if (!gh_pair_p (ln) && i )
- {
- cols[i]->set_grob_property ("left-neighbors", gh_cons (cols[i-1]->self_scm(), SCM_EOL));
- }
-
- SCM rn = cols[i] ->get_grob_property ("right-neighbors");
- if (!gh_pair_p (rn) && i < cols.size () - 1)
- {
- cols[i]->set_grob_property ("right-neighbors", gh_cons (cols[i + 1]->self_scm(), SCM_EOL));
- }
- }
+vector<Grob *>
+Spacing_spanner::get_columns (Grob *me_grob)
+{
+ Spanner *me = dynamic_cast<Spanner *> (me_grob);
+ vector<Grob *> all (get_root_system (me)->used_columns ());
+ vsize start = binary_search (all, (Grob *)me->get_bound (LEFT),
+ &Paper_column::less_than);
+ vsize end = binary_search (all, (Grob *) me->get_bound (RIGHT),
+ &Paper_column::less_than);
+
+ all = vector<Grob *> (all.begin () + start,
+ all.begin () + end + 1);
+ return all;
}
-
-MAKE_SCHEME_CALLBACK (Spacing_spanner, set_springs,1);
+MAKE_SCHEME_CALLBACK (Spacing_spanner, set_springs, 1);
SCM
Spacing_spanner::set_springs (SCM smob)
{
- Grob *me = unsmob_grob (smob);
-
- Link_array<Grob> all (me->pscore_l_->line_l_->column_l_arr ()) ;
+ Spanner *me = unsmob_spanner (smob);
- set_explicit_neighbor_columns (all);
+ /*
+ can't use get_system () ? --hwn.
+ */
+ Spacing_options options;
+ options.init_from_grob (me);
+ vector<Grob *> cols = Spacing_spanner::get_columns (me);
+ set_explicit_neighbor_columns (cols);
- Rational global_shortest = find_shortest (all);
- prune_loose_colunms (me, &all, global_shortest);
- set_implicit_neighbor_columns (all);
-
-
- int j = 0;
- for (int i = 1; i < all.size (); i++)
- {
- Grob *sc = all[i];
- if (Item::breakable_b (sc))
- {
- Link_array<Grob> measure (all.slice (j, i+1));
- do_measure (global_shortest, me, &measure);
- j = i;
- }
- }
+ prune_loose_columns (me, &cols, &options);
+ set_implicit_neighbor_columns (cols);
+ generate_springs (me, cols, &options);
return SCM_UNSPECIFIED;
}
-
/*
We want the shortest note that is also "common" in the piece, so we
find the shortest in each measure, and take the most frequently
This probably gives weird effects with modern music, where every
note has a different duration, but hey, don't write that kind of
stuff, then.
-
*/
-Rational
-Spacing_spanner::find_shortest (Link_array<Grob> const &cols)
+
+MAKE_SCHEME_CALLBACK (Spacing_spanner, calc_common_shortest_duration, 1);
+SCM
+Spacing_spanner::calc_common_shortest_duration (SCM grob)
{
+ Spanner *me = unsmob_spanner (grob);
+
+ vector<Grob *> cols (get_columns (me));
+
/*
ascending in duration
- */
- Array<Rational> durations;
- Array<int> counts;
-
+ */
+ vector<Rational> durations;
+ vector<int> counts;
+
Rational shortest_in_measure;
shortest_in_measure.set_infinite (1);
-
- for (int i =0 ; i < cols.size (); i++)
+
+ for (vsize i = 0; i < cols.size (); i++)
{
- if (Paper_column::musical_b (cols[i]))
- {
- Moment *when = unsmob_moment (cols[i]->get_grob_property ("when"));
-
- /*
- ignore grace notes for shortest notes.
- */
- if (when && when->grace_part_)
- continue;
-
- SCM st = cols[i]->get_grob_property ("shortest-starter-duration");
- Moment this_shortest = *unsmob_moment (st);
- assert (this_shortest.to_bool());
- shortest_in_measure = shortest_in_measure <? this_shortest.main_part_;
- }
- else if (!shortest_in_measure.infty_b()
- && Item::breakable_b (cols[i]))
- {
- int j = 0;
- for (; j < durations.size(); j++)
- {
- if (durations[j] > shortest_in_measure)
- {
- counts.insert (1, j);
- durations.insert (shortest_in_measure, j);
- break;
- }
- else if (durations[j] == shortest_in_measure)
- {
- counts[j]++;
- break;
- }
- }
-
- if (durations.size() == j)
- {
- durations.push (shortest_in_measure);
- counts.push (1);
- }
-
- shortest_in_measure.set_infinite(1);
- }
+ if (Paper_column::is_musical (cols[i]))
+ {
+ Moment *when = unsmob_moment (cols[i]->get_property ("when"));
+
+ /*
+ ignore grace notes for shortest notes.
+ */
+ if (when && when->grace_part_)
+ continue;
+
+ SCM st = cols[i]->get_property ("shortest-starter-duration");
+ Moment this_shortest = *unsmob_moment (st);
+ assert (this_shortest.to_bool ());
+ shortest_in_measure = min (shortest_in_measure, this_shortest.main_part_);
+ }
+ else if (!shortest_in_measure.is_infinity ()
+ && Paper_column::is_breakable (cols[i]))
+ {
+ vsize j = 0;
+ for (; j < durations.size (); j++)
+ {
+ if (durations[j] > shortest_in_measure)
+ {
+ counts.insert (counts.begin () + j, 1);
+ durations.insert (durations.begin () + j, shortest_in_measure);
+ break;
+ }
+ else if (durations[j] == shortest_in_measure)
+ {
+ counts[j]++;
+ break;
+ }
+ }
+
+ if (durations.size () == j)
+ {
+ durations.push_back (shortest_in_measure);
+ counts.push_back (1);
+ }
+
+ shortest_in_measure.set_infinite (1);
+ }
}
- int max_idx = -1;
+ vsize max_idx = VPOS;
int max_count = 0;
- for (int i =durations.size(); i--;)
+ for (vsize i = durations.size (); i--;)
{
if (counts[i] >= max_count)
- {
- max_idx = i;
- max_count = counts[i];
- }
-
- // printf ("Den %d/%d, c %d\n", durations[i].num (), durations[i].den (), counts[i]);
+ {
+ max_idx = i;
+ max_count = counts[i];
+ }
}
- /*
- TODO: 1/8 should be adjustable?
- */
- Rational d = Rational (1,8);
- if (max_idx >= 0)
- d = d <? durations[max_idx] ;
+ SCM bsd = me->get_property ("base-shortest-duration");
+ Rational d = Rational (1, 8);
+ if (Moment *m = unsmob_moment (bsd))
+ d = m->main_part_;
- return d;
+ if (max_idx != VPOS)
+ d = min (d, durations[max_idx]);
+
+ return Moment (d).smobbed_copy ();
}
-/*
- Generate spacing for a single measure. We used to have code that did
- per-measure spacing. Now we have piecewise spacing. We should fix
- this to support "spacing-regions": some regions have different notes
- (different time sigs) than others, and should be spaced differently.
- */
void
-Spacing_spanner::do_measure (Rational shortest, Grob*me, Link_array<Grob> *cols)
+Spacing_spanner::generate_pair_spacing (Grob *me,
+ Paper_column *left_col, Paper_column *right_col,
+ Paper_column *after_right_col,
+ Spacing_options const *options)
{
+ if (Paper_column::is_musical (left_col))
+ {
+ if (!Paper_column::is_musical (right_col)
+ && (options->float_nonmusical_columns_ || to_boolean (right_col->get_property ("maybe-loose")))
+ && after_right_col
+ && Paper_column::is_musical (after_right_col))
+ {
+ /*
+ TODO: should generate rods to prevent collisions.
+ */
+ musical_column_spacing (me, left_col, after_right_col, options);
+ right_col->set_object ("between-cols", scm_cons (left_col->self_scm (),
+ after_right_col->self_scm ()));
+ }
+ else
+ musical_column_spacing (me, left_col, right_col, options);
- Real headwid = gh_scm2double (me->get_grob_property ("spacing-increment"));
- for (int i= 0; i < cols->size () - 1; i++)
+ if (Item *rb = right_col->find_prebroken_piece (LEFT))
+ musical_column_spacing (me, left_col, rb, options);
+ }
+ else
{
- Item * l = dynamic_cast<Item*> (cols->elem (i));
- Item * r = dynamic_cast<Item*> (cols->elem (i+1));
-
- Paper_column * lc = dynamic_cast<Paper_column*> (l);
- Paper_column * rc = dynamic_cast<Paper_column*> (r);
-
- if (!Paper_column::musical_b (l))
- {
- breakable_column_spacing (me, l, r, shortest);
-
- /*
-
- The case that the right part is broken as well is rather
- rare, but it is possible, eg. with a single empty measure,
- or if one staff finishes a tad earlier than the rest.
-
- */
- Item *lb = l->find_prebroken_piece (RIGHT);
- Item *rb = r->find_prebroken_piece (LEFT);
-
- if (lb)
- breakable_column_spacing (me, lb,r, shortest);
-
- if (rb)
- breakable_column_spacing (me, l, rb, shortest);
- if (lb && rb)
- breakable_column_spacing (me, lb, rb, shortest);
-
- continue ;
- }
-
-
- musical_column_spacing (me, lc, rc, headwid, shortest);
- if (Item *rb = r->find_prebroken_piece (LEFT))
- musical_column_spacing (me, lc, rb, headwid, shortest);
- }
-}
+ /*
+ The case that the right part is broken as well is rather
+ rare, but it is possible, eg. with a single empty measure,
+ or if one staff finishes a tad earlier than the rest.
+ */
+ Item *lb = left_col->find_prebroken_piece (RIGHT);
+ Item *rb = right_col->find_prebroken_piece (LEFT);
+ if (left_col && right_col)
+ breakable_column_spacing (me, left_col, right_col, options);
-/*
- Generate the space between two musical columns LC and RC, given spacing parameters INCR and SHRTEST.
- */
-void
-Spacing_spanner::musical_column_spacing (Grob *me, Item * lc, Item *rc, Real increment, Rational shortest)
-{
- bool expand_only = false;
- Real base_note_space = note_spacing (me, lc, rc, shortest, &expand_only);
+ if (lb && right_col)
+ breakable_column_spacing (me, lb, right_col, options);
- Real max_note_space = -infinity_f;
- Real max_fixed_note_space = -infinity_f;
+ if (left_col && rb)
+ breakable_column_spacing (me, left_col, rb, options);
- SCM seq = lc->get_grob_property ("right-neighbors");
+ if (lb && rb)
+ breakable_column_spacing (me, lb, rb, options);
+ }
+}
- /*
- 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 (SCM s = seq; gh_pair_p (s); s = ly_cdr (s))
+static void
+set_column_rods (vector<Grob *> const &cols, Real padding)
+{
+ /* distances[i] will be the minimum distance between column i and column i+1 */
+ vector<Real> distances;
+
+ for (vsize i = 1; i < cols.size (); i++)
{
- Grob * wish = unsmob_grob (gh_car (s));
+ assert (distances.size () == i - 1);
- Item *wish_rcol = Note_spacing::right_column (wish);
- if (Note_spacing::left_column (wish) != lc
- || (wish_rcol != rc && wish_rcol != rc->original_l_))
- continue;
+ Item *r = dynamic_cast<Item *> (cols[i]);
+ Item *rb = r->find_prebroken_piece (LEFT);
- /*
- 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, rc, base_note_space, increment, &space, &fixed);
- max_note_space = max_note_space >? space;
- max_fixed_note_space = max_fixed_note_space >? fixed;
- }
+ if (Separation_item::is_empty (r) && (!rb || Separation_item::is_empty (rb)))
+ {
+ distances.push_back (0);
+ continue;
+ }
- }
+ Skyline_pair *skys = Skyline_pair::unsmob (r->get_property ("horizontal-skylines"));
+ Real right_stickout = skys ? (*skys)[LEFT].max_height () : 0.0;
- if (max_note_space < 0)
- {
- max_note_space = base_note_space;
- max_fixed_note_space = increment;
- }
+ /* min rather than max because right-stickout will be negative if the right-hand column
+ sticks out a lot to the left */
+ right_stickout = min (right_stickout,
+ Separation_item::conditional_skyline (r, cols[i - 1]).max_height ());
+
+ Drul_array<Item *> r_cols (r, rb);
+ Drul_array<Real> cur_dist (0.0, 0.0);
- Spaceable_grob::add_spring (lc, rc, max_note_space, 1 / (max_note_space -max_fixed_note_space), expand_only);
+ /* 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<Item *> (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 its 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];
+
+ cur_dist[d] = max (cur_dist[d], dist);
+ 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::standard_breakable_column_spacing (Grob * me, Item*l, Item*r,
- Real * fixed, Real * space,
- Moment shortest)
+Spacing_spanner::generate_springs (Grob *me,
+ vector<Grob *> const &cols,
+ Spacing_options const *options)
{
- *fixed = l->extent (l, X_AXIS)[RIGHT] - r->extent (r, X_AXIS)[LEFT];
-
- if (l->breakable_b (l) && r->breakable_b(r))
+ Paper_column *prev = dynamic_cast<Paper_column *> (cols[0]);
+ for (vsize i = 1; i < cols.size (); i++)
{
- Moment *dt = unsmob_moment (l->get_grob_property ("measure-length"));
- Moment mlen (1);
- if (dt)
- mlen = *dt;
-
- Real incr = gh_scm2double (me->get_grob_property ("spacing-increment"));
-
- *space = *fixed + incr * double (mlen.main_part_ / shortest.main_part_) * 0.8;
- }
- else
- {
- Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
- bool dummy;
+ Paper_column *col = dynamic_cast<Paper_column *> (cols[i]);
+ Paper_column *next = (i + 1 < cols.size ()) ? dynamic_cast<Paper_column *> (cols[i + 1]) : 0;
+
+ generate_pair_spacing (me, prev, col, next, options);
- *space = *fixed + get_duration_space (me, dt, shortest.main_part_, &dummy);
+ prev = col;
}
-
-
-}
+ Real padding = robust_scm2double (prev->get_property ("padding"), 0.1);
+ set_column_rods (cols, padding);
+}
/*
- Read hints from L and generate springs.
- */
+ Generate the space between two musical columns LEFT_COL and RIGHT_COL.
+*/
void
-Spacing_spanner::breakable_column_spacing (Grob*me, Item* l, Item *r,Moment shortest)
+Spacing_spanner::musical_column_spacing (Grob *me,
+ Item *left_col,
+ Item *right_col,
+ Spacing_options const *options)
{
- Real max_fixed = -infinity_f;
- Real max_space = -infinity_f;
-
- standard_breakable_column_spacing (me, l, r, &max_fixed, &max_space ,
- shortest);
-
- for (SCM s = l->get_grob_property ("spacing-wishes");
- gh_pair_p (s); s = gh_cdr (s))
- {
- Item * spacing_grob = dynamic_cast<Item*> (unsmob_grob (gh_car (s)));
-
- if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
- continue;
+ Real base_note_space = note_spacing (me, left_col, right_col, options);
+ Spring spring;
- Real space;
- Real fixed_space;
-
- /*
- column for the left one settings should be ok due automatic
- pointer munging.
+ if (options->stretch_uniformly_)
+ spring = Spring (base_note_space, 0.0);
+ else
+ {
+ vector<Spring> springs;
+ extract_grob_set (left_col, "spacing-wishes", wishes);
- */
- assert (spacing_grob-> column_l () == l);
-
- Staff_spacing::get_spacing_params (spacing_grob,
- &space, &fixed_space);
- if (space > max_space)
- {
- max_space = space;
- max_fixed = fixed_space;
- }
- }
+ for (vsize i = 0; i < wishes.size (); i++)
+ {
+ Grob *wish = wishes[i];
+ if (Spacing_interface::left_column (wish) != left_col)
+ {
+ /* This shouldn't really happen, but the ancient music
+ stuff really messes up the spacing code, grrr
+ */
+ continue;
+ }
+
+ extract_grob_set (wish, "right-items", right_items);
+ bool found_matching_column = false;
+ for (vsize j = 0; j < right_items.size (); j++)
+ {
+ Item *it = dynamic_cast<Item *> (right_items[j]);
+ if (it && (right_col == it->get_column ()
+ || right_col->original () == it->get_column ()))
+ found_matching_column = true;
+ }
+
+ /*
+ This is probably a waste of time in the case of polyphonic
+ music. */
+ if (found_matching_column && Note_spacing::has_interface (wish))
+ {
+ Real inc = options->increment_;
+ Grob *gsp = unsmob_grob (left_col->get_object ("grace-spacing"));
+ if (gsp && Paper_column::when_mom (left_col).grace_part_)
+ {
+ Spacing_options grace_opts;
+ grace_opts.init_from_grob (gsp);
+ inc = grace_opts.increment_;
+ }
+ springs.push_back (Note_spacing::get_spacing (wish, right_col, base_note_space, inc));
+ }
+ }
-
-
+ if (springs.empty ())
+ {
- if (isinf (max_space))
- {
- programming_error ("No pref spacing found");
- max_space = 2.0;
- max_fixed = 1.0;
+ if (!Paper_column::is_musical (right_col))
+ {
+ /*
+ There used to be code that examined left_col->extent
+ (X_AXIS), but this is resulted in unexpected wide
+ spacing, because the width of s^"text" output is also
+ taken into account here.
+ */
+ spring = Spring (max (base_note_space, options->increment_),
+ options->increment_);
+ }
+ else
+ {
+ /*
+ Min distance should be 0.0. If there are no spacing
+ wishes, we're probably dealing with polyphonic spacing
+ of hemiolas.
+ */
+ spring = Spring (base_note_space, 0.0);
+ }
+ }
+ else
+ spring = merge_springs (springs);
}
-
- if (l->break_status_dir() == RIGHT
- && Paper_column::when_mom (l) == Paper_column::when_mom (r))
+ if (Paper_column::when_mom (right_col).grace_part_
+ && !Paper_column::when_mom (left_col).grace_part_)
{
- /* Start of line: this space is not stretchable */
- max_fixed = max_space;
+ /*
+ Ugh. 0.8 is arbitrary.
+ */
+ spring *= 0.8;
}
/*
- Hmm. we do 1/0 in the next thing. Perhaps we should check if this
- works on all architectures.
- */
-
- Spaceable_grob::add_spring (l, r, max_space, 1/(max_space - max_fixed), false);
-}
-
-
-/**
- Get the measure wide ant for arithmetic spacing.
+ TODO: make sure that the space doesn't exceed the right margin.
*/
-Real
-Spacing_spanner::get_duration_space (Grob*me, Moment d, Rational shortest, bool * expand_only)
-{
- Real k = gh_scm2double (me->get_grob_property ("shortest-duration-space"));
-
- if (d < shortest)
- {
- Rational ratio = d.main_part_ / shortest;
-
- *expand_only = true;
- return (0.5 + 0.5 * double (ratio)) * k ;
- }
- else
+ if (options->packed_)
{
/*
- @see
- John S. Gourlay. ``Spacing a Line of Music,'' Technical Report
- OSU-CISRC-10/87-TR35, Department of Computer and Information Science,
- The Ohio State University, 1987.
- */
- Real log = log_2 (shortest);
- k -= log;
- Rational compdur = d.main_part_ + d.grace_part_ /Rational (3);
- *expand_only = false;
-
- return (log_2 (compdur) + k) * gh_scm2double (me->get_grob_property ("spacing-increment"));
- }
-}
-
-Real
-Spacing_spanner::note_spacing (Grob*me, Grob *lc, Grob *rc,
- Moment shortest, bool * expand_only)
-{
- Moment shortest_playing_len = 0;
- SCM s = lc->get_grob_property ("shortest-playing-duration");
-
- if (unsmob_moment (s))
- shortest_playing_len = *unsmob_moment (s);
-
- if (! shortest_playing_len.to_bool ())
- {
- programming_error ("can't find a ruling note at " + Paper_column::when_mom (lc).str ());
- shortest_playing_len = 1;
- }
-
- Moment lwhen = Paper_column::when_mom (lc);
- Moment rwhen = Paper_column::when_mom (rc);
-
- Moment delta_t = rwhen - lwhen;
- Real dist = 0.0;
-
- if (delta_t.main_part_ && !lwhen.grace_part_)
- {
- dist = get_duration_space (me, shortest_playing_len, shortest.main_part_, expand_only);
- dist *= (double) (delta_t.main_part_ / shortest_playing_len.main_part_);
- }
- else if (delta_t.grace_part_)
- {
- /*
- TODO: figure out how to space grace notes.
+ In packed mode, pack notes as tight as possible. This makes
+ sense mostly in combination with ragged-right mode: the notes
+ are then printed at minimum distance. This is mostly useful
+ for ancient notation, but may also be useful for some flavours
+ of contemporary music. If not in ragged-right mode, lily will
+ pack as many bars of music as possible into a line, but the
+ line will then be stretched to fill the whole linewidth.
+
+ Note that we don't actually pack things as tightly as possible:
+ we don't allow the next column to begin before this one ends.
*/
- dist = get_duration_space (me, shortest, shortest.main_part_, expand_only);
-
- Real grace_fact = 1.0;
- SCM gf = me->get_grob_property ("grace-space-factor");
- if (gh_number_p (gf))
- grace_fact = gh_scm2double (gf);
+ /* FIXME: the else clause below is the "right" thing to do,
+ but we can't do it because of all the empty columns that the
+ ligature-engravers leave lying around. In that case, the extent of
+ the column is incorrect because it includes note-heads that aren't
+ there. We get around this by only including the column extent if
+ the left-hand column is "genuine". This is a dirty hack and it
+ should be fixed in the ligature-engravers. --jneem
+ */
+ if (Paper_column::is_extraneous_column_from_ligature (left_col))
+ spring.set_distance (spring.min_distance ());
+ else
+ spring.set_distance (max (left_col->extent (left_col, X_AXIS)[RIGHT],
+ spring.min_distance ()));
- dist *= grace_fact;
+ spring.set_inverse_stretch_strength (1.0);
}
-
- return dist;
+ Spaceable_grob::add_spring (left_col, right_col, spring);
}
+/*
+ Check if COL fills the whole measure.
+ */
+bool
+Spacing_spanner::fills_measure (Grob *me, Item *left, Item *col)
+{
+ System *sys = get_root_system (me);
+ Item *next = sys->column (col->get_column ()->get_rank () + 1);
+ if (!next)
+ return false;
+ if (Paper_column::is_musical (next)
+ || Paper_column::is_musical (left)
+ || !Paper_column::is_musical (col)
+ || !Paper_column::is_used (next))
+ return false;
-ADD_INTERFACE (Spacing_spanner,"spacing-spanner-interface",
- " SPACE = arithmetic_multiplier * ( C + log2 (TIME) ))
-The space taken by a note is determined by the formula
+ Moment dt
+ = Paper_column::when_mom (next) - Paper_column::when_mom (col);
+ Moment *len = unsmob_moment (left->get_property ("measure-length"));
+ if (!len)
+ return false;
+ /*
+ Don't check for exact measure length, since ending measures are
+ often shortened due to pickups.
+ */
+ if (dt.main_part_ > len->main_part_ / Rational (2)
+ && (next->is_broken ()
+ || next->break_status_dir ()))
+ return true;
-where TIME is the amount of time a note occupies. The value of C is
-chosen such that the smallest space within a measure is
-arithmetic_basicspace:
+ return false;
+}
-C = arithmetic_basicspace - log2 (mininum (SHORTEST, 1/8))
+/*
+ Read hints from L and generate springs.
+*/
+void
+Spacing_spanner::breakable_column_spacing (Grob *me, Item *l, Item *r,
+ Spacing_options const *options)
+{
+ vector<Spring> springs;
+ Spring spring;
-The smallest space is the one following the shortest note in the
-measure, or the space following a hypothetical 1/8 note. Typically
-arithmetic_basicspace is set to a value so that the shortest note
-takes about two noteheads of space (ie, is followed by a notehead of
-space):
+ Real full_measure_space = 0.0;
+ if (Paper_column::is_musical (r)
+ && l->break_status_dir () == CENTER
+ && fills_measure (me, l, r))
+ full_measure_space = robust_scm2double (l->get_property ("full-measure-extra-space"), 1.0);
-@example
-2*quartwidth = arithmetic_multiplier * ( C + log2 (SHORTEST) ))
+ Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
-@{ using: C = arithmetic_basicspace - log2 (mininum (SHORTEST, 1/8)) @}
-@{ assuming: SHORTEST <= 1/8 @}
+ if (dt == Moment (0, 0))
+ {
+ extract_grob_set (l, "spacing-wishes", wishes);
-= arithmetic_multiplier *
-( arithmetic_basicspace - log2 (SHORTEST) + log2 (SHORTEST) )
+ for (vsize i = 0; i < wishes.size (); i++)
+ {
+ Item *spacing_grob = dynamic_cast<Item *> (wishes[i]);
-= arithmetic_multiplier * arithmetic_basicspace
+ if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
+ continue;
-@{ choose: arithmetic_multiplier = 1.0*quartwidth (why?) @}
+ /*
+ column for the left one settings should be ok due automatic
+ pointer munging.
+ */
+ assert (spacing_grob->get_column () == l);
-= quartwidth * arithmetic_basicspace
+ springs.push_back (Staff_spacing::get_spacing (spacing_grob, r,
+ full_measure_space));
+ }
+ }
-=>
+ if (springs.empty ())
+ spring = standard_breakable_column_spacing (me, l, r, options);
+ else
+ spring = merge_springs (springs);
-arithmetic_basicspace = 2/1 = 2
+ if (Paper_column::when_mom (r).grace_part_)
+ {
+ /*
+ Correct for grace notes.
+ Ugh. The 0.8 is arbitrary.
+ */
+ spring *= 0.8;
+ }
-If you want to space your music wider, use something like:
+ if (options->stretch_uniformly_ && l->break_status_dir () != RIGHT)
+ {
+ spring.set_min_distance (0.0);
+ spring.set_default_strength ();
+ }
-arithmetic_basicspace = 4.;
+ Spaceable_grob::add_spring (l, r, spring);
+}
-@end example",
- "spacing-increment shortest-duration-space");
+ADD_INTERFACE (Spacing_spanner,
+ "The space taken by a note is dependent on its duration."
+ " Doubling a duration adds @code{spacing-increment} to the"
+ " space. The most common shortest note gets"
+ " @code{shortest-duration-space}. Notes that are even shorter"
+ " are spaced proportonial to their duration.\n"
+ "\n"
+ "Typically, the increment is the width of a black note head."
+ " In a piece with lots of 8th notes, and some 16th notes, the"
+ " eighth note gets a 2@tie{}note heads width (i.e., the space"
+ " following a note is a 1@tie{}note head width). A 16th note"
+ " is followed by 0.5 note head width. The quarter note is"
+ " followed by 3@tie{}NHW, the half by 4@tie{}NHW, etc.",
+
+ /* properties */
+ "average-spacing-wishes "
+ "base-shortest-duration "
+ "common-shortest-duration "
+ "packed-spacing "
+ "shortest-duration-space "
+ "spacing-increment "
+ "strict-grace-spacing "
+ "strict-note-spacing "
+ "uniform-stretching "
+ );