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 SHORTEST.
 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   Spaceable_grob::add_spring (lc, rc, distance, strength, false);
 564 }
 565
 566 void
 567 Spacing_spanner::standard_breakable_column_spacing (Grob * me, Item*l, Item*r,
 568                                    Real * fixed, Real * space,
 569                                    Moment shortest)
 570 {
 571   *fixed = l->extent (l, X_AXIS)[RIGHT] - r->extent (r, X_AXIS)[LEFT];
 572
 573   if (l->breakable_b (l) && r->breakable_b(r))
 574     {
 575       Moment *dt = unsmob_moment (l->get_grob_property ("measure-length"));
 576       Moment mlen (1);
 577       if (dt)
 578         mlen = *dt;
 579
 580       Real incr = gh_scm2double (me->get_grob_property ("spacing-increment"));
 581
 582       *space =  *fixed + incr * double (mlen.main_part_ / shortest.main_part_) * 0.8;
 583     }
 584   else
 585     {
 586       Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
 587       bool dummy;
 588
 589       *space = *fixed + get_duration_space (me, dt, shortest.main_part_, &dummy);
 590     }
 591
 592
 593 }
 594
 595
 596 /*
 597   Read hints from L and generate springs.
 598  */
 599 void
 600 Spacing_spanner::breakable_column_spacing (Grob*me, Item* l, Item *r,Moment shortest)
 601 {
 602   Real max_fixed = -infinity_f;
 603   Real max_space = -infinity_f;
 604
 605   standard_breakable_column_spacing (me, l, r, &max_fixed, &max_space ,
 606                                      shortest);
 607
 608   for (SCM s = l->get_grob_property ("spacing-wishes");
 609        gh_pair_p (s); s = gh_cdr (s))
 610     {
 611       Item * spacing_grob = dynamic_cast<Item*> (unsmob_grob (gh_car (s)));
 612
 613       if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
 614         continue;
 615
 616       Real space;
 617       Real fixed_space;
 618
 619       /*
 620         column for the left one settings should be ok due automatic
 621         pointer munging.
 622
 623       */
 624       assert (spacing_grob-> column_l () == l);
 625
 626       Staff_spacing::get_spacing_params (spacing_grob,
 627                                          &space, &fixed_space);
 628       if (space > max_space)
 629         {
 630           max_space = space;
 631           max_fixed = fixed_space;
 632         }
 633     }
 634
 635
 636
 637
 638   if (isinf (max_space))
 639     {
 640       programming_error ("No pref spacing found");
 641       max_space = 2.0;
 642       max_fixed = 1.0;
 643     }
 644
 645
 646   if (l->break_status_dir() == RIGHT
 647       && Paper_column::when_mom (l) == Paper_column::when_mom (r))
 648     {
 649       /* Start of line: this space is not stretchable */
 650       max_fixed = max_space;
 651     }
 652
 653   /*
 654     Hmm.  we do 1/0 in the next thing. Perhaps we should check if this
 655     works on all architectures.
 656    */
 657
 658   bool ragged = to_boolean (me->paper_l ()->get_scmvar ("raggedright"));
 659   Real strength = (ragged) ? 1.0 : 1 / (max_space - max_fixed);
 660   Real distance = (ragged) ? max_fixed : max_space;
 661   Spaceable_grob::add_spring (l, r, distance, strength, false);
 662 }
 663
 664
 665 /**
 666   Get the measure wide ant for arithmetic spacing.
 667   */
 668 Real
 669 Spacing_spanner::get_duration_space (Grob*me, Moment d, Rational shortest, bool * expand_only)
 670 {
 671   Real k = gh_scm2double (me->get_grob_property ("shortest-duration-space"));
 672   Real incr = gh_scm2double (me->get_grob_property ("spacing-increment"));
 673
 674   if (d < shortest)
 675     {
 676       /*
 677         We don't space really short notes using the log of the
 678         duration, since it would disproportionally stretches the long
 679         notes in a piece. In stead, we use geometric spacing with constant 0.5
 680         (i.e. linear.)
 681
 682         This should probably be tunable, to use other base numbers.
 683
 684         In Mozart hrn3 by EB., we have 8th note = 3.9 mm (total), 16th note =
 685         3.6 mm (total).  head-width = 2.4, so we 1.2mm for 16th, 1.5
 686         mm for 8th. (white space), suggesting that we use
 687
 688         (1.2 / 1.5)^{-log2(duration ratio)}
 689
 690
 691        */
 692       Rational ratio = d.main_part_ / shortest;
 693
 694       *expand_only = true;
 695       return ((k-1) + double (ratio)) * incr;
 696     }
 697   else
 698     {
 699       /*
 700           John S. Gourlay. ``Spacing a Line of Music,'' Technical
 701           Report OSU-CISRC-10/87-TR35, Department of Computer and
 702           Information Science, The Ohio State University, 1987.
 703        */
 704       Real log =  log_2 (shortest);
 705       k -= log;
 706       Rational compdur = d.main_part_ + d.grace_part_ /Rational (3);
 707       *expand_only = false;
 708
 709       return (log_2 (compdur) + k) * incr;
 710     }
 711 }
 712
 713 Real
 714 Spacing_spanner::note_spacing (Grob*me, Grob *lc, Grob *rc,
 715                                Moment shortest, bool * expand_only)
 716 {
 717   Moment shortest_playing_len = 0;
 718   SCM s = lc->get_grob_property ("shortest-playing-duration");
 719
 720   if (unsmob_moment (s))
 721     shortest_playing_len = *unsmob_moment (s);
 722
 723   if (! shortest_playing_len.to_bool ())
 724     {
 725       programming_error ("can't find a ruling note at " + Paper_column::when_mom (lc).str ());
 726       shortest_playing_len = 1;
 727     }
 728
 729   Moment lwhen = Paper_column::when_mom (lc);
 730   Moment rwhen =  Paper_column::when_mom (rc);
 731
 732   Moment delta_t = rwhen - lwhen;
 733   Real dist = 0.0;
 734
 735   /*
 736     In normal situations, the next column is at most
 737     SHORTEST_PLAYING_LEN away. However chord-tremolos do funky faking stuff
 738     with durations, invalidating this assumption. Here we kludge
 739     around to get chord tremolos to behave properly.
 740
 741    */
 742   shortest_playing_len = shortest_playing_len >? delta_t;
 743   if (delta_t.main_part_ && !lwhen.grace_part_)
 744     {
 745       dist = get_duration_space (me, shortest_playing_len, shortest.main_part_, expand_only);
 746       dist *= (double) (delta_t.main_part_ / shortest_playing_len.main_part_);
 747     }
 748   else if (delta_t.grace_part_)
 749     {
 750       /*
 751         TODO: figure out how to space grace notes.
 752       */
 753       dist = get_duration_space (me, shortest, shortest.main_part_, expand_only);
 754
 755       Real grace_fact = 1.0;
 756       SCM gf = me->get_grob_property ("grace-space-factor");
 757       if (gh_number_p (gf))
 758         grace_fact = gh_scm2double (gf);
 759
 760       dist *= grace_fact;
 761     }
 762
 763
 764   return dist;
 765 }
 766
 767
 768
 769 ADD_INTERFACE (Spacing_spanner,"spacing-spanner-interface",
 770   "
 771 The space taken by a note is dependent on its duration. Doubling a
 772 duration adds spacing-increment to the space. The most common shortest
 773 note gets shortest-duration-space. Notes that are even shorter are
 774 spaced proportonial to their duration.
 775
 776 Typically, the increment is the width of a black note head.  In a
 777 piece with lots of 8th notes, and some 16th notes, the eighth note
 778 gets 2 note heads width (i.e. the space following a note is 1 note
 779 head width) A 16th note is followed by 0.5 note head width. The
 780 quarter note is followed by  3 NHW, the half by 4 NHW, etc.
 781 ",
 782   "grace-space-factor spacing-increment shortest-duration-space");
 783