X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fseparation-item.cc;h=c0536b6ce3ab69b95f545b860d45ba65a707ee8e;hb=87eedcd59f4082cb0841528ad5bc82cb1d1191e3;hp=8a777a0df9aadf51563972e725b7ff022fc77953;hpb=94189ec2b8da6d7e89dc619c646a927adead9b19;p=lilypond.git diff --git a/lily/separation-item.cc b/lily/separation-item.cc index 8a777a0df9..c0536b6ce3 100644 --- a/lily/separation-item.cc +++ b/lily/separation-item.cc @@ -1,68 +1,191 @@ -/* - single-malt-grouping-item.cc -- implement Separation_item - +/* + separation-item.cc -- implement Separation_item + source file of the GNU LilyPond music typesetter - - (c) 1998--2001 Han-Wen Nienhuys - - */ + + (c) 1998--2007 Han-Wen Nienhuys +*/ #include "separation-item.hh" + +#include "skyline.hh" #include "paper-column.hh" -#include "debug.hh" -#include "group-interface.hh" +#include "warn.hh" +#include "pointer-group-interface.hh" +#include "accidental-placement.hh" void -Separation_item::set_interface (Grob*s) +Separation_item::add_item (Grob *s, Item *i) { - s->set_extent_callback (SCM_EOL, X_AXIS); - s->set_extent_callback (SCM_EOL, Y_AXIS); + assert (i); + Pointer_group_interface::add_grob (s, ly_symbol2scm ("elements"), i); } void -Separation_item::add_item (Grob*s,Item* i) +Separation_item::add_conditional_item (Grob *me, Grob *e) { - assert (i); - Pointer_group_interface::add_element (s,"elements",i); - s->add_dependency (i); + Pointer_group_interface::add_grob (me, ly_symbol2scm ("conditional-elements"), e); } -Interval -Separation_item::my_width (Grob *me) +void +Separation_item::set_skyline_distance (Drul_array items, + Real padding) { - Item *item = dynamic_cast (me); - Paper_column * pc = item->column_l (); - Interval w; + Drul_array lines (Skyline_pair::unsmob (items[LEFT]->get_property ("skylines")), + Skyline_pair::unsmob (items[RIGHT]->get_property ("skylines"))); + Skyline right = conditional_skyline (items[RIGHT], items[LEFT]); + right.merge ((*lines[RIGHT])[LEFT]); - for (SCM s = me->get_grob_property ("elements"); gh_pair_p (s); s = gh_cdr (s)) + Real dist = padding + (*lines[LEFT])[RIGHT].distance (right); + if (dist > 0) { - SCM elt = gh_car (s); - if (!unsmob_grob (elt)) - continue; + Rod rod; - Item *il = dynamic_cast (unsmob_grob (elt)); - if (pc != il->column_l ()) - { - /* this shouldn't happen, but let's continue anyway. */ - programming_error (_("Separation_item: I've been drinking too much")); - continue; /*UGH UGH*/ - } + rod.item_drul_ = items; + + rod.distance_ = dist; + rod.add_to_cols (); + } +} + +bool +Separation_item::set_distance (Drul_array items, + Real padding) +{ + set_skyline_distance (items, padding); + return true; +} + +/* + Return the width of ME given that we are considering the object on + the LEFT. +*/ +Skyline +Separation_item::conditional_skyline (Grob *me, Grob *left) +{ + vector bs = boxes (me, left); + return Skyline (bs, 0.1, Y_AXIS, LEFT); +} + + +MAKE_SCHEME_CALLBACK(Separation_item,calc_skylines,1); +SCM +Separation_item::calc_skylines (SCM smob) +{ + Item *me = unsmob_item (smob); + vector bs = boxes (me, 0); + /* todo: the horizon_padding is somewhat arbitrary */ + return Skyline_pair (bs, 0.1, Y_AXIS).smobbed_copy (); +} + +/* if left is non-NULL, get the boxes corresponding to the + conditional-elements (conditioned on the grob LEFT). This + sounds more general than it is: conditional-elements are + always accidentals attached to a tied note. +*/ +vector +Separation_item::boxes (Grob *me, Grob *left) +{ + Item *item = dynamic_cast (me); + + int very_large = INT_MAX; + Paper_column *pc = item->get_column (); + vector out; + extract_grob_set (me, left ? "conditional-elements" : "elements", read_only_elts); + vector elts; - if (to_boolean (il->get_grob_property ("no-spacing-rods"))) + if (left) + elts = Accidental_placement::get_break_reminder_accidentals (read_only_elts, left); + else + elts = read_only_elts; + + Grob *ycommon = common_refpoint_of_array (elts, me, Y_AXIS); + + for (vsize i = 0; i < elts.size (); i++) + { + Item *il = dynamic_cast (elts[i]); + if (pc != il->get_column ()) { continue; } - Interval iv (il->extent (pc, X_AXIS)); - if (!iv.empty_b ()) + Interval y (il->pure_height (ycommon, 0, very_large)); + Interval x (il->extent (pc, X_AXIS)); + + Interval extra = robust_scm2interval (elts[i]->get_property ("extra-spacing-width"), + Interval (0, 0)); + x[LEFT] += extra[LEFT]; + x[RIGHT] += extra[RIGHT]; + if (to_boolean (elts[i]->get_property ("infinite-spacing-height"))) + y = Interval (-infinity_f, infinity_f); + + out.push_back (Box (x, y)); + } + + return out; +} + +Interval +Separation_item::width (Grob *me) +{ + SCM sw = me->get_property ("X-extent"); + return ly_scm2interval (sw); +} + +Interval +Separation_item::relative_width (Grob *me, Grob *common) +{ + Interval iv = width (me); + + return dynamic_cast (me)->get_column ()->relative_coordinate (common, X_AXIS) + iv; +} + +/* + Try to find the break-aligned symbol in SEPARATION_ITEM that is + sticking out at direction D. The x size is put in LAST_EXT +*/ +Grob * +Separation_item::extremal_break_aligned_grob (Grob *me, + Direction d, + Interval *last_ext) +{ + Grob *col = dynamic_cast (me)->get_column (); + last_ext->set_empty (); + Grob *last_grob = 0; + + extract_grob_set (me, "elements", elts); + for (vsize i = elts.size (); i--;) + { + Grob *break_item = elts[i]; + if (!scm_is_symbol (break_item->get_property ("break-align-symbol"))) + continue; + + if (!scm_is_pair (break_item->get_property ("space-alist"))) + continue; + + Interval ext = break_item->extent (col, X_AXIS); + + if (ext.is_empty ()) + continue; + + if (!last_grob + || (last_grob && d * (ext[d]- (*last_ext)[d]) > 0)) { - w.unite (iv); + *last_ext = ext; + last_grob = break_item; } } - return w; - // add this->offset_ ? this-> relative_coordinate ()? + return last_grob; } +ADD_INTERFACE (Separation_item, + "Item that computes widths to generate spacing rods. " + "This is done in concert with @ref{separating-group-spanner-interface}.", - + "X-extent " + "conditional-elements " + "elements " + "padding " + "skylines " + );