return SCM_BOOL_T;
}
-/* for each grob, find its upper and lower skylines. If the grob has
- an empty extent, delete it from the list instead. If the extent is
+/* for each grob, find its upper and lower skylines. If the extent is
non-empty but there is no skyline available (or pure is true), just
create a flat skyline from the bounding box */
// TODO(jneem): the pure and non-pure parts seem to share very little
// code. Split them into 2 functions, perhaps?
static void
get_skylines (Grob *me,
- vector<Grob *> *const elements,
+ vector<Grob *> const &elements,
Axis a,
bool pure, int start, int end,
- vector<Skyline_pair> *const ret)
+ vector<Skyline_pair> *ret,
+ vector<bool> const *skip_elt)
{
- Grob *other_common = common_refpoint_of_array (*elements, me, other_axis (a));
+ Grob *other_common = common_refpoint_of_array (elements, me, other_axis (a));
- for (vsize i = elements->size (); i--;)
+ for (vsize i = elements.size (); i--;)
{
- Grob *g = (*elements)[i];
+ Grob *g = elements[i];
Skyline_pair skylines;
if (!pure)
Real offset = g->relative_coordinate (other_common, other_axis (a));
skylines.shift (offset);
}
- else
+ else if (!(*skip_elt)[i])
{
assert (a == Y_AXIS);
Interval extent = g->pure_height (g, start, end);
// of the system. This way, the tall treble clefs are only compared with the treble
// clefs of the other staff and they will be ignored if the staff above is, for example,
// lyrics.
- if (Axis_group_interface::has_interface (g)
- && !Hara_kiri_group_spanner::request_suicide (g, start, end))
+ if (Axis_group_interface::has_interface (g))
{
extent = Axis_group_interface::rest_of_line_pure_height (g, start, end);
Interval begin_of_line_extent = Axis_group_interface::begin_of_line_pure_height (g, start);
}
}
- if (skylines.is_empty ())
- elements->erase (elements->begin () + i);
- else
- ret->push_back (skylines);
+ // even if the skyline is empty, we want to push it back
+ // the heap because we will use things like system-system-distance
+ // to account for its presence
+ ret->push_back (skylines);
}
reverse (*ret);
}
// else centered dynamics will break when there is a fixed alignment).
vector<Real>
Align_interface::internal_get_minimum_translations (Grob *me,
- vector<Grob *> const &all_grobs,
+ vector<Grob *> const &elems,
Axis a,
bool include_fixed_spacing,
bool pure, int start, int end)
Direction stacking_dir = robust_scm2dir (me->get_property ("stacking-dir"),
DOWN);
- vector<Grob *> elems (all_grobs); // writable copy
vector<Skyline_pair> skylines;
+ vector<bool> skip_elt;
+ // only add to skip elt if pure
+ // if not pure, no dead element should be in the list
+ for (vsize i = 0; i < elems.size (); i++)
+ {
+ if (!pure && !elems[i]->is_live ())
+ elems[i]->programming_error ("I should be dead by now...");
+ skip_elt.push_back (pure && Hara_kiri_group_spanner::request_suicide (elems[i], start, end));
+ }
- get_skylines (me, &elems, a, pure, start, end, &skylines);
+ get_skylines (me, elems, a, pure, start, end, &skylines, &skip_elt);
Real where = 0;
Real default_padding = robust_scm2double (me->get_property ("padding"), 0.0);
int spaceable_count = 0;
for (vsize j = 0; j < elems.size (); j++)
{
+ // This means that it will be suicided later downstream, so we
+ // skip it so that its padding is not added in.
+ if (pure && skip_elt[j])
+ continue;
+
Real dy = 0;
Real padding = default_padding;
// So far, we've computed the translates for all the non-empty elements.
// Here, we set the translates for the empty elements: an empty element
// gets the same translation as the last non-empty element before it.
+ vector<Grob *> non_empty_elems;
+ for (vsize i = 0; i < elems.size (); i++)
+ if (!skip_elt[i])
+ non_empty_elems.push_back (elems[i]);
+
vector<Real> all_translates;
if (!translates.empty ())
{
Real w = translates[0];
- for (vsize i = 0, j = 0; j < all_grobs.size (); j++)
+ for (vsize i = 0, j = 0; j < elems.size (); j++)
{
- if (i < elems.size () && all_grobs[j] == elems[i])
+ if (i < non_empty_elems.size () && elems[j] == non_empty_elems[i])
w = translates[i++];
all_translates.push_back (w);
}