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