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