]> git.donarmstrong.com Git - lilypond.git/blobdiff - lily/side-position-interface.cc
lilypond-manuals.css: edit color scheme and some spacing
[lilypond.git] / lily / side-position-interface.cc
index b515aa3d5277835828b339b8252ed88e3c829de9..52551e8b5286452342d4eae53dbc1f9396efef36 100644 (file)
@@ -1,7 +1,7 @@
 /*
   This file is part of LilyPond, the GNU music typesetter.
 
-  Copyright (C) 1998--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
+  Copyright (C) 1998--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
   LilyPond is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -32,6 +32,8 @@ using namespace std;
 #include "directional-element-interface.hh"
 #include "grob.hh"
 #include "grob-array.hh"
+#include "international.hh"
+#include "item.hh"
 #include "main.hh"
 #include "misc.hh"
 #include "note-head.hh"
@@ -44,6 +46,7 @@ using namespace std;
 #include "string-convert.hh"
 #include "system.hh"
 #include "warn.hh"
+#include "unpure-pure-container.hh"
 
 void
 Side_position_interface::add_support (Grob *me, Grob *e)
@@ -51,37 +54,6 @@ Side_position_interface::add_support (Grob *me, Grob *e)
   Pointer_group_interface::add_unordered_grob (me, ly_symbol2scm ("side-support-elements"), e);
 }
 
-SCM
-finish_offset (Grob *me, Direction dir, Real total_off, Real *current_offset)
-{
-  Real ss = Staff_symbol_referencer::staff_space (me);
-  Real minimum_space = ss * robust_scm2double (me->get_property ("minimum-space"), -1);
-  total_off += dir * ss * robust_scm2double (me->get_property ("padding"), 0);
-
-  if (minimum_space >= 0
-      && dir
-      && total_off * dir < minimum_space)
-    total_off = minimum_space * dir;
-
-  if (current_offset)
-    total_off = dir * max (dir * total_off,
-                           dir * (*current_offset));
-
-  /* FIXME: 1000 should relate to paper size.  */
-  if (fabs (total_off) > 1000)
-    {
-      string msg
-        = String_convert::form_string ("Improbable offset for grob %s: %f",
-                                       me->name ().c_str (), total_off);
-
-      programming_error (msg);
-      if (strict_infinity_checking)
-        scm_misc_error (__FUNCTION__, "Improbable offset.", SCM_EOL);
-    }
-
-  return scm_from_double (total_off);
-}
-
 set<Grob *>
 get_support_set (Grob *me)
 {
@@ -93,14 +65,14 @@ get_support_set (Grob *me)
 
   for (vsize i = 0; i < proto_support.size (); i++)
     {
-      if (Accidental_placement::has_interface (proto_support[i]))
+      if (has_interface<Accidental_placement> (proto_support[i]))
         {
           Grob *accs = proto_support[i];
           for (SCM acs = accs->get_object ("accidental-grobs"); scm_is_pair (acs);
                acs = scm_cdr (acs))
             for (SCM s = scm_cdar (acs); scm_is_pair (s); s = scm_cdr (s))
               {
-                Grob *a = unsmob_grob (scm_car (s));
+                Grob *a = unsmob<Grob> (scm_car (s));
                 support.insert (a);
               }
         }
@@ -110,349 +82,318 @@ get_support_set (Grob *me)
   return support;
 }
 
-/* Put the element next to the support, optionally taking in
-   account the extent of the support.
-
-   Does not take into account the extent of ME.
+/*
+  Position next to support, taking into account my own dimensions and padding.
 */
 SCM
-Side_position_interface::general_side_position (Grob *me, Axis a, bool use_extents,
-                                                bool include_my_extent,
-                                                bool pure, int start, int end,
-                                                Real *current_offset)
+axis_aligned_side_helper (SCM smob, Axis a, bool pure, int start, int end, SCM current_off_scm)
 {
-  set<Grob *> support = get_support_set (me);
-
-  Grob *common = common_refpoint_of_array (support, me->get_parent (a), a);
-  Grob *staff_symbol = Staff_symbol_referencer::get_staff_symbol (me);
-  bool include_staff
-    = staff_symbol
-      && a == Y_AXIS
-      && scm_is_number (me->get_property ("staff-padding"))
-      && !to_boolean (me->get_property ("quantize-position"));
-
-  Interval dim;
-  Interval staff_extents;
-  if (include_staff)
+  Real r;
+  Real *current_off_ptr = 0;
+  if (scm_is_number (current_off_scm))
     {
-      common = staff_symbol->common_refpoint (common, Y_AXIS);
-      staff_extents = staff_symbol->maybe_pure_extent (common, Y_AXIS, pure, start, end);
-
-      if (include_staff)
-        dim.unite (staff_extents);
+      r = scm_to_double (current_off_scm);
+      current_off_ptr = &r;
     }
 
-  Direction dir = get_grob_direction (me);
+  Grob *me = unsmob<Grob> (smob);
+  // We will only ever want widths of spanners after line breaking
+  // so we can set pure to false
+  if (dynamic_cast<Spanner *> (me) && a == X_AXIS)
+    pure = false;
 
-  set<Grob *>::iterator it;
+  return Side_position_interface::aligned_side (me, a, pure, start, end, current_off_ptr);
+}
 
-  for (it = support.begin (); it != support.end (); it++)
-    {
-      Grob *e = *it;
+MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Side_position_interface, x_aligned_side, 2, 1, "");
+SCM
+Side_position_interface::x_aligned_side (SCM smob, SCM current_off)
+{
+  // Because horizontal skylines need vertical heights, we'd trigger
+  // unpure calculations too soon if this were called before line breaking.
+  // So, we always use pure heights.  Given that horizontal skylines are
+  // almost always used before line breaking anyway, this doesn't cause
+  // problems.
+  return axis_aligned_side_helper (smob, X_AXIS, true, 0, 0, current_off);
+}
 
-      // In the case of a stem, we will find a note head as well
-      // ignoring the stem solves cyclic dependencies if the stem is
-      // attached to a cross-staff beam.
-      if (a == Y_AXIS
-          && Stem::has_interface (e)
-          && dir == - get_grob_direction (e))
-        continue;
+MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Side_position_interface, y_aligned_side, 2, 1, "");
+SCM
+Side_position_interface::y_aligned_side (SCM smob, SCM current_off)
+{
+  return axis_aligned_side_helper (smob, Y_AXIS, false, 0, 0, current_off);
+}
 
