lily/align-element.cc

   1 /*
   2   align-elem.cc -- implement Align_elem
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "align-element.hh"
  10 #include "interval.hh"
  11 #include "direction.hh"
  12 #include "debug.hh"
  13 #include "hash-table-iter.hh"
  14 #include "dimension-cache.hh"
  15
  16 struct Align_element_content {
  17   Graphical_element * elem_l_;
  18   int priority_i_;
  19
  20   static int compare (Align_element_content const &h1,
  21                       Align_element_content const &h2)
  22     {
  23       return h1.priority_i_ - h2.priority_i_;
  24     }
  25   Align_element_content (Graphical_element *elem_l, int p)
  26     {
  27       priority_i_ = p;
  28       elem_l_ = elem_l;
  29     }
  30   Align_element_content () {
  31     elem_l_ = 0;
  32     priority_i_ = 0;
  33   }
  34 };
  35
  36
  37
  38 void
  39 Align_element::add_element (Score_element*el_l)
  40 {
  41   int p = elem_l_arr_.size ();
  42   add_element_priority (el_l, p);
  43 }
  44
  45 void
  46 Align_element::add_element_priority (Score_element *el, int p)
  47 {
  48   assert (! contains_b (el));
  49   Axis_group_element::add_element (el);
  50   priority_i_hash_[el] = p;
  51   add_dependency (el);
  52 }
  53
  54 void
  55 Align_element::do_substitute_element_pointer (Score_element*o,
  56                                               Score_element*n)
  57 {
  58   Axis_group_element :: do_substitute_element_pointer (o,n);
  59   if (o == center_l_)
  60     {
  61       center_l_ = n;
  62     }
  63   if (priority_i_hash_.elem_b (o))
  64     {
  65       priority_i_hash_[n] = priority_i_hash_[o];
  66       /*
  67         Huh? It seems the old pointers are still used.  Why?
  68        */
  69       // priority_i_hash_.remove (o);
  70     }
  71 }
  72
  73 void
  74 Align_element::do_post_processing()
  75 {
  76   if (axis () == Y_AXIS)
  77     do_side_processing ();
  78 }
  79
  80 void
  81 Align_element::do_pre_processing ()
  82 {
  83   if (axis () == X_AXIS)
  84     do_side_processing ();
  85 }
  86
  87 void
  88 Align_element::do_side_processing ()
  89 {
  90   Array<Interval> dims;
  91
  92   Link_array<Score_element> elems;
  93   for (int i=0; i < elem_l_arr_.size(); i++)
  94     {
  95       Interval y = elem_l_arr_[i]->extent(axis ());
  96       if (!y.empty_b())
  97         {
  98
  99           Score_element *e =dynamic_cast<Score_element*>(elem_l_arr_[i]);
 100
 101           // todo: fucks up if item both in Halign & Valign.
 102           SCM min_dims = e->remove_elt_property (minimum_space_scm_sym);
 103           if (min_dims != SCM_BOOL_F)
 104             {
 105               min_dims = SCM_CDR (min_dims);
 106               y.unite (Interval (gh_scm2double (SCM_CAR (min_dims)),
 107                                  gh_scm2double (SCM_CDR (min_dims))));
 108             }
 109
 110           SCM extra_dims = e->remove_elt_property (extra_space_scm_sym);
 111           if (extra_dims != SCM_BOOL_F)
 112             {
 113               extra_dims = SCM_CDR (extra_dims);
 114               y[LEFT] += gh_scm2double (SCM_CAR (extra_dims));
 115               y[RIGHT] += gh_scm2double (SCM_CDR (extra_dims));
 116             }
 117
 118           elems.push (e);
 119           dims.push (y);
 120         }
 121     }
 122
 123   Real where_f=0;
 124   Real center_f = 0.0;
 125   for (int i=0 ;  i < elems.size(); i++)
 126     {
 127       Real dy = - stacking_dir_ * dims[i][-stacking_dir_];
 128       if (i)
 129         dy += stacking_dir_ * dims[i-1][stacking_dir_];
 130
 131       if (i)
 132         {
 133           dy = (dy >? threshold_interval_[SMALLER] )
 134             <? threshold_interval_[BIGGER];
 135         }
 136
 137       if (!i && align_dir_ == LEFT)
 138         center_f = where_f;
 139       else if (align_dir_ == CENTER && elems[i] == center_l_)
 140         center_f = where_f;
 141
 142       where_f += stacking_dir_ * dy;
 143       elems[i]->translate_axis (where_f, axis ());
 144     }
 145
 146   if (dims.size ())
 147     where_f += dims.top ()[stacking_dir_];
 148   if (align_dir_ == RIGHT)
 149     center_f = where_f;
 150   else if (align_dir_ == CENTER && !center_l_)
 151     center_f = where_f / 2;
 152
 153   if (center_f)
 154     translate_axis ( - center_f, axis ());
 155
 156   dim_cache_[axis ()]->invalidate ();
 157 }
 158
 159 Align_element::Align_element()
 160 {
 161   ordered_b_ = true;
 162   threshold_interval_ = Interval (0, Interval::infinity ());
 163   stacking_dir_ = DOWN;
 164   align_dir_ = CENTER;
 165   center_l_ =0;
 166   priority_i_hash_.hash_func_ = pointer_hash;
 167 }
 168
 169 Axis
 170 Align_element::axis () const
 171 {
 172   return axes_[0];
 173 }
 174
 175 void
 176 Align_element::set_axis (Axis a)
 177 {
 178   set_axes (a,a);
 179 }
 180
 181
 182 bool
 183 Align_element::contains_b (Score_element const *e) const
 184 {
 185   return elem_l_arr_.find_l (e);
 186 }
 187
 188 void
 189 Align_element::sort_elements ()
 190 {
 191   Array<Align_element_content> content;
 192   for  (int i =0; i < elem_l_arr_.size(); i++)
 193     {
 194       Score_element * e = dynamic_cast<Score_element*> (elem_l_arr_[i]);
 195       assert (priority_i_hash_.elem_b (e));
 196       int p = priority_i_hash_[e];
 197       content.push (Align_element_content (e, p));
 198     }
 199   content.sort (Align_element_content::compare);
 200
 201   elem_l_arr_.clear();
 202   priority_i_hash_.clear();
 203
 204   for  (int i =0; i < content.size(); i++)
 205     {
 206       elem_l_arr_.push (content[i].elem_l_);
 207     }
 208 }
 209
 210 void
 211 Align_element::do_print () const
 212 {
 213 #ifndef NPRINT
 214   DOUT << "contains: ";
 215   for (int i=0 ;  i < elem_l_arr_.size(); i++)
 216     DOUT << classname (elem_l_arr_[i]) << ", ";
 217 #endif
 218 }
 219
 220 Score_element*
 221 Align_element::get_elt_by_priority (int p) const
 222 {
 223   for (Hash_table_iter<Score_element*, int>  i(priority_i_hash_); i.ok (); i++)
 224     {
 225       if (i.val () == p)
 226         return i.key();
 227     }
 228   return 0;
 229 }
 230
 231 int
 232 Align_element::get_priority (Score_element* e) const
 233 {
 234   if ( priority_i_hash_.elem_b (e))
 235     return priority_i_hash_[e];
 236   else
 237     return elem_l_arr_.find_i (e);
 238 }