lily/axis-group-interface.cc

   1 /*
   2   axis-group-interface.cc -- implement Axis_group_interface
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2000--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 #include "axis-group-interface.hh"
  10
  11 #include "align-interface.hh"
  12 #include "directional-element-interface.hh"
  13 #include "pointer-group-interface.hh"
  14 #include "grob.hh"
  15 #include "grob-array.hh"
  16 #include "hara-kiri-group-spanner.hh"
  17 #include "international.hh"
  18 #include "item.hh"
  19 #include "paper-column.hh"
  20 #include "paper-score.hh"
  21 #include "std-vector.hh"
  22 #include "system.hh"
  23 #include "warn.hh"
  24
  25 void
  26 Axis_group_interface::add_element (Grob *me, Grob *e)
  27 {
  28   SCM axes = me->get_property ("axes");
  29   if (!scm_is_pair (axes))
  30     programming_error ("axes should be nonempty");
  31
  32   for (SCM ax = axes; scm_is_pair (ax); ax = scm_cdr (ax))
  33     {
  34       Axis a = (Axis) scm_to_int (scm_car (ax));
  35
  36       if (!e->get_parent (a))
  37         e->set_parent (me, a);
  38
  39       e->set_object ((a == X_AXIS)
  40                      ? ly_symbol2scm ("axis-group-parent-X")
  41                      : ly_symbol2scm ("axis-group-parent-Y"),
  42                      me->self_scm ());
  43     }
  44
  45   /* must be ordered, because Align_interface also uses
  46      Axis_group_interface  */
  47   Pointer_group_interface::add_grob (me, ly_symbol2scm ("elements"), e);
  48 }
  49
  50 bool
  51 Axis_group_interface::has_axis (Grob *me, Axis a)
  52 {
  53   SCM axes = me->get_property ("axes");
  54
  55   return (SCM_BOOL_F != scm_memq (scm_from_int (a), axes));
  56 }
  57
  58 Interval
  59 Axis_group_interface::relative_group_extent (vector<Grob*> const &elts,
  60                                              Grob *common, Axis a)
  61 {
  62   Interval r;
  63   for (vsize i = 0; i < elts.size (); i++)
  64     {
  65       Grob *se = elts[i];
  66       Interval dims = se->extent (common, a);
  67       if (!dims.is_empty ())
  68         r.unite (dims);
  69     }
  70   return r;
  71 }
  72
  73 Interval
  74 Axis_group_interface::cached_pure_height (Grob *me,
  75                                           vector<Grob*> const &elts,
  76                                           Grob *common,
  77                                           int start, int end)
  78 {
  79   Paper_score *ps = get_root_system (me)->paper_score ();
  80   vector<vsize> breaks = ps->get_break_indices ();
  81   vector<Grob*> cols = ps->get_columns ();
  82   vsize start_index = VPOS;
  83   vsize end_index = VPOS;
  84
  85   for (vsize i = 0; i < breaks.size (); i++)
  86     {
  87       int r = Paper_column::get_rank (cols[breaks[i]]);
  88       if (start == r)
  89         start_index = i;
  90       if (end == r)
  91         end_index = i;
  92     }
  93
  94   if (start_index == VPOS || end_index == VPOS)
  95     {
  96       programming_error (_ ("tried to calculate pure-height at a non-breakpoint"));
  97       return Interval (0, 0);
  98     }
  99
 100   SCM extents = me->get_property ("cached-pure-extents");
 101   if (!scm_is_vector (extents))
 102     {
 103       extents = scm_c_make_vector (breaks.size () - 1, SCM_EOL);
 104       for (vsize i = 0; i < breaks.size () - 1; i++)
 105         {
 106           int st = Paper_column::get_rank (cols[breaks[i]]);
 107           int ed = Paper_column::get_rank (cols[breaks[i+1]]);
 108           Interval iv = relative_pure_height (me, elts, common, st, ed, false);
 109           scm_vector_set_x (extents, scm_from_int (i), ly_interval2scm (iv));
 110         }
 111       me->set_property ("cached-pure-extents", extents);
 112     }
 113
 114   Interval ext (0, 0);
 115   for (vsize i = start_index; i < end_index; i++)
 116     ext.unite (ly_scm2interval (scm_c_vector_ref (extents, i)));
 117   return ext;
 118 }
 119
 120 Interval
 121 Axis_group_interface::relative_pure_height (Grob *me,
 122                                             vector<Grob*> const &elts,
 123                                             Grob *common,
 124                                             int start, int end,
 125                                             bool use_cache)
 126 {
 127   /* It saves a _lot_ of time if we assume a VerticalAxisGroup is additive
 128      (ie. height (i, k) = height (i, j) + height (j, k) for all i <= j <= k).
 129      Unfortunately, it isn't always true, particularly if there is a
 130      VerticalAlignment somewhere in the descendants.
 131
 132      Apart from PianoStaff, which has a fixed VerticalAlignment so it doesn't
 133      count, the only VerticalAlignment comes from Score. This makes it
 134      reasonably safe to assume that if our parent is a VerticalAlignment,
 135      we can assume additivity and cache things nicely. */
 136   Grob *p = me->get_parent (Y_AXIS);
 137   if (use_cache && p && Align_interface::has_interface (p))
 138     return Axis_group_interface::cached_pure_height (me, elts, common, start, end);
 139
 140   Interval r;
 141
 142   for (vsize i = 0; i < elts.size (); i++)
 143     {
 144       Interval_t<int> rank_span = elts[i]->spanned_rank_iv ();
 145       Item *it = dynamic_cast<Item*> (elts[i]);
 146       if (rank_span[LEFT] <= end && rank_span[RIGHT] >= start && (!it || it->pure_is_visible (start, end)))
 147         {
 148           Interval dims = elts[i]->pure_height (common, start, end);
 149           if (!dims.is_empty ())
 150             r.unite (dims);
 151         }
 152     }
 153   return r;
 154 }
 155
 156 MAKE_SCHEME_CALLBACK (Axis_group_interface, width, 1);
 157 SCM
 158 Axis_group_interface::width (SCM smob)
 159 {
 160   Grob *me = unsmob_grob (smob);
 161   return generic_group_extent (me, X_AXIS);
 162 }
 163
 164 MAKE_SCHEME_CALLBACK (Axis_group_interface, height, 1);
 165 SCM
 166 Axis_group_interface::height (SCM smob)
 167 {
 168   Grob *me = unsmob_grob (smob);
 169   return generic_group_extent (me, Y_AXIS);
 170 }
 171
 172 MAKE_SCHEME_CALLBACK (Axis_group_interface, pure_height, 3);
 173 SCM
 174 Axis_group_interface::pure_height (SCM smob, SCM start_scm, SCM end_scm)
 175 {
 176   int start = robust_scm2int (start_scm, 0);
 177   int end = robust_scm2int (end_scm, INT_MAX);
 178   Grob *me = unsmob_grob (smob);
 179
 180   return pure_group_height (me, start, end);
 181 }
 182
 183 SCM
 184 Axis_group_interface::generic_group_extent (Grob *me, Axis a)
 185 {
 186   extract_grob_set (me, "elements", elts);
 187   if (a == Y_AXIS && to_boolean (me->get_property ("skyline-spacing")))
 188     skyline_spacing (me, elts);
 189   Grob *common = common_refpoint_of_array (elts, me, a);
 190
 191   Real my_coord = me->relative_coordinate (common, a);
 192   Interval r (relative_group_extent (elts, common, a));
 193
 194   return ly_interval2scm (r - my_coord);
 195 }
 196
 197 SCM
 198 Axis_group_interface::pure_group_height (Grob *me, int start, int end)
 199 {
 200   Grob *common = unsmob_grob (me->get_object ("common-refpoint-of-elements"));
 201
 202   if (!common)
 203     {
 204       extract_grob_set (me, "elements", elts);
 205
 206       vector<Grob*> relevant_elts;
 207       SCM is_relevant = ly_lily_module_constant ("pure-relevant");
 208
 209       for (vsize i = 0; i < elts.size (); i++)
 210         {
 211           if (to_boolean (scm_apply_1 (is_relevant, elts[i]->self_scm (), SCM_EOL)))
 212             relevant_elts.push_back (elts[i]);
 213
 214           Item *it = dynamic_cast<Item*> (elts[i]);
 215           Direction d = LEFT;
 216           if (it)
 217             do
 218               {
 219                 Item *piece = it->find_prebroken_piece (d);
 220                 if (piece && to_boolean (scm_apply_1 (is_relevant, piece->self_scm (), SCM_EOL)))
 221                   relevant_elts.push_back (piece);
 222               }
 223             while (flip (&d) != LEFT);
 224         }
 225
 226       common = common_refpoint_of_array (relevant_elts, me, Y_AXIS);
 227       me->set_object ("common-refpoint-of-elements", common->self_scm ());
 228
 229       SCM ga_scm = Grob_array::make_array ();
 230       Grob_array *ga = unsmob_grob_array (ga_scm);
 231       ga->set_array (relevant_elts);
 232       me->set_object ("pure-relevant-elements", ga_scm);
 233     }
 234
 235   extract_grob_set (me, "pure-relevant-elements", elts);
 236   Real my_coord = me->relative_coordinate (common, Y_AXIS);
 237   Interval r (relative_pure_height (me, elts, common, start, end, true));
 238
 239   return ly_interval2scm (r - my_coord);
 240 }
 241
 242 void
 243 Axis_group_interface::get_children (Grob *me, vector<Grob*> *found)
 244 {
 245   found->push_back (me);
 246
 247   if (!has_interface (me))
 248     return;
 249
 250   extract_grob_set (me, "elements", elements);
 251   for (vsize i = 0; i < elements.size (); i++)
 252     {
 253       Grob *e = elements[i];
 254       Axis_group_interface::get_children (e, found);
 255     }
 256 }
 257
 258 bool
 259 staff_priority_less (Grob * const &g1, Grob * const &g2)
 260 {
 261   int priority_1 = robust_scm2int (g1->get_property ("outside-staff-priority"), INT_MIN);
 262   int priority_2 = robust_scm2int (g2->get_property ("outside-staff-priority"), INT_MIN);
 263
 264   if (priority_1 < priority_2)
 265     return true;
 266   else if (priority_1 > priority_2)
 267     return false;
 268
 269   /* if there is no preference in staff priority, choose the one with the lower rank */
 270   int rank_1 = g1->spanned_rank_iv ()[LEFT];
 271   int rank_2 = g2->spanned_rank_iv ()[LEFT];
 272   return rank_1 < rank_2;
 273 }
 274
 275 void
 276 Axis_group_interface::skyline_spacing (Grob *me, vector<Grob*> elements)
 277 {
 278   vector_sort (elements, staff_priority_less);
 279   Grob *x_common = common_refpoint_of_array (elements, me, X_AXIS);
 280   Grob *y_common = common_refpoint_of_array (elements, me, Y_AXIS);
 281
 282   vsize i = 0;
 283   vector<Box> boxes;
 284
 285   for (i = 0; i < elements.size ()
 286          && !scm_is_number (elements[i]->get_property ("outside-staff-priority")); i++)
 287     boxes.push_back (Box (elements[i]->extent (x_common, X_AXIS),
 288                           elements[i]->extent (y_common, Y_AXIS)));
 289
 290
 291   Drul_array<Skyline> skylines (Skyline (boxes, X_AXIS, DOWN),
 292                                 Skyline (boxes, X_AXIS, UP));
 293   for (; i < elements.size (); i++)
 294     {
 295       Direction dir = get_grob_direction (elements[i]);
 296       if (dir == CENTER)
 297         {
 298           warning (_ ("an outside-staff object should have a direction"));
 299           continue;
 300         }
 301
 302       Box b (elements[i]->extent (x_common, X_AXIS),
 303              elements[i]->extent (y_common, Y_AXIS));
 304       boxes.clear ();
 305       boxes.push_back (b);
 306       Skyline other = Skyline (boxes, X_AXIS, -dir);
 307       Real dist = skylines[dir].distance (other);
 308
 309       if (dist > 0)
 310         {
 311           b.translate (Offset (0, dir*dist));
 312           elements[i]->translate_axis (dir*dist, Y_AXIS);
 313         }
 314       skylines[dir].insert (b, X_AXIS);
 315     }
 316 }
 317
 318 ADD_INTERFACE (Axis_group_interface, "axis-group-interface",
 319
 320                "An object that groups other layout objects.",
 321
 322                /* properties */
 323                "axes "
 324                "elements "
 325                "common-refpoint-of-elements "
 326                "pure-relevant-elements "
 327                "skyline-spacing "
 328                "cached-pure-extents "
 329                );