/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 1999--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 1999--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
LilyPond is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
SCM
Spacing_spanner::set_springs (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = unsmob<Spanner> (smob);
/*
can't use get_system () ? --hwn.
SCM
Spacing_spanner::calc_common_shortest_duration (SCM grob)
{
- Spanner *me = unsmob_spanner (grob);
+ Spanner *me = unsmob<Spanner> (grob);
vector<Grob *> cols (get_columns (me));
{
if (Paper_column::is_musical (cols[i]))
{
- Moment *when = unsmob_moment (cols[i]->get_property ("when"));
+ Moment *when = unsmob<Moment> (cols[i]->get_property ("when"));
/*
ignore grace notes for shortest notes.
continue;
SCM st = cols[i]->get_property ("shortest-starter-duration");
- Moment this_shortest = *unsmob_moment (st);
+ Moment this_shortest = *unsmob<Moment> (st);
assert (this_shortest.to_bool ());
shortest_in_measure = min (shortest_in_measure, this_shortest.main_part_);
}
SCM bsd = me->get_property ("base-shortest-duration");
Rational d = Rational (1, 8);
- if (Moment *m = unsmob_moment (bsd))
+ if (Moment *m = unsmob<Moment> (bsd))
d = m->main_part_;
if (max_idx != VPOS)
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;
+ /* distances[i] will be the distance betwen cols[i-1] and cols[i], and
+ overhangs[j] the amount by which cols[0 thru j] extend beyond cols[j]
+ when each column is placed as far to the left as possible. */
+ vector<Real> distances (cols.size ());
+ vector<Real> overhangs (cols.size ());
- for (vsize i = 1; i < cols.size (); i++)
+ for (vsize i = 0; i < cols.size (); i++)
{
- assert (distances.size () == i - 1);
-
Item *r = dynamic_cast<Item *> (cols[i]);
Item *rb = r->find_prebroken_piece (LEFT);
if (Separation_item::is_empty (r) && (!rb || Separation_item::is_empty (rb)))
- {
- distances.push_back (0);
- continue;
- }
+ continue;
+
+ Skyline_pair *skys = unsmob<Skyline_pair> (r->get_property ("horizontal-skylines"));
+ overhangs[i] = skys ? (*skys)[RIGHT].max_height () : 0.0;
- Skyline_pair *skys = Skyline_pair::unsmob (r->get_property ("horizontal-skylines"));
- Real right_stickout = skys ? (*skys)[LEFT].max_height () : 0.0;
+ if (0 == i) continue;
- /* min rather than max because right-stickout will be negative if the right-hand column
+ /* min rather than max because 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 ());
+ Real stickout = min (skys ? (*skys)[LEFT].max_height () : 0.0,
+ 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);
+ Real prev_distances = 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--;)
{
+ if (overhangs[j] + padding <= prev_distances + distances[i] + stickout)
+ break; // cols[0 thru j] cannot reach cols[i]
+
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);
+ Real dist = Separation_item::set_distance (l, r, padding);
+ distances[i] = max (distances[i], dist - prev_distances);
- if (j == i - 1)
- cur_dist[d] = distances[j];
-
- cur_dist[d] = max (cur_dist[d], dist);
- done = done && !touches;
+ if (lb)
+ {
+ dist = Separation_item::set_distance (lb, r, padding);
+ // The left-broken version might reach more columns to the
+ // right than the unbroken version, by extending farther and/or
+ // nesting more closely;
+ if (j == i - 1) // check this, the first time we see each lb.
+ overhangs[j] = max (overhangs[j],
+ lb->extent (lb, X_AXIS)[RIGHT]
+ + distances[i] - dist);
}
- while (flip (&d) != LEFT && rb);
+ if (rb)
+ Separation_item::set_distance (l, rb, padding);
+ if (lb && rb)
+ Separation_item::set_distance (lb, rb, padding);
- /* 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;
+ prev_distances += distances[j];
}
+ overhangs[i] = max (overhangs[i],
+ overhangs[i - 1] - distances[i]);
}
}
Item *right_col,
Spacing_options const *options)
{
- Real base_note_space = note_spacing (me, left_col, right_col, options);
- Spring spring;
+ Spring spring = note_spacing (me, left_col, right_col, options);
if (options->stretch_uniformly_)
- spring = Spring (base_note_space, 0.0);
+ {
+ spring.set_min_distance (0.0);
+ spring.set_default_strength ();
+ }
else
{
vector<Spring> springs;
/*
This is probably a waste of time in the case of polyphonic
music. */
- if (found_matching_column && Note_spacing::has_interface (wish))
+ if (found_matching_column && has_interface<Note_spacing> (wish))
{
Real inc = options->increment_;
- Grob *gsp = unsmob_grob (left_col->get_object ("grace-spacing"));
+ 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));
+ springs.push_back (Note_spacing::get_spacing (wish, right_col, spring, inc));
}
}
if (springs.empty ())
{
-
- 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
+ if (Paper_column::is_musical (right_col))
{
/*
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);
+ spring.set_min_distance (0.0);
}
}
else
Moment dt
= Paper_column::when_mom (next) - Paper_column::when_mom (col);
- Moment *len = unsmob_moment (left->get_property ("measure-length"));
+ Moment *len = unsmob<Moment> (left->get_property ("measure-length"));
if (!len)
return false;
{
Item *spacing_grob = dynamic_cast<Item *> (wishes[i]);
- if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
+ if (!spacing_grob || !has_interface<Staff_spacing> (spacing_grob))
continue;
/*