lily/align-interface.cc

   1 /*
   2   align-interface.cc --  implement Align_interface
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2000--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7
   8  */
   9
  10 #include "align-interface.hh"
  11 #include "grob.hh"
  12 #include "group-interface.hh"
  13 #include "axis-group-interface.hh"
  14 #include "hara-kiri-group-spanner.hh"
  15 #include "output-def.hh"
  16
  17 MAKE_SCHEME_CALLBACK (Align_interface,alignment_callback,2);
  18 SCM
  19 Align_interface::alignment_callback (SCM element_smob, SCM axis)
  20 {
  21   Grob * me = unsmob_grob (element_smob);
  22   Axis ax = (Axis)scm_to_int (axis);
  23   Grob * par = me->get_parent (ax);
  24   if (par && !to_boolean (par->get_property ("positioning-done")))
  25     {
  26       Align_interface::align_elements_to_extents (par, ax);
  27     }
  28   return scm_make_real (0.0);
  29 }
  30
  31 MAKE_SCHEME_CALLBACK (Align_interface,fixed_distance_alignment_callback,2);
  32 SCM
  33 Align_interface::fixed_distance_alignment_callback (SCM element_smob, SCM axis)
  34 {
  35   Grob * me = unsmob_grob (element_smob);
  36   Axis ax = (Axis)scm_to_int (axis);
  37   Grob * par = me->get_parent (ax);
  38   if (par && !to_boolean (par->get_property ("positioning-done")))
  39     {
  40       Align_interface::align_to_fixed_distance (par, ax);
  41     }
  42   return scm_make_real (0.0);
  43 }
  44
  45 /*
  46   merge with align-to-extents?
  47  */
  48 void
  49 Align_interface::align_to_fixed_distance (Grob *me , Axis a)
  50 {
  51   me->set_property ("positioning-done", SCM_BOOL_T);
  52
  53   SCM d =   me->get_property ("stacking-dir");
  54
  55   Direction stacking_dir = ly_c_number_p (d) ? to_dir (d) : CENTER;
  56   if (!stacking_dir)
  57     stacking_dir = DOWN;
  58
  59   Real dy = robust_scm2double (me->get_property ("forced-distance"),0.0);
  60
  61   Link_array<Grob> elems
  62     = Pointer_group_interface__extract_grobs (me, (Grob*) 0, "elements");
  63
  64   Real where_f=0;
  65
  66   Interval v;
  67   v.set_empty ();
  68   Array<Real> translates;
  69
  70   for (int j= elems.size (); j--; )
  71     {
  72       /*
  73         This is not very elegant, in that we need special support for
  74         hara-kiri. Unfortunately, the generic wiring of
  75         force_hara_kiri_callback () (extent and offset callback) is
  76         such that we might get into a loop if we call extent () or
  77         offset () the elements.
  78
  79
  80        */
  81       if (a == Y_AXIS
  82           && Hara_kiri_group_spanner::has_interface (elems[j]))
  83         Hara_kiri_group_spanner::consider_suicide (elems[j]);
  84
  85       if (!elems[j]->is_live ())
  86         elems.del (j);
  87     }
  88
  89   for (int j =0; j < elems.size (); j++)
  90     {
  91       where_f += stacking_dir * dy;
  92       translates.push (where_f);
  93       v.unite (Interval (where_f, where_f));
  94     }
  95
  96   /*
  97     TODO: support self-alignment-{Y,X}
  98    */
  99   for (int i = 0; i < translates.size (); i++)
 100     {
 101       elems[i]->translate_axis (translates[i] - v.center (), a);
 102     }
 103 }
 104
 105 /*
 106   Hairy function to put elements where they should be. Can be tweaked
 107   from the outside by setting extra-space in its
 108   children
 109
 110   We assume that the children the refpoints of the children are still
 111   found at 0.0 -- we will fuck up with thresholds if children's
 112   extents are already moved to locations such as (-16, -8), since the
 113   dy needed to put things in a row doesn't relate to the distances
 114   between original refpoints.
 115
 116   TODO: maybe we should rethink and throw out thresholding altogether.
 117   The original function has been taken over by
 118   align_to_fixed_distance ().
 119 */
 120 void
 121 Align_interface::align_elements_to_extents (Grob * me, Axis a)
 122 {
 123   me->set_property ("positioning-done", SCM_BOOL_T);
 124
 125   SCM d =   me->get_property ("stacking-dir");
 126
 127   Direction stacking_dir = ly_c_number_p (d) ? to_dir (d) : CENTER;
 128   if (!stacking_dir)
 129     stacking_dir = DOWN;
 130
 131   Interval threshold = robust_scm2interval (me->get_property ("threshold"),
 132                                             Interval (0, Interval::infinity ()));
 133
 134   Array<Interval> dims;
 135
 136   Link_array<Grob> elems;
 137   Link_array<Grob> all_grobs
 138     = Pointer_group_interface__extract_grobs (me, (Grob*) 0, "elements");
 139   for (int i=0; i < all_grobs.size (); i++)
 140     {
 141       Interval y = all_grobs[i]->extent (me, a);
 142       if (!y.is_empty ())
 143         {
 144           Grob *e =dynamic_cast<Grob*> (all_grobs[i]);
 145
 146           elems.push (e);
 147           dims.push (y);
 148         }
 149     }
 150
 151
 152   /*
 153     Read self-alignment-X and self-alignment-Y. This may seem like
 154     code duplication. (and really: it is), but this is necessary to
 155     prevent ugly cyclic dependencies that arise when you combine
 156     self-alignment on a child with alignment of children.
 157   */
 158  static SCM  prop_syms[2];
 159
 160   if (!prop_syms[0])
 161     {
 162       prop_syms[X_AXIS] = ly_symbol2scm ("self-alignment-X");
 163       prop_syms[Y_AXIS] = ly_symbol2scm ("self-alignment-Y");
 164     }
 165
 166   SCM align (me->internal_get_property (prop_syms[a]));
 167
 168   Array<Real> translates ;
 169   Interval total;
 170   Real where_f=0;
 171
 172   for (int j=0 ;  j < elems.size (); j++)
 173     {
 174       Real dy = -  dims[j][-stacking_dir];
 175       if (j)
 176         dy += dims[j-1][stacking_dir];
 177
 178
 179       /*
 180         we want dy to be > 0
 181        */
 182       dy *= stacking_dir;
 183       if (j)
 184         {
 185           dy = (dy >? threshold[SMALLER])
 186             <? threshold[BIGGER];
 187         }
 188
 189       where_f += stacking_dir * dy;
 190       total.unite (dims[j] +   where_f);
 191       translates.push (where_f);
 192     }
 193
 194
 195   Real center_offset = 0.0;
 196   /*
 197     also move the grobs that were empty, to maintain spatial order.
 198   */
 199   Array<Real> all_translates;
 200   if (translates.size ())
 201     {
 202       int i =0;
 203       int j =0;
 204       Real w = translates[0];
 205       while (j  < all_grobs.size ())
 206         {
 207           if (i < elems.size () && all_grobs[j] == elems[i])
 208             {
 209               w = translates[i++];
 210             }
 211           all_translates.push (w);
 212           j++;
 213         }
 214
 215
 216       /*
 217         FIXME: uncommenting freaks out the Y-alignment of
 218         line-of-score.
 219        */
 220       if (ly_c_number_p (align))
 221         center_offset = total.linear_combination (scm_to_double (align));
 222
 223       for (int j = 0 ;  j < all_grobs.size (); j++)
 224         all_grobs[j]->translate_axis (all_translates[j] - center_offset, a);
 225     }
 226 }
 227 Axis
 228 Align_interface::axis (Grob*me)
 229 {
 230   return  Axis (scm_to_int (ly_car (me->get_property ("axes"))));
 231 }
 232
 233 void
 234 Align_interface::add_element (Grob*me,Grob* s, SCM cb)
 235 {
 236   s->add_offset_callback (cb, Align_interface::axis (me));
 237   Axis_group_interface::add_element (me, s);
 238 }
 239
 240 void
 241 Align_interface::set_axis (Grob*me,Axis a)
 242 {
 243   Axis_group_interface::set_axes (me, a,a);
 244 }
 245
 246
 247 /*
 248   Find Y-axis parent of G that has a #'forced-distance property. This
 249   has the effect of finding the piano-staff given an object in that
 250   piano staff.
 251  */
 252 Grob *
 253 find_fixed_alignment_parent  (Grob *g)
 254 {
 255   while (g)
 256     {
 257       if (ly_c_number_p (g->get_property ("forced-distance")))
 258         return g;
 259
 260       g = g->get_parent (Y_AXIS);
 261     }
 262
 263   return 0;
 264 }
 265
 266
 267
 268
 269 ADD_INTERFACE (Align_interface, "align-interface",
 270                "Order grobs from top to bottom, left to right, right to left or bottom"
 271                "to top."
 272                ,
 273                "forced-distance stacking-dir align-dir threshold positioning-done "
 274                "center-element elements axes");
 275
 276
 277 struct Foobar
 278 {
 279   bool has_interface (Grob*);
 280 };
 281