lily/spacing-spanner.cc

   1 /*
   2   spacing-spanner.cc -- implement Spacing_spanner
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1999--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7
   8  */
   9
  10 #include <math.h>
  11 #include <stdio.h>
  12
  13 #include "system.hh"
  14 #include "paper-def.hh"
  15 #include "paper-score.hh"
  16 #include "paper-column.hh"
  17 #include "item.hh"
  18 #include "moment.hh"
  19 #include "note-spacing.hh"
  20 #include "misc.hh"
  21 #include "warn.hh"
  22 #include "staff-spacing.hh"
  23 #include "spring.hh"
  24 #include "paper-column.hh"
  25 #include "spaceable-grob.hh"
  26
  27 /*
  28   paper-column:
  29
  30   Don't be confused by right-items: each spacing wish can also contain
  31   a number of items, with which a spacing constraint may be kept. It's
  32   a little baroque, but it might come in handy later on?
  33
  34  */
  35 class Spacing_spanner
  36 {
  37 public:
  38   static void standard_breakable_column_spacing (Grob * me, Item*l, Item*r,
  39                                                  Real * fixed, Real * space, Moment);
  40
  41
  42   static Real default_bar_spacing (Grob*,Grob*,Grob*,Moment);
  43   static Real note_spacing (Grob*,Grob*,Grob*,Moment, bool*);
  44   static Real get_duration_space (Grob*,Moment dur, Rational shortest, bool*);
  45   static Rational find_shortest (Link_array<Grob> const &);
  46   static void breakable_column_spacing (Grob*, Item* l, Item *r, Moment);
  47   static void find_loose_columns () {}
  48   static void prune_loose_colunms (Grob*,Link_array<Grob> *cols, Rational);
  49   static void find_loose_columns (Link_array<Grob> cols);
  50   static void set_explicit_neighbor_columns (Link_array<Grob> cols);
  51   static void set_implicit_neighbor_columns (Link_array<Grob> cols);
  52   static void do_measure (Rational, Grob*me,Link_array<Grob> *cols);
  53   static void musical_column_spacing (Grob*,Item*,Item*, Real, Rational);
  54   DECLARE_SCHEME_CALLBACK (set_springs, (SCM ));
  55   static bool has_interface (Grob*);
  56 };
  57
  58 /*
  59   Return whether COL is fixed to its neighbors by some kind of spacing
  60   constraint.
  61 */
  62 static bool
  63 loose_column (Grob *l, Grob *c, Grob *r)
  64 {
  65   SCM rns = c->get_grob_property ("right-neighbors");
  66   SCM lns = c->get_grob_property ("left-neighbors");
  67
  68  /*
  69     If this column doesn't have a proper neighbor, we should really
  70     make it loose, but spacing it correctly is more than we can
  71     currently can handle.
  72
  73     (this happens in the following situation:
  74
  75        |
  76        |    clef G
  77       *
  78
  79        |               |      ||
  80        |               |      ||
  81       O               O       ||
  82
  83
  84     the column containing the clef is really loose, and should be
  85     attached right to the first column, but that is a lot of work for
  86     such a borderline case.)
  87
  88   */
  89   if (!gh_pair_p (lns) || !gh_pair_p (rns))
  90     return false;
  91
  92   Item * l_neighbor = dynamic_cast<Item*>  (unsmob_grob (gh_car (lns)));
  93   Item * r_neighbor = dynamic_cast<Item*>  (unsmob_grob (gh_car (rns)));
  94
  95   if (!l_neighbor || !r_neighbor)
  96     return false;
  97
  98   l_neighbor = l_neighbor->column_l();
  99   r_neighbor = dynamic_cast<Item*> (Note_spacing::right_column  (r_neighbor));
 100
 101   if (l == l_neighbor && r == r_neighbor)
 102     return false;
 103
 104   if (!l_neighbor || !r_neighbor)
 105     return false;
 106
 107   /*
 108     Only declare loose if the bounds make a little sense.  This means
 109     some cases (two isolated, consecutive clef changes) won't be
 110     nicely folded, but hey, then don't do that.
 111   */
 112   if ((Paper_column::musical_b (l_neighbor) || Item::breakable_b (l_neighbor))
 113       && (Paper_column::musical_b (r_neighbor) || Item::breakable_b (r_neighbor)))
 114     {
 115       return true;
 116     }
 117
 118
 119   /*
 120     If in doubt: we're not loose; the spacing engine should space for
 121     it, risking suboptimal spacing.
 122
 123     (Otherwise, we might risk core dumps, and other weird stuff.)
 124
 125   */
 126   return false;
 127 }
 128
 129 /*
 130   Remove columns that are not tightly fitting from COLS. In the
 131   removed columns, set 'between-cols to the columns where it is in
 132   between.
 133 */
 134 void
 135 Spacing_spanner::prune_loose_colunms (Grob*me,Link_array<Grob> *cols, Rational shortest)
 136 {
 137   Link_array<Grob> newcols;
 138   Real increment = gh_scm2double (me->get_grob_property ("spacing-increment"));
 139   for (int i=0; i < cols->size ();  i++)
 140     {
 141       if (Item::breakable_b (cols->elem(i)) || Paper_column::musical_b (cols->elem (i)))
 142         {
 143           newcols.push (cols->elem(i));
 144           continue;
 145         }
 146
 147       Grob *c = cols->elem(i);
 148       if (loose_column (cols->elem (i-1), c, cols->elem (i+1)))
 149         {
 150           SCM lns = c->get_grob_property ("left-neighbors");
 151           lns = gh_pair_p (lns) ? gh_car (lns) : SCM_BOOL_F;
 152
 153           SCM rns = c->get_grob_property ("right-neighbors");
 154           rns = gh_pair_p (rns) ? gh_car (rns) : SCM_BOOL_F;
 155
 156           /*
 157             Either object can be non existent, if the score ends
 158             prematurely.
 159            */
 160           rns = gh_car (unsmob_grob (rns)->get_grob_property ("right-items"));
 161           c->set_grob_property ("between-cols", gh_cons (lns,
 162                                                          rns));
 163
 164           /*
 165             Set distance constraints for loose columns
 166           */
 167           Drul_array<Grob*> next_door;
 168           next_door[LEFT] =cols->elem (i - 1);
 169           next_door[RIGHT] =cols->elem (i + 1);
 170           Direction d = LEFT;
 171           Drul_array<Real> dists(0,0);
 172
 173           do
 174             {
 175               dists[d] = 0.0;
 176               Item *lc = dynamic_cast<Item*> ((d == LEFT)  ? next_door[LEFT] : c);
 177               Item *rc = dynamic_cast<Item*> (d == LEFT  ? c : next_door[RIGHT]);
 178
 179               for (SCM s = lc->get_grob_property ("spacing-wishes");
 180                    gh_pair_p (s); s = gh_cdr (s))
 181                 {
 182                   Grob *sp = unsmob_grob (gh_car (s));
 183                   if (Note_spacing::left_column (sp) != lc
 184                       || Note_spacing::right_column (sp) != rc)
 185                     continue;
 186
 187                   Real space, fixed;
 188                   fixed = 0.0;
 189                   bool dummy;
 190
 191                   if (d == LEFT)
 192                     {
 193                       /*
 194                         The note spacing should be taken from the musical
 195                         columns.
 196
 197                       */
 198                       Real base = note_spacing (me, lc, rc, shortest, &dummy);
 199                       Note_spacing::get_spacing (sp, rc, base, increment, &space, &fixed);
 200
 201                       space -= increment;
 202
 203                       dists[d] = dists[d] >? space;
 204                     }
 205                   else
 206                     {
 207                       Real space, fixed_space;
 208                       Staff_spacing::get_spacing_params (sp,
 209                                                          &space, &fixed_space);
 210
 211                       dists[d] = dists[d] >? fixed_space;
 212                     }
 213
 214                 }
 215             }
 216           while (flip (&d) != LEFT);
 217
 218           Rod r;
 219           r.distance_f_ = dists[LEFT] + dists[RIGHT];
 220           r.item_l_drul_[LEFT] = dynamic_cast<Item*> (cols->elem(i-1));
 221           r.item_l_drul_[RIGHT] = dynamic_cast<Item*> (cols->elem (i+1));
 222
 223           r.add_to_cols ();
 224         }
 225       else
 226         {
 227           newcols.push (c);
 228         }
 229     }
 230
 231   *cols = newcols;
 232 }
 233
 234 /*
 235   Set neighboring columns determined by the spacing-wishes grob property.
 236 */
 237 void
 238 Spacing_spanner::set_explicit_neighbor_columns (Link_array<Grob> cols)
 239 {
 240   for (int i=0; i < cols.size(); i++)
 241     {
 242       SCM right_neighbors = SCM_EOL;
 243       int min_rank = 100000;    // inf.
 244
 245
 246       SCM wishes=  cols[i]->get_grob_property ("spacing-wishes");
 247       for (SCM s =wishes; gh_pair_p (s); s = gh_cdr (s))
 248         {
 249           Item * wish = dynamic_cast<Item*> (unsmob_grob (gh_car (s)));
 250
 251           Item * lc = wish->column_l ();
 252           Grob * right = Note_spacing::right_column (wish);
 253
 254           if (!right)
 255             continue;
 256
 257           Item * rc = dynamic_cast<Item*> (right);
 258
 259           int right_rank = Paper_column::rank_i (rc);
 260           int left_rank = Paper_column::rank_i (lc);
 261
 262           /*
 263             update the left column.
 264            */
 265           if (right_rank <= min_rank)
 266             {
 267               if (right_rank < min_rank)
 268                 right_neighbors  =SCM_EOL;
 269
 270               min_rank = right_rank;
 271               right_neighbors = gh_cons (wish->self_scm (), right_neighbors);
 272             }
 273
 274           /*
 275             update the right column of the wish.
 276            */
 277           int maxrank = 0;
 278           SCM left_neighs = rc->get_grob_property ("left-neighbors");
 279           if (gh_pair_p (left_neighs)
 280               && unsmob_grob (gh_car (left_neighs)))
 281             {
 282               Item * it = dynamic_cast<Item*> (unsmob_grob (gh_car (left_neighs)));
 283               maxrank = Paper_column::rank_i (it->column_l());
 284             }
 285
 286           if (left_rank >= maxrank)
 287             {
 288               if (left_rank > maxrank)
 289                 left_neighs = SCM_EOL;
 290
 291               left_neighs = gh_cons (wish->self_scm (), left_neighs);
 292               rc->set_grob_property ("left-neighbors", right_neighbors);
 293             }
 294         }
 295
 296       if (gh_pair_p (right_neighbors))
 297         {
 298           cols[i]->set_grob_property ("right-neighbors", right_neighbors);
 299         }
 300     }
 301 }
 302
 303 /*
 304   Set neighboring columns that have no left/right-neighbor set
 305   yet. Only do breakable non-musical columns, and musical columns.
 306 */
 307 void
 308 Spacing_spanner::set_implicit_neighbor_columns (Link_array<Grob> cols)
 309 {
 310   for (int i = 0; i < cols.size (); i++)
 311     {
 312       Item * it = dynamic_cast<Item*>(cols[i]);
 313       if (!Item::breakable_b (it) && !Paper_column::musical_b (it))
 314         continue;
 315
 316       // it->breakable || it->musical
 317
 318       /*
 319         sloppy with typnig left/right-neighbors should take list, but paper-column found instead.
 320        */
 321       SCM ln = cols[i] ->get_grob_property ("left-neighbors");
 322       if (!gh_pair_p (ln) && i )
 323         {
 324           cols[i]->set_grob_property ("left-neighbors", gh_cons (cols[i-1]->self_scm(), SCM_EOL));
 325         }
 326
 327       SCM rn = cols[i] ->get_grob_property ("right-neighbors");
 328       if (!gh_pair_p (rn) && i < cols.size () - 1)
 329         {
 330           cols[i]->set_grob_property ("right-neighbors", gh_cons (cols[i + 1]->self_scm(), SCM_EOL));
 331         }
 332     }
 333 }
 334
 335
 336 MAKE_SCHEME_CALLBACK (Spacing_spanner, set_springs,1);
 337 SCM
 338 Spacing_spanner::set_springs (SCM smob)
 339 {
 340   Grob *me = unsmob_grob (smob);
 341
 342   Link_array<Grob> all (me->pscore_l_->line_l_->column_l_arr ()) ;
 343
 344   set_explicit_neighbor_columns (all);
 345
 346   Rational global_shortest = find_shortest (all);
 347   prune_loose_colunms (me, &all, global_shortest);
 348   set_implicit_neighbor_columns (all);
 349
 350
 351   int j = 0;
 352   for (int i = 1; i < all.size (); i++)
 353     {
 354       Grob *sc = all[i];
 355       if (Item::breakable_b (sc))
 356         {
 357           Link_array<Grob> measure (all.slice (j, i+1));
 358           do_measure (global_shortest, me, &measure);
 359           j = i;
 360         }
 361     }
 362
 363   return SCM_UNSPECIFIED;
 364 }
 365
 366
 367 /*
 368   We want the shortest note that is also "common" in the piece, so we
 369   find the shortest in each measure, and take the most frequently
 370   found duration.
 371
 372   This probably gives weird effects with modern music, where every
 373   note has a different duration, but hey, don't write that kind of
 374   stuff, then.
 375
 376 */
 377 Rational
 378 Spacing_spanner::find_shortest (Link_array<Grob> const &cols)
 379 {
 380   /*
 381     ascending in duration
 382    */
 383   Array<Rational> durations;
 384   Array<int> counts;
 385
 386   Rational shortest_in_measure;
 387   shortest_in_measure.set_infinite (1);
 388
 389   for (int i =0 ; i < cols.size (); i++)
 390     {
 391       if (Paper_column::musical_b (cols[i]))
 392         {
 393           Moment *when = unsmob_moment (cols[i]->get_grob_property  ("when"));
 394
 395           /*
 396             ignore grace notes for shortest notes.
 397           */
 398           if (when && when->grace_part_)
 399             continue;
 400
 401           SCM  st = cols[i]->get_grob_property ("shortest-starter-duration");
 402           Moment this_shortest = *unsmob_moment (st);
 403           assert (this_shortest.to_bool());
 404           shortest_in_measure = shortest_in_measure <? this_shortest.main_part_;
 405         }
 406       else if (!shortest_in_measure.infty_b()
 407                && Item::breakable_b (cols[i]))
 408         {
 409           int j = 0;
 410           for (; j < durations.size(); j++)
 411             {
 412               if (durations[j] > shortest_in_measure)
 413                 {
 414                   counts.insert (1, j);
 415                   durations.insert (shortest_in_measure, j);
 416                   break;
 417                 }
 418               else if (durations[j] == shortest_in_measure)
 419                 {
 420                   counts[j]++;
 421                   break;
 422                 }
 423             }
 424
 425           if (durations.size() == j)
 426             {
 427               durations.push (shortest_in_measure);
 428               counts.push (1);
 429             }
 430
 431           shortest_in_measure.set_infinite(1);
 432         }
 433     }
 434
 435   int max_idx = -1;
 436   int max_count = 0;
 437   for (int i =durations.size(); i--;)
 438     {
 439       if (counts[i] >= max_count)
 440         {
 441           max_idx = i;
 442           max_count = counts[i];
 443         }
 444
 445       //      printf ("duration %d/%d, count %d\n", durations[i].num (), durations[i].den (), counts[i]);
 446     }
 447
 448   /*
 449     TODO: 1/8 should be adjustable?
 450    */
 451   Rational d = Rational (1,8);
 452   if (max_idx >= 0)
 453     d = d <? durations[max_idx] ;
 454
 455   return d;
 456 }
 457
 458 /*
 459   Generate spacing for a single measure. We used to have code that did
 460   per-measure spacing. Now we have piecewise spacing. We should fix
 461   this to support "spacing-regions": some regions have different notes
 462   (different time sigs) than others, and should be spaced differently.
 463  */
 464 void
 465 Spacing_spanner::do_measure (Rational shortest, Grob*me, Link_array<Grob> *cols)
 466 {
 467
 468   Real headwid =       gh_scm2double (me->get_grob_property ("spacing-increment"));
 469   for (int i= 0; i < cols->size () - 1; i++)
 470     {
 471       Item * l = dynamic_cast<Item*> (cols->elem (i));
 472       Item * r =  dynamic_cast<Item*> (cols->elem (i+1));
 473
 474       Paper_column * lc = dynamic_cast<Paper_column*> (l);
 475       Paper_column * rc = dynamic_cast<Paper_column*> (r);
 476
 477       if (!Paper_column::musical_b (l))
 478         {
 479           breakable_column_spacing (me, l, r, shortest);
 480
 481           /*
 482
 483             The case that the right part is broken as well is rather
 484             rare, but it is possible, eg. with a single empty measure,
 485             or if one staff finishes a tad earlier than the rest.
 486
 487            */
 488           Item *lb = l->find_prebroken_piece (RIGHT);
 489           Item *rb = r->find_prebroken_piece (LEFT);
 490
 491           if (lb)
 492             breakable_column_spacing (me, lb,r, shortest);
 493
 494           if (rb)
 495             breakable_column_spacing (me, l, rb, shortest);
 496           if (lb && rb)
 497             breakable_column_spacing (me, lb, rb, shortest);
 498
 499           continue ;
 500         }
 501
 502
 503       musical_column_spacing (me, lc, rc, headwid, shortest);
 504       if (Item *rb = r->find_prebroken_piece (LEFT))
 505         musical_column_spacing (me, lc, rb, headwid, shortest);
 506     }
 507 }
 508
 509
 510 /*
 511   Generate the space between two musical columns LC and RC, given spacing parameters INCR and SHRTEST.
 512  */
 513 void
 514 Spacing_spanner::musical_column_spacing (Grob *me, Item * lc, Item *rc, Real increment, Rational shortest)
 515 {
 516   bool expand_only = false;
 517   Real base_note_space = note_spacing (me, lc, rc, shortest, &expand_only);
 518
 519   Real max_note_space = -infinity_f;
 520   Real max_fixed_note_space = -infinity_f;
 521
 522   SCM seq  = lc->get_grob_property ("right-neighbors");
 523
 524   /*
 525     We adjust the space following a note only if the next note
 526     happens after the current note (this is set in the grob
 527     property SPACING-SEQUENCE.
 528   */
 529   for (SCM s = seq; gh_pair_p (s); s = ly_cdr (s))
 530     {
 531       Grob * wish = unsmob_grob (gh_car (s));
 532
 533       Item *wish_rcol = Note_spacing::right_column (wish);
 534       if (Note_spacing::left_column (wish) != lc
 535           || (wish_rcol != rc && wish_rcol != rc->original_l_))
 536         continue;
 537
 538       /*
 539         This is probably a waste of time in the case of polyphonic
 540         music.  */
 541       if (Note_spacing::has_interface (wish))
 542         {
 543           Real space =0.0;
 544           Real fixed =0.0;
 545
 546           Note_spacing::get_spacing (wish, rc, base_note_space, increment, &space, &fixed);
 547           max_note_space = max_note_space >? space;
 548           max_fixed_note_space = max_fixed_note_space >? fixed;
 549         }
 550     }
 551
 552   if (max_note_space < 0)
 553     {
 554       max_note_space = base_note_space;
 555       max_fixed_note_space = increment;
 556     }
 557
 558   bool ragged = to_boolean (me->paper_l ()->get_scmvar ("raggedright"));
 559   Real strength = (ragged) ? 1.0 : 1 / (max_note_space - max_fixed_note_space);
 560   Real distance = (ragged) ? max_fixed_note_space : max_note_space;
 561   Spaceable_grob::add_spring (lc, rc, distance, strength, expand_only);
 562 }
 563
 564 void
 565 Spacing_spanner::standard_breakable_column_spacing (Grob * me, Item*l, Item*r,
 566                                    Real * fixed, Real * space,
 567                                    Moment shortest)
 568 {
 569   *fixed = l->extent (l, X_AXIS)[RIGHT] - r->extent (r, X_AXIS)[LEFT];
 570
 571   if (l->breakable_b (l) && r->breakable_b(r))
 572     {
 573       Moment *dt = unsmob_moment (l->get_grob_property ("measure-length"));
 574       Moment mlen (1);
 575       if (dt)
 576         mlen = *dt;
 577
 578       Real incr = gh_scm2double (me->get_grob_property ("spacing-increment"));
 579
 580       *space =  *fixed + incr * double (mlen.main_part_ / shortest.main_part_) * 0.8;
 581     }
 582   else
 583     {
 584       Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
 585       bool dummy;
 586
 587       *space = *fixed + get_duration_space (me, dt, shortest.main_part_, &dummy);
 588     }
 589
 590
 591 }
 592
 593
 594 /*
 595   Read hints from L and generate springs.
 596  */
 597 void
 598 Spacing_spanner::breakable_column_spacing (Grob*me, Item* l, Item *r,Moment shortest)
 599 {
 600   Real max_fixed = -infinity_f;
 601   Real max_space = -infinity_f;
 602
 603   standard_breakable_column_spacing (me, l, r, &max_fixed, &max_space ,
 604                                      shortest);
 605
 606   for (SCM s = l->get_grob_property ("spacing-wishes");
 607        gh_pair_p (s); s = gh_cdr (s))
 608     {
 609       Item * spacing_grob = dynamic_cast<Item*> (unsmob_grob (gh_car (s)));
 610
 611       if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
 612         continue;
 613
 614       Real space;
 615       Real fixed_space;
 616
 617       /*
 618         column for the left one settings should be ok due automatic
 619         pointer munging.
 620
 621       */
 622       assert (spacing_grob-> column_l () == l);
 623
 624       Staff_spacing::get_spacing_params (spacing_grob,
 625                                          &space, &fixed_space);
 626       if (space > max_space)
 627         {
 628           max_space = space;
 629           max_fixed = fixed_space;
 630         }
 631     }
 632
 633
 634
 635
 636   if (isinf (max_space))
 637     {
 638       programming_error ("No pref spacing found");
 639       max_space = 2.0;
 640       max_fixed = 1.0;
 641     }
 642
 643
 644   if (l->break_status_dir() == RIGHT
 645       && Paper_column::when_mom (l) == Paper_column::when_mom (r))
 646     {
 647       /* Start of line: this space is not stretchable */
 648       max_fixed = max_space;
 649     }
 650
 651   /*
 652     Hmm.  we do 1/0 in the next thing. Perhaps we should check if this
 653     works on all architectures.
 654    */
 655
 656   bool ragged = to_boolean (me->paper_l ()->get_scmvar ("raggedright"));
 657   Real strength = (ragged) ? 1.0 : 1 / (max_space - max_fixed);
 658   Real distance = (ragged) ? max_fixed : max_space;
 659   Spaceable_grob::add_spring (l, r, distance, strength, false);
 660 }
 661
 662
 663 /**
 664   Get the measure wide ant for arithmetic spacing.
 665   */
 666 Real
 667 Spacing_spanner::get_duration_space (Grob*me, Moment d, Rational shortest, bool * expand_only)
 668 {
 669   Real k = gh_scm2double (me->get_grob_property ("shortest-duration-space"));
 670   Real incr = gh_scm2double (me->get_grob_property ("spacing-increment"));
 671
 672   if (d < shortest)
 673     {
 674       /*
 675         We don't space really short notes using the log of the
 676         duration, since it would disproportionally stretches the long
 677         notes in a piece. In stead, we use geometric spacing with constant 0.5
 678         (i.e. linear.)
 679
 680         This should probably be tunable, to use other base numbers.
 681
 682         In Mozart hrn3 by EB., we have 8th note = 3.9 mm (total), 16th note =
 683         3.6 mm (total).  head-width = 2.4, so we 1.2mm for 16th, 1.5
 684         mm for 8th. (white space), suggesting that we use
 685
 686         (1.2 / 1.5)^{-log2(duration ratio)}
 687
 688
 689        */
 690       Rational ratio = d.main_part_ / shortest;
 691
 692       *expand_only = true;
 693       return ((k-1) + double (ratio)) * incr;
 694     }
 695   else
 696     {
 697       /*
 698           John S. Gourlay. ``Spacing a Line of Music,'' Technical
 699           Report OSU-CISRC-10/87-TR35, Department of Computer and
 700           Information Science, The Ohio State University, 1987.
 701        */
 702       Real log =  log_2 (shortest);
 703       k -= log;
 704       Rational compdur = d.main_part_ + d.grace_part_ /Rational (3);
 705       *expand_only = false;
 706
 707       return (log_2 (compdur) + k) * incr;
 708     }
 709 }
 710
 711 Real
 712 Spacing_spanner::note_spacing (Grob*me, Grob *lc, Grob *rc,
 713                                Moment shortest, bool * expand_only)
 714 {
 715   Moment shortest_playing_len = 0;
 716   SCM s = lc->get_grob_property ("shortest-playing-duration");
 717
 718   if (unsmob_moment (s))
 719     shortest_playing_len = *unsmob_moment (s);
 720
 721   if (! shortest_playing_len.to_bool ())
 722     {
 723       programming_error ("can't find a ruling note at " + Paper_column::when_mom (lc).str ());
 724       shortest_playing_len = 1;
 725     }
 726
 727   Moment lwhen = Paper_column::when_mom (lc);
 728   Moment rwhen =  Paper_column::when_mom (rc);
 729
 730   Moment delta_t = rwhen - lwhen;
 731   Real dist = 0.0;
 732
 733   if (delta_t.main_part_ && !lwhen.grace_part_)
 734     {
 735       dist = get_duration_space (me, shortest_playing_len, shortest.main_part_, expand_only);
 736       dist *= (double) (delta_t.main_part_ / shortest_playing_len.main_part_);
 737     }
 738   else if (delta_t.grace_part_)
 739     {
 740       /*
 741         TODO: figure out how to space grace notes.
 742       */
 743       dist = get_duration_space (me, shortest, shortest.main_part_, expand_only);
 744
 745       Real grace_fact = 1.0;
 746       SCM gf = me->get_grob_property ("grace-space-factor");
 747       if (gh_number_p (gf))
 748         grace_fact = gh_scm2double (gf);
 749
 750       dist *= grace_fact;
 751     }
 752
 753
 754   return dist;
 755 }
 756
 757
 758
 759 ADD_INTERFACE (Spacing_spanner,"spacing-spanner-interface",
 760   "
 761 The space taken by a note is dependent on its duration. Doubling a
 762 duration adds spacing-increment to the space. The most common shortest
 763 note gets shortest-duration-space. Notes that are even shorter are
 764 spaced proportonial to their duration.
 765
 766 Typically, the increment is the width of a black note head.  In a
 767 piece with lots of 8th notes, and some 16th notes, the eighth note
 768 gets 2 note heads width (i.e. the space following a note is 1 note
 769 head width) A 16th note is followed by 0.5 note head width. The
 770 quarter note is followed by  3 NHW, the half by 4 NHW, etc.
 771 ",
 772   "grace-space-factor spacing-increment shortest-duration-space");
 773