lily/slur.cc

   1 /*
   2   slur.cc -- implement  Slur
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1996,  1997--1999, 1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7     Jan Nieuwenhuizen <janneke@gnu.org>
   8 */
   9
  10 /*
  11   [TODO]
  12     * URG: share code with tie
  13     * begin and end should be treated as a Script.
  14     * damping
  15     * slur from notehead to stemend: c''()b''
  16  */
  17
  18 #include "slur.hh"
  19 #include "scalar.hh"
  20 #include "lookup.hh"
  21 #include "paper-def.hh"
  22 #include "note-column.hh"
  23 #include "stem.hh"
  24 #include "p-col.hh"
  25 #include "molecule.hh"
  26 #include "debug.hh"
  27 #include "box.hh"
  28 #include "bezier.hh"
  29 #include "encompass-info.hh"
  30 #include "main.hh"
  31
  32
  33 Slur::Slur ()
  34 {
  35 }
  36
  37 void
  38 Slur::add_column (Note_column*n)
  39 {
  40   if (!n->head_l_arr_.size ())
  41     warning (_ ("Putting slur over rest."));
  42   encompass_arr_.push (n);
  43   n->stem_l_->slur_l_ = this;
  44   add_dependency (n);
  45 }
  46
  47 void
  48 Slur::set_default_dir ()
  49 {
  50   dir_ = DOWN;
  51   for (int i=0; i < encompass_arr_.size (); i ++)
  52     {
  53       if (encompass_arr_[i]->dir_ < 0)
  54         {
  55           dir_ = UP;
  56           break;
  57         }
  58     }
  59 }
  60
  61 void
  62 Slur::do_add_processing ()
  63 {
  64   set_bounds (LEFT, encompass_arr_[0]);
  65   if (encompass_arr_.size () > 1)
  66     set_bounds (RIGHT, encompass_arr_.top ());
  67 }
  68
  69 void
  70 Slur::do_pre_processing ()
  71 {
  72   // don't set directions
  73 }
  74
  75 void
  76 Slur::do_substitute_dependency (Score_element*o, Score_element*n)
  77 {
  78   int i;
  79   while ((i = encompass_arr_.find_i (dynamic_cast<Note_column *> (o))) >=0)
  80     {
  81       if (n)
  82         encompass_arr_[i] = dynamic_cast<Note_column *> (n);
  83       else
  84         encompass_arr_.del (i);
  85     }
  86 }
  87
  88 static int
  89 Note_column_compare (Note_column *const&n1 , Note_column* const&n2)
  90 {
  91   return Item::left_right_compare (n1, n2);
  92 }
  93
  94 void
  95 Slur::do_post_processing ()
  96 {
  97   encompass_arr_.sort (Note_column_compare);
  98   if (!dir_)
  99     set_default_dir ();
 100
 101   Real interline_f = paper ()->interline_f ();
 102   Real internote_f = interline_f / 2;
 103   // URG
 104   Real notewidth_f = paper ()->note_width () * 0.8;
 105
 106   /*
 107    [OSU]: slur and tie placement
 108
 109    slurs:
 110    * x = centre of head (upside-down: inner raakpunt stem) - d * gap
 111
 112    * y = length < 5ss : horizontal raakpunt + d * 0.25 ss
 113      y = length >= 5ss : y next interline - d * 0.25 ss
 114      --> height <= 5 length ?? we use <= 3 length, now...
 115    */
 116
 117   Real gap_f = paper ()->get_var ("slur_x_gap");
 118
 119   Drul_array<Note_column*> extrema;
 120   extrema[LEFT] = encompass_arr_[0];
 121   extrema[RIGHT] = encompass_arr_.top ();
 122
 123   Direction d=LEFT;
 124
 125 #define BROKEN_SLUR_b(dir) \
 126   (extrema[dir] != spanned_drul_[d])
 127 #define NORMAL_SLUR_b(dir) \
 128   (extrema[dir]->stem_l_ \
 129    && !extrema[dir]->stem_l_->transparent_b_  \
 130    && extrema[dir]->head_l_arr_.size ())
 131
 132   do
 133     {
 134       if (BROKEN_SLUR_b (d))
 135         {
 136           // ugh -- check if needed
 137           dx_f_drul_[d] = -d
 138             *(spanned_drul_[d]->extent (X_AXIS).length () - 0.5 * notewidth_f);
 139
 140           // prebreak
 141           if (d == RIGHT)
 142             {
 143               dx_f_drul_[LEFT] = spanned_drul_[LEFT]->extent (X_AXIS).length ();
 144
 145               // urg -- check if needed
 146               if (encompass_arr_.size () > 1)
 147                 dx_f_drul_[RIGHT] += notewidth_f;
 148             }
 149         }
 150       /*
 151         normal slur
 152        */
 153       else if (NORMAL_SLUR_b (d))
 154         {
 155           Real notewidth_f = extrema[d]->extent (X_AXIS).length ();
 156           dy_f_drul_[d] = (int)rint (extrema[d]->stem_l_-> extent (Y_AXIS)[dir_]);
 157           dx_f_drul_[d] += 0.5 * notewidth_f - d * gap_f;
 158           if (dir_ == extrema[d]->stem_l_->dir_)
 159             {
 160               if (dir_ == d)
 161                 dx_f_drul_[d] += 0.5 * (dir_ * d) * d * notewidth_f;
 162               else
 163                 dx_f_drul_[d] += 0.25 * (dir_ * d) * d * notewidth_f;
 164             }
 165         }
 166         else
 167           {
 168             Real notewidth_f = extrema[d]->extent (X_AXIS).length ();
 169             dy_f_drul_[d] = (int)rint (extrema[d]->head_positions_interval ()
 170                                        [dir_]) * internote_f;
 171             dx_f_drul_[d] += 0.5 * notewidth_f - d * gap_f;
 172         }
 173         dy_f_drul_[d] += dir_ * interline_f;
 174         if (extrema[d]->stem_l_ && (dir_ == extrema[d]->stem_l_->dir_))
 175           dy_f_drul_[d] -= dir_ * internote_f;
 176       }
 177   while (flip(&d) != LEFT);
 178
 179   // now that both are set, do dependent
 180   do
 181     {
 182       if (BROKEN_SLUR_b (d))
 183         {
 184           Direction u = d;
 185           flip(&u);
 186
 187           // postbreak
 188           if (d == LEFT)
 189             dy_f_drul_[u] += dir_ * internote_f;
 190
 191           dy_f_drul_[d] = dy_f_drul_[u];
 192         }
 193      }
 194   while (flip(&d) != LEFT);
 195
 196   /*
 197     Slur should follow line of music
 198    */
 199   if (!BROKEN_SLUR_b (LEFT) && !BROKEN_SLUR_b (RIGHT)
 200       && NORMAL_SLUR_b (LEFT) && NORMAL_SLUR_b (RIGHT)
 201       && (extrema[LEFT]->stem_l_ != extrema[RIGHT]->stem_l_))
 202     {
 203       Real note_dy = extrema[RIGHT]->stem_l_->head_positions ()[dir_]
 204         - extrema[LEFT]->stem_l_->head_positions ()[dir_];
 205       Real dy = dy_f_drul_[RIGHT] - dy_f_drul_[LEFT];
 206       /*
 207         Should we always follow note-heads, (like a tie)?
 208         For now, only if the note_dy != slur_dy, we'll do
 209         slur_dy := note_dy * factor.
 210       */
 211       if (sign (dy) != sign (note_dy))
 212         {
 213           Real damp_f = paper ()->get_var ("slur_slope_follow_music_factor");
 214           Real realdy = note_dy * damp_f;
 215           Direction adjust_dir = (Direction)(- dir_ * sign (realdy));
 216           if (!adjust_dir)
 217             adjust_dir = -dir_;
 218           /*
 219             adjust only if no beam gets in the way
 220            */
 221           if (!extrema[adjust_dir]->stem_l_->beam_l_
 222               || (adjust_dir == extrema[adjust_dir]->stem_l_->dir_)
 223               || (extrema[adjust_dir]->stem_l_->beams_i_drul_[-adjust_dir] < 1))
 224             {
 225               dy_f_drul_[adjust_dir] = dy_f_drul_[-adjust_dir]
 226                 + 2 * adjust_dir * realdy;
 227               Real dx = notewidth_f / 2;
 228               if (adjust_dir != extrema[adjust_dir]->stem_l_->dir_)
 229                 dx /= 2;
 230               dx_f_drul_[adjust_dir] -= adjust_dir * dx;
 231             }
 232         }
 233     }
 234
 235   /*
 236     Avoid too steep slurs.
 237    */
 238   Real damp_f = paper ()->get_var ("slur_slope_damping");
 239   Offset d_off = Offset (dx_f_drul_[RIGHT] - dx_f_drul_[LEFT],
 240     dy_f_drul_[RIGHT] - dy_f_drul_[LEFT]);
 241   d_off[X_AXIS] += extent (X_AXIS).length ();
 242
 243   Real ratio_f = abs (d_off[Y_AXIS] / d_off[X_AXIS]);
 244   if (ratio_f > damp_f)
 245     dy_f_drul_[(Direction)(- dir_ * sign (d_off[Y_AXIS]))] +=
 246       dir_ * (ratio_f - damp_f) * d_off[X_AXIS];
 247 }
 248
 249 Array<Offset>
 250 Slur::get_encompass_offset_arr () const
 251 {
 252   Real notewidth = paper ()->note_width () * 0.8;
 253   Real gap = paper ()->get_var ("slur_x_gap");
 254   Real internote = paper ()->internote_f ();
 255
 256   Offset left = Offset (dx_f_drul_[LEFT], dy_f_drul_[LEFT]);
 257   left[X_AXIS] += encompass_arr_[0]->stem_l_->hpos_f ();
 258
 259   /*
 260     <URG>
 261     i don't understand these two, but *must* for symmetry
 262     look at encompass array:
 263        lilypond -D input/test/slur-symmetry*.ly
 264        lilypond -D input/test/sleur.ly
 265
 266     do_post_processing should have calculated these into
 267     dx_f_drul_[], no??
 268
 269    */
 270
 271   if (dir_ != encompass_arr_[0]->stem_l_->dir_)
 272     left[X_AXIS] += - 0.5 * notewidth * encompass_arr_[0]->stem_l_->dir_
 273       + gap;
 274   else if (encompass_arr_[0]->stem_l_->dir_ == UP)
 275     left[X_AXIS] -= notewidth;
 276
 277   if ((dir_ == encompass_arr_[0]->stem_l_->dir_)
 278     && (encompass_arr_[0]->stem_l_->dir_ == DOWN))
 279     left[Y_AXIS] -= internote * encompass_arr_[0]->stem_l_->dir_;
 280   /* </URG> */
 281
 282   Offset d = Offset (dx_f_drul_[RIGHT] - dx_f_drul_[LEFT],
 283     dy_f_drul_[RIGHT] - dy_f_drul_[LEFT]);
 284   d[X_AXIS] += extent (X_AXIS).length ();
 285
 286   int first = 1;
 287   int last = encompass_arr_.size () - 1;
 288
 289   // prebreak
 290   if (encompass_arr_.top () != spanned_drul_[RIGHT])
 291     last++;
 292
 293   // postbreak
 294   if (encompass_arr_[0] != spanned_drul_[LEFT])
 295     first--;
 296
 297   Array<Offset> notes;
 298   notes.push (Offset (0,0));
 299
 300   for (int i = first; i < last; i++)
 301     {
 302       Encompass_info info (encompass_arr_[i], dir_);
 303       notes.push (info.o_ - left);
 304     }
 305   Encompass_info info (encompass_arr_.top (), dir_);
 306   // [encompass_arr_.size () - 1]
 307
 308   // urg:
 309   Slur* urg = (Slur*)this;
 310   urg->interstaff_f_ = info.interstaff_f_;
 311
 312   d[Y_AXIS] += interstaff_f_;
 313
 314   // prebreak
 315   if (interstaff_f_ && (encompass_arr_.top () != spanned_drul_[RIGHT]))
 316     {
 317       Encompass_info info (encompass_arr_[encompass_arr_.size () - 1], dir_);
 318       d[Y_AXIS] -= info.o_[Y_AXIS] - interstaff_f_;
 319     }
 320
 321   notes.push (d);
 322
 323   return notes;
 324 }
 325
 326
 327 Array<Rod>
 328 Slur::get_rods () const
 329 {
 330   Array<Rod> a;
 331   Rod r;
 332   r.item_l_drul_ = spanned_drul_;
 333   r.distance_f_ = paper ()->get_var ("slur_x_minimum");
 334
 335   a.push (r);
 336   return a;
 337 }
 338