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