/*
- axis-group-interface.cc -- implement Axis_group_interface
+ This file is part of LilyPond, the GNU music typesetter.
- source file of the GNU LilyPond music typesetter
+ Copyright (C) 2000--2010 Han-Wen Nienhuys <hanwen@xs4all.nl>
- (c) 2000--2007 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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ 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.
+
+ You should have received a copy of the GNU General Public License
+ along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
*/
#include "axis-group-interface.hh"
#include "align-interface.hh"
#include "directional-element-interface.hh"
-#include "pointer-group-interface.hh"
#include "grob-array.hh"
#include "hara-kiri-group-spanner.hh"
#include "international.hh"
#include "lookup.hh"
#include "paper-column.hh"
#include "paper-score.hh"
+#include "pointer-group-interface.hh"
#include "separation-item.hh"
+#include "skyline-pair.hh"
+#include "staff-grouper-interface.hh"
#include "stencil.hh"
#include "system.hh"
#include "warn.hh"
return r;
}
+Interval
+Axis_group_interface::cached_pure_height (Grob *me, int start, int end)
+{
+ Interval iv = begin_of_line_pure_height (me, start);
+ iv.unite (rest_of_line_pure_height (me, start, end));
-/*
- FIXME: pure extent handling has a lot of ad-hoc caching.
- This should be done with grob property callbacks.
+ return iv;
+}
- --hwn
-*/
+Interval
+Axis_group_interface::rest_of_line_pure_height (Grob *me, int start, int end)
+{
+ SCM adjacent_pure_heights = me->get_property ("adjacent-pure-heights");
+
+ if (!scm_is_pair (adjacent_pure_heights)
+ || !scm_is_vector (scm_cdr (adjacent_pure_heights)))
+ return Interval (0, 0);
+
+ return combine_pure_heights (me, scm_cdr (adjacent_pure_heights), start, end);
+}
Interval
-Axis_group_interface::cached_pure_height (Grob *me, int start, int end)
+Axis_group_interface::begin_of_line_pure_height (Grob *me, int start)
+{
+ SCM adjacent_pure_heights = me->get_property ("adjacent-pure-heights");
+
+ if (!scm_is_pair (adjacent_pure_heights)
+ || !scm_is_vector (scm_car (adjacent_pure_heights)))
+ return Interval (0, 0);
+
+ return combine_pure_heights (me, scm_car (adjacent_pure_heights), start, start+1);
+}
+
+Interval
+Axis_group_interface::combine_pure_heights (Grob *me, SCM measure_extents, int start, int end)
{
Paper_score *ps = get_root_system (me)->paper_score ();
vector<vsize> breaks = ps->get_break_indices ();
vector<Grob*> cols = ps->get_columns ();
- SCM extents = me->get_property ("adjacent-pure-heights");
-
- if (!scm_is_vector (extents))
- return Interval (0, 0);
-
Interval ext;
for (vsize i = 0; i + 1 < breaks.size (); i++)
{
int r = Paper_column::get_rank (cols[breaks[i]]);
- if (r > end)
+ if (r >= end)
break;
if (r >= start)
- ext.unite (ly_scm2interval (scm_c_vector_ref (extents, i)));
+ ext.unite (ly_scm2interval (scm_c_vector_ref (measure_extents, i)));
}
return ext;
}
+// adjacent-pure-heights is a pair of vectors, each of which has one element
+// for every measure in the score. The first vector stores, for each measure,
+// the combined height of the elements that are present only when the bar
+// is at the beginning of a line. The second vector stores, for each measure,
+// the combined height of the elements that are present only when the bar
+// is not at the beginning of a line.
+
MAKE_SCHEME_CALLBACK (Axis_group_interface, adjacent_pure_heights, 1)
SCM
Axis_group_interface::adjacent_pure_heights (SCM smob)
{
Grob *me = unsmob_grob (smob);
- Grob *common = calc_pure_elts_and_common (me);
+ Grob *common = unsmob_grob (me->get_object ("pure-Y-common"));
extract_grob_set (me, "pure-relevant-items", items);
extract_grob_set (me, "pure-relevant-spanners", spanners);
vector<vsize> breaks = ps->get_break_indices ();
vector<Grob*> cols = ps->get_columns ();
- SCM ret = scm_c_make_vector (breaks.size () - 1, SCM_EOL);
+ SCM begin_line_heights = scm_c_make_vector (breaks.size () - 1, SCM_EOL);
+ SCM mid_line_heights = scm_c_make_vector (breaks.size () - 1, SCM_EOL);
+
vsize it_index = 0;
for (vsize i = 0; i + 1 < breaks.size (); i++)
{
int start = Paper_column::get_rank (cols[breaks[i]]);
int end = Paper_column::get_rank (cols[breaks[i+1]]);
- Interval iv;
+
+ Interval begin_line_iv;
+ Interval mid_line_iv;
for (vsize j = it_index; j < items.size (); j++)
{
&& !to_boolean (it->get_property ("cross-staff")))
{
Interval dims = items[j]->pure_height (common, start, end);
+ Interval &target_iv = start == it->get_column ()->get_rank () ? begin_line_iv : mid_line_iv;
+
if (!dims.is_empty ())
- iv.unite (dims);
+ target_iv.unite (dims);
}
if (rank < end)
&& !to_boolean (spanners[j]->get_property ("cross-staff")))
{
Interval dims = spanners[j]->pure_height (common, start, end);
+
if (!dims.is_empty ())
- iv.unite (dims);
+ mid_line_iv.unite (dims);
}
}
- scm_vector_set_x (ret, scm_from_int (i), ly_interval2scm (iv));
+ scm_vector_set_x (begin_line_heights, scm_from_int (i), ly_interval2scm (begin_line_iv));
+ scm_vector_set_x (mid_line_heights, scm_from_int (i), ly_interval2scm (mid_line_iv));
}
- return ret;
+ return scm_cons (begin_line_heights, mid_line_heights);
}
Interval
if (p && Align_interface::has_interface (p))
return Axis_group_interface::cached_pure_height (me, start, end);
- Grob *common = calc_pure_elts_and_common (me);
+ Grob *common = unsmob_grob (me->get_object ("pure-Y-common"));
extract_grob_set (me, "pure-relevant-items", items);
extract_grob_set (me, "pure-relevant-spanners", spanners);
if (rank > end)
break;
- else if (rank >= start && it->pure_is_visible (start, end))
+ else if (rank >= start && it->pure_is_visible (start, end)
+ && !to_boolean (it->get_property ("cross-staff")))
{
Interval dims = it->pure_height (common, start, end);
if (!dims.is_empty ())
for (vsize i = 0; i < spanners.size (); i++)
{
Interval_t<int> rank_span = spanners[i]->spanned_rank_interval ();
- if (rank_span[LEFT] <= end && rank_span[RIGHT] >= start)
+ if (rank_span[LEFT] <= end && rank_span[RIGHT] >= start
+ && !to_boolean (spanners[i]->get_property ("cross-staff")))
{
Interval dims = spanners[i]->pure_height (common, start, end);
if (!dims.is_empty ())
extract_grob_set (me, "elements", elts);
Skyline_pair skylines = skyline_spacing (me, elts);
- /* add a minimum-Y-extent-sized box to the skyline */
- SCM min_y_extent = me->get_property ("minimum-Y-extent");
- if (is_number_pair (min_y_extent))
- {
- Box b (me->extent (me, X_AXIS), ly_scm2interval (min_y_extent));
- skylines.insert (b, 0, X_AXIS);
- }
return skylines.smobbed_copy ();
}
return ly_interval2scm (r - my_coord);
}
+/* This is like generic_group_extent, but it only counts the grobs that
+ are children of some other axis-group. This is uncached; if it becomes
+ commonly used, it may be necessary to cache it somehow. */
+Interval
+Axis_group_interface::staff_extent (Grob *me, Grob *refp, Axis ext_a, Grob *staff, Axis parent_a)
+{
+ extract_grob_set (me, "elements", elts);
+ vector<Grob*> new_elts;
+
+ for (vsize i = 0; i < elts.size (); i++)
+ if (elts[i]->common_refpoint (staff, parent_a) == staff)
+ new_elts.push_back (elts[i]);
+
+ return relative_group_extent (new_elts, refp, ext_a);
+}
+
-Grob *
-Axis_group_interface::calc_pure_elts_and_common (Grob *me)
+MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_pure_relevant_grobs, 1);
+SCM
+Axis_group_interface::calc_pure_relevant_grobs (SCM smob)
{
- if (Grob *c = unsmob_grob (me->get_object ("pure-Y-common")))
- return c;
+ Grob *me = unsmob_grob (smob);
extract_grob_set (me, "elements", elts);
- vector<Grob*> relevant_items;
- vector<Grob*> relevant_spanners;
+ vector<Grob*> relevant_grobs;
SCM pure_relevant_p = ly_lily_module_constant ("pure-relevant?");
for (vsize i = 0; i < elts.size (); i++)
{
if (to_boolean (scm_apply_1 (pure_relevant_p, elts[i]->self_scm (), SCM_EOL)))
+ relevant_grobs.push_back (elts[i]);
+
+ if (Item *it = dynamic_cast<Item*> (elts[i]))
{
- if (dynamic_cast<Item*> (elts[i]))
- relevant_items.push_back (elts[i]);
- else if (dynamic_cast<Spanner*> (elts[i]))
- relevant_spanners.push_back (elts[i]);
+ Direction d = LEFT;
+ do
+ {
+ Item *piece = it->find_prebroken_piece (d);
+ if (piece && to_boolean (scm_apply_1 (pure_relevant_p, piece->self_scm (), SCM_EOL)))
+ relevant_grobs.push_back (piece);
+ }
+ while (flip (&d) != LEFT);
}
-
-
- Item *it = dynamic_cast<Item*> (elts[i]);
- Direction d = LEFT;
- if (it)
- do
- {
- Item *piece = it->find_prebroken_piece (d);
- if (piece && to_boolean (scm_apply_1 (pure_relevant_p, piece->self_scm (), SCM_EOL)))
- relevant_items.push_back (piece);
- }
- while (flip (&d) != LEFT);
}
- vector_sort (relevant_items, Item::less);
- Grob *common = common_refpoint_of_array (relevant_items, me, Y_AXIS);
- common = common_refpoint_of_array (relevant_spanners, common, Y_AXIS);
+ SCM grobs_scm = Grob_array::make_array ();
+ unsmob_grob_array (grobs_scm)->set_array (relevant_grobs);
- me->set_object ("pure-Y-common", common->self_scm ());
-
- SCM items_scm = Grob_array::make_array ();
- SCM spanners_scm = Grob_array::make_array ();
+ return grobs_scm;
+}
+
+MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_pure_relevant_items, 1);
+SCM
+Axis_group_interface::calc_pure_relevant_items (SCM smob)
+{
+ Grob *me = unsmob_grob (smob);
+
+ extract_grob_set (me, "pure-relevant-grobs", elts);
+
+ vector<Grob*> relevant_items;
+ for (vsize i = 0; i < elts.size (); i++)
+ if (Item *it = dynamic_cast<Item*> (elts[i]))
+ relevant_items.push_back (it);
+ vector_sort (relevant_items, Item::less);
+
+ SCM items_scm = Grob_array::make_array ();
unsmob_grob_array (items_scm)->set_array (relevant_items);
- unsmob_grob_array (spanners_scm)->set_array (relevant_spanners);
- me->set_object ("pure-relevant-items", items_scm);
- me->set_object ("pure-relevant-spanners", spanners_scm);
+ return items_scm;
+}
+
+MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_pure_relevant_spanners, 1);
+SCM
+Axis_group_interface::calc_pure_relevant_spanners (SCM smob)
+{
+ Grob *me = unsmob_grob (smob);
+
+ extract_grob_set (me, "pure-relevant-grobs", elts);
+
+ vector<Grob*> relevant_spanners;
+ for (vsize i = 0; i < elts.size (); i++)
+ if (dynamic_cast<Spanner*> (elts[i]))
+ relevant_spanners.push_back (elts[i]);
- return common;
+ SCM spanners_scm = Grob_array::make_array ();
+ unsmob_grob_array (spanners_scm)->set_array (relevant_spanners);
+ return spanners_scm;
}
-MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_x_common, 1);
+MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_pure_y_common, 1);
SCM
-Axis_group_interface::calc_x_common (SCM grob)
+Axis_group_interface::calc_pure_y_common (SCM smob)
{
- Grob *me = unsmob_grob (grob);
+ Grob *me = unsmob_grob (smob);
+
+ extract_grob_set (me, "pure-relevant-grobs", elts);
+ Grob *common = common_refpoint_of_array (elts, me, Y_AXIS);
+ if (!common)
+ {
+ me->programming_error ("No common parent found in calc_pure_y_common.");
+ return SCM_EOL;
+ }
+ return common->self_scm ();
+}
+
+SCM
+Axis_group_interface::calc_common (Grob *me, Axis axis)
+{
extract_grob_set (me, "elements", elts);
- Grob *common = common_refpoint_of_array (elts, me, X_AXIS);
+ Grob *common = common_refpoint_of_array (elts, me, axis);
+ if (!common)
+ {
+ me->programming_error ("No common parent found in calc_common axis.");
+ return SCM_EOL;
+ }
+
return common->self_scm ();
}
+
+MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_x_common, 1);
+SCM
+Axis_group_interface::calc_x_common (SCM grob)
+{
+ return calc_common (unsmob_grob (grob), X_AXIS);
+}
+
MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_y_common, 1);
SCM
Axis_group_interface::calc_y_common (SCM grob)
{
- Grob *me = unsmob_grob (grob);
-
- extract_grob_set (me, "elements", elts);
- Grob *common = common_refpoint_of_array (elts, me, Y_AXIS);
- return common->self_scm ();
+ return calc_common (unsmob_grob (grob), Y_AXIS);
}
Interval
Axis_group_interface::pure_group_height (Grob *me, int start, int end)
{
- Grob *common = calc_pure_elts_and_common (me);
-
+ Grob *common = unsmob_grob (me->get_object ("pure-Y-common"));
+
+ if (!common)
+ {
+ programming_error ("no pure Y common refpoint");
+ return Interval ();
+ }
Real my_coord = me->relative_coordinate (common, Y_AXIS);
Interval r (relative_pure_height (me, start, end));
b.translate (Offset (0, dir*dist));
elements[i]->translate_axis (dir*dist, Y_AXIS);
}
- (*skylines)[dir].insert (b, 0, X_AXIS);
+ skylines->insert (b, 0, X_AXIS);
elements[i]->set_property ("outside-staff-priority", SCM_BOOL_F);
last_affected_position[dir] = b[X_AXIS][RIGHT];
}
}
}
+// TODO: it is tricky to correctly handle skyline placement of cross-staff grobs.
+// For example, cross-staff beams cannot be formatted until the distance between
+// staves is known and therefore any grobs that depend on the beam cannot be placed
+// until the skylines are known. On the other hand, the distance between staves should
+// really depend on position of the cross-staff grobs that lie between them.
+// Currently, we just leave cross-staff grobs out of the
+// skyline altogether, but this could mean that staves are placed so close together
+// that there is no room for the cross-staff grob. It also means, of course, that
+// we don't get the benefits of skyline placement for cross-staff grobs.
Skyline_pair
Axis_group_interface::skyline_spacing (Grob *me, vector<Grob*> elements)
{
+ /* For grobs with an outside-staff-priority, the sorting function might
+ call extent and cause suicide. This breaks the contract that is required
+ for the STL sort function. To avoid this, we make sure that any suicides
+ are triggered beforehand.
+ */
+ for (vsize i = 0; i < elements.size (); i++)
+ if (scm_is_number (elements[i]->get_property ("outside-staff-priority")))
+ elements[i]->extent (elements[i], X_AXIS);
+
vector_sort (elements, staff_priority_less);
Grob *x_common = common_refpoint_of_array (elements, me, X_AXIS);
Grob *y_common = common_refpoint_of_array (elements, me, Y_AXIS);
Skyline_pair skylines;
for (i = 0; i < elements.size ()
&& !scm_is_number (elements[i]->get_property ("outside-staff-priority")); i++)
- add_boxes (elements[i], x_common, y_common, &boxes, &skylines);
+ if (!to_boolean (elements[i]->get_property ("cross-staff")))
+ add_boxes (elements[i], x_common, y_common, &boxes, &skylines);
SCM padding_scm = me->get_property ("skyline-horizontal-padding");
Real padding = robust_scm2double (padding_scm, 0.1);
skylines.merge (Skyline_pair (boxes, padding, X_AXIS));
for (; i < elements.size (); i++)
{
+ if (to_boolean (elements[i]->get_property ("cross-staff")))
+ continue;
+
SCM priority = elements[i]->get_property ("outside-staff-priority");
vector<Grob*> current_elts;
current_elts.push_back (elements[i]);
while (i + 1 < elements.size ()
&& scm_eq_p (elements[i+1]->get_property ("outside-staff-priority"), priority))
- current_elts.push_back (elements[++i]);
+ {
+ if (!to_boolean (elements[i+1]->get_property ("cross-staff")))
+ current_elts.push_back (elements[i+1]);
+ ++i;
+ }
add_grobs_of_one_priority (&skylines, current_elts, x_common, y_common);
}
return skylines;
}
-MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_max_stretch, 1)
-SCM
-Axis_group_interface::calc_max_stretch (SCM smob)
-{
- Grob *me = unsmob_grob (smob);
- Real ret = 0;
- extract_grob_set (me, "elements", elts);
-
- for (vsize i = 0; i < elts.size (); i++)
- if (Axis_group_interface::has_interface (elts[i]))
- ret += robust_scm2double (elts[i]->get_property ("max-stretch"), 0.0);
-
- return scm_from_double (ret);
-}
-
-extern bool debug_skylines;
MAKE_SCHEME_CALLBACK (Axis_group_interface, print, 1)
SCM
Axis_group_interface::print (SCM smob)
Stencil ret;
if (Skyline_pair *s = Skyline_pair::unsmob (me->get_property ("vertical-skylines")))
{
- ret.add_stencil (Lookup::points_to_line_stencil (0.1, (*s)[UP].to_points (X_AXIS)).in_color (255, 0, 255));
- ret.add_stencil (Lookup::points_to_line_stencil (0.1, (*s)[DOWN].to_points (X_AXIS)).in_color (0, 255, 255));
+ ret.add_stencil (Lookup::points_to_line_stencil (0.1, (*s)[UP].to_points (X_AXIS))
+ .in_color (255, 0, 255));
+ ret.add_stencil (Lookup::points_to_line_stencil (0.1, (*s)[DOWN].to_points (X_AXIS))
+ .in_color (0, 255, 255));
}
return ret.smobbed_copy ();
}
-ADD_INTERFACE (Axis_group_interface,
+MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_pure_next_staff_spacing, 3)
+SCM
+Axis_group_interface::calc_pure_next_staff_spacing (SCM smob, SCM start, SCM end)
+{
+ return calc_maybe_pure_next_staff_spacing (unsmob_grob (smob),
+ true,
+ scm_to_int (start),
+ scm_to_int (end));
+}
+
+MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_next_staff_spacing, 1)
+SCM
+Axis_group_interface::calc_next_staff_spacing (SCM smob)
+{
+ return calc_maybe_pure_next_staff_spacing (unsmob_grob (smob),
+ false,
+ 0,
+ INT_MAX);
+}
+SCM
+Axis_group_interface::calc_maybe_pure_next_staff_spacing (Grob *me, bool pure, int start, int end)
+{
+ Grob *grouper = unsmob_grob (me->get_object ("staff-grouper"));
+
+ if (grouper)
+ {
+ Grob *last_in_group = Staff_grouper_interface::get_maybe_pure_last_grob (grouper, pure, start, end);
+ if (me == last_in_group)
+ return grouper->get_maybe_pure_property ("after-last-staff-spacing", pure, start, end);
+ else
+ return grouper->get_maybe_pure_property ("between-staff-spacing", pure, start, end);
+ }
+ return me->get_maybe_pure_property ("default-next-staff-spacing", pure, start, end);
+}
+
+Real
+Axis_group_interface::minimum_distance (Grob *g1, Grob *g2, Axis a)
+{
+ SCM sym = ly_symbol2scm ((a == Y_AXIS) ? "vertical-skylines" : "horizontal-skylines");
+
+ Skyline_pair *s1 = Skyline_pair::unsmob (g1->get_property (sym));
+ Skyline_pair *s2 = Skyline_pair::unsmob (g2->get_property (sym));
+ if (s1 && s2)
+ return (*s1)[DOWN].distance ((*s2)[UP]);
+ return 0;
+}
+
+ADD_INTERFACE (Axis_group_interface,
"An object that groups other layout objects.",
+ // TODO: some of these properties are specific to
+ // VerticalAxisGroup. We should split off a
+ // vertical-axis-group-interface.
/* properties */
"X-common "
"Y-common "
"adjacent-pure-heights "
"axes "
+ "default-next-staff-spacing "
"elements "
+ "inter-loose-line-spacing "
+ "inter-staff-spacing "
"keep-fixed-while-stretching "
"max-stretch "
+ "non-affinity-spacing "
+ "next-staff-spacing "
"no-alignment "
"pure-Y-common "
+ "pure-relevant-grobs "
"pure-relevant-items "
"pure-relevant-spanners "
+ "staff-affinity "
+ "staff-grouper "
+ "system-Y-offset "
"vertical-skylines "
);
projects / lilypond.git / blobdiff