X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fsystem.cc;h=0551b85cbccda5286e770fdc238722edda48aec7;hb=b872748c6aa8bb721ced458691b38ac2fac5dfc8;hp=f4a37cd24dfa66d13eb4f891cf7c02cea064abfa;hpb=7aa6257a56d35226e88bab86fa17671751f580d1;p=lilypond.git

diff --git a/lily/system.cc b/lily/system.cc
index f4a37cd24d..0551b85cbc 100644
--- a/lily/system.cc
+++ b/lily/system.cc
@@ -1,7 +1,7 @@
 /*
   This file is part of LilyPond, the GNU music typesetter.
 
-  Copyright (C) 1996--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+  Copyright (C) 1996--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
@@ -36,9 +36,11 @@
 #include "pointer-group-interface.hh"
 #include "skyline-pair.hh"
 #include "staff-symbol-referencer.hh"
+#include "system-start-delimiter.hh"
 #include "text-interface.hh"
 #include "warn.hh"
 #include "unpure-pure-container.hh"
+#include "lily-imports.hh"
 
 System::System (System const &src)
   : Spanner (src)
@@ -46,7 +48,6 @@ System::System (System const &src)
   all_elements_ = 0;
   pscore_ = 0;
   rank_ = 0;
-  checked_footnotes_ = false;
   init_elements ();
 }
 
@@ -55,7 +56,6 @@ System::System (SCM s)
 {
   all_elements_ = 0;
   rank_ = 0;
-  checked_footnotes_ = false;
   init_elements ();
 }
 
@@ -63,7 +63,7 @@ void
 System::init_elements ()
 {
   SCM scm_arr = Grob_array::make_array ();
-  all_elements_ = unsmob_grob_array (scm_arr);
+  all_elements_ = unsmob<Grob_array> (scm_arr);
   all_elements_->set_ordered (false);
   set_object ("all-elements", scm_arr);
 }
@@ -106,16 +106,9 @@ System::typeset_grob (Grob *elem)
 void
 System::derived_mark () const
 {
-  if (!all_elements_->empty ())
-    {
-      Grob **ptr = &all_elements_->array_reference ()[0];
-      Grob **end = ptr + all_elements_->size ();
-      while (ptr < end)
-        {
-          scm_gc_mark ((*ptr)->self_scm ());
-          ptr++;
-        }
-    }
+  const vector <Grob *> &arr = all_elements_->array ();
+  for (vsize i = arr.size (); i--;)
+    scm_gc_mark (arr[i]->self_scm ());
 
   if (pscore_)
     scm_gc_mark (pscore_->self_scm ());
@@ -181,7 +174,7 @@ System::do_break_substitution_and_fixup_refpoints ()
 
   handle_broken_dependencies ();
 
-  /* Because the this->get_property (all-elements) contains items in 3
+  /* Because the get_property (all-elements) contains items in 3
      versions, handle_broken_dependencies () will leave duplicated
      items in all-elements.  Strictly speaking this is harmless, but
      it leads to duplicated symbols in the output.  uniq makes sure
@@ -190,6 +183,7 @@ System::do_break_substitution_and_fixup_refpoints ()
     {
       System *child = dynamic_cast<System *> (broken_intos_[i]);
       child->all_elements_->remove_duplicates ();
+
       for (vsize j = 0; j < child->all_elements_->size (); j++)
         {
           Grob *g = child->all_elements_->grob (j);
@@ -207,7 +201,7 @@ System::get_broken_system_grobs ()
   SCM ret = SCM_EOL;
   for (vsize i = 0; i < broken_intos_.size (); i++)
     ret = scm_cons (broken_intos_[i]->self_scm (), ret);
-  return scm_reverse (ret);
+  return scm_reverse_x (ret, SCM_EOL);
 }
 
 SCM
@@ -223,71 +217,102 @@ System::get_paper_systems ()
       scm_vector_set_x (lines, scm_from_int (i),
                         system->get_paper_system ());
 
-      debug_output (to_string (i) + "]", false);
+      debug_output (::to_string (i) + "]", false);
     }
   return lines;
 }
 
-void
-System::populate_footnote_grob_vector ()
-{
-  extract_grob_set (this, "all-elements", all_elts);
-  for (vsize i = 0; i < all_elts.size (); i++)
-    if (all_elts[i]->internal_has_interface (ly_symbol2scm ("footnote-interface")))
-      footnote_grobs_.push_back (all_elts[i]);
-
-  sort (footnote_grobs_.begin (), footnote_grobs_.end (), Grob::less);
-  checked_footnotes_ = true;
-}
-
-void
-System::get_footnote_grobs_in_range (vector<Grob *> &out, vsize start, vsize end)
+vector<Grob *>
+System::get_footnote_grobs_in_range (vsize start, vsize end)
 {
-  if (!checked_footnotes_)
-    populate_footnote_grob_vector ();
-
-  for (vsize i = 0; i < footnote_grobs_.size (); i++)
+  vector<Grob *> out;
+  extract_grob_set (this, "footnotes-before-line-breaking", footnote_grobs);
+  for (vsize i = 0; i < footnote_grobs.size (); i++)
     {
-      int pos = footnote_grobs_[i]->spanned_rank_interval ()[LEFT];
+      Grob *at_bat = footnote_grobs[i];
+      int pos = at_bat->spanned_rank_interval ()[LEFT];
       bool end_of_line_visible = true;
-      if (Spanner *s = dynamic_cast<Spanner *>(footnote_grobs_[i]))
+      if (Spanner *s = dynamic_cast<Spanner *>(at_bat))
         {
           Direction spanner_placement = robust_scm2dir (s->get_property ("spanner-placement"), LEFT);
           if (spanner_placement == CENTER)
             spanner_placement = LEFT;
 
           pos = s->spanned_rank_interval ()[spanner_placement];
+          if (s->original ())
+            {
+              Spanner *orig = dynamic_cast<Spanner *>(s->original ());
+              at_bat = spanner_placement == LEFT ? orig->broken_intos_[0] : orig->broken_intos_.back ();
+              pos = at_bat->spanned_rank_interval ()[RIGHT];
+            }
         }
 
-      if (Item *item = dynamic_cast<Item *>(footnote_grobs_[i]))
+      if (Item *item = dynamic_cast<Item *>(at_bat))
         {
+          /*
+            We use this to weed out grobs that fall at the end
+            of the line when we want grobs at the beginning.
+          */
+          end_of_line_visible = item->break_status_dir () == LEFT;
+
           if (!Item::break_visible (item))
             continue;
           // safeguard to bring down the column rank so that end of line footnotes show up on the correct line
