lily/dot-column.cc

   1 /*
   2   dot-column.cc -- implement Dot_column
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1997--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "dot-column.hh"
  10
  11 #include <cstdio>
  12 #include <cmath>
  13 #include <map>
  14 using namespace std;
  15
  16 #include "dots.hh"
  17 #include "rhythmic-head.hh"
  18 #include "staff-symbol-referencer.hh"
  19 #include "directional-element-interface.hh"
  20 #include "side-position-interface.hh"
  21 #include "axis-group-interface.hh"
  22 #include "stem.hh"
  23 #include "pointer-group-interface.hh"
  24
  25 /*
  26   TODO: let Dot_column communicate with stem via Note_column.
  27 */
  28
  29 MAKE_SCHEME_CALLBACK (Dot_column, force_shift_callback, 2);
  30 SCM
  31 Dot_column::force_shift_callback (SCM element_smob, SCM axis)
  32 {
  33   Grob *me = unsmob_grob (element_smob);
  34   (void) axis;
  35   assert (scm_to_int (axis) == Y_AXIS);
  36   me = me->get_parent (X_AXIS);
  37
  38   if (!to_boolean (me->get_property ("positioning-done")))
  39     {
  40       me->set_property ("positioning-done", SCM_BOOL_T);
  41
  42       do_shifts (me);
  43     }
  44   return scm_from_double (0.0);
  45 }
  46
  47 MAKE_SCHEME_CALLBACK (Dot_column, side_position, 2);
  48 SCM
  49 Dot_column::side_position (SCM element_smob, SCM axis)
  50 {
  51   Grob *me = unsmob_grob (element_smob);
  52   (void) axis;
  53   assert (scm_to_int (axis) == X_AXIS);
  54
  55   Grob *stem = unsmob_grob (me->get_object ("stem"));
  56   if (stem
  57       && !Stem::get_beam (stem)
  58       && Stem::duration_log (stem) > 2
  59       && !Stem::is_invisible (stem))
  60     {
  61       /*
  62         trigger stem end & direction calculation.
  63
  64         This will add the stem to the support if a flag collision happens.
  65       */
  66       Stem::stem_end_position (stem);
  67     }
  68   return Side_position_interface::aligned_side (element_smob, axis);
  69 }
  70
  71 struct Dot_position
  72 {
  73   int pos_;
  74   Direction dir_;
  75   Grob *dot_;
  76   bool extremal_head_;
  77
  78   Dot_position ()
  79   {
  80     dot_ = 0;
  81     pos_ = 0;
  82     dir_ = CENTER;
  83   }
  84 };
  85
  86 typedef map<int, Dot_position> Dot_configuration;
  87
  88 /*
  89   Value CFG according.
  90 */
  91 int
  92 dot_config_badness (Dot_configuration const &cfg)
  93 {
  94   int t = 0;
  95   for (Dot_configuration::const_iterator i (cfg.begin ());
  96        i != cfg.end (); i++)
  97     {
  98       int p = i->first;
  99       int demerit = sqr (p - i->second.pos_) * 2;
 100
 101       int dot_move_dir = sign (p - i->second.pos_);
 102       if (i->second.extremal_head_)
 103         {
 104           if (i->second.dir_
 105               && dot_move_dir != i->second.dir_)
 106             demerit += 3;
 107           else if (dot_move_dir != UP)
 108             demerit += 2;
 109         }
 110       else if (dot_move_dir != UP)
 111         demerit += 1;
 112
 113       t += demerit;
 114     }
 115
 116   return t;
 117 }
 118
 119 void
 120 print_dot_configuration (Dot_configuration const &cfg)
 121 {
 122   printf ("dotconf { ");
 123   for (Dot_configuration::const_iterator i (cfg.begin ());
 124        i != cfg.end (); i++)
 125     printf ("%d, ", i->first);
 126   printf ("} \n");
 127 }
 128
 129 /*
 130   Shift K and following (preceding) entries up (down) as necessary to
 131   prevent staffline collisions if D is up (down).
 132
 133   If K is in CFG, then do nothing.
 134 */
 135
 136 Dot_configuration
 137 shift_one (Dot_configuration const &cfg,
 138            int k, Direction d)
 139 {
 140   Dot_configuration new_cfg;
 141   int offset = 0;
 142
 143   if (d > 0)
 144     {
 145       for (Dot_configuration::const_iterator i (cfg.begin ());
 146            i != cfg.end (); i++)
 147         {
 148           int p = i->first;
 149           if (p == k)
 150             {
 151               if (Staff_symbol_referencer::on_staffline (i->second.dot_, p))
 152                 p += d;
 153               else
 154                 p += 2* d;
 155
 156               offset = 2*d;
 157
 158               new_cfg[p] = i->second;
 159             }
 160           else
 161             {
 162               if (new_cfg.find (p) == new_cfg.end ())
 163                 offset = 0;
 164               new_cfg[p + offset] = i->second;
 165             }
 166         }
 167     }
 168   else
 169     {
 170       Dot_configuration::const_iterator i (cfg.end ());
 171       do
 172         {
 173           i--;
 174
 175           int p = i->first;
 176           if (p == k)
 177             {
 178               if (Staff_symbol_referencer::on_staffline (i->second.dot_, p))
 179                 p += d;
 180               else
 181                 p += 2* d;
 182
 183               offset = 2*d;
 184
 185               new_cfg[p] = i->second;
 186             }
 187           else
 188             {
 189               if (new_cfg.find (p) == new_cfg.end ())
 190                 offset = 0;
 191
 192               new_cfg[p + offset] = i->second;
 193             }
 194         }
 195       while (i != cfg.begin ());
 196     }
 197
 198   return new_cfg;
 199 }
 200
 201 /*
 202   Remove the collision in CFG either by shifting up or down, whichever
 203   is best.
 204 */
 205 void
 206 remove_collision (Dot_configuration &cfg, int p)
 207 {
 208   bool collide = cfg.find (p) != cfg.end ();
 209
 210   if (collide)
 211     {
 212       Dot_configuration cfg_up = shift_one (cfg, p, UP);
 213       Dot_configuration cfg_down = shift_one (cfg, p, DOWN);
 214
 215       int b_up = dot_config_badness (cfg_up);
 216       int b_down = dot_config_badness (cfg_down);
 217
 218       cfg = (b_up < b_down) ? cfg_up : cfg_down;
 219     }
 220 }
 221
 222 SCM
 223 Dot_column::do_shifts (Grob *me)
 224 {
 225   Link_array<Grob> dots
 226     = extract_grob_array (me, "dots");
 227
 228   { /*
 229       Trigger note collision resolution first, since that may kill off
 230       dots when merging.
 231     */
 232     Grob *c = 0;
 233     for (int i = dots.size (); i--;)
 234       {
 235         Grob *n = dots[i]->get_parent (Y_AXIS);
 236         if (c)
 237           c = n->common_refpoint (c, X_AXIS);
 238         else
 239           c = n;
 240       }
 241     for (int i = dots.size (); i--;)
 242       {
 243         Grob *n = dots[i]->get_parent (Y_AXIS);
 244         n->relative_coordinate (c, X_AXIS);
 245       }
 246   }
 247
 248   dots.sort (compare_position);
 249   for (int i = dots.size (); i--;)
 250     if (!dots[i]->is_live ())
 251       dots.del (i);
 252
 253   Dot_configuration cfg;
 254   for (int i = 0;i < dots.size (); i++)
 255     {
 256       Dot_position dp;
 257       dp.dot_ = dots[i];
 258
 259       Grob *note = dots[i]->get_parent (Y_AXIS);
 260       if (note)
 261         {
 262           Grob *stem = unsmob_grob (note->get_object ("stem"));
 263           if (stem)
 264             dp.extremal_head_ = Stem::first_head (stem) == note;
 265         }
 266
 267       int p = Staff_symbol_referencer::get_rounded_position (dp.dot_);
 268       dp.pos_ = p;
 269
 270       if (dp.extremal_head_)
 271         dp.dir_ = to_dir (dp.dot_->get_property ("direction"));
 272
 273       remove_collision (cfg, p);
 274       cfg[p] = dp;
 275       if (Staff_symbol_referencer::on_staffline (dp.dot_, p))
 276         remove_collision (cfg, p);
 277     }
 278
 279   for (Dot_configuration::const_iterator i (cfg.begin ());
 280        i != cfg.end (); i++)
 281     Staff_symbol_referencer::set_position (i->second.dot_, i->first);
 282
 283   return SCM_UNSPECIFIED;
 284 }
 285
 286 void
 287 Dot_column::add_head (Grob *me, Grob *rh)
 288 {
 289   Grob *d = unsmob_grob (rh->get_object ("dot"));
 290   if (d)
 291     {
 292       Side_position_interface::add_support (me, rh);
 293
 294       Pointer_group_interface::add_grob (me, ly_symbol2scm ("dots"), d);
 295       d->add_offset_callback (Dot_column::force_shift_callback_proc, Y_AXIS);
 296       Axis_group_interface::add_element (me, d);
 297     }
 298 }
 299
 300 ADD_INTERFACE (Dot_column, "dot-column-interface",
 301                "Groups dot objects so they form a column, and position dots so they do not "
 302                "clash with staff lines ",
 303                "positioning-done direction stem");
 304