release: 1.2.8

[lilypond.git] / lily / word-wrap.cc

diff --git a/lily/word-wrap.cc b/lily/word-wrap.cc
index 9976e1bf1376565c16dc6c271cd37558810569f9..28f96e852c630d83450418df78f4ed607c3ff967 100644 (file)
--- a/lily/word-wrap.cc
+++ b/lily/word-wrap.cc
@@ -8,9 +8,9 @@
 
 #include "word-wrap.hh"
 #include "paper-def.hh"
-#include "p-score.hh"
+#include "paper-score.hh"
 #include "debug.hh"
-#include "p-col.hh"
+#include "paper-column.hh"
 #include "spring-spacer.hh"
 
 
@@ -20,36 +20,38 @@
    A Dynamic Programming type of algorithm
    similar to TeX's is in Gourlay_breaking
 
+   UGH.  Should think about pre/post break columns.
    */
 Array<Column_x_positions>
-Word_wrap::do_solve() const
+Word_wrap::do_solve () const
 {
-  problem_OK();
+  problem_OK ();
 
   Line_of_cols &allcols (pscore_l_->col_l_arr_);
   int curcol_idx = 0;
   
   Array<Column_x_positions> breaking;
-  Line_of_cols breakpoints (find_breaks());
-  assert (breakpoints.size()>=2);
+  Line_of_cols breakpoints (find_breaks ());
+  assert (breakpoints.size ()>=2);
 
   int break_idx=0;
-  int line_no = 0;
-  while (break_idx < breakpoints.size() -1)
+  while (break_idx < breakpoints.size () -1)
     {
       Column_x_positions minimum;
       Column_x_positions current;
 
 
       // do  another line
-      line_no ++;
-      Paper_column *post = breakpoints[break_idx]->postbreak_l();
+
+      Item *post = breakpoints[break_idx]->find_prebroken_piece (RIGHT);
+      Paper_column *postcol =dynamic_cast<Paper_column*>(post);
+      
       int start_break_idx = break_idx;
-      current.add_paper_column (post);
+      current.add_paper_column (postcol);
       curcol_idx++;            // skip the breakable.
       break_idx++;
 
-      while (break_idx < breakpoints.size())
+      while (break_idx < breakpoints.size ())
        {
          // add another measure.
          while (breakpoints[break_idx] != allcols[curcol_idx])
@@ -57,21 +59,23 @@ Word_wrap::do_solve() const
              current.add_paper_column (allcols[curcol_idx]);
              curcol_idx++;
            }
-         
-         current.add_paper_column (breakpoints[break_idx]->prebreak_l());
 
-         current.spacer_l_ = generate_spacing_problem (current.cols, 
-           pscore_l_->paper_l_->line_dimensions_int (line_no));
+         Item * pre = breakpoints[break_idx]->find_prebroken_piece (LEFT);
+         Paper_column* precol = dynamic_cast<Paper_column*>(pre);
+         current.add_paper_column (precol);
+
+         current.spacer_l_ = generate_spacing_problem (current.cols_, 
+           pscore_l_->paper_l_->line_dimensions_int (breaking.size ()));
 
          // try to solve
-         if (!feasible (current.cols))
+         if (!feasible (current.cols_))
            {
-             if (!minimum.cols.size())
+             if (!minimum.cols_.size ())
                {
                  warning (_ ("ugh, this measure is too long") 
                    + ", " + _f ("breakpoint: %d", break_idx) 
                    + "(" + _ ("generating stupido solution") + ")");
-                 current.stupid_solution();
+                 current.stupid_solution ();
                  current.energy_f_ = - 1; // make sure we break out.
                }
              else
@@ -79,8 +83,8 @@ Word_wrap::do_solve() const
            }
          else
            {
-             current.solve_line();
-             current.print();
+             current.solve_line ();
+             current.print ();
            }
 
          delete current.spacer_l_;
@@ -93,20 +97,24 @@ Word_wrap::do_solve() const
              break;
            }
 
+         /*
+           UGR! bug! 
+          */
          if (current.energy_f_ < minimum.energy_f_ || current.energy_f_ < 0)
            {
              minimum = current;
            }
-         else {                // we're one col too far.
-           break_idx--;
-           while (allcols[curcol_idx] != breakpoints[break_idx])
-             curcol_idx --;
-           break;              // do the next line.
-         }
+         else
+           {           // we're one col too far.
+             break_idx--;
+             while (allcols[curcol_idx] != breakpoints[break_idx])
+               curcol_idx --;
+             break;            // do the next line.
+           }
 
 
          // add nobreak version of breakable column
-         current.cols.top()=breakpoints[break_idx];
+         current.cols_.top ()=breakpoints[break_idx];
          curcol_idx ++;
          break_idx++;
        }
@@ -117,7 +125,3 @@ Word_wrap::do_solve() const
   return breaking;
 }
 
-Word_wrap::Word_wrap()
-{
-  get_line_spacer = Spring_spacer::constructor;
-}