Fix some bugs in the dynamic engraver and PostScript backend

[lilypond.git] / lily / simple-spacer.cc

diff --git a/lily/simple-spacer.cc b/lily/simple-spacer.cc
index e027b5e26ad85a387f2e0181ac902d444dbe729c..0c595f1d94b165c66a652ef31918f843f1892f67 100644 (file)
--- a/lily/simple-spacer.cc
+++ b/lily/simple-spacer.cc
@@ -211,22 +211,22 @@ Simple_spacer::compress_line ()
 void
 Simple_spacer::add_spring (Real ideal, Real inverse_hooke)
 {
-  Spring_description description;
+  Spring_description desc;
 
-  description.ideal_ = ideal;
-  description.inverse_hooke_ = inverse_hooke;
-  if (!description.is_sane ())
+  desc.ideal_ = ideal;
+  desc.inverse_hooke_ = inverse_hooke;
+  if (!desc.is_sane ())
     {
       programming_error ("insane spring found, setting to unit");
 
-      description.inverse_hooke_ = 1.0;
-      description.ideal_ = 1.0;
+      desc.inverse_hooke_ = 1.0;
+      desc.ideal_ = 1.0;
     }
 
-  description.block_force_ = -description.ideal_ / description.inverse_hooke_;
+  desc.block_force_ = -desc.ideal_ / desc.inverse_hooke_;
   // block at distance 0
 
-  springs_.push_back (description);
+  springs_.push_back (desc);
 }
 
 vector<Real>
@@ -279,48 +279,33 @@ Spring_description::length (Real f) const
   this closely.
 */
 
-struct Rod_description
+struct Rod_desc
 {
   vsize r_;
   Real dist_;
 
-  bool operator< (const Rod_description r)
+  bool operator< (const Rod_desc r)
   {
     return r_ < r.r_;
   }
 
-  Rod_description ()
-  {
-    r_ = 0;
-    dist_ = 0;
-  }
-
-  Rod_description (vsize r, Real d)
+  Rod_desc () {}
+  Rod_desc (vsize r, Real d)
   {
     r_ = r;
     dist_ = d;
   }
 };
 
-struct Column_description
+struct Column_desc
 {
-  vector<Rod_description> rods_;
-  vector<Rod_description> end_rods_;   /* use these if they end at the last column of the line */
+  vector<Rod_desc> rods_;
+  vector<Rod_desc> end_rods_;   /* use these if they end at the last column of the line */
   Real ideal_;
   Real inverse_hooke_;
   Real end_ideal_;
   Real end_inverse_hooke_;
-  SCM break_permission_;
   Interval keep_inside_line_;
-
-  Column_description ()
-  {
-    ideal_ = 0;
-    inverse_hooke_ = 0;
-    end_ideal_ = 0;
-    end_inverse_hooke_ = 0;
-    break_permission_ = SCM_EOL;
-  }
 };
 
 static int compare_paper_column_rank (Grob *const &a, Grob *const &b);
@@ -386,20 +371,20 @@ get_column_spring (Grob *this_col, Grob *next_col, Real *ideal, Real *inv_hooke)
   *inv_hooke = (spring) ? spring->inverse_strength_ : 1.0;
 }
 
-static Column_description
-get_column_description (vector<Grob*> const &cols, vsize col_index, bool line_starter)
+static Column_desc
+get_column_desc (vector<Grob*> const &cols, vsize col_index, bool line_starter)
 {
   Grob *col = cols[col_index];
   if (line_starter)
     col = maybe_find_prebroken_piece (col, RIGHT);
 
-  Column_description description;
+  Column_desc desc;
   Grob *next_col = next_spaceable_column (cols, col_index);
   if (next_col)
-    get_column_spring (col, next_col, &description.ideal_, &description.inverse_hooke_);
+    get_column_spring (col, next_col, &desc.ideal_, &desc.inverse_hooke_);
   Grob *end_col = next_line_ending_column (cols, col_index);
   if (end_col)
-    get_column_spring (col, end_col, &description.end_ideal_, &description.end_inverse_hooke_);
+    get_column_spring (col, end_col, &desc.end_ideal_, &desc.end_inverse_hooke_);
 
   for (SCM s = Spaceable_grob::get_minimum_distances (col);
        scm_is_pair (s); s = scm_cdr (s))
@@ -409,15 +394,14 @@ get_column_description (vector<Grob*> const &cols, vsize col_index, bool line_st
       if (j != VPOS)
        {
          if (cols[j] == other)
-           description.rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s))));
+           desc.rods_.push_back (Rod_desc (j, scm_to_double (scm_cdar (s))));
          else /* it must end at the LEFT prebroken_piece */