-          end_of_line_visible = (LEFT == item->break_status_dir ());
+          if (pos == int (start) && item->break_status_dir () != RIGHT)
+            continue;
+          if (pos == int (end) && item->break_status_dir () != LEFT)
+            continue;
+          if (pos != int (end) && pos != int (start) && item->break_status_dir () != CENTER)
+            continue;
         }
 
       if (pos < int (start))
         continue;
       if (pos > int (end))
-        break;
+        continue;
       if (pos == int (start) && end_of_line_visible)
         continue;
       if (pos == int (end) && !end_of_line_visible)
         continue;
-      if (!footnote_grobs_[i]->is_live ())
+      if (!at_bat->is_live ())
+        continue;
+      /*
+        TODO
+        Sometimes, there are duplicate entries in the all_elements_
+        list. In a separate patch, this practice should be squashed
+        so that the check below can be eliminated.
+      */
+      if (find (out.begin (), out.end (), at_bat) != out.end ())
         continue;
 
-      out.push_back (footnote_grobs_[i]);
+      out.push_back (at_bat);
     }
+  return out;
 }
 
-vector<Stencil *>
-System::get_footnotes_in_range (vsize start, vsize end)
+vector<Real>
+System::get_footnote_heights_in_range (vsize start, vsize end)
 {
-  vector<Grob *> footnote_grobs;
-  get_footnote_grobs_in_range (footnote_grobs, start, end);
-  vector<Stencil *> out;
+  return internal_get_note_heights_in_range (start, end, true);
+}
+
+vector<Real>
+System::get_in_note_heights_in_range (vsize start, vsize end)
+{
+  return internal_get_note_heights_in_range (start, end, false);
+}
+
+vector<Real>
+System::internal_get_note_heights_in_range (vsize start, vsize end, bool foot)
+{
+  vector<Grob *> footnote_grobs = get_footnote_grobs_in_range (start, end);
+  vector<Real> out;
+
+  for (vsize i = footnote_grobs.size (); i--;)
+    if (foot
+        ? !to_boolean (footnote_grobs[i]->get_property ("footnote"))
+        : to_boolean (footnote_grobs[i]->get_property ("footnote")))
+      footnote_grobs.erase (footnote_grobs.begin () + i);
 
   for (vsize i = 0; i < footnote_grobs.size (); i++)
     {
@@ -296,14 +321,14 @@ System::get_footnotes_in_range (vsize start, vsize end)
       if (!Text_interface::is_markup (footnote_markup))
         continue;
 
-      SCM props = scm_call_1 (ly_lily_module_constant ("layout-extract-page-properties"),
-                              pscore_->layout ()->self_scm ());
+      SCM props =
+        Lily::layout_extract_page_properties (pscore_->layout ()->self_scm ());
 
       SCM footnote_stl = Text_interface::interpret_markup (pscore_->layout ()->self_scm (),
                                                            props, footnote_markup);
 
-      Stencil *footnote_stencil = unsmob_stencil (footnote_stl);
-      out.push_back (footnote_stencil);
+      Stencil *footnote_stencil = unsmob<Stencil> (footnote_stl);
+      out.push_back (footnote_stencil->extent (Y_AXIS).length ());
     }
 
   return out;
@@ -312,13 +337,97 @@ System::get_footnotes_in_range (vsize start, vsize end)
 vsize
 System::num_footnotes ()
 {
-  return footnote_grobs_.size ();
+  extract_grob_set (this, "footnotes-after-line-breaking", footnote_grobs);
+  return footnote_grobs.size ();
 }
 
-vector<Grob *>*
-System::footnote_grobs ()
+bool
+grob_2D_less (Grob *g1, Grob *g2)
 {
-  return &footnote_grobs_;
+  int sri[] = {0, 0};
+  Grob *gs[] = {g1, g2};
+
+  for (int i = 0; i < 2; i++)
+    {
+      sri[i] = gs[i]->spanned_rank_interval ()[LEFT];
+      if (Spanner *s = dynamic_cast<Spanner *> (gs[i]))
+        {
+          if (s->broken_intos_.size ())
+            s = (scm_to_int (s->broken_intos_[0]->get_property ("spanner-placement")) == LEFT
+                 ? s->broken_intos_[0]
+                 : s->broken_intos_.back ());
+          gs[i] = s;
+          if (robust_scm2double (s->get_property ("X-offset"), 0.0) > 0)
+            sri[i] = s->spanned_rank_interval ()[RIGHT];
+        }
+    }
+
+  if (sri[0] == sri[1])
+    return Grob::vertical_less (gs[0], gs[1]);
+
+  return sri[0] < sri[1];
+}
+
+MAKE_SCHEME_CALLBACK (System, footnotes_before_line_breaking, 1);
+SCM
+System::footnotes_before_line_breaking (SCM smob)
+{
+  Grob *me = unsmob<Grob> (smob);
+  vector<Grob *> footnotes;
+  SCM grobs_scm = Grob_array::make_array ();
+  extract_grob_set (me, "all-elements", elts);
+  for (vsize i = 0; i < elts.size (); i++)
+    if (elts[i]->internal_has_interface (ly_symbol2scm ("footnote-interface")))
+      footnotes.push_back (elts[i]);
+
+  unsmob<Grob_array> (grobs_scm)->set_array (footnotes);
+  return grobs_scm;
+}
+
+MAKE_SCHEME_CALLBACK (System, footnotes_after_line_breaking, 1);
+SCM
+System::footnotes_after_line_breaking (SCM smob)
+{
+  Spanner *sys_span = unsmob<Spanner> (smob);
+  System *sys = dynamic_cast<System *> (sys_span);
+  Interval_t<int> sri = sys->spanned_rank_interval ();
+  vector<Grob *> footnote_grobs = sys->get_footnote_grobs_in_range (sri[LEFT], sri[RIGHT]);
+  vector_sort (footnote_grobs, grob_2D_less);
+
+  SCM grobs_scm = Grob_array::make_array ();
+  unsmob<Grob_array> (grobs_scm)->set_array (footnote_grobs);
+  return grobs_scm;
+}
+
+MAKE_SCHEME_CALLBACK (System, vertical_skyline_elements, 1);
+SCM
+System::vertical_skyline_elements (SCM smob)
+{
+  Grob *me_grob = unsmob<Grob> (smob);
+  vector<Grob *> vertical_skyline_grobs;
+  extract_grob_set (me_grob, "elements", my_elts);
+  for (vsize i = 0; i < my_elts.size (); i++)
+    if (has_interface<System_start_delimiter> (my_elts[i]))
+      vertical_skyline_grobs.push_back (my_elts[i]);
+
+  System *me = dynamic_cast<System *> (me_grob);
+  Grob *align = unsmob<Grob> (me->get_object ("vertical-alignment"));
+  if (!align)
+    {
+      SCM grobs_scm = Grob_array::make_array ();
+      unsmob<Grob_array> (grobs_scm)->set_array (vertical_skyline_grobs);
+      return grobs_scm;
+    }
+
+  extract_grob_set (align, "elements", elts);
+
+  for (vsize i = 0; i < elts.size (); i++)
+    if (has_interface<Hara_kiri_group_spanner> (elts[i]))
+      vertical_skyline_grobs.push_back (elts[i]);
+
+  SCM grobs_scm = Grob_array::make_array ();
+  unsmob<Grob_array> (grobs_scm)->set_array (vertical_skyline_grobs);
+  return grobs_scm;
 }
 
 void
@@ -334,11 +443,9 @@ System::break_into_pieces (vector<Column_x_positions> const &breaking)
 
       int st = Paper_column::get_rank (c[0]);
       int end = Paper_column::get_rank (c.back ());
-      Interval iv (pure_height (this, st, end));
+      Interval iv (pure_y_extent (this, st, end));
       system->set_property ("pure-Y-extent", ly_interval2scm (iv));
 
-      get_footnote_grobs_in_range (system->footnote_grobs_, st, end);
-
       system->set_bound (LEFT, c[0]);
       system->set_bound (RIGHT, c.back ());
       SCM system_labels = SCM_EOL;
@@ -376,12 +483,12 @@ void
 System::add_column (Paper_column *p)
 {
   Grob *me = this;
-  Grob_array *ga = unsmob_grob_array (me->get_object ("columns"));
+  Grob_array *ga = unsmob<Grob_array> (me->get_object ("columns"));
   if (!ga)
     {
       SCM scm_ga = Grob_array::make_array ();
       me->set_object ("columns", scm_ga);
-      ga = unsmob_grob_array (scm_ga);
+      ga = unsmob<Grob_array> (scm_ga);
     }
 
   p->set_rank (ga->size ());
@@ -435,9 +542,8 @@ System::post_processing ()
      anyway. */
 
   vector<Grob *> all_elts_sorted (all_elements_->array ());
-  vector_sort (all_elts_sorted, std::less<Grob *> ());
-  uniq (all_elts_sorted);
-  this->get_stencil ();
+  uniquify (all_elts_sorted);
+  get_stencil ();
   for (vsize i = all_elts_sorted.size (); i--;)
     {
       Grob *g = all_elts_sorted[i];
@@ -482,7 +588,7 @@ System::get_paper_system ()
       Grob *g = entries[j].grob_;
       Stencil st = g->get_print_stencil ();
 
-      if (st.expr () == SCM_EOL)
+      if (scm_is_null (st.expr ()))
         continue;
 
       Offset o;
@@ -512,7 +618,7 @@ System::get_paper_system ()
                                  exprs));
   if (debug_skylines)
     {
-      Skyline_pair *skylines = Skyline_pair::unsmob (get_property ("vertical-skylines"));
+      Skyline_pair *skylines = unsmob<Skyline_pair> (get_property ("vertical-skylines"));
       if (skylines)
         {
           Stencil up
@@ -524,24 +630,24 @@ System::get_paper_system ()
         }
     }
 
-  Grob *left_bound = this->get_bound (LEFT);
+  Grob *left_bound = get_bound (LEFT);
   SCM prop_init = left_bound->get_property ("line-break-system-details");
   Prob *pl = make_paper_system (prop_init);
   paper_system_set_stencil (pl, sys_stencil);
 
   /* information that the page breaker might need */
-  Grob *right_bound = this->get_bound (RIGHT);
-  pl->set_property ("vertical-skylines", this->get_property ("vertical-skylines"));
+  Grob *right_bound = get_bound (RIGHT);
+  pl->set_property ("vertical-skylines", get_property ("vertical-skylines"));
   pl->set_property ("page-break-permission", right_bound->get_property ("page-break-permission"));
   pl->set_property ("page-turn-permission", right_bound->get_property ("page-turn-permission"));
   pl->set_property ("page-break-penalty", right_bound->get_property ("page-break-penalty"));
   pl->set_property ("page-turn-penalty", right_bound->get_property ("page-turn-penalty"));
 
-  if (right_bound->original () == dynamic_cast<System*> (original ())->get_bound (RIGHT))
+  if (right_bound->original () == dynamic_cast<System *> (original ())->get_bound (RIGHT))
     pl->set_property ("last-in-score", SCM_BOOL_T);
 
   Interval staff_refpoints;
-  if (Grob *align = get_vertical_alignment ())
+  if (Grob *align = unsmob<Grob> (get_object ("vertical-alignment")))
     {
       extract_grob_set (align, "elements", staves);
       for (vsize i = 0; i < staves.size (); i++)
@@ -552,7 +658,7 @@ System::get_paper_system ()
     }
 
   pl->set_property ("staff-refpoint-extent", ly_interval2scm (staff_refpoints));
-  pl->set_property ("system-grob", this->self_scm ());
+  pl->set_property ("system-grob", self_scm ());
 
   return pl->unprotect ();
 }