-      if (e)
-        {
-          if (use_extents)
-            dim.unite (e->maybe_pure_extent (common, a, pure, start, end));
-          else
-            {
-              Real x = e->maybe_pure_coordinate (common, a, pure, start, end);
-              dim.unite (Interval (x, x));
-            }
-        }
-    }
+MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Side_position_interface, pure_y_aligned_side, 4, 1, "");
+SCM
+Side_position_interface::pure_y_aligned_side (SCM smob, SCM start, SCM end, SCM cur_off)
+{
+  return axis_aligned_side_helper (smob, Y_AXIS, true,
+                                   scm_to_int (start),
+                                   scm_to_int (end),
+                                   cur_off);
+}
 
-  if (dim.is_empty ())
-    dim = Interval (0, 0);
+MAKE_SCHEME_CALLBACK (Side_position_interface, calc_cross_staff, 1)
+SCM
+Side_position_interface::calc_cross_staff (SCM smob)
+{
+  Grob *me = unsmob<Grob> (smob);
+  extract_grob_set (me, "side-support-elements", elts);
 
-  Real off = me->get_parent (a)->maybe_pure_coordinate (common, a, pure, start, end);
+  Direction my_dir = get_grob_direction (me) ;
 
-  Real total_off = dim.linear_combination (dir) - off;
-  if (include_my_extent)
+  for (vsize i = 0; i < elts.size (); i++)
     {
-      Interval iv = me->maybe_pure_extent (me, a, pure, start, end);
-      if (!iv.is_empty ())
-        {
-          if (!dir)
-            {
-              programming_error ("direction unknown, but aligned-side wanted");
-              dir = DOWN;
-            }
-          total_off += -iv[-dir];
-        }
+      /*
+        If 'me' is placed relative to any cross-staff element with a
+        'direction callback defined, the placement of 'me' is likely
+        to depend on staff-spacing, thus 'me' should be considered
+        cross-staff.
+      */
+      if (to_boolean (elts[i]->get_property ("cross-staff"))
+           && !is_direction (elts[i]->get_property_data ("direction")))
+        return SCM_BOOL_T;
+
+      /*
+        If elts[i] is cross-staff and is pointing in the same
+        direction as 'me', we assume that the alignment
+        of 'me' is influenced the cross-staffitude of elts[i]
+        and thus we mark 'me' as cross-staff.
+      */
+      if (to_boolean (elts[i]->get_property ("cross-staff"))
+           && my_dir == get_grob_direction (elts[i]))
+        return SCM_BOOL_T;
     }
 
-  return finish_offset (me, dir, total_off, current_offset);
+  Grob *myvag = Grob::get_vertical_axis_group (me);
+  for (vsize i = 0; i < elts.size (); i++)
+    if (myvag != Grob::get_vertical_axis_group (elts[i]))
+      return SCM_BOOL_T;
+
+  return SCM_BOOL_F;
 }
 
