/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 1997--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 1997--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
= *unsmob_stencil (scm_call_1 (ly_lily_module_constant ("stencil-whiteout"),
retval.smobbed_copy ()));
}
+
+ SCM id = get_property ("id");
+ if (scm_is_string (id))
+ {
+ SCM expr = scm_list_3 (ly_symbol2scm ("id"),
+ id,
+ retval.expr ());
+
+ retval = Stencil (retval.extent_box (), expr);
+ }
+
}
return retval;
((Grob *)this)->dim_cache_[a].extent_ = new Interval (real_ext);
}
- real_ext.translate (offset);
+ // We never want nan, so we avoid shifting infinite values.
+ for (LEFT_and_RIGHT (d))
+ if (!isinf (real_ext[d]))
+ real_ext[d] += offset;
return real_ext;
}
Interval
Grob::maybe_pure_extent (Grob *refp, Axis a, bool pure, int start, int end)
{
- if (pure && a != Y_AXIS)
- programming_error ("tried to get pure width");
return (pure && a == Y_AXIS) ? pure_height (refp, start, end) : extent (refp, a);
}
Grob *
Grob::common_refpoint (Grob const *s, Axis a) const
{
- /* I don't like the quadratic aspect of this code, but I see no
- other way. The largest chain of parents might be 10 high or so,
- so it shouldn't be a real issue. */
- for (Grob const *c = this; c; c = c->dim_cache_[a].parent_)
- for (Grob const *d = s; d; d = d->dim_cache_[a].parent_)
- if (d == c)
- return (Grob *) d;
- return 0;
+ /* Catching the trivial cases is likely costlier than just running
+ through: one can't avoid going to the respective chain ends
+ anyway. We might save the second run through when the chain ends
+ differ, but keeping track of the ends makes the loop more costly.
+ */
+
+ int balance = 0;
+ Grob const *c;
+ Grob const *d;
+
+ for (c = this; c; ++balance)
+ c = c->dim_cache_[a].parent_;
+
+ for (d = s; d; --balance)
+ d = d->dim_cache_[a].parent_;
+
+ /* Cut down ancestry to same size */
+
+ for (c = this; balance > 0; --balance)
+ c = c->dim_cache_[a].parent_;
+
+ for (d = s; balance < 0; ++balance)
+ d = d->dim_cache_[a].parent_;
+
+ /* Now find point where our lineages converge */
+ while (c != d)
+ {
+ c = c->dim_cache_[a].parent_;
+ d = d->dim_cache_[a].parent_;
+ }
+
+ return (Grob *) c;
}
void
VERTICAL ORDERING
****************************************************************/
-Grob*
+Grob *
get_maybe_root_vertical_alignment (Grob *g, Grob *maybe)
{
if (!g)
}
-Grob*
+Grob *
Grob::get_root_vertical_alignment (Grob *g)
{
return get_maybe_root_vertical_alignment (g, 0);
}
-Grob*
+Grob *
Grob::get_vertical_axis_group (Grob *g)
{
if (!g)
return 0;
+ if (!g->get_parent (Y_AXIS))
+ return 0;
if (Axis_group_interface::has_interface (g)
&& Align_interface::has_interface (g->get_parent (Y_AXIS)))
return g;
bool
Grob::vertical_less (Grob *g1, Grob *g2)
+{
+ return internal_vertical_less (g1, g2, false);
+}
+
+bool
+Grob::pure_vertical_less (Grob *g1, Grob *g2)
+{
+ return internal_vertical_less (g1, g2, true);
+}
+
+bool
+Grob::internal_vertical_less (Grob *g1, Grob *g2, bool pure)
{
Grob *vag = get_root_vertical_alignment (g1);
- if (!vag)
- return false;
if (!vag)
{
g1->programming_error ("grob does not belong to a VerticalAlignment?");
return false;
}
+
Grob *ag1 = get_vertical_axis_group (g1);
Grob *ag2 = get_vertical_axis_group (g2);
extract_grob_set (vag, "elements", elts);
+ if (ag1 == ag2 && !pure)
+ {
+ Grob *common = g1->common_refpoint (g2, Y_AXIS);
+ return g1->relative_coordinate (common, Y_AXIS) > g2->relative_coordinate (common, Y_AXIS);
+ }
+
for (vsize i = 0; i < elts.size (); i++)
{
if (elts[i] == ag1)
"cause "
"color "
"cross-staff "
+ "id "
"extra-X-extent "
"extra-Y-extent "
"extra-offset "
+ "footnote-music "
+ "forced-spacing "
"interfaces "
"layer "
"meta "