@@ -642,22 +748,27 @@ get_root_system (Grob *me)
   return dynamic_cast<System *> (system_grob);
 }
 
-Grob *
-System::get_vertical_alignment ()
+MAKE_SCHEME_CALLBACK (System, get_vertical_alignment, 1);
+SCM
+System::get_vertical_alignment (SCM smob)
 {
-  extract_grob_set (this, "elements", elts);
+  Grob *me = unsmob<Grob> (smob);
+  extract_grob_set (me, "elements", elts);
   Grob *ret = 0;
   for (vsize i = 0; i < elts.size (); i++)
-    if (Align_interface::has_interface (elts[i]))
+    if (has_interface<Align_interface> (elts[i]))
       {
         if (ret)
-          programming_error ("found multiple vertical alignments in this system");
+          me->programming_error ("found multiple vertical alignments in this system");
         ret = elts[i];
       }
 
   if (!ret)
-    programming_error ("didn't find a vertical alignment in this system");
-  return ret;
+    {
+      me->programming_error ("didn't find a vertical alignment in this system");
+      return SCM_EOL;
+    }
+  return ret->self_scm ();
 }
 
 // Finds the furthest staff in the given direction whose x-extent
@@ -665,7 +776,7 @@ System::get_vertical_alignment ()
 Grob *
 System::get_extremal_staff (Direction dir, Interval const &iv)
 {
-  Grob *align = get_vertical_alignment ();
+  Grob *align = unsmob<Grob> (get_object ("vertical-alignment"));
   if (!align)
     return 0;
 
@@ -674,7 +785,7 @@ System::get_extremal_staff (Direction dir, Interval const &iv)
   vsize end = (dir == UP) ? elts.size () : VPOS;
   for (vsize i = start; i != end; i += dir)
     {
-      if (Hara_kiri_group_spanner::has_interface (elts[i]))
+      if (has_interface<Hara_kiri_group_spanner> (elts[i]))
         Hara_kiri_group_spanner::consider_suicide (elts[i]);
 
       Interval intersection = elts[i]->extent (this, X_AXIS);
@@ -685,11 +796,41 @@ System::get_extremal_staff (Direction dir, Interval const &iv)
   return 0;
 }
 
+// Finds the neighboring staff in the given direction over bounds
+Grob *
+System::get_neighboring_staff (Direction dir, Grob *vertical_axis_group, Interval_t<int> bounds)
+{
+  Grob *align = unsmob<Grob> (get_object ("vertical-alignment"));
+  if (!align)
+    return 0;
+
+  extract_grob_set (align, "elements", elts);
+  vsize start = (dir == UP) ? 0 : elts.size () - 1;
+  vsize end = (dir == UP) ? elts.size () : VPOS;
+
+  Grob *out = 0;
+
+  for (vsize i = start; i != end; i += dir)
+    {
+      if (elts[i] == vertical_axis_group)
+        return out;
+
+      if (has_interface<Hara_kiri_group_spanner> (elts[i]))
+        Hara_kiri_group_spanner::consider_suicide (elts[i]);
+
+      bounds.intersect (elts[i]->spanned_rank_interval ());
+      if (elts[i]->is_live () && !bounds.is_empty ())
+        out = elts[i];
+    }
+
+  return 0;
+}
+
 Interval
 System::pure_refpoint_extent (vsize start, vsize end)
 {
   Interval ret;
-  Grob *alignment = get_vertical_alignment ();
+  Grob *alignment = unsmob<Grob> (get_object ("vertical-alignment"));
   if (!alignment)
     return Interval ();
 
@@ -716,7 +857,7 @@ System::pure_refpoint_extent (vsize start, vsize end)
 Interval
 System::part_of_line_pure_height (vsize start, vsize end, bool begin)
 {
-  Grob *alignment = get_vertical_alignment ();
+  Grob *alignment = unsmob<Grob> (get_object ("vertical-alignment"));
   if (!alignment)
     return Interval ();
 
@@ -762,36 +903,32 @@ MAKE_SCHEME_CALLBACK (System, calc_pure_relevant_grobs, 1);
 SCM
 System::calc_pure_relevant_grobs (SCM smob)
 {
-  Grob *me = unsmob_grob (smob);
+  Grob *me = unsmob<Grob> (smob);
 
   extract_grob_set (me, "elements", elts);
   vector<Grob *> relevant_grobs;
-  SCM pure_relevant_p = ly_lily_module_constant ("pure-relevant?");
 
   for (vsize i = 0; i < elts.size (); ++i)
     {
-      if (!Axis_group_interface::has_interface (elts[i]))
+      if (!has_interface<Axis_group_interface> (elts[i]))
         {
-          if (to_boolean (scm_apply_1 (pure_relevant_p, elts[i]->self_scm (), SCM_EOL)))
-            relevant_grobs.push_back (elts[i]);
+          relevant_grobs.push_back (elts[i]);
 
           if (Item *it = dynamic_cast<Item *> (elts[i]))
             {
-              Direction d = LEFT;
-              do
+              for (LEFT_and_RIGHT (d))
                 {
                   Item *piece = it->find_prebroken_piece (d);
-                  if (piece && to_boolean (scm_apply_1 (pure_relevant_p, piece->self_scm (), SCM_EOL)))
+                  if (piece && piece->is_live ())
                     relevant_grobs.push_back (piece);
                 }
-              while (flip (&d) != LEFT);
             }
         }
     }
 
   SCM grobs_scm = Grob_array::make_array ();
 
-  unsmob_grob_array (grobs_scm)->set_array (relevant_grobs);
+  unsmob<Grob_array> (grobs_scm)->set_array (relevant_grobs);
   return grobs_scm;
 }
 
@@ -806,7 +943,7 @@ MAKE_SCHEME_CALLBACK (System, calc_pure_height, 3);
 SCM
 System::calc_pure_height (SCM smob, SCM start_scm, SCM end_scm)
 {
-  System *me = dynamic_cast<System *> (unsmob_grob (smob));
+  System *me = unsmob<System> (smob);
   int start = scm_to_int (start_scm);
   int end = scm_to_int (end_scm);
 
@@ -840,7 +977,8 @@ System::get_maybe_pure_bound (Direction d, bool pure, int start, int end)
   return pure ? get_pure_bound (d, start, end) : get_bound (d);
 }
 
-enum {
+enum
+{
   SPACEABLE_STAVES,
   NONSPACEABLE_STAVES,
   ALL_STAVES
@@ -849,8 +987,8 @@ enum {
 static SCM
 get_maybe_spaceable_staves (SCM smob, int filter)
 {
-  System *me = dynamic_cast<System*> (unsmob_grob (smob));
-  Grob *align = me->get_vertical_alignment ();
+  System *me = unsmob<System> (smob);
+  Grob *align = unsmob<Grob> (me->get_object ("vertical_alignment"));
   SCM ret = SCM_EOL;
 
   if (align)
@@ -861,10 +999,10 @@ get_maybe_spaceable_staves (SCM smob, int filter)
       for (vsize i = 0; i < staves.size (); ++i)
         {
           bool spaceable = Page_layout_problem::is_spaceable (staves[i]);
-          if (staves[i]->is_live () &&
-              ((filter == ALL_STAVES)
-               || (filter == SPACEABLE_STAVES && spaceable)
-               || (filter == NONSPACEABLE_STAVES && !spaceable)))
+          if (staves[i]->is_live ()
+              && ((filter == ALL_STAVES)
+                  || (filter == SPACEABLE_STAVES && spaceable)
+                  || (filter == NONSPACEABLE_STAVES && !spaceable)))
             {
               *tail = scm_cons (staves[i]->self_scm (), SCM_EOL);
               tail = SCM_CDRLOC (*tail);
@@ -896,7 +1034,6 @@ System::get_nonspaceable_staves (SCM smob)
   return get_maybe_spaceable_staves (smob, NONSPACEABLE_STAVES);
 }
 
-
 ADD_INTERFACE (System,
                "This is the top-level object: Each object in a score"
                " ultimately has a @code{System} object as its X and"
@@ -905,7 +1042,13 @@ ADD_INTERFACE (System,
                /* properties */
                "all-elements "
                "columns "
+               "footnote-stencil "
+               "footnotes-before-line-breaking "
+               "footnotes-after-line-breaking "
+               "in-note-direction "
+               "in-note-padding "
+               "in-note-stencil "
                "labels "
                "pure-Y-extent "
-               "skyline-horizontal-padding "
+               "vertical-alignment "
               );