X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fbeam.cc;h=65e1aafe382165e15c0cec292d5718b7d97e1a03;hb=c76d27c59244a331a2873a40e0d7e40ad378d4b8;hp=ef9f56ec379305a1af08ab9412734447e3f4f037;hpb=e8936ee66fdd3e7ebe30556590e8dc913908a533;p=lilypond.git

diff --git a/lily/beam.cc b/lily/beam.cc
index ef9f56ec37..65e1aafe38 100644
--- a/lily/beam.cc
+++ b/lily/beam.cc
@@ -3,21 +3,22 @@
   
   source file of the GNU LilyPond music typesetter
   
-  (c)  1997--2003 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+  (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   Jan Nieuwenhuizen <janneke@gnu.org>
 */
 
 /*
 TODO:
 
-  * Use Number_pair i.s.o Interval to represent (yl, yr).
-  
   - Determine auto knees based on positions if it's set by the user.
 
+  - the code is littered with * and / staff_space calls for
+    #'positions. Consider moving to real-world coordinates?
 
+    Problematic issue is user tweaks (user tweaks are in staff-coordinates.) 
+  
 Notes:
 
-
  - Stems run to the Y-center of the beam.
   
  - beam_translation is the offset between Y centers of the beam.
@@ -27,14 +28,14 @@ Notes:
 
 #include <math.h> // tanh.
 
-#include "molecule.hh" 
+#include "stencil.hh" 
 #include "directional-element-interface.hh"
 #include "beaming.hh"
 #include "beam.hh"
 #include "misc.hh"
 #include "least-squares.hh"
 #include "stem.hh"
-#include "paper-def.hh"
+#include "output-def.hh"
 #include "lookup.hh"
 #include "group-interface.hh"
 #include "staff-symbol-referencer.hh"
@@ -43,9 +44,6 @@ Notes:
 #include "warn.hh"
 
 
-#define DEBUG_QUANTING 0
-
-
 #if DEBUG_QUANTING
 #include "text-item.hh"  // debug output.
 #include "font-interface.hh"  // debug output.
@@ -60,7 +58,7 @@ Beam::add_stem (Grob *me, Grob *s)
   s->add_dependency (me);
 
   assert (!Stem::get_beam (s));
-  s->set_grob_property ("beam", me->self_scm ());
+  s->set_property ("beam", me->self_scm ());
 
   add_bound_item (dynamic_cast<Spanner*> (me), dynamic_cast<Item*> (s));
 }
@@ -69,20 +67,25 @@ Beam::add_stem (Grob *me, Grob *s)
 Real
 Beam::get_thickness (Grob * me)
 {
-  SCM th = me->get_grob_property ("thickness");
-  if (gh_number_p (th))
-    return gh_scm2double (th)* Staff_symbol_referencer::staff_space (me);
-  else
-    return 0.0;
+  return robust_scm2double (me->get_property ("thickness"), 0)
+    * Staff_symbol_referencer::staff_space (me);
 }
 
 /* Return the translation between 2 adjoining beams. */
 Real
 Beam::get_beam_translation (Grob *me)
 {
-  SCM func = me->get_grob_property ("space-function");
-  SCM s = gh_call2 (func, me->self_scm (), scm_int2num (get_beam_count (me)));
-  return gh_scm2double (s);
+  SCM func = me->get_property ("space-function");
+
+  if (ly_c_procedure_p (func))
+    {
+      SCM s = scm_call_2 (func, me->self_scm (), scm_int2num (get_beam_count (me)));
+      return scm_to_double (s);
+    }
+  else
+    {
+      return 0.81;
+    }
 }
 
 /* Maximum beam_count. */
@@ -90,7 +93,7 @@ int
 Beam::get_beam_count (Grob *me) 
 {
   int m = 0;
-  for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = ly_cdr (s))
+  for (SCM s = me->get_property ("stems"); ly_c_pair_p (s); s = ly_cdr (s))
     {
       Grob *stem = unsmob_grob (ly_car (s));
       m = m >? (Stem::beam_multiplicity (stem).length () + 1);
@@ -109,14 +112,14 @@ Beam::space_function (SCM smob, SCM beam_count)
   Grob *me = unsmob_grob (smob);
   
   Real staff_space = Staff_symbol_referencer::staff_space (me);
-  Real line = me->get_paper ()->get_realvar (ly_symbol2scm ("linethickness"));
+  Real line = Staff_symbol_referencer::line_thickness (me);
   Real thickness = get_thickness (me);
   
-  Real beam_translation = gh_scm2int (beam_count) < 4
+  Real beam_translation = scm_to_int (beam_count) < 4
     ? (2*staff_space + line - thickness) / 2.0
     : (3*staff_space + line - thickness) / 3.0;
   
-  return gh_double2scm (beam_translation);
+  return scm_make_real (beam_translation);
 }
 
 
@@ -145,12 +148,12 @@ Beam::before_line_breaking (SCM smob)
     {
       me->warning (_ ("beam has less than two visible stems"));
 
-      SCM stems = me->get_grob_property ("stems");
+      SCM stems = me->get_property ("stems");
       if (scm_ilength (stems) == 1)
 	{
-	  me->warning (_ ("Beam has less than two stems. Removing beam."));
+	  me->warning (_ ("removing beam with less than two stems"));
 
-	  unsmob_grob (gh_car (stems))->set_grob_property ("beam", SCM_EOL);
+	  unsmob_grob (ly_car (stems))->set_property ("beam", SCM_EOL);
 	  me->suicide ();
 
 	  return SCM_UNSPECIFIED;
@@ -196,7 +199,7 @@ position_with_maximal_common_beams (SCM left_beaming, SCM right_beaming,
 				    Direction left_dir,
 				    Direction right_dir)
 {
-  Slice lslice = int_list_to_slice (gh_cdr (left_beaming));
+  Slice lslice = int_list_to_slice (ly_cdr (left_beaming));
 
   int best_count = 0;
   int best_start = 0;
@@ -204,10 +207,10 @@ position_with_maximal_common_beams (SCM left_beaming, SCM right_beaming,
        (i - lslice[left_dir])* left_dir <= 0 ; i+= left_dir) 
     {
       int count =0;
-      for ( SCM s = gh_car (right_beaming); gh_pair_p (s); s = gh_cdr (s))
+      for ( SCM s = ly_car (right_beaming); ly_c_pair_p (s); s = ly_cdr (s))
 	{
-	  int k = - right_dir * gh_scm2int (gh_car (s)) + i;
-	  if (scm_memq (scm_int2num (k), left_beaming) != SCM_BOOL_F)
+	  int k = - right_dir * scm_to_int (ly_car (s)) + i;
+	  if (scm_c_memq (scm_int2num (k), left_beaming) != SCM_BOOL_F)
 	    count ++;
 	}
 
@@ -228,16 +231,16 @@ Beam::connect_beams (Grob *me)
     Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
 
   Slice last_int;
-  last_int.set_empty();
+  last_int.set_empty ();
   SCM last_beaming = SCM_EOL;
   Direction last_dir = CENTER;
-  for (int i = 0; i< stems.size(); i++)
+  for (int i = 0; i< stems.size (); i++)
     {
       Grob *this_stem = stems[i];
-      SCM this_beaming = this_stem->get_grob_property ("beaming");
+      SCM this_beaming = this_stem->get_property ("beaming");
 
-      Direction this_dir = Directional_element_interface::get(this_stem);
-      if (gh_pair_p (last_beaming) && gh_pair_p (this_beaming))
+      Direction this_dir = get_grob_direction (this_stem);
+      if (ly_c_pair_p (last_beaming) && ly_c_pair_p (this_beaming))
 	{
 	  int start_point = position_with_maximal_common_beams
 	    (last_beaming, this_beaming,
@@ -247,45 +250,45 @@ Beam::connect_beams (Grob *me)
 	  Slice new_slice ; 
 	  do
 	    {
-	      if (d == RIGHT && i == stems.size()-1)
+	      if (d == RIGHT && i == stems.size ()-1)
 		continue;
 	      
-	      new_slice.set_empty();
+	      new_slice.set_empty ();
 	      SCM s = index_get_cell (this_beaming, d);
-	      for (; gh_pair_p (s); s = gh_cdr (s))
+	      for (; ly_c_pair_p (s); s = ly_cdr (s))
 		{
 		  int new_beam_pos =
-		    start_point - this_dir * gh_scm2int (gh_car (s));
+		    start_point - this_dir * scm_to_int (ly_car (s));
 
 		  new_slice.add_point (new_beam_pos);
-		  gh_set_car_x (s, scm_int2num (new_beam_pos));
+		  scm_set_car_x (s, scm_int2num (new_beam_pos));
 		}
 
 
 	    }
 	  while (flip (&d) != LEFT);
 
-	  if (!new_slice.empty_b())
+	  if (!new_slice.is_empty ())
 	    last_int =  new_slice;
 	}
       else
 	{
-	  gh_set_car_x ( this_beaming, SCM_EOL);
-	  SCM s = gh_cdr (this_beaming);
-	  for (; gh_pair_p (s); s = gh_cdr (s))
+	  scm_set_car_x ( this_beaming, SCM_EOL);
+	  SCM s = ly_cdr (this_beaming);
+	  for (; ly_c_pair_p (s); s = ly_cdr (s))
 	    {
-	      int np = - this_dir * gh_scm2int (gh_car(s));
-	      gh_set_car_x (s, scm_int2num (np));
+	      int np = - this_dir * scm_to_int (ly_car (s));
+	      scm_set_car_x (s, scm_int2num (np));
 	      last_int.add_point (np);
 	    }
 	}
 
       if (i == stems.size () -1)
 	{
-	  gh_set_cdr_x (this_beaming, SCM_EOL);
+	  scm_set_cdr_x (this_beaming, SCM_EOL);
 	}
 
-      if (scm_ilength (gh_cdr (this_beaming)) > 0)
+      if (scm_ilength (ly_cdr (this_beaming)) > 0)
 	{
 	  last_beaming = this_beaming;
 	  last_dir = this_dir;
@@ -293,15 +296,24 @@ Beam::connect_beams (Grob *me)
     }
  }
 
-MAKE_SCHEME_CALLBACK (Beam, brew_molecule, 1);
+
+/*
+  TODO: should not make beams per stem, but per Y-level.
+ */
+MAKE_SCHEME_CALLBACK (Beam, print, 1);
 SCM
-Beam::brew_molecule (SCM grob)
+Beam::print (SCM grob)
 {
-  Grob *me = unsmob_grob (grob);
+  Spanner *me = unsmob_spanner (grob);
+  position_beam (me);
+  
   Link_array<Grob> stems=
     Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
   Grob* xcommon = common_refpoint_of_array (stems, me, X_AXIS);
 
+  xcommon = me->get_bound (LEFT)->common_refpoint (xcommon, X_AXIS);
+  xcommon = me->get_bound (RIGHT)->common_refpoint (xcommon, X_AXIS);
+
   Real x0, dx;
   if (visible_stem_count (me))
     {
@@ -315,58 +327,60 @@ Beam::brew_molecule (SCM grob)
       dx = stems.top ()->relative_coordinate (xcommon, X_AXIS) - x0;
     }
 
-  SCM posns = me->get_grob_property ("positions");
-  Interval pos;
-  if (!ly_number_pair_p (posns))
+  SCM posns = me->get_property ("positions");
+  Drul_array<Real> pos;
+  if (!is_number_pair (posns))
     {
       programming_error ("No beam posns");
       pos = Interval (0,0);
     }
   else
-    pos= ly_scm2interval (posns);
+    pos= ly_scm2realdrul (posns);
 
-  Real dy = pos.delta ();
-  Real dydx = dy && dx ? dy/dx : 0;
+  scale_drul (&pos,  Staff_symbol_referencer::staff_space (me));
+  
+  Real dy = pos[RIGHT] - pos[LEFT];
+  Real dydx = (dy && dx) ? dy/dx : 0;
   
   Real thick = get_thickness (me);
   Real bdy = get_beam_translation (me);
 
-  SCM last_beaming = SCM_EOL;;
+  SCM last_beaming = SCM_EOL;
   Real last_xposn = -1;
-  Real last_width = -1 ;
+  Real last_stem_width = -1 ;
 
-
-  SCM gap = me->get_grob_property ("gap");
-  Molecule the_beam;
-  Real lt = me->get_paper ()->get_realvar (ly_symbol2scm ("linethickness"));
+  Real gap_length = robust_scm2double (me->get_property ("gap"), 0.0);
+  
+  Stencil the_beam;
+  Real lt = me->get_paper ()->get_dimension (ly_symbol2scm ("linethickness"));
   
-  for (int i = 0; i<= stems.size(); i++)
+  for (int i = 0; i<= stems.size (); i++)
     {
-      Grob * st = (i < stems.size()) ? stems[i] : 0;
+      Grob * st = (i < stems.size ()) ? stems[i] : 0;
       
-      SCM this_beaming = st ? st->get_grob_property ("beaming") : SCM_EOL;
+      SCM this_beaming = st ? st->get_property ("beaming") : SCM_EOL;
       Real xposn = st ? st->relative_coordinate (xcommon, X_AXIS) : 0.0;
-      Real stem_width = st ? gh_scm2double (st->get_grob_property ("thickness")) *lt : 0 ;
-
+      Real stem_width = st ? robust_scm2double (st->get_property ("thickness"), 1.0) *lt : 0 ;
+      Direction stem_dir = st ? to_dir (st->get_property ("direction")) : CENTER;
       /*
 	We do the space left of ST, with lfliebertjes pointing to the
 	right from the left stem, and rfliebertjes pointing left from
 	right stem.
        */
-      SCM left = (i>0) ? gh_cdr (last_beaming) : SCM_EOL;
-      SCM right = st ? gh_car (this_beaming) : SCM_EOL;
+      SCM left = (i > 0) ? ly_cdr (last_beaming) : SCM_EOL;
+      SCM right = st ? ly_car (this_beaming) : SCM_EOL;
 
-      Array<int> fullbeams;
+      Array<int> full_beams;
       Array<int> lfliebertjes;
       Array<int> rfliebertjes;	  
 
       for (SCM s = left;
-	   gh_pair_p (s); s =gh_cdr (s))
+	   ly_c_pair_p (s); s =ly_cdr (s))
 	{
-	  int b = gh_scm2int (gh_car (s));
-	  if (scm_memq (gh_car(s), right) != SCM_BOOL_F)
+	  int b = scm_to_int (ly_car (s));
+	  if (scm_c_memq (ly_car (s), right) != SCM_BOOL_F)
 	    {
-	      fullbeams.push (b);
+	      full_beams.push (b);
 	    }
 	  else
 	    {
@@ -374,10 +388,10 @@ Beam::brew_molecule (SCM grob)
 	    }
 	}
       for (SCM s = right;
-	   gh_pair_p (s); s =gh_cdr (s))
+	   ly_c_pair_p (s); s =ly_cdr (s))
 	{
-	  int b = gh_scm2int (gh_car (s));
-	  if (scm_memq (gh_car(s), left) == SCM_BOOL_F)
+	  int b = scm_to_int (ly_car (s));
+	  if (scm_c_memq (ly_car (s), left) == SCM_BOOL_F)
 	    {
 	      rfliebertjes.push (b);
 	    }
@@ -387,37 +401,51 @@ Beam::brew_molecule (SCM grob)
 	how much to stick out for beams across linebreaks
        */
       Real break_overshoot = 3.0;
-      Real w = (i>0 && st)? xposn - last_xposn : break_overshoot;
-      Real stem_offset = 0.0;
-      Real width_corr = 0.0;
-      if (i == 1)
+      Real w = (i > 0 && st) ? (xposn - last_xposn) : break_overshoot;
+
+      Real stem_offset =0.0;
+      if (i > 0)
 	{
-	  stem_offset -= last_width/2;
-	  width_corr += last_width/2;
+	  w += last_stem_width / 2;
+	  stem_offset = -last_stem_width / 2;
 	}
-	  
-      if (i == stems.size() -1)
+
+      if (st)
+	w += stem_width/ 2 ;
+      
+
+      Real blot = me->get_paper ()->get_dimension (ly_symbol2scm ("blotdiameter"));
+      Stencil whole = Lookup::beam (dydx, w, thick, blot);
+      Stencil gapped;
+
+      int gap_count = 0;
+      if (scm_is_number (me->get_property ("gap-count")))
 	{
-	  width_corr += stem_width/2;
+	  gap_count = scm_to_int (me->get_property ("gap-count"));
+	  gapped = Lookup::beam (dydx, w - 2 * gap_length, thick, blot);
+
+	  full_beams.sort (default_compare);
+	  if (stem_dir == UP)
+	    full_beams.reverse ();
 	}
 
-      if (gh_number_p (gap))
+      int k = 0;
+      for (int j = full_beams.size (); j--;)
 	{
-	  Real g = gh_scm2double (gap);
-	  stem_offset += g;
-	  width_corr -= 2*g; 
-	}
+	  Stencil b (whole);
 	  
-      Molecule whole = Lookup::beam (dydx, w + width_corr, thick);
-      for (int j = fullbeams.size(); j--;)
-	{
-	  Molecule b (whole);
+	  if (k++ < gap_count)
+	    {
+	      b = gapped;
+	      b.translate_axis (gap_length, X_AXIS);
+	    }
 	  b.translate_axis (last_xposn -  x0 + stem_offset, X_AXIS);
-	  b.translate_axis (dydx * (last_xposn - x0) + bdy * fullbeams[j], Y_AXIS);
-	  the_beam.add_molecule (b);	      
-	}
+	  b.translate_axis (dydx * (last_xposn - x0) + bdy * full_beams[j], Y_AXIS);
 
-      if (lfliebertjes.size() || rfliebertjes.size())
+	  the_beam.add_stencil (b);	      
+	}
+	  
+      if (lfliebertjes.size () || rfliebertjes.size ())
 	{
 	  Real nw_f;
 
@@ -425,38 +453,53 @@ Beam::brew_molecule (SCM grob)
 	    {
 	      int t = Stem::duration_log (st); 
 
-	      SCM proc = me->get_grob_property ("flag-width-function");
-	      SCM result = gh_call1 (proc, scm_int2num (t));
-	      nw_f = gh_scm2double (result);
+	      SCM proc = me->get_property ("flag-width-function");
+	      SCM result = scm_call_1 (proc, scm_int2num (t));
+	      nw_f = scm_to_double (result);
 	    }
 	  else
-	    nw_f = break_overshoot;
+	    nw_f = break_overshoot / 2;
 	      
 	  /* Half beam should be one note-width,
 	     but let's make sure two half-beams never touch */
-	  Real w = (i>0 && st) ? (xposn - last_xposn) : break_overshoot;
-	  w = w/2 <? nw_f;
+	  Real lw = nw_f;
+	  Real rw = nw_f;
+	  if (i > 0)
+	    rw = nw_f <? ( (xposn - last_xposn) / 2);
+	  else
+	    /*
+	      TODO: 0.5 is a guess.
+	    */
+	    rw = xposn - me->get_bound (LEFT)->extent (xcommon, X_AXIS)[RIGHT]
+	      - 0.5;
+	  
+	  if (st)
+	    lw = nw_f <? ( (xposn - last_xposn) / 2);
+	  else
+	    lw = me->get_bound (RIGHT)->relative_coordinate (xcommon, X_AXIS)
+	      - last_xposn;
 
-	  Molecule half = Lookup::beam (dydx, w, thick);
-	  for (int j = lfliebertjes.size(); j--;)
+	  Stencil rhalf = Lookup::beam (dydx, rw, thick, blot);
+	  Stencil lhalf = Lookup::beam (dydx, lw, thick, blot);
+	  for (int j = lfliebertjes.size (); j--;)
 	    {
-	      Molecule b (half);
+	      Stencil b (lhalf);
 	      b.translate_axis (last_xposn -  x0, X_AXIS);
 	      b.translate_axis (dydx * (last_xposn-x0) + bdy * lfliebertjes[j], Y_AXIS);
-	      the_beam.add_molecule (b);	      
+	      the_beam.add_stencil (b);	      
 	    }
-	  for (int j = rfliebertjes.size(); j--;)
+	  for (int j = rfliebertjes.size (); j--;)
 	    {
-	      Molecule b (half);
-	      b.translate_axis (xposn -  x0 - w , X_AXIS);
-	      b.translate_axis (dydx * (xposn-x0 -w) + bdy * rfliebertjes[j], Y_AXIS);
-	      the_beam.add_molecule (b);	      
+	      Stencil b (rhalf);
+	      b.translate_axis (xposn -  x0 - rw , X_AXIS);
+	      b.translate_axis (dydx * (xposn-x0 -rw) + bdy * rfliebertjes[j], Y_AXIS);
+	      the_beam.add_stencil (b);	      
 	    }
 	}
 
 
       last_xposn = xposn;
-      last_width = stem_width;
+      last_stem_width = stem_width;
       last_beaming = this_beaming;
     }
 
@@ -464,32 +507,28 @@ Beam::brew_molecule (SCM grob)
   the_beam.translate_axis (pos[LEFT], Y_AXIS);
 
 #if (DEBUG_QUANTING)
+  SCM quant_score = me->get_property ("quant-score");
+  if (to_boolean (me->get_paper ()->lookup_variable (ly_symbol2scm ("debug-beam-quanting")))
+      && scm_is_string (quant_score))
     {
+      
       /*
 	This code prints the demerits for each beam. Perhaps this
 	should be switchable for those who want to twiddle with the
 	parameters.
       */
       String str;
-      if (1)
-	{
-	  str += to_string (gh_scm2int (me->get_grob_property ("best-idx")));
-	  str += ":";
-	}
-      str += to_string (gh_scm2double (me->get_grob_property ("quant-score")),
-		     "%.2f");
-
-      SCM properties = Font_interface::font_alist_chain (me);
+      SCM properties = Font_interface::text_font_alist_chain (me);
 
-      Molecule tm = Text_item::interpret_new_markup
-	(me->self_scm(),  properties, scm_makfrom0str (str.to_str0 ()));
-      the_beam.add_at_edge (Y_AXIS, UP, tm, 5.0, 0);
+      Direction stem_dir = stems.size() ? to_dir (stems[0]->get_property ("direction")) : UP;
+    
+      Stencil tm = *unsmob_stencil (Text_item::interpret_markup
+	 (me->get_paper ()->self_scm (), properties, quant_score));
+      the_beam.add_at_edge (Y_AXIS, stem_dir, tm, 1.0, 0);
     }
 #endif
-    
-  
   
-  return the_beam.smobbed_copy();
+  return the_beam.smobbed_copy ();
 }
   
 
@@ -507,12 +546,12 @@ Beam::get_default_dir (Grob *me)
   Link_array<Grob> stems=
 	Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
 
-  for (int i=0; i <stems.size (); i++)
+  for (int i=0; i < stems.size (); i++)
     do {
       Grob *s = stems[i];
-      Direction sd = Directional_element_interface::get (s);
+      Direction sd = get_grob_direction (s);
 
-      int center_distance = int(- d * Stem::head_positions (s) [-d]) >? 0;
+      int center_distance = int (- d * Stem::head_positions (s) [-d]) >? 0;
       int current = sd	? (1 + d * sd)/2 : center_distance;
 
       if (current)
@@ -522,18 +561,18 @@ Beam::get_default_dir (Grob *me)
 	}
     } while (flip (&d) != DOWN);
   
-  SCM func = me->get_grob_property ("dir-function");
-  SCM s = gh_call2 (func,
-		    gh_cons (scm_int2num (count[UP]),
+  SCM func = me->get_property ("dir-function");
+  SCM s = scm_call_2 (func,
+		    scm_cons (scm_int2num (count[UP]),
 			     scm_int2num (count[DOWN])),
-		    gh_cons (scm_int2num (total[UP]),
+		    scm_cons (scm_int2num (total[UP]),
 			     scm_int2num (total[DOWN])));
 
-  if (gh_number_p (s) && gh_scm2int (s))
+  if (scm_is_number (s) && scm_to_int (s))
     return to_dir (s);
   
   /* If dir is not determined: get default */
-  return to_dir (me->get_grob_property ("neutral-direction"));
+  return to_dir (me->get_property ("neutral-direction"));
 }
 
 
@@ -550,9 +589,9 @@ Beam::set_stem_directions (Grob *me, Direction d)
     {
       Grob *s = stems[i];
   
-      SCM forcedir = s->get_grob_property ("direction");
+      SCM forcedir = s->get_property ("direction");
       if (!to_dir (forcedir))
-	Directional_element_interface::set (s, d);
+	set_grob_direction (s,  d);
     }
 }
 
@@ -567,14 +606,14 @@ struct Int_set
 {
   Array<Interval> allowed_regions_;
 
-  Int_set()
+  Int_set ()
   {
-    set_full();
+    set_full ();
   }
 
-  void set_full()
+  void set_full ()
   {
-    allowed_regions_.clear();
+    allowed_regions_.clear ();
     Interval s;
     s.set_full ();
     allowed_regions_.push (s);
@@ -582,13 +621,13 @@ struct Int_set
 
   void remove_interval (Interval rm)
   {
-    for (int i = 0; i < allowed_regions_.size(); )
+    for (int i = 0; i < allowed_regions_.size (); )
       {
 	Interval s = rm;
 
 	s.intersect (allowed_regions_[i]);
 
-	if (!s.empty_b ())
+	if (!s.is_empty ())
 	  {
 	    Interval before = allowed_regions_[i];
 	    Interval after = allowed_regions_[i];
@@ -596,13 +635,13 @@ struct Int_set
 	    before[RIGHT] = s[LEFT];
 	    after[LEFT] = s[RIGHT];
 
-	    if (!before.empty_b() && before.length () > 0.0)
+	    if (!before.is_empty () && before.length () > 0.0)
 	      {
 		allowed_regions_.insert (before, i);
 		i++;
 	      }
 	    allowed_regions_.del (i);
-	    if (!after.empty_b () && after.length () > 0.0)
+	    if (!after.is_empty () && after.length () > 0.0)
 	      {
 		allowed_regions_.insert (after, i);
 		i++;
@@ -624,11 +663,11 @@ struct Int_set
 void
 Beam::consider_auto_knees (Grob* me)
 {
-  SCM scm = me->get_grob_property ("auto-knee-gap");
-  if (!gh_number_p (scm))
+  SCM scm = me->get_property ("auto-knee-gap");
+  if (!scm_is_number (scm))
     return ;
 
-  Real threshold = gh_scm2double (scm);
+  Real threshold = scm_to_double (scm);
   
   Int_set gaps;
 
@@ -644,11 +683,11 @@ Beam::consider_auto_knees (Grob* me)
   for (int i=0; i < stems.size (); i++)
     {
       Grob* stem = stems[i];
-      if (Stem::invisible_b (stem))
+      if (Stem::is_invisible (stem))
 	continue;
 
       Interval hps = Stem::head_positions (stem);
-      if(!hps.empty_b())
+      if (!hps.is_empty ())
 	{
 	  hps[LEFT] += -1;
 	  hps[RIGHT] += 1; 
@@ -662,9 +701,9 @@ Beam::consider_auto_knees (Grob* me)
 	   */
 	  hps += stem->relative_coordinate (common, Y_AXIS);
 
-	  if (to_dir (stem->get_grob_property ("direction")))
+	  if (to_dir (stem->get_property ("direction")))
 	    {
-	      Direction stemdir = to_dir (stem->get_grob_property ("direction"));
+	      Direction stemdir = to_dir (stem->get_property ("direction"));
 	      hps[-stemdir] = - stemdir * infinity_f;
 	    }
 	}
@@ -676,19 +715,19 @@ Beam::consider_auto_knees (Grob* me)
   Interval max_gap;
   Real max_gap_len =0.0;
 
-  for (int i  = gaps.allowed_regions_.size() -1;  i >=  0 ; i--)
+  for (int i  = gaps.allowed_regions_.size () -1;  i >=  0 ; i--)
     {
       Interval gap = gaps.allowed_regions_[i];
 
       /*
 	the outer gaps are not knees.
        */
-      if (isinf (gap[LEFT]) || isinf(gap[RIGHT]))
+      if (isinf (gap[LEFT]) || isinf (gap[RIGHT]))
 	continue;
       
       if (gap.length () >= max_gap_len)
 	{
-	  max_gap_len = gap.length();
+	  max_gap_len = gap.length ();
 	  max_gap = gap;
 	}
     }
@@ -696,22 +735,22 @@ Beam::consider_auto_knees (Grob* me)
   if (max_gap_len > threshold)
     {
       int j = 0;
-      for (int i = 0; i < stems.size(); i++)
+      for (int i = 0; i < stems.size (); i++)
 	{
 	  Grob* stem = stems[i];
-	  if (Stem::invisible_b (stem))
+	  if (Stem::is_invisible (stem))
 	    continue;
 
 	  Interval hps = hps_array[j++];
 
 
-	  Direction d =  (hps.center () < max_gap.center()) ?
+	  Direction d =  (hps.center () < max_gap.center ()) ?
 	    UP : DOWN ;
 	  
-	  stem->set_grob_property ("direction", scm_int2num (d));
+	  stem->set_property ("direction", scm_int2num (d));
 	  
 	  hps.intersect (max_gap);
-	  assert (hps.empty_b () || hps.length () < 1e-6 );
+	  assert (hps.is_empty () || hps.length () < 1e-6 );
 	}
     }
 }
@@ -734,7 +773,7 @@ Beam::set_stem_shorten (Grob *me)
   /*
     shortening looks silly for x staff beams
    */
-  if (knee_b(me))
+  if (is_knee (me))
     return ;
   
   Real forced_fraction = 1.0 * forced_stem_count (me)
@@ -742,7 +781,7 @@ Beam::set_stem_shorten (Grob *me)
 
   int beam_count = get_beam_count (me);
 
-  SCM shorten_list = me->get_grob_property ("beamed-stem-shorten");
+  SCM shorten_list = me->get_property ("beamed-stem-shorten");
   if (shorten_list == SCM_EOL)
     return;
 
@@ -750,13 +789,13 @@ Beam::set_stem_shorten (Grob *me)
   
   SCM shorten_elt =
     robust_list_ref (beam_count -1, shorten_list);
-  Real shorten_f = gh_scm2double (shorten_elt) * staff_space;
+  Real shorten_f = scm_to_double (shorten_elt) * staff_space;
 
   /* your similar cute comment here */
   shorten_f *= forced_fraction;
 
   if (shorten_f)
-    me->set_grob_property ("shorten", gh_double2scm (shorten_f));
+    me->set_property ("shorten", scm_make_real (shorten_f));
 }
 
 /*  Call list of y-dy-callbacks, that handle setting of
@@ -768,22 +807,32 @@ SCM
 Beam::after_line_breaking (SCM smob)
 {
   Grob *me = unsmob_grob (smob);
-  
+
+  position_beam (me);
+  return SCM_UNSPECIFIED;
+}
+
+void
+Beam::position_beam (Grob *me)
+{
+  if (to_boolean (me->get_property ("positioning-done")))
+    return ;
+
+  me->set_property ("positioning-done", SCM_BOOL_T);
+
   /* Copy to mutable list. */
-  SCM s = ly_deep_copy (me->get_grob_property ("positions"));
-  me->set_grob_property ("positions", s);
+  SCM s = ly_deep_copy (me->get_property ("positions"));
+  me->set_property ("positions", s);
 
   if (ly_car (s) == SCM_BOOL_F)
     {
-
       // one wonders if such genericity is necessary  --hwn.
-      SCM callbacks = me->get_grob_property ("position-callbacks");
-      for (SCM i = callbacks; gh_pair_p (i); i = ly_cdr (i))
-	gh_call1 (ly_car (i), smob);
+      SCM callbacks = me->get_property ("position-callbacks");
+      for (SCM i = callbacks; ly_c_pair_p (i); i = ly_cdr (i))
+	scm_call_1 (ly_car (i), me->self_scm ());
     }
 
   set_stem_lengths (me);  
-  return SCM_UNSPECIFIED;
 }
 
 
@@ -799,9 +848,9 @@ Beam::least_squares (SCM smob)
   int count = visible_stem_count (me);
   Interval pos (0, 0);
   
-  if (count <= 1)
+  if (count < 1)
     {
-      me->set_grob_property ("positions", ly_interval2scm (pos));
+      me->set_property ("positions", ly_interval2scm (pos));
       return SCM_UNSPECIFIED;
     }
 
@@ -832,6 +881,7 @@ Beam::least_squares (SCM smob)
     }
   Real dx = last_visible_stem (me)->relative_coordinate (commonx, X_AXIS) - x0;
 
+  
   Real y =0;  
   Real dydx = 0;
   Real dy = 0;
@@ -852,7 +902,7 @@ Beam::least_squares (SCM smob)
 	{
 	  /* FIXME. -> UP */
 	  Direction d = (Direction) (sign (chord.delta ()) * UP);
-	  pos[d] = gh_scm2double (me->get_grob_property ("thickness")) / 2;
+	  pos[d] = get_thickness (me) / 2;
 	  pos[-d] = - pos[d];
 	}
       else
@@ -860,9 +910,13 @@ Beam::least_squares (SCM smob)
 	  pos = ideal;
 	}
 
-      y = pos[LEFT];
-      dy = pos[RIGHT]- y;
-      dydx = dy/dx;
+      /*
+	For broken beams this doesn't work well. In this case, the
+	slope esp. of the first part of a broken beam should predict
+	where the second part goes.
+      */
+      me->set_property ("least-squares-dy",
+			scm_make_real (pos[RIGHT] - pos[LEFT]));
     }
   else
     {
@@ -870,21 +924,27 @@ Beam::least_squares (SCM smob)
       for (int i=0; i < stems.size (); i++)
 	{
 	  Grob* s = stems[i];
-	  if (Stem::invisible_b (s))
+	  if (Stem::is_invisible (s))
 	    continue;
 	  ideals.push (Offset (x_posns[i],
 			       Stem::get_stem_info (s).ideal_y_
 			       + s->relative_coordinate (commony, Y_AXIS)
 			       - my_y));
 	}
+      
       minimise_least_squares (&dydx, &y, ideals);
 
       dy = dydx * dx;
-      me->set_grob_property ("least-squares-dy", gh_double2scm (dy));
+      me->set_property ("least-squares-dy", scm_make_real (dy));
       pos = Interval (y, (y+dy));
     }
 
-  me->set_grob_property ("positions", ly_interval2scm (pos));
+  /*
+    "position" is relative to the staff.
+   */
+  scale_drul (&pos,  1/ Staff_symbol_referencer::staff_space (me)); 
+  
+  me->set_property ("positions", ly_interval2scm (pos));
  
   return SCM_UNSPECIFIED;
 }
@@ -932,8 +992,11 @@ Beam::shift_region_to_valid (SCM grob)
   
   Real dx = lvs->relative_coordinate (commonx, X_AXIS) - x0;
 
-  Interval pos = ly_scm2interval ( me->get_grob_property ("positions"));
-  Real dy = pos.delta();
+  Drul_array<Real> pos = ly_scm2interval ( me->get_property ("positions"));
+
+  scale_drul (&pos,  Staff_symbol_referencer::staff_space (me));
+  
+  Real dy = pos[RIGHT] - pos[LEFT];
   Real y = pos[LEFT];
   Real dydx =dy/dx;
 
@@ -947,7 +1010,7 @@ Beam::shift_region_to_valid (SCM grob)
   for (int i=0; i < stems.size (); i++)
     {
       Grob* s = stems[i];
-      if (Stem::invisible_b (s))
+      if (Stem::is_invisible (s))
 	continue;
 
       Direction d = Stem::get_direction (s);
@@ -971,11 +1034,9 @@ Beam::shift_region_to_valid (SCM grob)
       feasible_left_point.intersect (flp);
     }
       
-  if (feasible_left_point.empty_b())
-    {
-      warning (_("Not sure that we can find a nice beam slope (no viable initial configuration found)."));
-    }
-  else if (!feasible_left_point.elem_b(y))
+  if (feasible_left_point.is_empty ())
+    warning (_ ("no viable initial configuration found: may not find good beam slope"));
+  else if (!feasible_left_point.contains (y))
     {
       if (isinf (feasible_left_point[DOWN]))
 	y = feasible_left_point[UP] - REGION_SIZE;
@@ -984,12 +1045,14 @@ Beam::shift_region_to_valid (SCM grob)
       else
 	y = feasible_left_point.center ();
     }
-  pos = Interval (y, (y+dy));
-  me->set_grob_property ("positions", ly_interval2scm (pos));
+  
+  pos = Drul_array<Real> (y, (y+dy));
+  scale_drul (&pos, 1/ Staff_symbol_referencer::staff_space (me));
+  
+  me->set_property ("positions", ly_interval2scm (pos));
   return SCM_UNSPECIFIED;
 }
 
-
 MAKE_SCHEME_CALLBACK (Beam, check_concave, 1);
 SCM
 Beam::check_concave (SCM smob)
@@ -999,12 +1062,25 @@ Beam::check_concave (SCM smob)
   Link_array<Grob> stems = 
     Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
 
+  Direction beam_dir = CENTER;
   for (int i = 0; i < stems.size ();)
     {
-      if (Stem::invisible_b (stems[i]))
+      if (Stem::is_invisible (stems[i]))
 	stems.del (i);
       else
-	i++;
+	{
+	  if (Direction sd = Stem::get_direction (stems[i]))
+	    {
+	      /*
+		Don't do knee beams.
+	       */
+	      if (beam_dir && sd && sd != beam_dir)
+		return SCM_UNSPECIFIED;
+	      
+	      beam_dir = sd;
+	    }
+	  i++;
+	}
     }
   
   if (stems.size () < 3)
@@ -1021,13 +1097,11 @@ Beam::check_concave (SCM smob)
      different directions. --hwn
      
   */
-  bool concaveness1 = false;
-  SCM gap = me->get_grob_property ("concaveness-gap");
-  if (gh_number_p (gap)
-      && Stem::get_direction(stems.top ())
-         == Stem::get_direction(stems[0]))
+  bool is_concave1 = false;
+  SCM gap = me->get_property ("concaveness-gap");
+  if (scm_is_number (gap))
     {
-      Real r1 = gh_scm2double (gap);
+      Real r1 = scm_to_double (gap);
       Real dy = Stem::chord_start_y (stems.top ())
 	- Stem::chord_start_y (stems[0]);
 
@@ -1037,10 +1111,11 @@ Beam::check_concave (SCM smob)
       Real y0 = Stem::chord_start_y (stems[0]);
       for (int i = 1; i < stems.size () - 1; i++)
 	{
-	  Real c = (Stem::chord_start_y (stems[i]) - y0) - i * slope;
-	  if (c > r1)
+	  Real c =
+	    beam_dir *((Stem::chord_start_y (stems[i]) - y0) - i * slope);
+	  if (c - r1 > 0)
 	    {
-	      concaveness1 = true;
+	      is_concave1 = true;
 	      break;
 	    }
 	}
@@ -1059,57 +1134,35 @@ Beam::check_concave (SCM smob)
   */
   
   Real concaveness2 = 0;
-  SCM thresh = me->get_grob_property ("concaveness-threshold");
+  SCM thresh = me->get_property ("concaveness-threshold");
   Real r2 = infinity_f;
-  if (!concaveness1 && gh_number_p (thresh)
-      && Stem::get_direction(stems.top ())
-         == Stem::get_direction(stems[0]))
+  if (!is_concave1 && scm_is_number (thresh))
     {
-      r2 = gh_scm2double (thresh);
-
-      Direction dir = Stem::get_direction(stems.top ());
-      Real concave = 0;
-      Interval iv (Stem::chord_start_y (stems[0]),
-		   Stem::chord_start_y (stems.top ()));
+      r2 = scm_to_double (thresh);
       
-      if (iv[MAX] < iv[MIN])
-	iv.swap ();
+      Interval iv;
+      iv.add_point (Stem::chord_start_y (stems[0]));
+      iv.add_point (Stem::chord_start_y (stems.top ()));
       
       for (int i = 1; i < stems.size () - 1; i++)
 	{
 	  Real f = Stem::chord_start_y (stems[i]);
-	  concave += ((f - iv[MAX] ) >? 0) +
-	    ((f - iv[MIN] ) <? 0);
+	  concaveness2 += ( (f - iv[MAX] ) >? 0) +
+	    ( (f - iv[MIN] ) <? 0);
 	}
-      concave *= dir;
-      concaveness2 = concave / (stems.size () - 2);
       
-      /*
-
-      ugh: this is the a kludge to get
-      input/regression/beam-concave.ly to behave as
-      baerenreiter.
-
-      */
-
-      /*
-	huh? we're dividing twice (which is not scalable) meaning that
-	the longer the beam, the more unlikely it will be
-	concave. Maybe you would even expect the other way around??
-
-	--hwn.
-	
-       */
-      concaveness2 /= (stems.size () - 2);
+      concaveness2 *= beam_dir / (stems.size () - 2);
     }
   
   /* TODO: some sort of damping iso -> plain horizontal */
-  if (concaveness1 || concaveness2 > r2)
+  if (is_concave1 || concaveness2 > r2)
     {
-      Interval pos = ly_scm2interval (me->get_grob_property ("positions"));
-      Real r = pos.linear_combination (0);
-      me->set_grob_property ("positions", ly_interval2scm (Interval (r, r)));
-      me->set_grob_property ("least-squares-dy", gh_double2scm (0));
+      Drul_array<Real> pos = ly_scm2interval (me->get_property ("positions"));
+      Real r = linear_combination (pos, 0.0);
+
+      r /= Staff_symbol_referencer::staff_space (me);
+      me->set_property ("positions", ly_interval2scm (Drul_array<Real> (r, r)));
+      me->set_property ("least-squares-dy", scm_make_real (0));
     }
 
   return SCM_UNSPECIFIED;
@@ -1127,13 +1180,15 @@ Beam::slope_damping (SCM smob)
   if (visible_stem_count (me) <= 1)
     return SCM_UNSPECIFIED;
 
-  SCM s = me->get_grob_property ("damping"); 
-  int damping = gh_scm2int (s);
+  SCM s = me->get_property ("damping"); 
+  int damping = scm_to_int (s);
 
   if (damping)
     {
-      Interval pos = ly_scm2interval (me->get_grob_property ("positions"));
-      Real dy = pos.delta ();
+      Drul_array<Real>  pos = ly_scm2interval (me->get_property ("positions"));
+      scale_drul (&pos,  Staff_symbol_referencer::staff_space (me));
+      
+      Real dy = pos[RIGHT] - pos[LEFT];
 
       Grob *fvs  = first_visible_stem (me);
       Grob *lvs  = last_visible_stem (me);
@@ -1149,8 +1204,10 @@ Beam::slope_damping (SCM smob)
       Real damped_dy = dydx * dx;
       pos[LEFT] += (dy - damped_dy) / 2;
       pos[RIGHT] -= (dy - damped_dy) / 2;
+
+      scale_drul (&pos, 1/Staff_symbol_referencer::staff_space (me));
       
-      me->set_grob_property ("positions", ly_interval2scm (pos));
+      me->set_property ("positions", ly_interval2scm (pos));
     }
   return SCM_UNSPECIFIED;
 }
@@ -1160,15 +1217,15 @@ Beam::slope_damping (SCM smob)
   and (cdr BEAMING)
  */
 Slice
-where_are_the_whole_beams(SCM beaming)
+where_are_the_whole_beams (SCM beaming)
 {
   Slice l; 
   
-  for( SCM s = gh_car (beaming); gh_pair_p (s) ; s = gh_cdr (s))
+  for ( SCM s = ly_car (beaming); ly_c_pair_p (s) ; s = ly_cdr (s))
     {
-      if (scm_memq (gh_car (s), gh_cdr (beaming)) != SCM_BOOL_F)
+      if (scm_c_memq (ly_car (s), ly_cdr (beaming)) != SCM_BOOL_F)
 	
-	l.add_point (gh_scm2int (gh_car (s)));
+	l.add_point (scm_to_int (ly_car (s)));
     }
 
   return l;
@@ -1179,33 +1236,33 @@ where_are_the_whole_beams(SCM beaming)
 Real
 Beam::calc_stem_y (Grob *me, Grob* s, Grob ** common,
 		   Real xl, Real xr,
-		   Interval pos, bool french) 
+		   Drul_array<Real> pos, bool french) 
 {
   Real beam_translation = get_beam_translation (me);
 
     
   Real r = s->relative_coordinate (common[X_AXIS], X_AXIS) - xl;
-  Real dy = pos.delta ();
+  Real dy = pos[RIGHT] - pos[LEFT];
   Real dx = xr - xl;
   Real stem_y_beam0 = (dy && dx
 		       ? r / dx
 		       * dy
 		       : 0) + pos[LEFT];
   
-  Direction my_dir = Directional_element_interface::get (s);
-  SCM beaming = s->get_grob_property ("beaming");
+  Direction my_dir = get_grob_direction (s);
+  SCM beaming = s->get_property ("beaming");
  
   Real stem_y = stem_y_beam0;
   if (french)
     {
       Slice bm = where_are_the_whole_beams (beaming);
-      if (!bm.empty_b())
+      if (!bm.is_empty ())
 	stem_y += beam_translation * bm[-my_dir];
     }
   else
     {
-      Slice bm = Stem::beam_multiplicity(s);
-      if (!bm.empty_b())
+      Slice bm = Stem::beam_multiplicity (s);
+      if (!bm.is_empty ())
 	stem_y +=bm[my_dir] * beam_translation;
     }
   
@@ -1225,24 +1282,25 @@ Beam::set_stem_lengths (Grob *me)
   Link_array<Grob> stems=
     Pointer_group_interface__extract_grobs (me, (Grob*)0, "stems");
 
-  if (stems.size () <= 1)
+  if (!stems.size ())
     return;
   
   Grob *common[2];
   for (int a = 2; a--;)
-    common[a] = common_refpoint_of_array (stems, me, Axis(a));
+    common[a] = common_refpoint_of_array (stems, me, Axis (a));
   
-  Interval pos = ly_scm2interval (me->get_grob_property ("positions"));
+  Drul_array<Real> pos = ly_scm2realdrul (me->get_property ("positions"));
   Real staff_space = Staff_symbol_referencer::staff_space (me);
+  scale_drul (&pos,  staff_space);
 
   bool gap = false;
   Real thick =0.0;
-  if (gh_number_p (me->get_grob_property ("gap"))
-      &&gh_scm2double (me->get_grob_property ("gap")))
-  {
-    gap = true;
-    thick = get_thickness(me);
-  }
+  if (scm_is_number (me->get_property ("gap-count"))
+      &&scm_to_int (me->get_property ("gap-count")))
+    {
+      gap = true;
+      thick = get_thickness (me);
+    }
       
   // ugh -> use commonx
   Grob * fvs = first_visible_stem (me);
@@ -1254,22 +1312,21 @@ Beam::set_stem_lengths (Grob *me)
   for (int i=0; i < stems.size (); i++)
     {
       Grob* s = stems[i];
-      if (Stem::invisible_b (s))
+      if (Stem::is_invisible (s))
 	continue;
 
-      
-      bool french = to_boolean (s->get_grob_property ("french-beaming"));
+      bool french = to_boolean (s->get_property ("french-beaming"));
       Real stem_y = calc_stem_y (me, s, common,
 				 xl, xr,
-				 pos, french && i > 0&& (i < stems.size  () -1));
+				 pos, french && s != lvs && s!= fvs);
 
       /*
 	Make the stems go up to the end of the beam. This doesn't matter
 	for normal beams, but for tremolo beams it looks silly otherwise.
        */
       if (gap)
-	stem_y += thick * 0.5 * Directional_element_interface::get(s);
-      
+	stem_y += thick * 0.5 * get_grob_direction (s);
+
       Stem::set_stemend (s, 2* stem_y / staff_space);
     }
 }
@@ -1290,20 +1347,20 @@ Beam::set_beaming (Grob *me, Beaming_info_list *beaming)
       do
 	{
 	  /* Don't set beaming for outside of outer stems */	  
-	  if ((d == LEFT && i == 0)
-	      ||(d == RIGHT && i == stems.size () -1))
+	  if ( (d == LEFT && i == 0)
+	      || (d == RIGHT && i == stems.size () -1))
 	    continue;
 
 	  Grob *st =  stems[i];
-	  SCM beaming_prop = st->get_grob_property ("beaming");
+	  SCM beaming_prop = st->get_property ("beaming");
 	  if (beaming_prop == SCM_EOL ||
 	      index_get_cell (beaming_prop, d) == SCM_EOL)
 	    {
 	      int b = beaming->infos_.elem (i).beams_i_drul_[d];
 	      if (i>0
-		  && i < stems.size() -1
-		  && Stem::invisible_b (st))
-		b = b <? beaming->infos_.elem(i).beams_i_drul_[-d];
+		  && i < stems.size () -1
+		  && Stem::is_invisible (st))
+		b = b <? beaming->infos_.elem (i).beams_i_drul_[-d];
 	      
 	      Stem::set_beaming (st, b, d);
 	    }
@@ -1322,7 +1379,7 @@ Beam::forced_stem_count (Grob *me)
     {
       Grob *s = stems[i];
 
-      if (Stem::invisible_b (s))
+      if (Stem::is_invisible (s))
 	continue;
 
       /* I can imagine counting those boundaries as a half forced stem,
@@ -1345,7 +1402,7 @@ Beam::visible_stem_count (Grob *me)
   int c = 0;
   for (int i = stems.size (); i--;)
     {
-      if (!Stem::invisible_b (stems[i]))
+      if (!Stem::is_invisible (stems[i]))
         c++;
     }
   return c;
@@ -1359,7 +1416,7 @@ Beam::first_visible_stem (Grob *me)
   
   for (int i = 0; i < stems.size (); i++)
     {
-      if (!Stem::invisible_b (stems[i]))
+      if (!Stem::is_invisible (stems[i]))
         return stems[i];
     }
   return 0;
@@ -1372,7 +1429,7 @@ Beam::last_visible_stem (Grob *me)
     Pointer_group_interface__extract_grobs (me, (Grob*) 0, "stems");
   for (int i = stems.size (); i--;)
     {
-      if (!Stem::invisible_b (stems[i]))
+      if (!Stem::is_invisible (stems[i]))
         return stems[i];
     }
   return 0;
@@ -1394,88 +1451,86 @@ SCM
 Beam::rest_collision_callback (SCM element_smob, SCM axis)
 {
   Grob *rest = unsmob_grob (element_smob);
-  Axis a = (Axis) gh_scm2int (axis);
+  Axis a = (Axis) scm_to_int (axis);
+
+  if (scm_is_number (rest->get_property ("staff-position")))
+    return scm_int2num (0);
   
   assert (a == Y_AXIS);
 
-  Grob *st = unsmob_grob (rest->get_grob_property ("stem"));
+  Grob *st = unsmob_grob (rest->get_property ("stem"));
   Grob *stem = st;
   if (!stem)
-    return gh_double2scm (0.0);
-  Grob *beam = unsmob_grob (stem->get_grob_property ("beam"));
+    return scm_make_real (0.0);
+  Grob *beam = unsmob_grob (stem->get_property ("beam"));
   if (!beam
       || !Beam::has_interface (beam)
       || !Beam::visible_stem_count (beam))
-    return gh_double2scm (0.0);
+    return scm_make_real (0.0);
 
-  Interval pos (0, 0);
-  SCM s = beam->get_grob_property ("positions");
-  if (gh_pair_p (s) && gh_number_p (ly_car (s)))
+  Drul_array<Real> pos (0, 0);
+  SCM s = beam->get_property ("positions");
+  if (ly_c_pair_p (s) && scm_is_number (ly_car (s)))
     pos = ly_scm2interval (s);
+  Real staff_space = Staff_symbol_referencer::staff_space (rest);
+
+  scale_drul (&pos, staff_space);
+  
 
-  Real dy = pos.delta ();
+  Real dy = pos[RIGHT] - pos[LEFT];
+  
   // ugh -> use commonx
   Real x0 = first_visible_stem (beam)->relative_coordinate (0, X_AXIS);
   Real dx = last_visible_stem (beam)->relative_coordinate (0, X_AXIS) - x0;
   Real dydx = dy && dx ? dy/dx : 0;
   
   Direction d = Stem::get_direction (stem);
-  Real stem_y = (pos[LEFT]
-		 + (stem->relative_coordinate (0, X_AXIS) - x0) * dydx)
-    * d;
+  Real stem_y = pos[LEFT] + (stem->relative_coordinate (0, X_AXIS) - x0) * dydx;
   
   Real beam_translation = get_beam_translation (beam);
-  Real beam_thickness = gh_scm2double (beam->get_grob_property ("thickness"));
+  Real beam_thickness = Beam::get_thickness (beam);
+  
   int beam_count = get_direction_beam_count (beam, d);
-  Real height_of_my_beams = beam_thickness
+  Real height_of_my_beams = beam_thickness / 2
     + (beam_count - 1) * beam_translation;
-  Real beam_y = stem_y - height_of_my_beams + beam_thickness / 2.0;
+  Real beam_y = stem_y - d * height_of_my_beams;
 
-  Real staff_space = Staff_symbol_referencer::staff_space (rest);
+  Grob *common_y = rest->common_refpoint (beam, Y_AXIS);
 
-  /* Better calculate relative-distance directly, rather than using
-     rest_dim? */
-  Grob *common_x = rest->common_refpoint (beam, Y_AXIS);
-  Real rest_dim = rest->extent (common_x, Y_AXIS)[d] / staff_space * d;
+  Real rest_dim = rest->extent (common_y, Y_AXIS)[d];
+  Real minimum_distance =
+    staff_space * robust_scm2double (rest->get_property ("minimum-distance"), 0.0);
 
-  Real minimum_distance = gh_scm2double
-    (rest->get_grob_property ("minimum-beam-collision-distance"));
+  Real shift = d * ( ((beam_y - d * minimum_distance) - rest_dim) * d  <? 0.0);
 
-  Real distance = beam_y - rest_dim;
-  Real shift = 0;
-  if (distance < 0)
-    shift = minimum_distance - distance;
-  else if (minimum_distance > distance)
-    shift = minimum_distance - distance;
-      
-  int stafflines = Staff_symbol_referencer::line_count (rest);
+  shift /= staff_space;
+  Real rad = Staff_symbol_referencer::line_count (rest) * staff_space / 2;
 
   /* Always move discretely by half spaces */
-  Real discrete_shift = ceil (shift * 2.0) / 2.0;
+  shift = ceil (fabs (shift * 2.0)) / 2.0 * sign (shift);
 
   /* Inside staff, move by whole spaces*/
-  if ((rest->extent (common_x, Y_AXIS)[d] + discrete_shift) * d
-      < stafflines / 2.0
-      ||(rest->extent (common_x, Y_AXIS)[-d] + discrete_shift) * -d
-      < stafflines / 2.0)
-    discrete_shift = ceil (discrete_shift);
+  if ( (rest->extent (common_y, Y_AXIS)[d] + staff_space * shift) * d
+      < rad
+      || (rest->extent (common_y, Y_AXIS)[-d] + staff_space * shift) * -d
+      < rad)
+    shift = ceil (fabs (shift)) *sign (shift);
 
-  return gh_double2scm (-d * discrete_shift);
+  return scm_make_real (staff_space * shift);
 }
 
 bool
-Beam::knee_b (Grob* me)
+Beam::is_knee (Grob* me)
 {
-  SCM k = me->get_grob_property ("knee");
-  if (gh_boolean_p (k))
-    return gh_scm2bool (k);
+  SCM k = me->get_property ("knee");
+  if (scm_is_bool (k))
+    return ly_scm2bool (k);
 
   bool knee = false;
   int d = 0;
-  for (SCM s = me->get_grob_property ("stems"); gh_pair_p (s); s = ly_cdr (s))
+  for (SCM s = me->get_property ("stems"); ly_c_pair_p (s); s = ly_cdr (s))
     {
-      Direction dir = Directional_element_interface::get
-	(unsmob_grob (ly_car (s)));
+      Direction dir = get_grob_direction (unsmob_grob (ly_car (s)));
       if (d && d != dir)
 	{
 	  knee = true;
@@ -1484,7 +1539,7 @@ Beam::knee_b (Grob* me)
       d = dir;
     }
   
-  me->set_grob_property ("knee", gh_bool2scm (knee));
+  me->set_property ("knee", ly_bool2scm (knee));
 
   return knee;
 }
@@ -1510,22 +1565,14 @@ Beam::get_direction_beam_count (Grob *me, Direction d )
 
 
 ADD_INTERFACE (Beam, "beam-interface",
-  "A beam. \n\n"
-" "
-"#'thickness= weight of beams, in staffspace "
-" "
-" "
-"We take the least squares line through the ideal-length stems, and "
-"then damp that using "
-" \n"
-"	damped = tanh (slope) \n"
-" \n"
-"this gives an unquantized left and right position for the beam end. "
-"Then we take all combinations of quantings near these left and right "
-"positions, and give them a score (according to how close they are to "
-"the ideal slope, how close the result is to the ideal stems, etc.). We "
-"take the best scoring combination. "
-,
-  "knee position-callbacks concaveness-gap concaveness-threshold dir-function quant-score auto-knee-gap gap chord-tremolo beamed-stem-shorten shorten least-squares-dy damping flag-width-function neutral-direction positions space-function thickness");
+	       "A beam. \n\n"
+	       "The @code{thickness} property is the weight of beams, and is measured "
+	       "in  staffspace"
+	       ,
+	       "knee positioning-done position-callbacks concaveness-gap "
+	       "concaveness-threshold dir-function quant-score auto-knee-gap gap "
+	       "gap-count chord-tremolo beamed-stem-shorten shorten least-squares-dy "
+	       "damping inspect-quants flag-width-function neutral-direction positions space-function "
+	       "thickness");