* Ignore test failures on non-i386/amd64 architectures (Closes:

[lilypond.git] / lily / constrained-breaking.cc

diff --git a/lily/constrained-breaking.cc b/lily/constrained-breaking.cc
index 1c2d5287c0cfa4f3a29ef9ea279cabce4ba2f8e5..3a56aa47541190b7bd2f6e2669d5292f7e4d1fac 100644 (file)
--- a/lily/constrained-breaking.cc
+++ b/lily/constrained-breaking.cc
@@ -4,7 +4,7 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c) 2006--2007 Joe Neeman <joeneeman@gmail.com>
+  (c) 2006--2009 Joe Neeman <joeneeman@gmail.com>
 */
 
 #include "constrained-breaking.hh"
@@ -109,15 +109,6 @@ Constrained_breaking::calc_subproblem (vsize start, vsize sys, vsize brk)
   return found_something;
 }
 
-vector<Column_x_positions>
-Constrained_breaking::solve ()
-{
-  if (!systems_)
-    return get_best_solution (0, VPOS);
-
-  resize (systems_);
-  return get_solution (0, VPOS, systems_);
-}
 
 Column_x_positions
 Constrained_breaking::space_line (vsize i, vsize j)
@@ -132,6 +123,15 @@ Constrained_breaking::space_line (vsize i, vsize j)
   bool last = j == breaks_.size () - 1;
   bool ragged = ragged_right || (last && ragged_last);
 
+  /* As a special case, if there is only one line in the score and ragged-right
+     hasn't been specifically forbidden and the line is stretched, use
+     ragged spacing. */
+  if (last && i == 0
+      && lines_.at (i, j).force_ >= 0
+      && !scm_is_bool (pscore_->layout ()->c_variable ("ragged-right"))
+      && !scm_is_bool (pscore_->layout ()->c_variable ("ragged-last")))
+    ragged = true;
+
   return get_line_configuration (line, line_dims[RIGHT] - line_dims[LEFT], line_dims[LEFT], ragged);
 }
 
@@ -156,7 +156,7 @@ Constrained_breaking::resize (vsize systems)
 }
 
 vector<Column_x_positions>
-Constrained_breaking::get_solution (vsize start, vsize end, vsize sys_count)
+Constrained_breaking::solve (vsize start, vsize end, vsize sys_count)
 {
   vsize start_brk = starting_breakpoints_[start];
   vsize end_brk = prepare_solution (start, end, sys_count);
@@ -190,16 +190,16 @@ Constrained_breaking::get_solution (vsize start, vsize end, vsize sys_count)
         }
     }
   /* if we get to here, just put everything on one line */
-  warning (_ ("cannot find line breaking that satisfies constraints" ));
+  warning (_ ("cannot find line breaking that satisfies constraints"));
   ret.push_back (space_line (0, end_brk));
   return ret;
 }
 
 vector<Column_x_positions>
-Constrained_breaking::get_best_solution (vsize start, vsize end)
+Constrained_breaking::best_solution (vsize start, vsize end)
 {
-  vsize min_systems =  get_min_systems (start, end);
-  vsize max_systems = get_max_systems (start, end);
+  vsize min_systems = min_system_count (start, end);
+  vsize max_systems = max_system_count (start, end);
   Real best_demerits = infinity_f;
   vector<Column_x_positions> best_so_far;
 
@@ -211,11 +211,11 @@ Constrained_breaking::get_best_solution (vsize start, vsize end)
       if (dem < best_demerits)
        {
          best_demerits = dem;
-         best_so_far = get_solution (start, end, i);
+         best_so_far = solve (start, end, i);
        }
       else
        {
-         vector<Column_x_positions> cur = get_solution (start, end, i);
+         vector<Column_x_positions> cur = solve (start, end, i);
          bool too_many_lines = true;
          
          for (vsize j = 0; j < cur.size (); j++)
@@ -230,11 +230,11 @@ Constrained_breaking::get_best_solution (vsize start, vsize end)
     }
   if (best_so_far.size ())
     return best_so_far;
-  return get_solution (start, end, max_systems);
+  return solve (start, end, max_systems);
 }
 
 std::vector<Line_details>
-Constrained_breaking::get_details (vsize start, vsize end, vsize sys_count)
+Constrained_breaking::line_details (vsize start, vsize end, vsize sys_count)
 {
   vsize brk = prepare_solution (start, end, sys_count);
   Matrix<Constrained_break_node> const &st = state_[start];
@@ -250,7 +250,7 @@ Constrained_breaking::get_details (vsize start, vsize end, vsize sys_count)
 }
 
 int
-Constrained_breaking::get_min_systems (vsize start, vsize end)
+Constrained_breaking::min_system_count (vsize start, vsize end)
 {
   vsize sys_count;
   vsize brk = prepare_solution (start, end, 1);
@@ -272,9 +272,9 @@ Constrained_breaking::get_min_systems (vsize start, vsize end)
 }
 
 int
-Constrained_breaking::get_max_systems (vsize start, vsize end)
+Constrained_breaking::max_system_count (vsize start, vsize end)
 {
-  vsize brk = (end >= start_.size ()) ? breaks_.size () : starting_breakpoints_[end];
+  vsize brk = (end >= start_.size ()) ? breaks_.size () - 1 : starting_breakpoints_[end];
   return brk - starting_breakpoints_[start];
 }
 
@@ -310,6 +310,17 @@ Constrained_breaking::Constrained_breaking (Paper_score *ps, vector<vsize> const
   initialize ();
 }
 
+static SCM
+min_permission (SCM perm1, SCM perm2)
+{
+  if (perm1 == ly_symbol2scm ("force"))
+    return perm2;
+  if (perm1 == ly_symbol2scm ("allow")
+     && perm2 != ly_symbol2scm ("force"))
+    return perm2;
+  return SCM_EOL;
+}
+
 /* find the forces for all possible lines and cache ragged_ and ragged_right_ */
 void
 Constrained_breaking::initialize ()
@@ -340,7 +351,6 @@ Constrained_breaking::initialize ()
                                         ragged_right_);
   for (vsize i = 0; i + 1 < breaks_.size (); i++)
     {
-      Real max_ext = 0;
       for (vsize j = i + 1; j < breaks_.size (); j++)
        {
          int start = Paper_column::get_rank (all_[breaks_[i]]);
@@ -352,7 +362,7 @@ Constrained_breaking::initialize ()
 
          line.force_ = forces[i*breaks_.size () + j];
          if (ragged && last && !isinf (line.force_))
-           line.force_ = 0;
+           line.force_ = (line.force_ < 0 && j > i + 1) ? infinity_f : 0;
          if (isinf (line.force_))
            break;
 
@@ -363,9 +373,18 @@ Constrained_breaking::initialize ()
          line.break_permission_ = c->get_property ("line-break-permission");
          line.page_permission_ = c->get_property ("page-break-permission");
          line.turn_permission_ = c->get_property ("page-turn-permission");
-
-         max_ext = max (max_ext, extent.length ());
-         line.extent_ = extent;
+         
+         /* turn permission should always be stricter than page permission
+            and page permission should always be stricter than line permission */
+         line.page_permission_ = min_permission (line.break_permission_,
+                                                 line.page_permission_);
+         line.turn_permission_ = min_permission (line.page_permission_,
+                                                 line.turn_permission_);
+
+         line.extent_ = (extent.is_empty ()
+                         || isnan (extent[LEFT])
+                         || isnan (extent[RIGHT]))
+           ? Interval (0, 0) : extent;
          line.padding_ = padding;
          line.space_ = space;
          line.inverse_hooke_ = extent.length () + space;