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
 512   spacing parameters INCR and SHORTEST.
 513  */
 514 void
 515 Spacing_spanner::musical_column_spacing (Grob *me, Item * lc, Item *rc, Real increment, Rational shortest)
 516 {
 517   bool expand_only = false;
 518   Real base_note_space = note_spacing (me, lc, rc, shortest, &expand_only);
 519
 520   Real max_note_space = -infinity_f;
 521   Real max_fixed_note_space = -infinity_f;
 522
 523   SCM seq  = lc->get_grob_property ("right-neighbors");
 524
 525   /*
 526     We adjust the space following a note only if the next note
 527     happens after the current note (this is set in the grob
 528     property SPACING-SEQUENCE.
 529   */
 530   for (SCM s = seq; gh_pair_p (s); s = ly_cdr (s))
 531     {
 532       Grob * wish = unsmob_grob (gh_car (s));
 533
 534       Item *wish_rcol = Note_spacing::right_column (wish);
 535       if (Note_spacing::left_column (wish) != lc
 536           || (wish_rcol != rc && wish_rcol != rc->original_l_))
 537         continue;
 538
 539       /*
 540         This is probably a waste of time in the case of polyphonic
 541         music.  */
 542       if (Note_spacing::has_interface (wish))
 543         {
 544           Real space =0.0;
 545           Real fixed =0.0;
 546
 547           Note_spacing::get_spacing (wish, rc, base_note_space, increment, &space, &fixed);
 548           max_note_space = max_note_space >? space;
 549           max_fixed_note_space = max_fixed_note_space >? fixed;
 550         }
 551     }
 552
 553   if (max_note_space < 0)
 554     {
 555       max_note_space = base_note_space;
 556       max_fixed_note_space =  increment;
 557     }
 558
 559   bool ragged = to_boolean (me->paper_l ()->get_scmvar ("raggedright"));
 560
 561   /*
 562     Whatever we do, the fixed space is smaller than the real
 563     space.
 564
 565     TODO: this criterion is discontinuous in the derivative.
 566     Maybe it should be continuous?
 567   */
 568   max_fixed_note_space = max_fixed_note_space <?  max_note_space;
 569
 570   Real strength = (ragged) ? 1.0 : 1 / (max_note_space - max_fixed_note_space);
 571   Real distance = (ragged) ? max_fixed_note_space : max_note_space;
 572   //  Spaceable_grob::add_spring (lc, rc, distance, strength, expand_only);
 573
 574   Spaceable_grob::add_spring (lc, rc, distance, strength, false);
 575 }
 576
 577
 578 /*
 579   The one-size-fits all spacing. It doesn't take into account
 580   different spacing wishes from one to the next column.
 581  */
 582 void
 583 Spacing_spanner::standard_breakable_column_spacing (Grob * me, Item*l, Item*r,
 584                                    Real * fixed, Real * space,
 585                                    Moment shortest)
 586 {
 587   *fixed = l->extent (l, X_AXIS)[RIGHT] - r->extent (r, X_AXIS)[LEFT];
 588
 589   if (l->breakable_b (l) && r->breakable_b(r))
 590     {
 591       Moment *dt = unsmob_moment (l->get_grob_property ("measure-length"));
 592       Moment mlen (1);
 593       if (dt)
 594         mlen = *dt;
 595
 596       Real incr = gh_scm2double (me->get_grob_property ("spacing-increment"));
 597
 598       *space =  *fixed + incr * double (mlen.main_part_ / shortest.main_part_) * 0.8;
 599     }
 600   else
 601     {
 602       Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
 603       bool dummy;
 604
 605       *space = *fixed + get_duration_space (me, dt, shortest.main_part_, &dummy);
 606     }
 607
 608
 609 }
 610
 611
 612 /*
 613   Read hints from L and generate springs.
 614  */
 615 void
 616 Spacing_spanner::breakable_column_spacing (Grob*me, Item* l, Item *r,Moment shortest)
 617 {
 618   Real max_fixed = -infinity_f;
 619   Real max_space = -infinity_f;
 620
 621   standard_breakable_column_spacing (me, l, r, &max_fixed, &max_space ,
 622                                      shortest);
 623
 624   for (SCM s = l->get_grob_property ("spacing-wishes");
 625        gh_pair_p (s); s = gh_cdr (s))
 626     {
 627       Item * spacing_grob = dynamic_cast<Item*> (unsmob_grob (gh_car (s)));
 628
 629       if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
 630         continue;
 631
 632       Real space;
 633       Real fixed_space;
 634
 635       /*
 636         column for the left one settings should be ok due automatic
 637         pointer munging.
 638
 639       */
 640       assert (spacing_grob-> column_l () == l);
 641
 642       Staff_spacing::get_spacing_params (spacing_grob,
 643                                          &space, &fixed_space);
 644       if (space > max_space)
 645         {
 646           max_space = space;
 647           max_fixed = fixed_space;
 648         }
 649     }
 650
 651
 652
 653
 654   if (isinf (max_space))
 655     {
 656     /*
 657       One situation where this can happen is when there is a column
 658       that only serves as a spanning point for a short staff-symbol.
 659
 660      ===============X===
 661
 662          |=======Y
 663
 664
 665       (here no StaffSpacing from Y to X is found.)
 666     */
 667       programming_error ("No StaffSpacing wishes found");
 668       max_space = 2.0;
 669       max_fixed = 1.0;
 670     }
 671
 672
 673   if (l->break_status_dir() == RIGHT
 674       && Paper_column::when_mom (l) == Paper_column::when_mom (r))
 675     {
 676       /* Start of line: this space is not stretchable */
 677       max_fixed = max_space;
 678     }
 679
 680   /*
 681     Hmm.  we do 1/0 in the next thing. Perhaps we should check if this
 682     works on all architectures.
 683    */
 684
 685   bool ragged = to_boolean (me->paper_l ()->get_scmvar ("raggedright"));
 686   Real strength = (ragged) ? 1.0 : 1 / (max_space - max_fixed);
 687   Real distance = (ragged) ? max_fixed : max_space;
 688   Spaceable_grob::add_spring (l, r, distance, strength, false);
 689 }
 690
 691
 692 /**
 693   Get the measure wide ant for arithmetic spacing.
 694   */
 695 Real
 696 Spacing_spanner::get_duration_space (Grob*me, Moment d, Rational shortest, bool * expand_only)
 697 {
 698   Real k = gh_scm2double (me->get_grob_property ("shortest-duration-space"));
 699   Real incr = gh_scm2double (me->get_grob_property ("spacing-increment"));
 700
 701   if (d < shortest)
 702     {
 703       /*
 704         We don't space really short notes using the log of the
 705         duration, since it would disproportionally stretches the long
 706         notes in a piece. In stead, we use geometric spacing with constant 0.5
 707         (i.e. linear.)
 708
 709         This should probably be tunable, to use other base numbers.
 710
 711         In Mozart hrn3 by EB., we have 8th note = 3.9 mm (total), 16th note =
 712         3.6 mm (total).  head-width = 2.4, so we 1.2mm for 16th, 1.5
 713         mm for 8th. (white space), suggesting that we use
 714
 715         (1.2 / 1.5)^{-log2(duration ratio)}
 716
 717
 718        */
 719       Rational ratio = d.main_part_ / shortest;
 720
 721       *expand_only = true;
 722       return ((k-1) + double (ratio)) * incr;
 723     }
 724   else
 725     {
 726       /*
 727           John S. Gourlay. ``Spacing a Line of Music,'' Technical
 728           Report OSU-CISRC-10/87-TR35, Department of Computer and
 729           Information Science, The Ohio State University, 1987.
 730        */
 731       Real log =  log_2 (shortest);
 732       k -= log;
 733       Rational compdur = d.main_part_ + d.grace_part_ /Rational (3);
 734       *expand_only = false;
 735
 736       return (log_2 (compdur) + k) * incr;
 737     }
 738 }
 739
 740 Real
 741 Spacing_spanner::note_spacing (Grob*me, Grob *lc, Grob *rc,
 742                                Moment shortest, bool * expand_only)
 743 {
 744   Moment shortest_playing_len = 0;
 745   SCM s = lc->get_grob_property ("shortest-playing-duration");
 746
 747   if (unsmob_moment (s))
 748     shortest_playing_len = *unsmob_moment (s);
 749
 750   if (! shortest_playing_len.to_bool ())
 751     {
 752       programming_error ("can't find a ruling note at " + Paper_column::when_mom (lc).str ());
 753       shortest_playing_len = 1;
 754     }
 755
 756   Moment lwhen = Paper_column::when_mom (lc);
 757   Moment rwhen =  Paper_column::when_mom (rc);
 758
 759   Moment delta_t = rwhen - lwhen;
 760   Real dist = 0.0;
 761
 762   /*
 763     In normal situations, the next column is at most
 764     SHORTEST_PLAYING_LEN away. However chord-tremolos do funky faking stuff
 765     with durations, invalidating this assumption. Here we kludge
 766     around to get chord tremolos to behave properly.
 767
 768    */
 769   shortest_playing_len = shortest_playing_len >? delta_t;
 770   if (delta_t.main_part_ && !lwhen.grace_part_)
 771     {
 772       dist = get_duration_space (me, shortest_playing_len, shortest.main_part_, expand_only);
 773       dist *= (double) (delta_t.main_part_ / shortest_playing_len.main_part_);
 774     }
 775   else if (delta_t.grace_part_)
 776     {
 777       /*
 778         TODO: figure out how to space grace notes.
 779       */
 780       dist = get_duration_space (me, shortest, shortest.main_part_, expand_only);
 781
 782       Real grace_fact = 1.0;
 783       SCM gf = me->get_grob_property ("grace-space-factor");
 784       if (gh_number_p (gf))
 785         grace_fact = gh_scm2double (gf);
 786
 787       dist *= grace_fact;
 788     }
 789
 790
 791   return dist;
 792 }
 793
 794
 795
 796 ADD_INTERFACE (Spacing_spanner,"spacing-spanner-interface",
 797   "
 798 The space taken by a note is dependent on its duration. Doubling a
 799 duration adds spacing-increment to the space. The most common shortest
 800 note gets shortest-duration-space. Notes that are even shorter are
 801 spaced proportonial to their duration.
 802
 803 Typically, the increment is the width of a black note head.  In a
 804 piece with lots of 8th notes, and some 16th notes, the eighth note
 805 gets 2 note heads width (i.e. the space following a note is 1 note
 806 head width) A 16th note is followed by 0.5 note head width. The
 807 quarter note is followed by  3 NHW, the half by 4 NHW, etc.
 808 ",
 809   "grace-space-factor spacing-increment shortest-duration-space");
 810