lily/separation-item.cc

   1 /*
   2   separation-item.cc -- implement Separation_item
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1998--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 #include "separation-item.hh"
  10
  11 #include "skyline.hh"
  12 #include "paper-column.hh"
  13 #include "warn.hh"
  14 #include "pointer-group-interface.hh"
  15 #include "accidental-placement.hh"
  16
  17 void
  18 Separation_item::add_item (Grob *s, Item *i)
  19 {
  20   assert (i);
  21   Pointer_group_interface::add_grob (s, ly_symbol2scm ("elements"), i);
  22 }
  23
  24 void
  25 Separation_item::add_conditional_item (Grob *me, Grob *e)
  26 {
  27   Pointer_group_interface::add_grob (me, ly_symbol2scm ("conditional-elements"), e);
  28 }
  29
  30 void
  31 Separation_item::set_skyline_distance (Drul_array<Item *> items,
  32                                        Real padding)
  33 {
  34   Drul_array<Skyline*> lines;
  35   Direction d = LEFT;
  36
  37   do
  38     {
  39       SCM prop = items[d]->get_property ("skylines");
  40       lines[d] = Skyline::unsmob (index_get_cell (prop, -d));
  41     }
  42   while (flip (&d) != LEFT);
  43
  44   Real dist = padding + lines[LEFT]->distance (*lines[RIGHT]);
  45   if (dist > 0)
  46     {
  47       Rod rod;
  48
  49       rod.item_drul_ = items;
  50
  51       rod.distance_ = dist;
  52       rod.add_to_cols ();
  53     }
  54 }
  55
  56 bool
  57 Separation_item::set_distance (Drul_array<Item *> items,
  58                                Real padding)
  59 {
  60   if (!Item::is_non_musical (items[LEFT])
  61       && !Item::is_non_musical (items[RIGHT]))
  62     {
  63       set_skyline_distance (items, padding);
  64       return true;
  65     }
  66
  67   Interval li (Separation_item::width (items[LEFT]));
  68   Interval ri (Separation_item::conditional_width (items[RIGHT], items[LEFT]));
  69   if (!li.is_empty () && !ri.is_empty ())
  70     {
  71       Rod rod;
  72
  73       rod.item_drul_ = items;
  74
  75       rod.distance_ = li[RIGHT] - ri[LEFT] + padding;
  76
  77       if (rod.distance_  > 0)
  78         rod.add_to_cols ();
  79       return true;
  80     }
  81   return false;
  82 }
  83
  84 /*
  85   Return the width of ME given that we are considering the object on
  86   the LEFT.
  87 */
  88 Interval
  89 Separation_item::conditional_width (Grob *me, Grob *left)
  90 {
  91   Interval w = width (me);
  92
  93   Item *item = dynamic_cast<Item *> (me);
  94   Paper_column *pc = item->get_column ();
  95
  96   extract_grob_set (me, "conditional-elements", elts);
  97   for (vsize i = 0; i < elts.size (); i++)
  98     {
  99       Item *il = dynamic_cast<Item *> (elts[i]);
 100       if (pc != il->get_column ())
 101         {
 102           programming_error ("Separation_item element from wrong column");
 103           continue;
 104         }
 105
 106       if (to_boolean (il->get_property ("no-spacing-rods")))
 107         continue;
 108
 109       if (Accidental_placement::has_interface (il))
 110         w.unite (Accidental_placement::get_relevant_accidental_extent (il, pc, left));
 111     }
 112
 113   SCM pad = me->get_property ("padding");
 114
 115   w.widen (robust_scm2double (pad, 0.0));
 116   return w;
 117 }
 118
 119
 120 MAKE_SCHEME_CALLBACK(Separation_item,calc_skylines,1);
 121 SCM
 122 Separation_item::calc_skylines (SCM smob)
 123 {
 124   Item *me = unsmob_item (smob);
 125   SCM lines = scm_cons (SCM_BOOL_F,SCM_BOOL_F);
 126
 127   Direction d = LEFT;
 128   vector<Box> bs = boxes (me);
 129   do
 130     {
 131       /* todo: make skyline max-slope configurable? */
 132       Skyline l (bs, 2, Y_AXIS, d);
 133       index_set_cell (lines, d, l.smobbed_copy ());
 134     }
 135   while (flip (&d) != LEFT);
 136
 137   return lines;
 138 }
 139
 140
 141 vector<Box>
 142 Separation_item::boxes (Grob *me)
 143 {
 144   Item *item = dynamic_cast<Item *> (me);
 145
 146   int very_large = INT_MAX;
 147   Paper_column *pc = item->get_column ();
 148   vector<Box> out;
 149   extract_grob_set (me, "elements", elts);
 150
 151   Grob *ycommon = common_refpoint_of_array (elts, me, Y_AXIS);
 152
 153   for (vsize i = 0; i < elts.size (); i++)
 154     {
 155       Item *il = dynamic_cast<Item *> (elts[i]);
 156       if (pc != il->get_column ())
 157         {
 158           continue;
 159         }
 160
 161       if (to_boolean (il->get_property ("no-spacing-rods")))
 162         continue;
 163
 164       Interval y (il->pure_height (ycommon, 0, very_large));
 165       y.widen (0.01);           // fixme
 166       Box b (il->extent (pc, X_AXIS), y);
 167
 168       out.push_back (b);
 169     }
 170
 171   return out;
 172 }
 173
 174 Interval
 175 Separation_item::width (Grob *me)
 176 {
 177   SCM sw = me->get_property ("X-extent");
 178   if (is_number_pair (sw))
 179     return ly_scm2interval (sw);
 180
 181   Item *item = dynamic_cast<Item *> (me);
 182   Paper_column *pc = item->get_column ();
 183   Interval w;
 184
 185   extract_grob_set (me, "elements", elts);
 186   for (vsize i = 0; i < elts.size (); i++)
 187     {
 188       Item *il = dynamic_cast<Item *> (elts[i]);
 189       if (pc != il->get_column ())
 190         {
 191           /* this shouldn't happen, but let's continue anyway. */
 192           programming_error ("Separation_item:  I've been drinking too much");
 193           continue;             /*UGH UGH*/
 194         }
 195
 196       if (to_boolean (il->get_property ("no-spacing-rods")))
 197         continue;
 198
 199       Interval iv (il->extent (pc, X_AXIS));
 200       if (!iv.is_empty ())
 201         w.unite (iv);
 202     }
 203
 204   SCM pad = me->get_property ("padding");
 205
 206   w.widen (robust_scm2double (pad, 0.0));
 207
 208   me->set_property ("X-extent", ly_interval2scm (w));
 209
 210   return w;
 211 }
 212
 213 Interval
 214 Separation_item::relative_width (Grob *me, Grob *common)
 215 {
 216   Interval iv = width (me);
 217
 218   return dynamic_cast<Item *> (me)->get_column ()->relative_coordinate (common, X_AXIS) + iv;
 219 }
 220
 221 /*
 222   Try to find the break-aligned symbol in SEPARATION_ITEM that is
 223   sticking out at direction D. The x size is put in LAST_EXT
 224 */
 225 Grob *
 226 Separation_item::extremal_break_aligned_grob (Grob *me,
 227                                               Direction d,
 228                                               Interval *last_ext)
 229 {
 230   Grob *col = dynamic_cast<Item *> (me)->get_column ();
 231   last_ext->set_empty ();
 232   Grob *last_grob = 0;
 233
 234   extract_grob_set (me, "elements", elts);
 235   for (vsize i = elts.size (); i--;)
 236     {
 237       Grob *break_item = elts[i];
 238       if (!scm_is_symbol (break_item->get_property ("break-align-symbol")))
 239         continue;
 240
 241       if (!scm_is_pair (break_item->get_property ("space-alist")))
 242         continue;
 243
 244       Interval ext = break_item->extent (col, X_AXIS);
 245
 246       if (ext.is_empty ())
 247         continue;
 248
 249       if (!last_grob
 250           || (last_grob && d * (ext[d]- (*last_ext)[d]) > 0))
 251         {
 252           *last_ext = ext;
 253           last_grob = break_item;
 254         }
 255     }
 256
 257   return last_grob;
 258 }
 259
 260 ADD_INTERFACE (Separation_item,
 261                "Item that computes widths to generate spacing rods. "
 262                "This is done in concert with @ref{separating-group-spanner-interface}.",
 263
 264                "X-extent "
 265                "conditional-elements "
 266                "elements "
 267                "padding "
 268                "skylines "
 269                );