/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 2000--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 2000--2012 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
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);
Box b;
b[a] = begin_of_line_extent;
b[other_axis (a)] = Interval (-infinity_f, -1);
- skylines.insert (b, 0, other_axis (a));
+ skylines.insert (b, other_axis (a));
}
}
Box b;
b[a] = extent;
b[other_axis (a)] = Interval (0, infinity_f);
- skylines.insert (b, 0, other_axis (a));
+ skylines.insert (b, other_axis (a));
}
}
- 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);
}
}
// If include_fixed_spacing is false, the only constraints that will be measured
-// here are those that result from collisions (+ padding) and minimum-distance
+// here are those that result from collisions (+ padding) and the spacing spec
// between adjacent staves.
// If include_fixed_spacing is true, constraints from line-break-system-details,
// basic-distance+stretchable=0, and staff-staff-spacing of spaceable staves
// 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)
if (!pure && a == Y_AXIS && dynamic_cast<Spanner *> (me) && !me->get_system ())
me->programming_error ("vertical alignment called before line-breaking");
+ // check the cache
+ if (pure)
+ {
+ SCM fv = ly_assoc_get (scm_cons (scm_from_int (start), scm_from_int (end)),
+ me->get_property ("minimum-translations-alist"),
+ SCM_EOL);
+ if (fv != SCM_EOL)
+ return ly_scm2floatvector (fv);
+ }
+
// If include_fixed_spacing is true, we look at things like system-system-spacing
// and alignment-distances, which only make sense for the toplevel VerticalAlignment.
// If we aren't toplevel, we're working on something like BassFigureAlignment
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;
dy = down_skyline.distance (skylines[j][-stacking_dir]) + padding;
- Real min_distance = 0;
- if (Page_layout_problem::read_spacing_spec (spec, &min_distance, ly_symbol2scm ("minimum-distance")))
- dy = max (dy, min_distance);
+ Real spec_distance = 0;
+ if (Page_layout_problem::read_spacing_spec (spec, &spec_distance, ly_symbol2scm ("minimum-distance")))
+ dy = max (dy, spec_distance);
+ // Consider the likely final spacing when estimating distance between staves of the full score
+ if (INT_MAX == end && 0 == start
+ && Page_layout_problem::read_spacing_spec (spec, &spec_distance, ly_symbol2scm ("basic-distance")))
+ dy = max (dy, spec_distance);
if (include_fixed_spacing && Page_layout_problem::is_spaceable (elems[j]) && last_spaceable_element)
{
// 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);
}
}
+
+ if (pure)
+ {
+ SCM mta = me->get_property ("minimum-translations-alist");
+ mta = scm_cons (scm_cons (scm_cons (scm_from_int (start), scm_from_int (end)),
+ ly_floatvector2scm (all_translates)),
+ mta);
+ me->set_property ("minimum-translations-alist", mta);
+ }
return all_translates;
}
all_grobs[j]->translate_axis (translates[j], a);
}
-
-MAKE_SCHEME_CALLBACK (Align_interface, full_score_pure_minimum_translations, 1);
-SCM
-Align_interface::full_score_pure_minimum_translations (SCM smob)
-{
- Grob *me = unsmob_grob (smob);
- extract_grob_set (me, "elements", all_grobs);
-
- vector<Real> pure_minimum_translations = Align_interface::get_pure_minimum_translations (me, all_grobs, Y_AXIS, 0, INT_MAX);
- return ly_floatvector2scm (pure_minimum_translations);
-}
-
Real
Align_interface::get_pure_child_y_translation (Grob *me, Grob *ch, int start, int end)
{
extract_grob_set (me, "elements", all_grobs);
- vector<Real> translates = start == 0 && end == INT_MAX
- ? ly_scm2floatvector (me->get_object ("full-score-pure-minimum-translations"))
- : get_pure_minimum_translations (me, all_grobs, Y_AXIS, start, end);
+ vector<Real> translates = get_pure_minimum_translations (me, all_grobs, Y_AXIS, start, end);
if (translates.size ())
{
/* properties */
"align-dir "
"axes "
- "full-score-pure-minimum-translations "
"elements "
+ "minimum-translations-alist "
"padding "
"positioning-done "
"stacking-dir "
projects / lilypond.git / blobdiff