+// long function - each stage is clearly marked
+
 SCM
-Side_position_interface::skyline_side_position (Grob *me, Axis a,
-                                                bool pure, int start, int end,
-                                                Real *current_offset)
+Side_position_interface::aligned_side (Grob *me, Axis a, bool pure, int start, int end,
+                                       Real *current_off)
 {
+  Direction dir = get_grob_direction (me);
+
   set<Grob *> support = get_support_set (me);
 
   Grob *common[2];
   for (Axis ax = X_AXIS; ax < NO_AXES; incr (ax))
-    common[ax] = common_refpoint_of_array (support, ax == a ? me->get_parent (ax) : me, ax);
+    common[ax] = common_refpoint_of_array (support,
+                                           (ax == a
+                                           ? me->get_parent (ax)
+                                           : me),
+                                           ax);
 
   Grob *staff_symbol = Staff_symbol_referencer::get_staff_symbol (me);
-  Direction dir = get_grob_direction (me);
+  bool quantize_position = to_boolean (me->get_maybe_pure_property ("quantize-position", pure, start, end));
+  bool me_cross_staff = to_boolean (me->get_property ("cross-staff"));
+
+  bool include_staff
+    = staff_symbol
+      && a == Y_AXIS
+      && scm_is_number (me->get_maybe_pure_property ("staff-padding", pure, start, end))
+      && !quantize_position;
+
+  if (include_staff)
+    common[Y_AXIS] = staff_symbol->common_refpoint (common[Y_AXIS], Y_AXIS);
 
   Skyline my_dim;
-  Skyline_pair *sp = Skyline_pair::unsmob (me->get_property ("vertical-skylines"));
-  if (sp && a == Y_AXIS && !pure)
+  SCM skyp = me->get_maybe_pure_property (a == X_AXIS
+                                          ? "horizontal-skylines"
+                                          : "vertical-skylines",
+                                          pure,
+                                          start,
+                                          end);
+  if (unsmob<Skyline_pair> (skyp))
     {
-      Skyline_pair copy = Skyline_pair (*sp);
-      copy.shift (me->relative_coordinate (common[X_AXIS], X_AXIS));
-      copy.raise (me->get_parent (Y_AXIS)->relative_coordinate (common[Y_AXIS], Y_AXIS));
+      // for spanner pure heights, we don't know horizontal spacing,
+      // so a spanner can never have a meaningful x coordiante
+      // we just give it the parents' coordinate because its
+      // skyline will likely be of infinite width anyway
+      // and we don't want to prematurely trigger H spacing
+      Real xc = a == X_AXIS || (pure && dynamic_cast<Spanner *> (me))
+                ? me->parent_relative (common[X_AXIS], X_AXIS)
+                : me->relative_coordinate (common[X_AXIS], X_AXIS);
+      // same here, for X_AXIS spacing, if it's happening, it should only be
+      // before line breaking.  because there is no thing as "pure" x spacing,
+      // we assume that it is all pure
+      Real yc = a == X_AXIS
+                ? me->pure_relative_y_coordinate (common[Y_AXIS], start, end)
+                : me->get_parent (Y_AXIS)->maybe_pure_coordinate (common[Y_AXIS], Y_AXIS, pure, start, end);
+      Skyline_pair copy = *unsmob<Skyline_pair> (skyp);
+      copy.shift (a == X_AXIS ? yc : xc);
+      copy.raise (a == X_AXIS ? xc : yc);
       my_dim = copy[-dir];
     }
   else
-    {
-      Box off;
-      for (Axis ax = X_AXIS; ax < NO_AXES; incr (ax))
-        {
-          if (ax == a)
-            off[ax] = me->get_parent (ax)->maybe_pure_coordinate (common[ax], ax, pure, start, end)
-                      + me->maybe_pure_extent (me, ax, pure, start, end);
-          else
-            off[ax] = me->maybe_pure_extent (common[ax], ax, pure, start, end);
-        }
+    me->warning ("cannot find skylines - strange alignment will follow");
 
-      if (off[X_AXIS].is_empty () || off[Y_AXIS].is_empty ())
-        return scm_from_double (0.0);
-
-      my_dim = Skyline (off, other_axis (a), -dir);
-    }
-  bool include_staff
-    = staff_symbol
-      && a == Y_AXIS
-      && scm_is_number (me->get_property ("staff-padding"))
-      && !to_boolean (me->get_property ("quantize-position"));
 
   vector<Box> boxes;
   vector<Skyline_pair> skyps;
-  Real min_h = dir == LEFT ? infinity_f : -infinity_f;
   set<Grob *>::iterator it;
 
-  map<Grob *, vector<Grob *> > note_column_map; // for parts of a note column
   for (it = support.begin (); it != support.end (); it++)
     {
       Grob *e = *it;
 
-      // In the case of a stem, we will find a note head as well
-      // ignoring the stem solves cyclic dependencies if the stem is
-      // attached to a cross-staff beam.
+      bool cross_staff = to_boolean (e->get_property ("cross-staff"));
       if (a == Y_AXIS
-          && Stem::has_interface (e)
-          && dir == - get_grob_direction (e))
-        continue;
+          && !me_cross_staff // 'me' promised not to adapt to staff-spacing
+          && cross_staff) // but 'e' might move based on staff-pacing
+        continue; // so 'me' may not move in response to 'e'
 
-      if (e)
+      if (a == Y_AXIS
+          && has_interface<Stem> (e))
         {
-           if (Note_column::has_interface (e->get_parent (X_AXIS))
-               && to_boolean (me->get_property ("add-stem-support")))
-             {
-               note_column_map[e->get_parent (X_AXIS)].push_back (e);
-               continue;
-             }
+          // If called as 'pure' we may not force a stem to set its direction,
+          if (pure && !is_direction (e->get_property_data ("direction")))
+            continue;
+          // There is no need to consider stems pointing away.
+          if (dir == -get_grob_direction (e))
+            continue;
+        }
 
-           Skyline_pair *sp = Skyline_pair::unsmob (e->get_property ("vertical-skylines"));
-           if (sp && a == Y_AXIS && !pure)
+      if (e)
+        {
+           SCM sp = e->get_maybe_pure_property (a == X_AXIS
+                                                ? "horizontal-skylines"
+                                                : "vertical-skylines",
+                                                pure,
+                                                start,
+                                                end);
+
+           if (unsmob<Skyline_pair> (sp))
              {
-               Skyline_pair copy = Skyline_pair (*sp);
-               copy.shift (e->relative_coordinate (common[X_AXIS], X_AXIS));
-               copy.raise (e->relative_coordinate (common[Y_AXIS], Y_AXIS));
+               Real xc = pure && dynamic_cast<Spanner *> (e)
+                         ? e->parent_relative (common[X_AXIS], X_AXIS)
+                         : e->relative_coordinate (common[X_AXIS], X_AXIS);
+               // same logic as above
+               // we assume horizontal spacing is always pure
+               Real yc = a == X_AXIS
+                         ? e->pure_relative_y_coordinate (common[Y_AXIS], start, end)
+                         : e->maybe_pure_coordinate (common[Y_AXIS], Y_AXIS, pure, start, end);
+               Skyline_pair copy = *unsmob<Skyline_pair> (sp);
+               if (a == Y_AXIS
+                   && has_interface<Stem> (e)
+                   && to_boolean (me->get_maybe_pure_property ("add-stem-support", pure, start, end)))
+                 copy[dir].set_minimum_height (copy[dir].max_height ());
+               copy.shift (a == X_AXIS ? yc : xc);
+               copy.raise (a == X_AXIS ? xc : yc);
                skyps.push_back (copy);
-               continue;
              }
-           Box b;
-           for (Axis ax = X_AXIS; ax < NO_AXES; incr (ax))
-             b[ax] = e->maybe_pure_extent (common[ax], ax, pure, start, end);
-
-           if (b[X_AXIS].is_empty () || b[Y_AXIS].is_empty ())
-             continue;
-
-           boxes.push_back (b);
-           min_h = minmax (dir, b[a][-dir], min_h);
+           else { /* no warning*/ }
         }
     }
 