-           description.end_rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s))));
+           desc.end_rods_.push_back (Rod_desc (j, scm_to_double (scm_cdar (s))));
        }
     }
   if (!line_starter && to_boolean (col->get_property ("keep-inside-line")))
-    description.keep_inside_line_ = col->extent (col, X_AXIS);
-  description.break_permission_ = col->get_property ("line-break-permission");
-  return description;
+    desc.keep_inside_line_ = col->extent (col, X_AXIS);
+  return desc;
 }
 
 vector<Real>
@@ -425,13 +409,11 @@ get_line_forces (vector<Grob*> const &icols, vector<vsize> breaks,
                 Real line_len, Real indent, bool ragged)
 {
   vector<Real> force;
-  force.resize (breaks.size () * breaks.size (), infinity_f);
+  force.resize (breaks.size () * breaks.size ());
 
-  vector<Column_description> cols;
+  vector<Column_desc> cols;
   vsize b = 1;
-  SCM force_break = ly_symbol2scm ("force");
-
-  cols.push_back (Column_description ());
+  cols.push_back (Column_desc ());
   for (vsize i = 1; i < icols.size () - 1; i++)
     {
       if (b < breaks.size () && breaks[b] == i)
@@ -440,13 +422,13 @@ get_line_forces (vector<Grob*> const &icols, vector<vsize> breaks,
          b++;
        }
       if (!is_loose (icols[i]))
-       cols.push_back (get_column_description (icols, i, false));
+       cols.push_back (get_column_desc (icols, i, false));
     }
   breaks.back () = cols.size () - 1;
 
   for (vsize b = 0; b < breaks.size () - 1; b++)
     {
-      cols[breaks[b]] = get_column_description (icols, breaks[b], true);
+      cols[breaks[b]] = get_column_desc (icols, breaks[b], true);
       vsize st = breaks[b];
 
       for (vsize c = b+1; c < breaks.size (); c++)
@@ -475,9 +457,6 @@ get_line_forces (vector<Grob*> const &icols, vector<vsize> breaks,
            }
          spacer.solve ((b == 0) ? line_len - indent : line_len, ragged);
          force[b * breaks.size () + c] = spacer.force ();
-
-         if (cols[end].break_permission_ == force_break)
-           break;
          if (!spacer.fits ())
            {
              force[b * breaks.size () + c] = infinity_f;
@@ -494,7 +473,7 @@ get_line_configuration (vector<Grob*>const &columns,
                        Real indent,
                        bool ragged)
 {
-  vector<Column_description> cols;
+  vector<Column_desc> cols;
   Simple_spacer spacer;
   Column_x_positions ret;
 
@@ -511,22 +490,15 @@ get_line_configuration (vector<Grob*>const &columns,
   cols.resize (ret.cols_.size () - 1);
 
   /* since we've already put our line-ending column in the column list, we can ignore
-     the end_XXX_ fields of our column_description */
+     the end_XXX_ fields of our column_desc */
   for (vsize i = 0; i < cols.size (); i++)
     {
-      cols[i] = get_column_description (ret.cols_, i, i == 0);
+      cols[i] = get_column_desc (ret.cols_, i, i == 0);
       spacer.add_spring (cols[i].ideal_, cols[i].inverse_hooke_);
     }
   for (vsize i = 0; i < cols.size (); i++)
-    {
-      for (vsize r = 0; r < cols[i].rods_.size (); r++)
-       spacer.add_rod (i, cols[i].rods_[r].r_, cols[i].rods_[r].dist_);
-      if (!cols[i].keep_inside_line_.is_empty ())
-       {
-         spacer.add_rod (i, cols.size (), cols[i].keep_inside_line_[RIGHT]);
-         spacer.add_rod (0, i, cols[i].keep_inside_line_[LEFT]);
-       }
-    }
+    for (vsize r = 0; r < cols[i].rods_.size (); r++)
+      spacer.add_rod (i, cols[i].rods_[r].r_, cols[i].rods_[r].dist_);
 
   spacer.solve (line_len, ragged);
   ret.force_ = spacer.force ();