lily/beam.cc

   1 /*
   2   beam.cc -- implement Beam
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7     Jan Nieuwenhuizen <janneke@gnu.org>
   8
   9 */
  10
  11
  12 /*
  13   [TODO]
  14     * center beam symbol
  15     * less hairy code
  16     * redo grouping
  17
  18 TODO:
  19
  20 The relationship Stem <-> Beam is way too hairy.  Let's figure who
  21 needs what, and what information should be available when.
  22
  23     */
  24
  25 #include <math.h>
  26
  27 #include "beaming.hh"
  28 #include "proto.hh"
  29 #include "dimensions.hh"
  30 #include "beam.hh"
  31 #include "misc.hh"
  32 #include "debug.hh"
  33 #include "molecule.hh"
  34 #include "leastsquares.hh"
  35 #include "stem.hh"
  36 #include "paper-def.hh"
  37 #include "lookup.hh"
  38
  39 Beam::Beam ()
  40 {
  41   slope_f_ = 0;
  42   left_y_ = 0;
  43   multiple_i_ = 0;
  44 }
  45
  46 void
  47 Beam::add_stem (Stem*s)
  48 {
  49 #if 0
  50   /*
  51     should figure out why this didn't work.
  52
  53     --hwn.
  54    */
  55   if (!stems_.size ())
  56     {
  57       set_parent (s, Y_AXIS);
  58     }
  59 #endif
  60   stems_.push (s);
  61   s->add_dependency (this);
  62
  63   assert (!s->beam_l_);
  64   s->beam_l_ = this;
  65
  66   if (!spanned_drul_[LEFT])
  67     set_bounds (LEFT,s);
  68   else
  69     set_bounds (RIGHT,s);
  70 }
  71
  72 Stem_info
  73 Beam::get_stem_info (Stem *s)
  74 {
  75   Stem_info i;
  76   for (int i=0; i < sinfo_.size (); i++)
  77     {
  78       if (sinfo_[i].stem_l_ == s)
  79         return sinfo_[i];
  80     }
  81   assert (false);
  82   return i;
  83 }
  84
  85 Molecule*
  86 Beam::do_brew_molecule_p () const
  87 {
  88   Molecule *mol_p = new Molecule;
  89   if (!sinfo_.size ())
  90     return mol_p;
  91
  92   Real x0 = stems_[0]->hpos_f ();
  93   for (int j=0; j <stems_.size (); j++)
  94     {
  95       Stem *i = stems_[j];
  96       Stem * prev = (j > 0)? stems_[j-1] : 0;
  97       Stem * next = (j < stems_.size ()-1) ? stems_[j+1] :0;
  98
  99       Molecule sb = stem_beams (i, next, prev);
 100       Real  x = i->hpos_f ()-x0;
 101       sb.translate (Offset (x, (x * slope_f_ + left_y_) *
 102                             i->staff_line_leading_f ()/2 ));
 103       mol_p->add_molecule (sb);
 104     }
 105   mol_p->translate_axis (x0
 106     - spanned_drul_[LEFT]->relative_coordinate (0, X_AXIS), X_AXIS);
 107
 108   return mol_p;
 109 }
 110
 111 Offset
 112 Beam::center () const
 113 {
 114   Stem_info si = sinfo_[0];
 115
 116   Real w= (si.stem_l_->note_delta_f () + extent (X_AXIS).length ())/2.0;
 117   return Offset (w, ( w* slope_f_) *
 118                  si.stem_l_->staff_line_leading_f ()/2);
 119 }
 120
 121 /*
 122   Simplistic auto-knees; only consider vertical gap between two
 123   adjacent chords
 124  */
 125 bool
 126 Beam::auto_knee (SCM gap, bool interstaff_b)
 127 {
 128   bool knee = false;
 129   int knee_y = 0;
 130   Real internote_f = stems_[0]->staff_line_leading_f ()/2;
 131   if (gap != SCM_UNDEFINED)
 132     {
 133       int auto_gap_i = gh_scm2int (gap);
 134       for (int i=1; i < stems_.size (); i++)
 135         {
 136           bool is_b = (bool)(sinfo_[i].interstaff_f_ - sinfo_[i-1].interstaff_f_);
 137           int l_y = (int)(stems_[i-1]->chord_start_f () / internote_f)
 138             + (int)sinfo_[i-1].interstaff_f_;
 139           int r_y = (int)(stems_[i]->chord_start_f () / internote_f)
 140             + (int)sinfo_[i].interstaff_f_;
 141           int gap_i = r_y - l_y;
 142
 143           /*
 144             Forced stem directions are ignored.  If you don't want auto-knees,
 145             don't set, or unset autoKneeGap/autoInterstaffKneeGap.
 146            */
 147           if ((abs (gap_i) >= auto_gap_i) && (!interstaff_b || is_b))
 148             {
 149               knee_y = (r_y + l_y) / 2;
 150               knee = true;
 151               break;
 152             }
 153         }
 154     }
 155   if (knee)
 156     {
 157       for (int i=0; i < stems_.size (); i++)
 158         {
 159           int y = (int)(stems_[i]->chord_start_f () / internote_f)
 160             + (int)sinfo_[i].interstaff_f_;
 161           stems_[i]->set_direction ( y < knee_y ? UP : DOWN);
 162           stems_[i]->set_elt_property ("dir-forced", SCM_BOOL_T);
 163         }
 164     }
 165   return knee;
 166 }
 167
 168 bool
 169 Beam::auto_knees ()
 170 {
 171   if (auto_knee (get_elt_property ("auto-interstaff-knee-gap"), true))
 172     return true;
 173
 174   return auto_knee (get_elt_property ("auto-knee-gap"), false);
 175 }
 176
 177
 178 void
 179 Beam::do_pre_processing ()
 180 {
 181   /*
 182     urg: it seems that info on whether beam (voice) dir was forced
 183          is being junked here?
 184   */
 185   if (!get_direction ())
 186     set_direction ( get_default_dir ());
 187
 188   set_direction (get_direction ());
 189 }
 190
 191 void
 192 Beam::do_print () const
 193 {
 194 #ifndef NPRINT
 195   DEBUG_OUT << "slope_f_ " << slope_f_ << "left ypos " << left_y_;
 196   Spanner::do_print ();
 197 #endif
 198 }
 199
 200 void
 201 Beam::do_post_processing ()
 202 {
 203   if (stems_.size () < 2)
 204     {
 205       warning (_ ("beam with less than two stems"));
 206       set_elt_property ("transparent", SCM_BOOL_T);
 207       return;
 208     }
 209   set_steminfo ();
 210   if (auto_knees ())
 211     {
 212       /*
 213         if auto-knee did its work, most probably stem directions
 214         have changed, so we must recalculate all.
 215        */
 216       set_direction ( get_default_dir ());
 217       set_direction (get_direction ());
 218
 219       /* auto-knees used to only work for slope = 0
 220          anyway, should be able to set slope per beam
 221          set_elt_property ("damping", gh_int2scm(1000));
 222       */
 223
 224       sinfo_.clear ();
 225       set_steminfo ();
 226     }
 227   calculate_slope ();
 228   set_stemlens ();
 229 }
 230
 231 void
 232 Beam::do_substitute_element_pointer (Score_element*o,Score_element*n)
 233 {
 234   if (Stem * os = dynamic_cast<Stem*> (o))
 235     stems_.substitute (os,
 236                        dynamic_cast<Stem *> (n));
 237 }
 238
 239 Interval
 240 Beam::do_width () const
 241 {
 242   return Interval (stems_[0]->hpos_f (),
 243                    stems_.top ()->hpos_f ());
 244 }
 245
 246 Direction
 247 Beam::get_default_dir () const
 248 {
 249   Drul_array<int> total;
 250   total[UP]  = total[DOWN] = 0;
 251   Drul_array<int> count;
 252   count[UP]  = count[DOWN] = 0;
 253   Direction d = DOWN;
 254
 255   for (int i=0; i <stems_.size (); i++)
 256     do {
 257       Stem *s = stems_[i];
 258       int current = s->get_direction ()
 259         ? (1 + d * s->get_direction ())/2
 260         : s->get_center_distance ((Direction)-d);
 261
 262       if (current)
 263         {
 264           total[d] += current;
 265           count[d] ++;
 266         }
 267
 268     } while (flip(&d) != DOWN);
 269
 270   /*
 271      [Ross] states that the majority of the notes dictates the
 272      direction (and not the mean of "center distance")
 273
 274      But is that because it really looks better, or because he wants
 275      to provide some real simple hands-on rules?
 276
 277      We have our doubts, so we simply provide all sensible alternatives.
 278
 279      If dir is not determined: up (see stem::get_default_dir ()) */
 280
 281   Direction beam_dir = CENTER;
 282   Direction neutral_dir = (Direction)(int)paper_l ()->get_var ("stem_default_neutral_direction");
 283
 284   SCM a = get_elt_property ("beam-dir-algorithm");
 285
 286   if (a == ly_symbol2scm ("majority")) // should get default from paper.
 287     beam_dir = (count[UP] == count[DOWN]) ? neutral_dir
 288       : (count[UP] > count[DOWN]) ? UP : DOWN;
 289   else if (a == ly_symbol2scm ("mean"))
 290     // mean center distance
 291     beam_dir = (total[UP] == total[DOWN]) ? neutral_dir
 292       : (total[UP] > total[DOWN]) ? UP : DOWN;
 293   else if (a == ly_symbol2scm ("median"))
 294     {
 295       // median center distance
 296       if (count[DOWN] && count[UP])
 297         {
 298           beam_dir = (total[UP] / count[UP] == total[DOWN] / count[DOWN])
 299             ? neutral_dir
 300             : (total[UP] / count[UP] > total[DOWN] / count[DOWN]) ? UP : DOWN;
 301         }
 302       else
 303         {
 304           beam_dir = (count[UP] == count[DOWN]) ? neutral_dir
 305             : (count[UP] > count[DOWN]) ? UP : DOWN;
 306         }
 307     }
 308
 309   return beam_dir;
 310 }
 311
 312 void
 313 Beam::set_direction (Direction d)
 314 {
 315   Directional_spanner::set_direction (d);
 316   for (int i=0; i <stems_.size (); i++)
 317     {
 318       Stem *s = stems_[i];
 319       s->set_elt_property ("beam-dir", gh_int2scm (d));
 320
 321       SCM force = s->remove_elt_property ("dir-forced");
 322       if (force == SCM_UNDEFINED)
 323         s->set_direction ( d);
 324     }
 325 }
 326
 327 /*
 328   See Documentation/tex/fonts.doc
 329  */
 330
 331 void
 332 Beam::solve_slope ()
 333 {
 334   assert (sinfo_.size () > 1);
 335
 336   Least_squares l;
 337   for (int i=0; i < sinfo_.size (); i++)
 338     {
 339       l.input.push (Offset (sinfo_[i].x_, sinfo_[i].idealy_f_));
 340     }
 341   l.minimise (slope_f_, left_y_);
 342 }
 343
 344 /*
 345   ugh. Naming: this doesn't check, but sets as well.
 346  */
 347
 348 Real
 349 Beam::check_stemlengths_f (bool set_b)
 350 {
 351   Real interbeam_f = paper_l ()->interbeam_f (multiple_i_);
 352
 353   Real beam_f = gh_scm2double (get_elt_property ("beam-thickness"));
 354   Real staffline_f = paper_l ()-> get_var ("stafflinethickness");
 355   Real epsilon_f = staffline_f / 8;
 356   Real dy_f = 0.0;
 357   for (int i=0; i < sinfo_.size (); i++)
 358     {
 359       Real y = sinfo_[i].x_ * slope_f_ + left_y_;
 360
 361       // correct for knee
 362       if (get_direction () != sinfo_[i].get_direction ())
 363         {
 364           Real internote_f = sinfo_[i].stem_l_->staff_line_leading_f ()/2;
 365           y -= get_direction () * (beam_f / 2
 366                        + (sinfo_[i].mult_i_ - 1) * interbeam_f) / internote_f;
 367           if (!i && sinfo_[i].stem_l_->staff_symbol_l () !=
 368               sinfo_.top ().stem_l_->staff_symbol_l ())
 369             y += get_direction () * (multiple_i_ - (sinfo_[i].stem_l_->flag_i_ - 2) >? 0)
 370               * interbeam_f / internote_f;
 371         }
 372
 373       if (set_b)
 374         sinfo_[i].stem_l_->set_stemend (y - sinfo_[i].interstaff_f_);
 375
 376       y *= get_direction ();
 377       if (y > sinfo_[i].maxy_f_)
 378         dy_f = dy_f <? sinfo_[i].maxy_f_ - y;
 379       if (y < sinfo_[i].miny_f_)
 380         {
 381           // when all too short, normal stems win..
 382           if (dy_f < -epsilon_f)
 383             warning (_ ("weird beam vertical offset"));
 384           dy_f = dy_f >? sinfo_[i].miny_f_ - y;
 385         }
 386     }
 387   return dy_f;
 388 }
 389
 390 void
 391 Beam::set_steminfo ()
 392 {
 393   if(!stems_.size ())
 394     return;
 395
 396   assert (multiple_i_);
 397
 398   int total_count_i = 0;
 399   int forced_count_i = 0;
 400   for (int i=0; i < stems_.size (); i++)
 401     {
 402       Stem *s = stems_[i];
 403
 404       s->set_default_extents ();
 405       if (s->invisible_b ())
 406         continue;
 407       if (((int)s->chord_start_f ()) && (s->get_direction () != s->get_default_dir ()))
 408         forced_count_i++;
 409       total_count_i++;
 410     }
 411
 412   bool grace_b = get_elt_property ("grace") == SCM_BOOL_T;
 413   String type_str = grace_b ? "grace_" : "";
 414   int stem_max = (int)rint(paper_l ()->get_var ("stem_max"));
 415   Real shorten_f = paper_l ()->get_var (type_str + "forced_stem_shorten"
 416                                         + to_str (multiple_i_ <? stem_max));
 417
 418   Real leftx = 0;
 419   for (int i=0; i < stems_.size (); i++)
 420     {
 421       Stem *s = stems_[i];
 422       /*
 423         Chord tremolo needs to beam over invisible stems of wholes
 424       */
 425       SCM trem = get_elt_property ("chord-tremolo");
 426       if (gh_boolean_p (trem) && gh_scm2bool (trem))
 427         {
 428           if (s->invisible_b ())
 429             continue;
 430         }
 431
 432       Stem_info info (s, multiple_i_);
 433       if (leftx == 0)
 434         leftx = info.x_;
 435       info.x_ -= leftx;
 436       if (info.get_direction () == get_direction ())
 437         {
 438           if (forced_count_i == total_count_i)
 439             info.idealy_f_ -= shorten_f;
 440           else if (forced_count_i > total_count_i / 2)
 441             info.idealy_f_ -= shorten_f / 2;
 442         }
 443       sinfo_.push (info);
 444     }
 445 }
 446
 447 void
 448 Beam::calculate_slope ()
 449 {
 450   if (!sinfo_.size ())
 451     slope_f_ = left_y_ = 0;
 452   else if (sinfo_[0].idealy_f_ == sinfo_.top ().idealy_f_)
 453     {
 454       slope_f_ = 0;
 455       left_y_ = sinfo_[0].idealy_f_;
 456       left_y_ *= get_direction ();
 457     }
 458   else
 459     {
 460       solve_slope ();
 461       Real solved_slope_f = slope_f_;
 462
 463       /*
 464         steep slope running against lengthened stem is suspect
 465       */
 466       Real dx_f = stems_.top ()->hpos_f () - stems_[0]->hpos_f ();
 467
 468       // urg, these y internote-y-dimensions
 469       Real internote_f = stems_[0]->staff_line_leading_f ()/2;
 470
 471       Real lengthened = paper_l ()->get_var ("beam_lengthened") / internote_f;
 472       Real steep = paper_l ()->get_var ("beam_steep_slope") / internote_f;
 473       if (((left_y_ - sinfo_[0].idealy_f_ > lengthened)
 474            && (slope_f_ > steep))
 475           || ((left_y_ + slope_f_ * dx_f - sinfo_.top ().idealy_f_ > lengthened)
 476               && (slope_f_ < -steep)))
 477         {
 478           slope_f_ = 0;
 479         }
 480
 481       /*
 482         This neat trick is by Werner Lemberg,
 483         damped = tanh (slope_f_)
 484         corresponds with some tables in [Wanske]
 485       */
 486       SCM damp = remove_elt_property ("damping");
 487       int damping = 1;          // ugh.
 488       if (damp!= SCM_UNDEFINED)
 489         damping = gh_int2scm (damp);
 490
 491       if (damping)
 492         slope_f_ = 0.6 * tanh (slope_f_) / damping;
 493
 494       quantise_dy ();
 495
 496       Real damped_slope_dy_f = (solved_slope_f - slope_f_) * dx_f / 2;
 497       left_y_ += damped_slope_dy_f;
 498
 499       left_y_ *= get_direction ();
 500       slope_f_ *= get_direction ();
 501     }
 502 }
 503
 504 void
 505 Beam::quantise_dy ()
 506 {
 507   /*
 508     [Ross] (simplification of)
 509     Try to set slope_f_ complying with y-span of:
 510       - zero
 511       - beam_f / 2 + staffline_f / 2
 512       - beam_f + staffline_f
 513     + n * interline
 514     */
 515
 516   SCM q = get_elt_property ("slope-quantisation");
 517
 518   if (q == ly_symbol2scm ("none"))
 519     return;
 520
 521   Real interline_f = stems_[0]->staff_line_leading_f ();
 522   Real internote_f = interline_f / 2;
 523   Real staffline_f = paper_l ()->get_var ("stafflinethickness");
 524   Real beam_f = gh_scm2double (get_elt_property ("beam-thickness"));;
 525
 526   Real dx_f = stems_.top ()->hpos_f () - stems_[0]->hpos_f ();
 527
 528   // dim(y) = internote; so slope = (y/internote)/x
 529   Real dy_f = dx_f * abs (slope_f_ * internote_f);
 530
 531   Real quanty_f = 0.0;
 532
 533   Array<Real> allowed_fraction (3);
 534   allowed_fraction[0] = 0;
 535   allowed_fraction[1] = (beam_f / 2 + staffline_f / 2);
 536   allowed_fraction[2] = (beam_f + staffline_f);
 537
 538
 539   Interval iv = quantise_iv (allowed_fraction, interline_f, dy_f);
 540   quanty_f = (dy_f - iv[SMALLER] <= iv[BIGGER] - dy_f)
 541     ? iv[SMALLER]
 542     : iv[BIGGER];
 543
 544
 545   slope_f_ = (quanty_f / dx_f) / internote_f * sign (slope_f_);
 546 }
 547
 548 /*
 549
 550   Prevent interference from stafflines and beams.  See Documentation/tex/fonts.doc
 551
 552  */
 553 void
 554 Beam::quantise_left_y (bool extend_b)
 555 {
 556    /*
 557     we only need to quantise the start of the beam as dy is quantised too
 558    if extend_b then stems must *not* get shorter
 559    */
 560   SCM q = get_elt_property ("slope-quantisation");
 561
 562
 563   /*
 564     ----------------------------------------------------------
 565                                                    ########
 566                                         ########
 567                              ########
 568     --------------########------------------------------------
 569        ########
 570
 571        hang       straddle   sit        inter      hang
 572    */
 573
 574   Real space = stems_[0]->staff_line_leading_f ();
 575   Real internote_f = space /2;
 576   Real staffline_f = paper_l ()->get_var ("stafflinethickness");
 577   Real beam_f = gh_scm2double (get_elt_property ("beam-thickness"));;
 578
 579   /*
 580     [TODO]
 581     it would be nice to have all allowed positions in a runtime matrix:
 582     (multiplicity, minimum_beam_dy, maximum_beam_dy)
 583    */
 584
 585   Real straddle = 0;
 586   Real sit = beam_f / 2 - staffline_f / 2;
 587   Real hang = space - beam_f / 2 + staffline_f / 2;
 588
 589   /*
 590     Put all allowed positions into an array.
 591     Whether a position is allowed or not depends on
 592     strictness of quantisation, multiplicity and direction.
 593
 594     For simplicity, we'll assume dir = UP and correct if
 595     dir = DOWN afterwards.
 596    */
 597   // isn't this asymmetric ? --hwn
 598
 599   // dim(left_y_) = internote
 600   Real dy_f = get_direction () * left_y_ * internote_f;
 601
 602   Real beamdx_f = stems_.top ()->hpos_f () - stems_[0]->hpos_f ();
 603   Real beamdy_f = beamdx_f * slope_f_ * internote_f;
 604
 605   Array<Real> allowed_position;
 606   if (q == ly_symbol2scm ("normal"))
 607     {
 608       if ((multiple_i_ <= 2) || (abs (beamdy_f) >= staffline_f / 2))
 609         allowed_position.push (straddle);
 610       if ((multiple_i_ <= 1) || (abs (beamdy_f) >= staffline_f / 2))
 611         allowed_position.push (sit);
 612       allowed_position.push (hang);
 613     }
 614   else if (q == ly_symbol2scm ("traditional"))
 615     {
 616       // TODO: check and fix TRADITIONAL
 617       if ((multiple_i_ <= 2) || (abs (beamdy_f) >= staffline_f / 2))
 618         allowed_position.push (straddle);
 619       if ((multiple_i_ <= 1) && (beamdy_f <= staffline_f / 2))
 620         allowed_position.push (sit);
 621       if (beamdy_f >= -staffline_f / 2)
 622         allowed_position.push (hang);
 623     }
 624
 625
 626   Interval iv = quantise_iv (allowed_position, space, dy_f);
 627
 628   Real quanty_f = dy_f - iv[SMALLER] <= iv[BIGGER] - dy_f ? iv[SMALLER] : iv[BIGGER];
 629   if (extend_b)
 630     quanty_f = iv[BIGGER];
 631
 632   // dim(left_y_) = internote
 633   left_y_ = get_direction () * quanty_f / internote_f;
 634 }
 635
 636 void
 637 Beam::set_stemlens ()
 638 {
 639   Real staffline_f = paper_l ()->get_var ("stafflinethickness");
 640   // enge floots
 641   Real epsilon_f = staffline_f / 8;
 642
 643
 644   // je bent zelf eng --hwn.
 645   Real dy_f = check_stemlengths_f (false);
 646   for (int i = 0; i < 2; i++)   // 2 ?
 647     {
 648       left_y_ += dy_f * get_direction ();
 649       quantise_left_y (dy_f);
 650       dy_f = check_stemlengths_f (true);
 651       if (abs (dy_f) <= epsilon_f)
 652         {
 653           break;
 654         }
 655     }
 656 }
 657
 658 void
 659 Beam::set_beaming (Beaming_info_list *beaming)
 660 {
 661   Direction d = LEFT;
 662   for (int i=0; i  < stems_.size (); i++)
 663     {
 664       do
 665         {
 666           if (stems_[i]->beams_i_drul_[d] < 0)
 667             stems_[i]->beams_i_drul_[d] = beaming->infos_.elem (i).beams_i_drul_[d];
 668         }
 669       while (flip (&d) != LEFT);
 670     }
 671 }
 672
 673
 674 void
 675 Beam::do_add_processing ()
 676 {
 677   for (int i=0; i < stems_.size () ; i++)
 678     {
 679       Direction d = LEFT;
 680       do {
 681         multiple_i_ = multiple_i_ >? stems_[i]->beams_i_drul_[d];
 682       } while ((flip (&d)) != LEFT);
 683     }
 684
 685   if (stems_.size ())
 686     {
 687       stems_[0]->beams_i_drul_[LEFT] =0;
 688       stems_.top()->beams_i_drul_[RIGHT] =0;
 689     }
 690 }
 691
 692
 693
 694 /*
 695   beams to go with one stem.
 696
 697   clean  me up.
 698   */
 699 Molecule
 700 Beam::stem_beams (Stem *here, Stem *next, Stem *prev) const
 701 {
 702   if ((next && !(next->hpos_f () > here->hpos_f ())) ||
 703       (prev && !(prev->hpos_f () < here->hpos_f ())))
 704       programming_error ("Beams are not left-to-right");
 705
 706   Real staffline_f = paper_l ()->get_var ("stafflinethickness");
 707   Real interbeam_f = paper_l ()->interbeam_f (multiple_i_);
 708
 709   Real internote_f = here->staff_line_leading_f ()/2;
 710   Real beam_f = gh_scm2double (get_elt_property ("beam-thickness"));;
 711
 712   Real dy = interbeam_f;
 713   Real stemdx = staffline_f;
 714   Real sl = slope_f_* internote_f;
 715
 716   Molecule leftbeams;
 717   Molecule rightbeams;
 718
 719   // UGH
 720   Real nw_f;
 721   if (!here->head_l_arr_.size ())
 722     nw_f = 0;
 723   else if (here->type_i ()== 1)
 724     nw_f = paper_l ()->get_var ("wholewidth");
 725   else if (here->type_i () == 2)
 726     nw_f = paper_l ()->get_var ("notewidth") * 0.8;
 727   else
 728     nw_f = paper_l ()->get_var ("quartwidth");
 729
 730   /* half beams extending to the left. */
 731   if (prev)
 732     {
 733       int lhalfs= lhalfs = here->beams_i_drul_[LEFT] - prev->beams_i_drul_[RIGHT] ;
 734       int lwholebeams= here->beams_i_drul_[LEFT] <? prev->beams_i_drul_[RIGHT] ;
 735       /*
 736        Half beam should be one note-width,
 737        but let's make sure two half-beams never touch
 738        */
 739       Real w = here->hpos_f () - prev->hpos_f ();
 740       w = w/2 <? nw_f;
 741       Molecule a;
 742       if (lhalfs)               // generates warnings if not
 743         a =  lookup_l ()->beam (sl, w, beam_f);
 744       a.translate (Offset (-w, -w * sl));
 745       for (int j = 0; j  < lhalfs; j++)
 746         {
 747           Molecule b (a);
 748           b.translate_axis (-get_direction () * dy * (lwholebeams+j), Y_AXIS);
 749           leftbeams.add_molecule (b);
 750         }
 751     }
 752
 753   if (next)
 754     {
 755       int rhalfs = here->beams_i_drul_[RIGHT] - next->beams_i_drul_[LEFT];
 756       int rwholebeams = here->beams_i_drul_[RIGHT] <? next->beams_i_drul_[LEFT];
 757
 758       Real w = next->hpos_f () - here->hpos_f ();
 759       Molecule a = lookup_l ()->beam (sl, w + stemdx, beam_f);
 760       a.translate_axis( - stemdx/2, X_AXIS);
 761       int j = 0;
 762       Real gap_f = 0;
 763
 764       SCM gap = get_elt_property ("beam-gap");
 765       if (gap != SCM_UNDEFINED)
 766         {
 767           int gap_i = gh_scm2int ( (gap));
 768           int nogap = rwholebeams - gap_i;
 769
 770           for (; j  < nogap; j++)
 771             {
 772               Molecule b (a);
 773               b.translate_axis (-get_direction () * dy * j, Y_AXIS);
 774               rightbeams.add_molecule (b);
 775             }
 776           // TODO: notehead widths differ for different types
 777           gap_f = nw_f / 2;
 778           w -= 2 * gap_f;
 779           a = lookup_l ()->beam (sl, w + stemdx, beam_f);
 780         }
 781
 782       for (; j  < rwholebeams; j++)
 783         {
 784           Molecule b (a);
 785           if (!here->invisible_b ())
 786             b.translate (Offset (gap_f, -get_direction () * dy * j));
 787           else
 788             b.translate (Offset (0, -get_direction () * dy * j));
 789           rightbeams.add_molecule (b);
 790         }
 791
 792       w = w/2 <? nw_f;
 793       if (rhalfs)
 794         a = lookup_l ()->beam (sl, w, beam_f);
 795
 796       for (; j  < rwholebeams + rhalfs; j++)
 797         {
 798           Molecule b (a);
 799           b.translate_axis (-get_direction () * dy * j, Y_AXIS);
 800           rightbeams.add_molecule (b);
 801         }
 802
 803     }
 804   leftbeams.add_molecule (rightbeams);
 805
 806   /*
 807     Does beam quanting think  of the asymetry of beams?
 808     Refpoint is on bottom of symbol. (FIXTHAT) --hwn.
 809    */
 810   return leftbeams;
 811 }
 812
 813