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       Skyline l (bs, Y_AXIS, d);
 132       index_set_cell (lines, d, l.smobbed_copy ());
 133     }
 134   while (flip (&d) != LEFT);
 135
 136   return lines;
 137 }
 138
 139
 140 vector<Box>
 141 Separation_item::boxes (Grob *me)
 142 {
 143   Item *item = dynamic_cast<Item *> (me);
 144
 145   int very_large = INT_MAX;
 146   Paper_column *pc = item->get_column ();
 147   vector<Box> out;
 148   extract_grob_set (me, "elements", elts);
 149
 150   Grob *ycommon = common_refpoint_of_array (elts, me, Y_AXIS);
 151
 152   for (vsize i = 0; i < elts.size (); i++)
 153     {
 154       Item *il = dynamic_cast<Item *> (elts[i]);
 155       if (pc != il->get_column ())
 156         {
 157           continue;
 158         }
 159
 160       if (to_boolean (il->get_property ("no-spacing-rods")))
 161         continue;
 162
 163       Interval y (il->pure_height (ycommon, 0, very_large));
 164       y.widen (0.01);           // fixme
 165       Box b (il->extent (pc, X_AXIS), y);
 166
 167       out.push_back (b);
 168     }
 169
 170   return out;
 171 }
 172
 173 Interval
 174 Separation_item::width (Grob *me)
 175 {
 176   SCM sw = me->get_property ("X-extent");
 177   if (is_number_pair (sw))
 178     return ly_scm2interval (sw);
 179
 180   Item *item = dynamic_cast<Item *> (me);
 181   Paper_column *pc = item->get_column ();
 182   Interval w;
 183
 184   extract_grob_set (me, "elements", elts);
 185   for (vsize i = 0; i < elts.size (); i++)
 186     {
 187       Item *il = dynamic_cast<Item *> (elts[i]);
 188       if (pc != il->get_column ())
 189         {
 190           /* this shouldn't happen, but let's continue anyway. */
 191           programming_error ("Separation_item:  I've been drinking too much");
 192           continue;             /*UGH UGH*/
 193         }
 194
 195       if (to_boolean (il->get_property ("no-spacing-rods")))
 196         continue;
 197
 198       Interval iv (il->extent (pc, X_AXIS));
 199       if (!iv.is_empty ())
 200         w.unite (iv);
 201     }
 202
 203   SCM pad = me->get_property ("padding");
 204
 205   w.widen (robust_scm2double (pad, 0.0));
 206
 207   me->set_property ("X-extent", ly_interval2scm (w));
 208
 209   return w;
 210 }
 211
 212 Interval
 213 Separation_item::relative_width (Grob *me, Grob *common)
 214 {
 215   Interval iv = width (me);
 216
 217   return dynamic_cast<Item *> (me)->get_column ()->relative_coordinate (common, X_AXIS) + iv;
 218 }
 219
 220 /*
 221   Try to find the break-aligned symbol in SEPARATION_ITEM that is
 222   sticking out at direction D. The x size is put in LAST_EXT
 223 */
 224 Grob *
 225 Separation_item::extremal_break_aligned_grob (Grob *me,
 226                                               Direction d,
 227                                               Interval *last_ext)
 228 {
 229   Grob *col = dynamic_cast<Item *> (me)->get_column ();
 230   last_ext->set_empty ();
 231   Grob *last_grob = 0;
 232
 233   extract_grob_set (me, "elements", elts);
 234   for (vsize i = elts.size (); i--;)
 235     {
 236       Grob *break_item = elts[i];
 237       if (!scm_is_symbol (break_item->get_property ("break-align-symbol")))
 238         continue;
 239
 240       if (!scm_is_pair (break_item->get_property ("space-alist")))
 241         continue;
 242
 243       Interval ext = break_item->extent (col, X_AXIS);
 244
 245       if (ext.is_empty ())
 246         continue;
 247
 248       if (!last_grob
 249           || (last_grob && d * (ext[d]- (*last_ext)[d]) > 0))
 250         {
 251           *last_ext = ext;
 252           last_grob = break_item;
 253         }
 254     }
 255
 256   return last_grob;
 257 }
 258
 259 ADD_INTERFACE (Separation_item,
 260                "Item that computes widths to generate spacing rods. "
 261                "This is done in concert with @ref{separating-group-spanner-interface}.",
 262
 263                "X-extent "
 264                "conditional-elements "
 265                "elements "
 266                "padding "
 267                "skylines "
 268                );