lily/tie-column.cc

   1 /*
   2   tie-column.cc -- implement Tie_column
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2000--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "tie-column.hh"
  10
  11 #include <math.h>
  12 #include <map>
  13 #include <set>
  14
  15 #include "note-head.hh"
  16 #include "stem.hh"
  17 #include "skyline.hh"
  18 #include "staff-symbol-referencer.hh"
  19 #include "warn.hh"
  20 #include "paper-column.hh"
  21 #include "spanner.hh"
  22 #include "pointer-group-interface.hh"
  23 #include "tie.hh"
  24 #include "directional-element-interface.hh"
  25 #include "rhythmic-head.hh"
  26
  27 void
  28 Tie_column::add_tie (Grob *me, Grob *tie)
  29 {
  30   if (tie->get_parent (Y_AXIS)
  31       && Tie_column::has_interface (tie->get_parent (Y_AXIS)))
  32     return;
  33
  34   if (!Pointer_group_interface::count (me, ly_symbol2scm ("ties")))
  35     {
  36       dynamic_cast<Spanner *> (me)->set_bound (LEFT, Tie::head (tie, LEFT));
  37       dynamic_cast<Spanner *> (me)->set_bound (RIGHT, Tie::head (tie, RIGHT));
  38     }
  39
  40   tie->set_parent (me, Y_AXIS);
  41   Pointer_group_interface::add_grob (me, ly_symbol2scm ("ties"), tie);
  42   tie->add_dependency (me);
  43 }
  44
  45 void
  46 Tie_column::set_directions (Grob *me)
  47 {
  48   if (!to_boolean (me->get_property ("positioning-done")))
  49     {
  50       me->set_property ("positioning-done", SCM_BOOL_T);
  51       new_directions (me);
  52     }
  53 }
  54
  55 int
  56 Tie::compare (Grob *const &s1,
  57               Grob *const &s2)
  58 {
  59   return sign (Tie::get_position (s1) - Tie::get_position (s2));
  60 }
  61
  62 MAKE_SCHEME_CALLBACK (Tie_column, after_line_breaking, 1);
  63 SCM
  64 Tie_column::after_line_breaking (SCM smob)
  65 {
  66   set_directions (unsmob_grob (smob));
  67   return SCM_UNSPECIFIED;
  68 }
  69
  70 /*
  71   Extend the spanner over its Tie constituents.
  72 */
  73 MAKE_SCHEME_CALLBACK (Tie_column, before_line_breaking, 1);
  74 SCM
  75 Tie_column::before_line_breaking (SCM smob)
  76 {
  77   Spanner *me = dynamic_cast<Spanner *> (unsmob_grob (smob));
  78   for (SCM s = me->get_property ("ties"); scm_is_pair (s); s = scm_cdr (s))
  79     {
  80       Spanner *tie = dynamic_cast<Spanner *> (unsmob_grob (scm_car (s)));
  81       Direction dir = LEFT;
  82       do
  83         {
  84           if (dir * tie->get_bound (dir)->get_column ()->get_rank ()
  85               > dir * me->get_bound (dir)->get_column ()->get_rank ())
  86             me->set_bound (dir, Tie::head (tie, dir));
  87         }
  88       while (flip (&dir) != LEFT);
  89     }
  90   return SCM_UNSPECIFIED;
  91 }
  92
  93
  94 void
  95 set_chord_outline (Array<Skyline_entry> *skyline,
  96                    Link_array<Item> bounds,
  97                    Grob *common,
  98                    Direction d)
  99 {
 100   Real staff_space = Staff_symbol_referencer::staff_space (bounds[0]);
 101
 102   Array<Box> boxes;
 103   Interval x_union;
 104
 105   Grob *stem = 0;
 106   for (int i = 0; i < bounds.size (); i++)
 107     {
 108       Grob *head = bounds[i];
 109       if (!Note_head::has_interface (head))
 110         continue;
 111
 112       if (!stem)
 113         stem = unsmob_grob (head->get_object ("stem"));
 114
 115       Real p = Staff_symbol_referencer::get_position (head);
 116       Interval y ((p-1) * 0.5 * staff_space,
 117                   (p+1) * 0.5 * staff_space);
 118
 119       Interval x = head->extent (common, X_AXIS);
 120       boxes.push (Box (x, y));
 121       x_union.unite (x);
 122     }
 123
 124   (*skyline) = empty_skyline (-d);
 125
 126   if (bounds[0]->break_status_dir ())
 127     {
 128       Real x = robust_relative_extent (bounds[0],  common, X_AXIS)[-d];
 129       skyline->elem_ref (0).height_ = x;
 130     }
 131
 132   for (int i = 0; i < boxes.size (); i++)
 133     insert_extent_into_skyline (skyline,
 134                                 boxes[i], Y_AXIS, -d);
 135   if (stem
 136       && !Stem::is_invisible (stem))
 137     {
 138       Interval x;
 139       x.add_point (stem->relative_coordinate (common, X_AXIS));
 140       x.widen (staff_space / 20); // ugh.
 141       Interval y;
 142       y.add_point (Stem::stem_end_position (stem) * staff_space * .5);
 143
 144       Direction stemdir = Stem::get_direction (stem);
 145       y.add_point (Stem::head_positions (stem)[-stemdir]
 146                    * staff_space * .5);
 147
 148       insert_extent_into_skyline (skyline, Box (x,y), Y_AXIS, -d);
 149
 150
 151
 152       if (d == LEFT)
 153         {
 154           Box flag_box = Stem::get_translated_flag (stem).extent_box ();
 155           flag_box.translate( Offset (x[RIGHT], X_AXIS));
 156           insert_extent_into_skyline (skyline, flag_box,
 157                                       Y_AXIS, -d);
 158         }
 159     }
 160
 161   Direction updowndir = DOWN;
 162   do
 163     {
 164       Interval x ;
 165       Interval y;
 166       if (boxes.size())
 167         {
 168           Box b = boxes.boundary (updowndir, 0);
 169           x = b[X_AXIS];
 170           x[-d] =  b[X_AXIS].linear_combination (-d / 2);
 171           y[-updowndir] = b[Y_AXIS][updowndir];
 172           y[updowndir] = updowndir * infinity_f;
 173         }
 174
 175       if (!x.is_empty ())
 176         insert_extent_into_skyline (skyline,
 177                                     Box (x,y),
 178                                     Y_AXIS, -d);
 179     }
 180   while (flip (&updowndir) != DOWN);
 181
 182   for (int i = 0; i < bounds.size (); i++)
 183     {
 184       if (!Note_head::has_interface (bounds[i]))
 185         continue;
 186
 187
 188       Grob *dots = unsmob_grob (bounds[i]->get_object ("dot"));
 189       if (dots && d == LEFT)
 190         {
 191           Interval x = dots->extent (common, X_AXIS);
 192           Real p = Staff_symbol_referencer::get_position (dots);
 193
 194           Interval y (-1,1);
 195           y *= (staff_space /4);
 196           y.translate (p * staff_space * .5);
 197
 198           insert_extent_into_skyline (skyline,
 199                                       Box (x,y), Y_AXIS, -d);
 200         }
 201     }
 202 }
 203
 204 void
 205 set_chord_outlines (Drul_array< Array<Skyline_entry> > *skyline_drul,
 206                     Link_array<Grob> ties,
 207                     Grob *common)
 208 {
 209   Direction d = LEFT;
 210
 211   do
 212     {
 213       Link_array<Item> bounds;
 214
 215       for (int i = 0; i < ties.size (); i++)
 216         {
 217           Item *it = dynamic_cast<Spanner*> (ties[i])->get_bound (d);
 218
 219           bounds.push (it);
 220         }
 221
 222       set_chord_outline (&skyline_drul->elem_ref (d),
 223                          bounds, common, d);
 224     }
 225   while (flip (&d) != LEFT);
 226 }
 227
 228 void
 229 shift_small_ties (Array<Tie_configuration> *tie_configs,
 230                   Grob *staff_referencer,
 231                   Tie_details const &details)
 232 {
 233   set<int> positions_taken;
 234   for (int i = 0; i < tie_configs->size (); i++)
 235     positions_taken.insert (int (rint (tie_configs->elem (i).position_)));
 236
 237   for (int i = 0; i < tie_configs->size (); i++)
 238     {
 239       Tie_configuration * conf = &tie_configs->elem_ref (i);
 240
 241       /*
 242         on staff line and small enough, translate a little further
 243       */
 244       Real h = conf->height (details);
 245       bool next_free = positions_taken.find (int (rint (conf->position_ + conf->dir_)))
 246         == positions_taken.end ();
 247
 248       int rounded_pos = int (rint (conf->position_ + conf->delta_y_ / details.staff_space_));
 249       bool on_line = Staff_symbol_referencer::on_staffline (staff_referencer, rounded_pos);
 250
 251       if (next_free)
 252         if (on_line && h < 0.4 * details.staff_space_)
 253           {
 254             positions_taken.insert (int (rint (conf->position_ + conf->dir_)));
 255             conf->delta_y_ += 0.2 * details.staff_space_ * conf->dir_;
 256           }
 257         else if (!on_line && h > 0.6 * details.staff_space_)
 258           {
 259             positions_taken.insert (int (rint (conf->position_ + conf->dir_)));
 260             conf->delta_y_ += 0.5 * details.staff_space_ * conf->dir_;
 261           }
 262     }
 263 }
 264
 265
 266 void
 267 final_shape_adjustment (Tie_configuration &conf,
 268                         Drul_array< Array<Skyline_entry> > const &skylines,
 269                         Grob *staff_referencer,
 270                         Tie_details const &details)
 271 {
 272   Real line_dy = 0.0;
 273   bool on_line = Staff_symbol_referencer::on_staffline (staff_referencer,
 274                                                         int (rint (conf.position_)));
 275   if (on_line)
 276     line_dy = - sign (conf.height (details) - 0.6 * details.staff_space_)
 277       * 0.2 * details.staff_space_ * conf.dir_;
 278
 279   Real y = conf.position_ * details.staff_space_ * 0.5
 280     + line_dy;
 281
 282   conf.attachment_x_ = get_skyline_attachment (skylines, y);
 283   conf.attachment_x_.intersect (get_skyline_attachment (skylines,
 284                                                         y + conf.dir_ * details.staff_space_ * 0.5));
 285
 286   conf.delta_y_ += line_dy;
 287   conf.attachment_x_.widen (-details.x_gap_);
 288   if (!on_line
 289       && Staff_symbol_referencer::staff_radius (staff_referencer) * details.staff_space_ > y)
 290     conf.center_tie_vertically (details);
 291 }
 292
 293 void
 294 set_tie_config_directions (Array<Tie_configuration> *tie_configs_ptr)
 295 {
 296   Array<Tie_configuration> &tie_configs (*tie_configs_ptr);
 297
 298   if (!tie_configs[0].dir_)
 299     tie_configs[0].dir_ = DOWN;
 300   if (!tie_configs.top().dir_)
 301     tie_configs.top().dir_ = UP;
 302
 303   /*
 304     Seconds
 305    */
 306   for (int i = 1; i < tie_configs.size(); i++)
 307     {
 308       if (fabs (tie_configs[i-1].position_ - tie_configs[i].position_) <= 1)
 309         {
 310           if (!tie_configs[i-1].dir_)
 311             tie_configs[i-1].dir_ = DOWN;
 312           if (!tie_configs[i].dir_)
 313             tie_configs[i].dir_ = UP;
 314         }
 315     }
 316
 317   for (int i = 1; i < tie_configs.size() - 1; i++)
 318     {
 319       if (tie_configs[i].dir_)
 320         continue;
 321
 322       Direction position_dir = (Direction) sign (tie_configs[i].position_);
 323       if (!position_dir)
 324         position_dir = DOWN;
 325
 326       tie_configs[i].dir_ = position_dir;
 327     }
 328 }
 329
 330
 331 void
 332 Tie_column::new_directions (Grob *me)
 333 {
 334   extract_grob_set (me, "ties", ro_ties);
 335   Link_array<Grob> ties (ro_ties);
 336   if (!ties.size ())
 337     return;
 338
 339   if (ties.size() == 1)
 340     {
 341       Tie::set_default_control_points (ties[0]);
 342       return ;
 343     }
 344
 345   ties.sort (&Tie::compare);
 346
 347   Array<Tie_configuration> tie_configs;
 348   for (int i = 0; i < ties.size (); i++)
 349     {
 350       Tie_configuration conf;
 351       conf.dir_ = get_grob_direction (ties[i]);
 352       conf.position_ = Tie::get_position (ties[i]);
 353       tie_configs.push (conf);
 354     }
 355
 356   SCM manual_configs = me->get_property ("tie-configuration");
 357   bool manual_override = false;
 358   int k = 0;
 359   for (SCM s = manual_configs;
 360        scm_is_pair (s) && k < tie_configs.size(); s = scm_cdr (s))
 361     {
 362       SCM entry = scm_car (s);
 363       if (!scm_is_pair (entry))
 364         continue;
 365
 366       manual_override = true;
 367       Real complete_pos = robust_scm2double (scm_car (entry), tie_configs[k].position_);
 368
 369       tie_configs[k].position_ = int (rint (complete_pos));
 370       tie_configs[k].delta_y_ = complete_pos - tie_configs[k].position_;
 371       tie_configs[k].dir_ = Direction (robust_scm2int (scm_cdr (entry), tie_configs[k].dir_));
 372       k ++;
 373     }
 374
 375   set_tie_config_directions (&tie_configs);
 376
 377   Grob *common = me;
 378   for (int i = 0; i < ties.size (); i++)
 379     {
 380       common = dynamic_cast<Spanner*> (ties[i])->get_bound (LEFT)->common_refpoint (common, X_AXIS);
 381       common = dynamic_cast<Spanner*> (ties[i])->get_bound (RIGHT)->common_refpoint (common, X_AXIS);
 382     }
 383
 384   Drul_array< Array<Skyline_entry> > skylines;
 385   set_chord_outlines (&skylines, ties, common);
 386
 387   Tie_details details;
 388   details.init (ties[0]);
 389
 390   /*
 391     Let the ties flow out, according to our single-tie formatting.
 392    */
 393   if (!manual_override)
 394     {
 395       Tie::get_configuration (ties[0], common, &tie_configs.elem_ref (0),
 396                               &skylines,
 397                               details
 398                               );
 399       Tie::get_configuration (ties.top (), common,
 400                               &tie_configs.elem_ref (tie_configs.size()-1),
 401                               &skylines,
 402                               details
 403                               );
 404     }
 405
 406   /*
 407     Calculate final width and shape of the ties.
 408    */
 409   for (int i = 0; i < ties.size(); i++)
 410     {
 411       if (!manual_override
 412           && (i == 0 || i == ties.size () -1))
 413         continue;
 414
 415
 416       final_shape_adjustment (tie_configs[i],
 417                               skylines,
 418                               ties[0],
 419                               details);
 420     }
 421
 422
 423   /*
 424     Try to shift small ties into available spaces.
 425    */
 426   if (!manual_override)
 427     {
 428       shift_small_ties (&tie_configs, ties[0], details);
 429     }
 430
 431   for (int i = 0; i < ties.size(); i++)
 432     {
 433       Tie::set_control_points (ties[i], common, tie_configs[i],
 434                                details
 435                                );
 436       set_grob_direction (ties[i], tie_configs[i].dir_);
 437     }
 438 }
 439
 440
 441 ADD_INTERFACE (Tie_column, "tie-column-interface",
 442                "Object that sets directions of multiple ties in a tied chord",
 443
 444                /* properties */
 445                "positioning-done "
 446                "tie-configuration "
 447                );