-  // this loop ensures that parts of a note column will be in the same box
-  // pushes scripts and such over stems instead of just over heads
-  for (map<Grob *, vector<Grob *> >::iterator i = note_column_map.begin (); i != note_column_map.end (); i++)
-    {
-      Box big;
-      for (vsize j = 0; j < (*i).second.size (); j++)
-        {
-          Grob *e = (*i).second[j];
-          Box b;
-          for (Axis ax = X_AXIS; ax < NO_AXES; incr (ax))
-            b[ax] = e->maybe_pure_extent (common[ax], ax, pure, start, end);
-
-          if (b[X_AXIS].is_empty () || b[Y_AXIS].is_empty ())
-            continue;
-
-          big.unite (b);
-        }
-      if (!big[X_AXIS].is_empty () && !big[Y_AXIS].is_empty ())
-        boxes.push_back (big);
-    }
-
   Skyline dim (boxes, other_axis (a), dir);
   if (skyps.size ())
     {
       Skyline_pair merged (skyps);
       dim.merge (merged[dir]);
     }
-  if (!boxes.size ())
-    dim.set_minimum_height (0.0);
-  else
-    dim.set_minimum_height (min_h);
 
   if (include_staff)
     {
       Interval staff_extents;
       common[Y_AXIS] = staff_symbol->common_refpoint (common[Y_AXIS], Y_AXIS);
       staff_extents = staff_symbol->maybe_pure_extent (common[Y_AXIS], Y_AXIS, pure, start, end);
-      dim.set_minimum_height (minmax (dir, min_h, staff_extents[dir]));
+      dim.set_minimum_height (staff_extents[dir]);
     }
 
