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 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 "paper-def.hh"
  15
  16 /*
  17   This callback is set in the children of the align element. It does
  18   not compute anything, but a side effect of a->do_side_processing ()
  19   is that the elements are placed correctly.  */
  20 MAKE_SCHEME_CALLBACK(Align_interface,alignment_callback,2);
  21 SCM
  22 Align_interface::alignment_callback (SCM element_smob, SCM axis)
  23 {
  24   Grob * me = unsmob_grob (element_smob);
  25   Axis ax = (Axis )gh_scm2int (axis);
  26   Grob * par = me->parent_l (ax);
  27   if (par && !to_boolean (par->get_grob_property ("alignment-done")))
  28     {
  29       Align_interface::align_to_extents (par, ax);
  30     }
  31   return gh_double2scm (0.0);
  32 }
  33
  34 MAKE_SCHEME_CALLBACK(Align_interface,fixed_distance_alignment_callback,2);
  35 SCM
  36 Align_interface::fixed_distance_alignment_callback (SCM element_smob, SCM axis)
  37 {
  38   Grob * me = unsmob_grob (element_smob);
  39   Axis ax = (Axis )gh_scm2int (axis);
  40   Grob * par = me->parent_l (ax);
  41   if (par && !to_boolean (par->get_grob_property ("alignment-done")))
  42     {
  43       Align_interface::align_to_fixed_distance (par, ax);
  44     }
  45   return gh_double2scm (0.0);
  46 }
  47
  48 void
  49 Align_interface::align_to_fixed_distance (Grob *me , Axis a)
  50 {
  51   me->set_grob_property ("alignment-done", SCM_BOOL_T);
  52
  53   SCM d =   me->get_grob_property ("stacking-dir");
  54
  55
  56   Direction stacking_dir = gh_number_p(d) ? to_dir (d) : CENTER;
  57   if (!stacking_dir)
  58     stacking_dir = DOWN;
  59
  60
  61   SCM force = me->get_grob_property ("forced-distance");
  62
  63   Real dy = 0.0;
  64   if (gh_number_p (force))
  65     {
  66       dy = gh_scm2double (force);
  67     }
  68
  69   Link_array<Grob> elems
  70     = Pointer_group_interface__extract_elements (  me, (Grob*) 0, "elements");
  71   Real where_f=0;
  72   for (int j=0 ;  j < elems.size(); j++)
  73     {
  74       where_f += stacking_dir * dy;
  75       elems[j]->translate_axis (where_f, a);
  76     }
  77 }
  78
  79 /*
  80   Hairy function to put elements where they should be. Can be tweaked
  81   from the outside by setting minimum-space and extra-space in its
  82   children */
  83 void
  84 Align_interface::align_to_extents (Grob * me, Axis a)
  85 {
  86   me->set_grob_property ("alignment-done", SCM_BOOL_T);
  87
  88   SCM d =   me->get_grob_property ("stacking-dir");
  89
  90
  91   Direction stacking_dir = gh_number_p(d) ? to_dir (d) : CENTER;
  92   if (!stacking_dir)
  93     stacking_dir = DOWN;
  94
  95
  96
  97   Interval threshold = Interval (0, Interval::infinity ());
  98   SCM thr = me->get_grob_property ("threshold");
  99   if (gh_pair_p (thr))
 100     {
 101       threshold[SMALLER] = gh_scm2double (gh_car (thr));
 102       threshold[BIGGER] = gh_scm2double (gh_cdr (thr));
 103     }
 104
 105
 106   Array<Interval> dims;
 107
 108   Link_array<Grob> elems;
 109   Link_array<Grob> all_elts
 110     = Pointer_group_interface__extract_elements (  me, (Grob*) 0, "elements");
 111   for (int i=0; i < all_elts.size(); i++)
 112     {
 113       Interval y = all_elts[i]->extent(me, a);
 114       if (!y.empty_b())
 115         {
 116           Grob *e =dynamic_cast<Grob*>(all_elts[i]);
 117
 118           // todo: fucks up if item both in Halign & Valign.
 119           SCM min_dims = e->remove_grob_property ("minimum-space");
 120           if (gh_pair_p (min_dims) &&
 121               gh_number_p (gh_car (min_dims))
 122               && gh_number_p (gh_cdr (min_dims)))
 123             {
 124               y.unite (ly_scm2interval (min_dims));
 125
 126             }
 127
 128           SCM extra_dims = e->remove_grob_property ("extra-space");
 129           if (gh_pair_p (extra_dims) &&
 130               gh_number_p (gh_car (extra_dims))
 131               && gh_number_p (gh_cdr (extra_dims)))
 132             {
 133               y[LEFT] += gh_scm2double (gh_car  (extra_dims));
 134               y[RIGHT] += gh_scm2double (gh_cdr (extra_dims));
 135             }
 136
 137           elems.push (e);
 138           dims.push (y);
 139         }
 140     }
 141
 142
 143   Real where_f=0;
 144   for (int j=0 ;  j < elems.size(); j++)
 145     {
 146       Real dy = 0.0;
 147       dy = - stacking_dir * dims[j][-stacking_dir];
 148       if (j)
 149         dy += stacking_dir * dims[j-1][stacking_dir];
 150
 151       if (j)
 152         {
 153           dy = (dy >? threshold[SMALLER] )
 154             <? threshold[BIGGER];
 155         }
 156
 157       where_f += stacking_dir * dy;
 158       elems[j]->translate_axis (where_f, a);
 159     }
 160 }
 161
 162
 163 Axis
 164 Align_interface::axis (Grob*me)
 165 {
 166   return  Axis (gh_scm2int (gh_car (me->get_grob_property ("axes"))));
 167 }
 168
 169
 170 /*
 171   should  use generic Scm funcs.
 172  */
 173 int
 174 Align_interface::get_count (Grob*me,Grob*s)
 175 {
 176   SCM e = me->get_grob_property ("elements");
 177   int c =0;
 178   while (gh_pair_p (e))
 179     {
 180       if (gh_car (e) == s->self_scm ())
 181         break;
 182       c++;
 183       e = gh_cdr (e);
 184     }
 185   return c;
 186 }
 187
 188 void
 189 Align_interface::add_element (Grob*me,Grob* s, SCM cb)
 190 {
 191   s->add_offset_callback (cb, Align_interface::axis (me));
 192   Axis_group_interface::add_element (me, s);
 193 }
 194
 195
 196 void
 197 Align_interface::set_interface (Grob*me)
 198 {
 199   me->set_interface (ly_symbol2scm ("align-interface"));
 200
 201   Axis_group_interface::set_interface (me);
 202 }
 203
 204 void
 205 Align_interface::set_axis (Grob*me,Axis a)
 206 {
 207   Axis_group_interface::set_axes (me, a,a );
 208 }
 209
 210 bool
 211 Align_interface::has_interface (Grob*me)
 212 {
 213   return me && me->has_interface (ly_symbol2scm ("align-interface"));
 214 }
 215