X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faxis-group-interface.cc;h=c7a5b8eff90b5c0cd4b45501465987b94ee381b5;hb=32426e733840b1d33afbf023639ca7e21a9f647e;hp=fbac83ee5bcb152af29540b746e04bd5f2404cf2;hpb=c659cb200486c2f908703696a1b2873e78c8160a;p=lilypond.git diff --git a/lily/axis-group-interface.cc b/lily/axis-group-interface.cc index fbac83ee5b..c7a5b8eff9 100644 --- a/lily/axis-group-interface.cc +++ b/lily/axis-group-interface.cc @@ -1,48 +1,68 @@ -/* - axis-group-interface.cc -- implement Axis_group_interface - +/* + axis-group-interface.cc -- implement Axis_group_interface + source file of the GNU LilyPond music typesetter - - (c) 2000--2004 Han-Wen Nienhuys - - */ + + (c) 2000--2006 Han-Wen Nienhuys +*/ #include "axis-group-interface.hh" +#include "align-interface.hh" +#include "directional-element-interface.hh" +#include "pointer-group-interface.hh" +#include "grob.hh" +#include "grob-array.hh" #include "hara-kiri-group-spanner.hh" +#include "international.hh" +#include "item.hh" +#include "paper-column.hh" +#include "paper-score.hh" +#include "std-vector.hh" +#include "system.hh" +#include "warn.hh" void -Axis_group_interface::add_element (Grob*me,Grob *e) +Axis_group_interface::add_element (Grob *me, Grob *e) { - for (SCM ax = me->get_property ("axes"); ax != SCM_EOL ; ax = scm_cdr (ax)) + SCM axes = me->get_property ("axes"); + if (!scm_is_pair (axes)) + programming_error ("axes should be nonempty"); + + for (SCM ax = axes; scm_is_pair (ax); ax = scm_cdr (ax)) { Axis a = (Axis) scm_to_int (scm_car (ax)); - + if (!e->get_parent (a)) e->set_parent (me, a); + + e->set_object ((a == X_AXIS) + ? ly_symbol2scm ("axis-group-parent-X") + : ly_symbol2scm ("axis-group-parent-Y"), + me->self_scm ()); } + /* must be ordered, because Align_interface also uses + Axis_group_interface */ Pointer_group_interface::add_grob (me, ly_symbol2scm ("elements"), e); - me->add_dependency (e); } bool -Axis_group_interface::has_axis (Grob*me,Axis a) +Axis_group_interface::has_axis (Grob *me, Axis a) { - /* - urg. FIXME, check for Hara_kiri_group_spanner shouldn't be necessary? - */ - return me->has_extent_callback (group_extent_callback_proc, a) || - (me->has_extent_callback (Hara_kiri_group_spanner::y_extent_proc, a)); + SCM axes = me->get_property ("axes"); + + return (SCM_BOOL_F != scm_memq (scm_from_int (a), axes)); } Interval -Axis_group_interface::relative_group_extent (Axis a, Grob *common, SCM elts) +Axis_group_interface::relative_group_extent (vector const &elts, + Grob *common, Axis a) { Interval r; - for (SCM s = elts; scm_is_pair (s); s = scm_cdr (s)) + for (vsize i = 0; i < elts.size (); i++) { - Grob * se = unsmob_grob (scm_car (s)); + Grob *se = elts[i]; Interval dims = se->extent (common, a); if (!dims.is_empty ()) r.unite (dims); @@ -50,75 +70,260 @@ Axis_group_interface::relative_group_extent (Axis a, Grob *common, SCM elts) return r; } -MAKE_SCHEME_CALLBACK (Axis_group_interface,group_extent_callback,2); +Interval +Axis_group_interface::cached_pure_height (Grob *me, + vector const &elts, + Grob *common, + int start, int end) +{ + Paper_score *ps = get_root_system (me)->paper_score (); + vector breaks = ps->get_break_indices (); + vector cols = ps->get_columns (); + vsize start_index = VPOS; + vsize end_index = VPOS; + + for (vsize i = 0; i < breaks.size (); i++) + { + int r = Paper_column::get_rank (cols[breaks[i]]); + if (start == r) + start_index = i; + if (end == r) + end_index = i; + } + + if (start_index == VPOS || end_index == VPOS) + { + programming_error (_ ("tried to calculate pure-height at a non-breakpoint")); + return Interval (0, 0); + } + + SCM extents = me->get_property ("cached-pure-extents"); + if (!scm_is_vector (extents)) + { + extents = scm_c_make_vector (breaks.size () - 1, SCM_EOL); + for (vsize i = 0; i < breaks.size () - 1; i++) + { + int st = Paper_column::get_rank (cols[breaks[i]]); + int ed = Paper_column::get_rank (cols[breaks[i+1]]); + Interval iv = relative_pure_height (me, elts, common, st, ed, false); + scm_vector_set_x (extents, scm_from_int (i), ly_interval2scm (iv)); + } + me->set_property ("cached-pure-extents", extents); + } + + Interval ext (0, 0); + for (vsize i = start_index; i < end_index; i++) + ext.unite (ly_scm2interval (scm_c_vector_ref (extents, i))); + return ext; +} + +Interval +Axis_group_interface::relative_pure_height (Grob *me, + vector const &elts, + Grob *common, + int start, int end, + bool use_cache) +{ + /* It saves a _lot_ of time if we assume a VerticalAxisGroup is additive + (ie. height (i, k) = height (i, j) + height (j, k) for all i <= j <= k). + Unfortunately, it isn't always true, particularly if there is a + VerticalAlignment somewhere in the descendants. + + Apart from PianoStaff, which has a fixed VerticalAlignment so it doesn't + count, the only VerticalAlignment comes from Score. This makes it + reasonably safe to assume that if our parent is a VerticalAlignment, + we can assume additivity and cache things nicely. */ + Grob *p = me->get_parent (Y_AXIS); + if (use_cache && p && Align_interface::has_interface (p)) + return Axis_group_interface::cached_pure_height (me, elts, common, start, end); + + Interval r; + + for (vsize i = 0; i < elts.size (); i++) + { + Interval_t rank_span = elts[i]->spanned_rank_iv (); + Item *it = dynamic_cast (elts[i]); + if (rank_span[LEFT] <= end && rank_span[RIGHT] >= start && (!it || it->pure_is_visible (start, end))) + { + Interval dims = elts[i]->pure_height (common, start, end); + if (!dims.is_empty ()) + r.unite (dims); + } + } + return r; +} + +MAKE_SCHEME_CALLBACK (Axis_group_interface, width, 1); SCM -Axis_group_interface::group_extent_callback (SCM element_smob, SCM scm_axis) +Axis_group_interface::width (SCM smob) { - Grob *me = unsmob_grob (element_smob); - Axis a = (Axis) scm_to_int (scm_axis); + Grob *me = unsmob_grob (smob); + return generic_group_extent (me, X_AXIS); +} - SCM elts = me->get_property ("elements"); - Grob * common = common_refpoint_of_list (elts, me, a); +MAKE_SCHEME_CALLBACK (Axis_group_interface, height, 1); +SCM +Axis_group_interface::height (SCM smob) +{ + Grob *me = unsmob_grob (smob); + return generic_group_extent (me, Y_AXIS); +} + +MAKE_SCHEME_CALLBACK (Axis_group_interface, pure_height, 3); +SCM +Axis_group_interface::pure_height (SCM smob, SCM start_scm, SCM end_scm) +{ + int start = robust_scm2int (start_scm, 0); + int end = robust_scm2int (end_scm, INT_MAX); + Grob *me = unsmob_grob (smob); + + return pure_group_height (me, start, end); +} + +SCM +Axis_group_interface::generic_group_extent (Grob *me, Axis a) +{ + extract_grob_set (me, "elements", elts); + if (a == Y_AXIS && to_boolean (me->get_property ("skyline-spacing"))) + skyline_spacing (me, elts); + Grob *common = common_refpoint_of_array (elts, me, a); Real my_coord = me->relative_coordinate (common, a); - Interval r (relative_group_extent (a, common, elts)); + Interval r (relative_group_extent (elts, common, a)); return ly_interval2scm (r - my_coord); } -void -Axis_group_interface::set_axes (Grob*me,Axis a1, Axis a2) +SCM +Axis_group_interface::pure_group_height (Grob *me, int start, int end) { - SCM sa1= scm_int2num (a1); - SCM sa2 = scm_int2num (a2); + Grob *common = unsmob_grob (me->get_object ("common-refpoint-of-elements")); - SCM axes = me->get_property ("axes"); - - if (!scm_is_pair (axes) - || scm_c_memq (sa1, axes) == SCM_BOOL_F - || scm_c_memq (sa2, axes) == SCM_BOOL_F) + if (!common) { - SCM ax = scm_cons (sa1, SCM_EOL); - if (a1 != a2) - ax= scm_cons (sa2, ax); - me->set_property ("axes", ax); + extract_grob_set (me, "elements", elts); + + vector relevant_elts; + SCM is_relevant = ly_lily_module_constant ("pure-relevant"); + + for (vsize i = 0; i < elts.size (); i++) + { + if (to_boolean (scm_apply_1 (is_relevant, elts[i]->self_scm (), SCM_EOL))) + relevant_elts.push_back (elts[i]); + + Item *it = dynamic_cast (elts[i]); + Direction d = LEFT; + if (it) + do + { + Item *piece = it->find_prebroken_piece (d); + if (piece && to_boolean (scm_apply_1 (is_relevant, piece->self_scm (), SCM_EOL))) + relevant_elts.push_back (piece); + } + while (flip (&d) != LEFT); + } + + common = common_refpoint_of_array (relevant_elts, me, Y_AXIS); + me->set_object ("common-refpoint-of-elements", common->self_scm ()); + + SCM ga_scm = Grob_array::make_array (); + Grob_array *ga = unsmob_grob_array (ga_scm); + ga->set_array (relevant_elts); + me->set_object ("pure-relevant-elements", ga_scm); } - if (a1 != X_AXIS && a2 != X_AXIS) - me->set_extent (SCM_EOL, X_AXIS); - if (a1 != Y_AXIS && a2 != Y_AXIS) - me->set_extent (SCM_EOL, Y_AXIS); - - /* - why so convoluted ? (fixme/documentme?) - */ - if (me->has_extent_callback (Grob::stencil_extent_proc, a1)) - me->set_extent (Axis_group_interface::group_extent_callback_proc,a1); - if (me->has_extent_callback (Grob::stencil_extent_proc, a2)) - me->set_extent (Axis_group_interface::group_extent_callback_proc,a2); + extract_grob_set (me, "pure-relevant-elements", elts); + Real my_coord = me->relative_coordinate (common, Y_AXIS); + Interval r (relative_pure_height (me, elts, common, start, end, true)); + + return ly_interval2scm (r - my_coord); } -Link_array -Axis_group_interface::get_children (Grob*me) +void +Axis_group_interface::get_children (Grob *me, vector *found) { - Link_array childs; - childs.push (me) ; + found->push_back (me); if (!has_interface (me)) - return childs; - - for (SCM ep = me->get_property ("elements"); scm_is_pair (ep); ep = scm_cdr (ep)) + return; + + extract_grob_set (me, "elements", elements); + for (vsize i = 0; i < elements.size (); i++) { - Grob* e = unsmob_grob (scm_car (ep)); - if (e) - childs.concat (Axis_group_interface::get_children (e)); + Grob *e = elements[i]; + Axis_group_interface::get_children (e, found); } - - return childs; } +bool +staff_priority_less (Grob * const &g1, Grob * const &g2) +{ + int priority_1 = robust_scm2int (g1->get_property ("outside-staff-priority"), INT_MIN); + int priority_2 = robust_scm2int (g2->get_property ("outside-staff-priority"), INT_MIN); + + if (priority_1 < priority_2) + return true; + else if (priority_1 > priority_2) + return false; + + /* if there is no preference in staff priority, choose the one with the lower rank */ + int rank_1 = g1->spanned_rank_iv ()[LEFT]; + int rank_2 = g2->spanned_rank_iv ()[LEFT]; + return rank_1 < rank_2; +} + +void +Axis_group_interface::skyline_spacing (Grob *me, vector elements) +{ + 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); + + vsize i = 0; + vector boxes; + + for (i = 0; i < elements.size () + && !scm_is_number (elements[i]->get_property ("outside-staff-priority")); i++) + boxes.push_back (Box (elements[i]->extent (x_common, X_AXIS), + elements[i]->extent (y_common, Y_AXIS))); + + + Drul_array skylines (Skyline (boxes, X_AXIS, DOWN), + Skyline (boxes, X_AXIS, UP)); + for (; i < elements.size (); i++) + { + Direction dir = get_grob_direction (elements[i]); + if (dir == CENTER) + { + warning (_ ("an outside-staff object should have a direction")); + continue; + } + + Box b (elements[i]->extent (x_common, X_AXIS), + elements[i]->extent (y_common, Y_AXIS)); + boxes.clear (); + boxes.push_back (b); + Skyline other = Skyline (boxes, X_AXIS, -dir); + Real dist = skylines[dir].distance (other); + if (dist > 0) + { + b.translate (Offset (0, dir*dist)); + elements[i]->translate_axis (dir*dist, Y_AXIS); + } + skylines[dir].insert (b, X_AXIS); + } +} ADD_INTERFACE (Axis_group_interface, "axis-group-interface", - "An object that groups other layout objects.", - "axes elements"); + + "An object that groups other layout objects.", + + /* properties */ + "axes " + "elements " + "common-refpoint-of-elements " + "pure-relevant-elements " + "skyline-spacing " + "cached-pure-extents " + );