-  Real dist = dim.distance (my_dim, 0.1); // 0.1 m4g1c value...fix...
-  Real total_off = !isinf (dist) ? dir * dist : 0.0;
-
-  return finish_offset (me, dir, total_off, current_offset);
-}
-
-MAKE_SCHEME_CALLBACK (Side_position_interface, y_aligned_on_support_refpoints, 1);
-SCM
-Side_position_interface::y_aligned_on_support_refpoints (SCM smob)
-{
-  return general_side_position (unsmob_grob (smob), Y_AXIS, false, false, false, 0, 0, 0);
-}
-
-MAKE_SCHEME_CALLBACK (Side_position_interface, pure_y_aligned_on_support_refpoints, 3);
-SCM
-Side_position_interface::pure_y_aligned_on_support_refpoints (SCM smob, SCM start, SCM end)
-{
-  return general_side_position (unsmob_grob (smob), Y_AXIS, false, false,
-                                true, scm_to_int (start), scm_to_int (end), 0);
-}
-
-/*
-  Position next to support, taking into account my own dimensions and padding.
-*/
-SCM
-axis_aligned_side_helper (SCM smob, Axis a, bool pure, int start, int end, SCM current_off_scm)
-{
-  Real r;
-  Real *current_off_ptr = 0;
-  if (scm_is_number (current_off_scm))
+  // Sometimes, we want to side position for grobs but they
+  // don't position against anything.  Some cases where this is true:
+  //   - StanzaNumber if the supporting lyrics are hara-kiri'd
+  //     SystemStartBracket
+  //     InstrumentName
+  // In all these cases, we set the height of the support to 0.
+  // This becomes then like the self-alignment-interface with the
+  // caveat that there is padding added.
+  // TODO: if there is a grob that never has side-support-elements
+  // (like InstrumentName), why are we using this function? Isn't it
+  // overkill? A function like self-alignment-interface with padding
+  // works just fine.
+  // One could even imagine the two interfaces merged, as the only
+  // difference is that in self-alignment-interface we align on the parent
+  // where as here we align on a group of grobs.
+  if (dim.is_empty ())
     {
-      r = scm_to_double (current_off_scm);
-      current_off_ptr = &r;
+      dim = Skyline (dim.direction ());
+      dim.set_minimum_height (0.0);
     }
 
-  return Side_position_interface::aligned_side (unsmob_grob (smob), a, pure, start, end, current_off_ptr);
-}
-
-MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Side_position_interface, x_aligned_side, 2, 1, "");
-SCM
-Side_position_interface::x_aligned_side (SCM smob, SCM current_off)
-{
-  return axis_aligned_side_helper (smob, X_AXIS, false, 0, 0, current_off);
-}
-
-MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Side_position_interface, y_aligned_side, 2, 1, "");
-SCM
-Side_position_interface::y_aligned_side (SCM smob, SCM current_off)
-{
-  return axis_aligned_side_helper (smob, Y_AXIS, false, 0, 0, current_off);
-}
+  Real ss = Staff_symbol_referencer::staff_space (me);
+  Real dist = dim.distance (my_dim, robust_scm2double (me->get_maybe_pure_property ("horizon-padding", pure, start, end), 0.0));
+  Real total_off = !isinf (dist) ? dir * dist : 0.0;
 
-MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Side_position_interface, pure_y_aligned_side, 4, 1, "");
-SCM
-Side_position_interface::pure_y_aligned_side (SCM smob, SCM start, SCM end, SCM cur_off)
-{
-  return axis_aligned_side_helper (smob, Y_AXIS, true,
-                                   scm_to_int (start),
-                                   scm_to_int (end),
-                                   cur_off);
-}
+  total_off += dir * ss * robust_scm2double (me->get_maybe_pure_property ("padding", pure, start, end), 0.0);
 
-MAKE_SCHEME_CALLBACK (Side_position_interface, calc_cross_staff, 1)
-SCM
-Side_position_interface::calc_cross_staff (SCM smob)
-{
-  Grob *me = unsmob_grob (smob);
-  extract_grob_set (me, "side-support-elements", elts);
+  Real minimum_space = ss * robust_scm2double (me->get_maybe_pure_property ("minimum-space", pure, start, end), -1);
 
-  for (vsize i = 0; i < elts.size (); i++)
-    if (to_boolean (elts[i]->get_property ("cross-staff")))
-      return SCM_BOOL_T;
+  if (minimum_space >= 0
+      && dir
+      && total_off * dir < minimum_space)
+    total_off = minimum_space * dir;
 
-  Grob *common = common_refpoint_of_array (elts, me->get_parent (Y_AXIS), Y_AXIS);
-  return scm_from_bool (common != me->get_parent (Y_AXIS));
-}
+  if (current_off)
+    total_off = dir * max (dir * total_off,
+                           dir * (*current_off));
 
