Add a hack to packed spacing to work around extra columns.

The ligature engravers leave unused paper columns lying around
and it's up to the spacing engine to deal with them. Here we
add a test for these extraneous columns and ignore them in
the packed-spacing part of the spacing engine.

diff --git a/lily/include/paper-column.hh b/lily/include/paper-column.hh
index 350ed4e63525904b642f4ac1ac64e9252e90ada2..66d7ba16da1b85b12b4c8f4cd759bec2060bcb16 100644 (file)
--- a/lily/include/paper-column.hh
+++ b/lily/include/paper-column.hh
@@ -48,6 +48,7 @@ public:
   static Moment when_mom (Grob *);
   static bool is_used (Grob *);
   static bool is_breakable (Grob *);
+  static bool is_extraneous_column_from_ligature (Grob *);
   static Real minimum_distance (Grob *l, Grob *r);
   static Interval break_align_width (Grob *me);
 };

diff --git a/lily/paper-column.cc b/lily/paper-column.cc
index 0eb40d1b97a48c8297ff378de172d65de6cd5072..7d4b92d990970d58111c100f0e0c750476eeca43 100644 (file)
--- a/lily/paper-column.cc
+++ b/lily/paper-column.cc
@@ -18,6 +18,7 @@
 #include "output-def.hh"
 #include "paper-score.hh"
 #include "pointer-group-interface.hh"
+#include "rhythmic-head.hh"
 #include "separation-item.hh"
 #include "skyline-pair.hh"
 #include "spaceable-grob.hh"
@@ -313,6 +314,33 @@ Paper_column::before_line_breaking (SCM grob)
   return SCM_UNSPECIFIED;
 }
 
+/* FIXME: This is a hack that we use to identify columns that used to
+   contain note-heads but whose note-heads were moved by one of the ligature
+   engravers. Once the ligature engravers are fixed to behave nicely, this
+   function can be removed.
+*/
+bool
+Paper_column::is_extraneous_column_from_ligature (Grob *me)
+{
+  if (!is_musical (me))
+    return false;
+
+  // If all the note-heads that I think are my children actually belong
+  // to another column, then I am extraneous.
+  extract_grob_set (me, "elements", elts);
+  bool has_notehead = false;
+  for (vsize i = 0; i < elts.size (); i++)
+    {
+      if (Rhythmic_head::has_interface (elts[i]))
+       {
+         has_notehead = true;
+         if (dynamic_cast<Item*> (elts[i])->get_column () == me)
+           return false;
+       }
+    }
+  return has_notehead;
+}
+
 
 ADD_INTERFACE (Paper_column,
               "@code{Paper_column} objects form the top-most X@tie{}parents"

diff --git a/lily/separation-item.cc b/lily/separation-item.cc
index 617c6fd4ebc9e25b641a2a83332f960e79d1427f..ec8c0db24faf6ea9ff6cfbddf39747722e2d9797 100644 (file)
--- a/lily/separation-item.cc
+++ b/lily/separation-item.cc
@@ -146,7 +146,7 @@ Separation_item::boxes (Grob *me, Grob *left)
       y[UP] += extra_height[UP];
  
       if (!x.is_empty () && !y.is_empty ())
-      out.push_back (Box (x, y));
+       out.push_back (Box (x, y));
     }
 
   return out;      

diff --git a/lily/spacing-spanner.cc b/lily/spacing-spanner.cc
index ba5d40e51879ffe7f5b7709c51cbfed96579ed41..7b1756620f17884c207ba7a2b47d0415c3c61a06 100644 (file)
--- a/lily/spacing-spanner.cc
+++ b/lily/spacing-spanner.cc
@@ -405,8 +405,20 @@ Spacing_spanner::musical_column_spacing (Grob *me,
        Note that we don't actually pack things as tightly as possible:
        we don't allow the next column to begin before this one ends.
       */
-      spring.set_distance (max (left_col->extent (left_col, X_AXIS)[RIGHT],
-                               spring.min_distance ()));
+      /* FIXME: the else clause below is the "right" thing to do,
+        but we can't do it because of all the empty columns that the
+        ligature-engravers leave lying around. In that case, the extent of
+        the column is incorrect because it includes note-heads that aren't
+        there. We get around this by only including the column extent if
+        the left-hand column is "genuine". This is a dirty hack and it
+        should be fixed in the ligature-engravers. --jneem
+      */
+      if (Paper_column::is_extraneous_column_from_ligature (left_col))
+       spring.set_distance (spring.min_distance ());
+      else
+       spring.set_distance (max (left_col->extent (left_col, X_AXIS)[RIGHT],
+                                 spring.min_distance ()));
+
       spring.set_inverse_stretch_strength (1.0);
     }