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