-SCM
-Side_position_interface::aligned_side (Grob *me, Axis a, bool pure, int start, int end,
-                                       Real *current_off)
-{
-  Direction dir = get_grob_direction (me);
-  bool skyline = to_boolean (me->get_property ("use-skylines"));
+  /* FIXME: 1000 should relate to paper size.  */
+  if (fabs (total_off) > 1000)
+    {
+      string msg
+        = String_convert::form_string ("Improbable offset for grob %s: %f",
+                                       me->name ().c_str (), total_off);
 
-  Real o = scm_to_double (skyline && !pure
-                          ? skyline_side_position (me, a, pure, start, end, current_off)
-                          : general_side_position (me, a, true, true, pure, start, end, current_off));
+      programming_error (msg);
+      if (strict_infinity_checking)
+        scm_misc_error (__FUNCTION__, "Improbable offset.", SCM_EOL);
+    }
 
   /*
-    Maintain a minimum distance to the staff. This is similar to side
-    position with padding, but it will put adjoining objects on a row if
+    Ensure 'staff-padding' from my refpoint to the staff.  This is similar to
+    side-position with padding, but it will put adjoining objects on a row if
     stuff sticks out of the staff a little.
   */
   Grob *staff = Staff_symbol_referencer::get_staff_symbol (me);
   if (staff && a == Y_AXIS)
     {
-      if (to_boolean (me->get_property ("quantize-position")))
+      if (quantize_position)
         {
           Grob *common = me->common_refpoint (staff, Y_AXIS);
           Real my_off = me->get_parent (Y_AXIS)->maybe_pure_coordinate (common, Y_AXIS, pure, start, end);
           Real staff_off = staff->maybe_pure_coordinate (common, Y_AXIS, pure, start, end);
           Real ss = Staff_symbol::staff_space (staff);
-          Real position = 2 * (my_off + o - staff_off) / ss;
+          Real position = 2 * (my_off + total_off - staff_off) / ss;
           Real rounded = directed_round (position, dir);
           Grob *head = me->get_parent (X_AXIS);
 
           Interval staff_span = Staff_symbol::line_span (staff);
           staff_span.widen (1);
           if (staff_span.contains (position)
-              /* In case of a ledger lines, quantize even if we're outside the staff. */
-              || (Note_head::has_interface (head)
-
-                  && abs (Staff_symbol_referencer::get_position (head)) > abs (position)))
+              /* If we are between notehead and staff, quantize for ledger lines. */
+              || (has_interface<Note_head> (head)
+                  && dir * position < 0))
             {
-              o += (rounded - position) * 0.5 * ss;
+              total_off += (rounded - position) * 0.5 * ss;
               if (Staff_symbol_referencer::on_line (me, int (rounded)))
-                o += dir * 0.5 * ss;
+                total_off += dir * 0.5 * ss;
             }
         }
-      else if (scm_is_number (me->get_property ("staff-padding")) && dir)
+      else if (scm_is_number (me->get_maybe_pure_property ("staff-padding", pure, start, end)) && dir)
         {
-          Interval iv = me->maybe_pure_extent (me, a, pure, start, end);
-
           Real staff_padding
             = Staff_symbol_referencer::staff_space (me)
-              * scm_to_double (me->get_property ("staff-padding"));
+              * scm_to_double (me->get_maybe_pure_property ("staff-padding", pure, start, end));
 
           Grob *parent = me->get_parent (Y_AXIS);
           Grob *common = me->common_refpoint (staff, Y_AXIS);
@@ -460,12 +401,12 @@ Side_position_interface::aligned_side (Grob *me, Axis a, bool pure, int start, i
           Real staff_position = staff->maybe_pure_coordinate (common, Y_AXIS, pure, start, end);
           Interval staff_extent = staff->maybe_pure_extent (staff, a, pure, start, end);
           Real diff = (dir * staff_extent[dir] + staff_padding
-                       - dir * (o + iv[-dir])
+                       - dir * total_off
                        + dir * (staff_position - parent_position));
-          o += dir * max (diff, 0.0);
+          total_off += dir * max (diff, 0.0);
         }
     }
-  return scm_from_double (o);
+  return scm_from_double (total_off);
 }
 
 void
@@ -477,7 +418,7 @@ Side_position_interface::set_axis (Grob *me, Axis a)
       chain_offset_callback (me,
                              (a == X_AXIS)
                              ? x_aligned_side_proc
-                             : y_aligned_side_proc,
+                             : Unpure_pure_container::make_smob (y_aligned_side_proc, pure_y_aligned_side_proc),
                              a);
     }
 }
@@ -498,7 +439,7 @@ MAKE_SCHEME_CALLBACK (Side_position_interface, move_to_extremal_staff, 1);
 SCM
 Side_position_interface::move_to_extremal_staff (SCM smob)
 {
-  Grob *me = unsmob_grob (smob);
+  Grob *me = unsmob<Grob> (smob);
   System *sys = dynamic_cast<System *> (me->get_system ());
   Direction dir = get_grob_direction (me);
   if (dir != DOWN)
@@ -523,7 +464,7 @@ Side_position_interface::move_to_extremal_staff (SCM smob)
   Axis_group_interface::add_element (top_staff, me);
 
   // Remove any cross-staff side-support dependencies
-  Grob_array *ga = unsmob_grob_array (me->get_object ("side-support-elements"));
+  Grob_array *ga = unsmob<Grob_array> (me->get_object ("side-support-elements"));
   if (ga)
     {
       vector<Grob *> const &elts = ga->array ();
@@ -552,6 +493,7 @@ ADD_INTERFACE (Side_position_interface,
                "add-stem-support "
                "direction "
                "minimum-space "
+               "horizon-padding "
                "padding "
                "quantize-position "
                "side-axis "