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 void
  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;
  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     }
  80 }
  81
  82 /*
  83   Return the width of ME given that we are considering the object on
  84   the LEFT.
  85 */
  86 Interval
  87 Separation_item::conditional_width (Grob *me, Grob *left)
  88 {
  89   Interval w = width (me);
  90
  91   Item *item = dynamic_cast<Item *> (me);
  92   Paper_column *pc = item->get_column ();
  93
  94   extract_grob_set (me, "conditional-elements", elts);
  95   for (vsize i = 0; i < elts.size (); i++)
  96     {
  97       Item *il = dynamic_cast<Item *> (elts[i]);
  98       if (pc != il->get_column ())
  99         {
 100           programming_error ("Separation_item element from wrong column");
 101           continue;
 102         }
 103
 104       if (to_boolean (il->get_property ("no-spacing-rods")))
 105         continue;
 106
 107       if (Accidental_placement::has_interface (il))
 108         w.unite (Accidental_placement::get_relevant_accidental_extent (il, pc, left));
 109     }
 110
 111   SCM pad = me->get_property ("padding");
 112
 113   w.widen (robust_scm2double (pad, 0.0));
 114   return w;
 115 }
 116
 117
 118 MAKE_SCHEME_CALLBACK(Separation_item,calc_skylines,1);
 119 SCM
 120 Separation_item::calc_skylines (SCM smob)
 121 {
 122   Item *me = unsmob_item (smob);
 123   SCM lines = scm_cons (SCM_BOOL_F,SCM_BOOL_F);
 124
 125   Direction d = LEFT;
 126   vector<Box> bs = boxes (me);
 127   do
 128     {
 129       Skyline l (bs, Y_AXIS, d);
 130       index_set_cell (lines, d, l.smobbed_copy ());
 131     }
 132   while (flip (&d) != LEFT);
 133
 134   return lines;
 135 }
 136
 137
 138 vector<Box>
 139 Separation_item::boxes (Grob *me)
 140 {
 141   Item *item = dynamic_cast<Item *> (me);
 142
 143   int very_large = INT_MAX;
 144   Paper_column *pc = item->get_column ();
 145   vector<Box> out;
 146   extract_grob_set (me, "elements", elts);
 147
 148   Grob *ycommon = common_refpoint_of_array (elts, me, Y_AXIS);
 149
 150   for (vsize i = 0; i < elts.size (); i++)
 151     {
 152       Item *il = dynamic_cast<Item *> (elts[i]);
 153       if (pc != il->get_column ())
 154         {
 155           continue;
 156         }
 157
 158       if (to_boolean (il->get_property ("no-spacing-rods")))
 159         continue;
 160
 161       Interval y (il->pure_height (ycommon, 0, very_large));
 162       y.widen (0.01);           // fixme
 163       Box b (il->extent (pc, X_AXIS), y);
 164
 165       out.push_back (b);
 166     }
 167
 168   return out;
 169 }
 170
 171 Interval
 172 Separation_item::width (Grob *me)
 173 {
 174   SCM sw = me->get_property ("X-extent");
 175   if (is_number_pair (sw))
 176     return ly_scm2interval (sw);
 177
 178   Item *item = dynamic_cast<Item *> (me);
 179   Paper_column *pc = item->get_column ();
 180   Interval w;
 181
 182   extract_grob_set (me, "elements", elts);
 183   for (vsize i = 0; i < elts.size (); i++)
 184     {
 185       Item *il = dynamic_cast<Item *> (elts[i]);
 186       if (pc != il->get_column ())
 187         {
 188           /* this shouldn't happen, but let's continue anyway. */
 189           programming_error ("Separation_item:  I've been drinking too much");
 190           continue;             /*UGH UGH*/
 191         }
 192
 193       if (to_boolean (il->get_property ("no-spacing-rods")))
 194         continue;
 195
 196       Interval iv (il->extent (pc, X_AXIS));
 197       if (!iv.is_empty ())
 198         w.unite (iv);
 199     }
 200
 201   SCM pad = me->get_property ("padding");
 202
 203   w.widen (robust_scm2double (pad, 0.0));
 204
 205   me->set_property ("X-extent", ly_interval2scm (w));
 206
 207   return w;
 208 }
 209
 210 Interval
 211 Separation_item::relative_width (Grob *me, Grob *common)
 212 {
 213   Interval iv = width (me);
 214
 215   return dynamic_cast<Item *> (me)->get_column ()->relative_coordinate (common, X_AXIS) + iv;
 216 }
 217
 218 /*
 219   Try to find the break-aligned symbol in SEPARATION_ITEM that is
 220   sticking out at direction D. The x size is put in LAST_EXT
 221 */
 222 Grob *
 223 Separation_item::extremal_break_aligned_grob (Grob *me,
 224                                               Direction d,
 225                                               Interval *last_ext)
 226 {
 227   Grob *col = dynamic_cast<Item *> (me)->get_column ();
 228   last_ext->set_empty ();
 229   Grob *last_grob = 0;
 230
 231   extract_grob_set (me, "elements", elts);
 232   for (vsize i = elts.size (); i--;)
 233     {
 234       Grob *break_item = elts[i];
 235       if (!scm_is_symbol (break_item->get_property ("break-align-symbol")))
 236         continue;
 237
 238       if (!scm_is_pair (break_item->get_property ("space-alist")))
 239         continue;
 240
 241       Interval ext = break_item->extent (col, X_AXIS);
 242
 243       if (ext.is_empty ())
 244         continue;
 245
 246       if (!last_grob
 247           || (last_grob && d * (ext[d]- (*last_ext)[d]) > 0))
 248         {
 249           *last_ext = ext;
 250           last_grob = break_item;
 251         }
 252     }
 253
 254   return last_grob;
 255 }
 256
 257 ADD_INTERFACE (Separation_item,
 258                "Item that computes widths to generate spacing rods. "
 259                "This is done in concert with @ref{separation-spanner-interface}.",
 260
 261                "X-extent "
 262                "conditional-elements "
 263                "elements"
 264                "padding "
 265                "skylines "
 266                );