lily/tie.cc

   1 /*
   2   tie.cc -- implement Tie
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8 #include <math.h>
   9
  10
  11 #include "spanner.hh"
  12 #include "lookup.hh"
  13 #include "paper-def.hh"
  14 #include "tie.hh"
  15 #include "rhythmic-head.hh"
  16 #include "bezier.hh"
  17 #include "paper-column.hh"
  18 #include "debug.hh"
  19 #include "staff-symbol-referencer.hh"
  20 #include "directional-element-interface.hh"
  21 #include "molecule.hh"
  22 #include "bezier-bow.hh"
  23 #include "stem.hh"
  24 #include "note-head.hh"
  25
  26 /*
  27   tie: Connect two noteheads.
  28
  29   What if we have
  30
  31   c4 ~ \clef bass ; c4 or
  32
  33   c4 \staffchange c4
  34
  35   do we have non-horizontal ties then?
  36   */
  37
  38
  39 void
  40 Tie::set_head (Grob*me,Direction d, Item * head_l)
  41 {
  42   assert (!head (me,d));
  43   index_set_cell (me->get_grob_property ("heads"), d, head_l->self_scm ());
  44
  45   dynamic_cast<Spanner*> (me)->set_bound (d, head_l);
  46   me->add_dependency (head_l);
  47 }
  48
  49 void
  50 Tie::set_interface (Grob*me)
  51 {
  52   me->set_grob_property ("heads", gh_cons (SCM_EOL, SCM_EOL));
  53   me->set_interface (ly_symbol2scm ("tie-interface"));
  54 }
  55
  56 bool
  57 Tie::has_interface (Grob*me)
  58 {
  59   return me->has_interface (ly_symbol2scm ("tie-interface"));
  60 }
  61
  62 Grob*
  63 Tie::head (Grob*me, Direction d)
  64 {
  65   SCM c = me->get_grob_property ("heads");
  66   c = index_cell (c, d);
  67
  68   return unsmob_grob (c);
  69 }
  70
  71 Real
  72 Tie::position_f (Grob*me)
  73 {
  74   Direction d = head (me,LEFT) ? LEFT:RIGHT;
  75   return Staff_symbol_referencer::position_f (head (me,d));
  76 }
  77
  78
  79 /*
  80   Default:  Put the tie oppositie of the stem [Wanske p231]
  81
  82   In case of chords: Tie_column takes over
  83
  84   The direction of the Tie is more complicated (See [Ross] p136 and
  85   further).
  86 */
  87 Direction
  88 Tie::get_default_dir (Grob*me)
  89 {
  90   Item * sl =  head (me,LEFT) ? Rhythmic_head::stem_l (head (me,LEFT)) :0;
  91   Item * sr =  head (me,RIGHT) ? Rhythmic_head::stem_l (head (me,RIGHT)) :0;
  92
  93   if (sl && sr)
  94     {
  95       if (Directional_element_interface::get (sl) == UP
  96           && Directional_element_interface::get (sr) == UP)
  97         return DOWN;
  98     }
  99   else if (sl || sr)
 100     {
 101       Item *s = sl ? sl : sr;
 102       return - Directional_element_interface::get (s);
 103     }
 104
 105
 106   return UP;
 107 }
 108
 109
 110 SCM
 111 Tie::get_control_points (SCM smob)
 112 {
 113   Spanner*me = unsmob_spanner (smob);
 114   Direction headdir = CENTER;
 115   if (head (me,LEFT))
 116     headdir = LEFT;
 117   else if (head (me,RIGHT))
 118     headdir = RIGHT;
 119   else
 120     {
 121       programming_error ("Tie without heads.");
 122       me->suicide ();
 123       return SCM_UNSPECIFIED;
 124     }
 125
 126   if (!Directional_element_interface::get (me))
 127     Directional_element_interface::set (me, Tie::get_default_dir (me));
 128
 129   Real staff_space = Staff_symbol_referencer::staff_space (me);
 130
 131   Real x_gap_f = gh_scm2double (me->get_grob_property ("x-gap"));
 132
 133   Grob* l = me->get_bound (LEFT);
 134   Grob* r = me->get_bound (RIGHT);
 135
 136   Grob* commonx = me->common_refpoint (l, X_AXIS);
 137   commonx = me->common_refpoint (r, X_AXIS);
 138
 139   Real left_x;
 140
 141   /*
 142     this is a kludge: the tie has to be long enough to be
 143     visible, but should not go through key sigs.
 144
 145  (please fixme)
 146    */
 147   Real lambda = 0.5;
 148
 149   if (Note_head::has_interface (l))
 150     left_x = l->extent (l, X_AXIS)[RIGHT] + x_gap_f;
 151   else
 152     left_x = l->extent (l, X_AXIS).linear_combination (lambda);
 153
 154
 155   Real width;
 156   if (Note_head::has_interface (l) && Note_head::has_interface (r))
 157     {
 158       width =
 159         + r->extent (commonx,X_AXIS)[LEFT]
 160         - l->extent (commonx, X_AXIS)[RIGHT]
 161         -2 * x_gap_f;
 162     }
 163   else
 164     {
 165       if (Note_head::has_interface (l))
 166         width = r->relative_coordinate (commonx, X_AXIS)
 167           - l->extent (commonx, X_AXIS)[RIGHT]
 168           - 2 * x_gap_f;
 169       else
 170         width =
 171           - l->extent (commonx, X_AXIS).linear_combination (lambda)
 172           + r->extent (commonx, X_AXIS)[LEFT]
 173           - 2 * x_gap_f;
 174     }
 175
 176   Direction dir = Directional_element_interface::get (me);
 177
 178   SCM details = me->get_grob_property ("details");
 179
 180   SCM lim // groetjes aan de chirurgendochter.
 181     = scm_assq (ly_symbol2scm ("height-limit"),details);
 182
 183   Real h_inf = gh_scm2double (ly_cdr (lim)) *  staff_space;
 184   Real r_0 = gh_scm2double (ly_cdr (scm_assq (ly_symbol2scm ("ratio"),details)));
 185
 186   Bezier b  = slur_shape (width, h_inf, r_0);
 187
 188   /*
 189     I think this better, particularly for small ties. It always allows the user to move ties if
 190     they seem in the wrong place
 191
 192     TODO: what if 2 heads have different size.
 193
 194   */
 195
 196   Real ypos = Tie::position_f (me) * staff_space/2
 197     + dir * gh_scm2double (me->get_grob_property ("y-offset"));;
 198
 199   /*
 200     Make sure we don't start on a dots
 201    */
 202   if (Note_head::has_interface (l) && Rhythmic_head::dots_l (l))
 203     {
 204       Grob* dots = Rhythmic_head::dots_l(l);
 205       if(fabs (staff_space * Staff_symbol_referencer::position_f (dots) /2
 206                - ypos) < 0.5)
 207         {
 208           ypos += 0.5 * dir ;
 209         }
 210     }
 211
 212
 213   /*
 214     todo: prevent ending / staffline collision.
 215
 216     todo: tie / stem collision
 217    */
 218
 219   b = slur_shape (width,h_inf, r_0);
 220   b.scale (1, dir);
 221   b.translate (Offset (left_x, ypos));
 222
 223
 224   /*
 225     Avoid colliding of the horizontal part with stafflines.
 226
 227
 228     TODO: redo this, heuristic is half-baken, and ties often look ugly
 229     as a result.
 230
 231     TODO: doesn't work when on staff with even number of lines.
 232    */
 233   Array<Real> horizontal (b.solve_derivative (Offset (1,0)));
 234   if (horizontal.size ())
 235     {
 236       /*
 237         ugh. Doesnt work for non-horizontal curves.
 238        */
 239       Real y = b.curve_point (horizontal[0])[Y_AXIS];
 240
 241       Real ry = rint (y/staff_space) * staff_space;
 242       Real diff = ry - y;
 243       Real newy = y;
 244
 245       Real clear = staff_space * gh_scm2double (me->get_grob_property ("staffline-clearance"));
 246
 247       if (fabs (y) <= Staff_symbol_referencer::staff_radius (me)
 248           && fabs (diff) < clear)
 249         {
 250           Real y1 = ry + clear;
 251           Real y2 = ry - clear;
 252
 253           newy = (fabs (y1 - y) < fabs (y2 - y)) ? y1 : y2;
 254
 255           // newy = ry - 0.5 * staff_space * sign (diff) ;
 256
 257           /*
 258             we don't want horizontal ties
 259            */
 260           if (fabs (newy - b.control_[0][Y_AXIS]) < 1e-2)
 261             {
 262               newy = newy + dir * staff_space;
 263             }
 264         }
 265
 266       Real y0 = b.control_ [0][Y_AXIS];
 267       b.control_[2][Y_AXIS] =
 268       b.control_[1][Y_AXIS] =
 269  (b.control_[1][Y_AXIS] - y0)  * ((newy - y0) / (y - y0)) + y0;
 270     }
 271   else
 272     programming_error ("Tie is nowhere horizontal");
 273
 274
 275
 276   SCM controls = SCM_EOL;
 277   for (int i= 4; i--;)
 278     controls = gh_cons (ly_offset2scm (b.control_[i]), controls);
 279   return controls;
 280 }
 281
 282
 283 MAKE_SCHEME_CALLBACK (Tie,brew_molecule,1);
 284 SCM
 285 Tie::brew_molecule (SCM smob)
 286 {
 287   Grob*me = unsmob_grob (smob);
 288
 289   SCM cp = me->get_grob_property ("control-points");
 290   if (cp == SCM_EOL)
 291     {
 292       cp = get_control_points (smob);
 293       me->set_grob_property ("control-points", cp);
 294     }
 295
 296   Real thick =
 297     gh_scm2double (me->get_grob_property ("thickness"))
 298     * me->paper_l ()->get_var ("stafflinethickness");
 299
 300   Bezier b;
 301   int i = 0;
 302   for (SCM s= cp; s != SCM_EOL; s = ly_cdr (s))
 303     {
 304       b.control_[i] = ly_scm2offset (ly_car (s));
 305       i++;
 306     }
 307
 308    Molecule a = Lookup::slur (b, Directional_element_interface::get (me) * thick, thick);
 309
 310    return a.smobbed_copy ();
 311 }
 312
 313