page breaking coding style

- Page_spacing_result in separate file.
- declare variables at init.

diff --git a/lily/constrained-breaking.cc b/lily/constrained-breaking.cc
index 4604f5439d0173ae9c048f448ee341a77644190f..1cce9bd66eb34d1c87d9504fa54e526dae8b3f68 100644 (file)
--- a/lily/constrained-breaking.cc
+++ b/lily/constrained-breaking.cc
@@ -189,7 +189,7 @@ Constrained_breaking::solve (vsize start, vsize end, vsize sys_count)
 vector<Column_x_positions>
 Constrained_breaking::best_solution (vsize start, vsize end)
 {
-  vsize min_systems =  min_system_count (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;

diff --git a/lily/include/lily-proto.hh b/lily/include/lily-proto.hh
index 768f24002cf4436bbb067b618b9f02558f2f1e7a..4754d498da31ff385e54412bb9571604fec9ac70 100644 (file)
--- a/lily/include/lily-proto.hh
+++ b/lily/include/lily-proto.hh
@@ -123,6 +123,7 @@ class Object_key_dumper;
 class Object_key_undumper;
 class Open_type_font;
 class Output_property;
+class Page_breaking;
 class Pango_font;
 class Paper_book;
 class Paper_column;

diff --git a/lily/include/page-breaking.hh b/lily/include/page-breaking.hh
index 208c1e8b0e9b57760ffb3183fb5eacb2ac87cf78..082384d0fe61daba22f62d30205dc9e6b5e9b68f 100644 (file)
--- a/lily/include/page-breaking.hh
+++ b/lily/include/page-breaking.hh
@@ -41,6 +41,9 @@ struct System_spec
 
 struct Break_position
 {
+  /*
+    index in system_spec_index_, if VPOS start of book. 
+   */
   vsize system_spec_index_;
 
   /* if system_spec_index_ is a score, then we start at the score_brk_'th possible
@@ -122,11 +125,11 @@ protected:
 
   vsize current_configuration_count () const;
   Line_division current_configuration (vsize configuration_index) const;
-  Spacing_result space_systems_on_n_pages (vsize configuration_index,
+  Page_spacing_result space_systems_on_n_pages (vsize configuration_index,
                                           vsize n, vsize first_page_num);
-  Spacing_result space_systems_on_n_or_one_more_pages (vsize configuration_index, vsize n,
+  Page_spacing_result space_systems_on_n_or_one_more_pages (vsize configuration_index, vsize n,
                                                       vsize first_page_num);
-  Spacing_result space_systems_on_best_pages (vsize configuration_index,
+  Page_spacing_result space_systems_on_best_pages (vsize configuration_index,
                                              vsize first_page_num);
   vsize min_page_count (vsize configuration_index, vsize first_page_num);
   bool all_lines_stretched (vsize configuration_index);
@@ -168,9 +171,9 @@ private:
                           Line_division *cur);
 
   vector<Line_details> line_details (vsize start, vsize end, Line_division const &div);
-  Spacing_result space_systems_on_1_page (vector<Line_details> const &lines, Real page_height, bool ragged);
-  Spacing_result space_systems_on_2_pages (vsize configuration_index, vsize first_page_num);
-  Spacing_result finalize_spacing_result (vsize configuration_index, Spacing_result);
+  Page_spacing_result space_systems_on_1_page (vector<Line_details> const &lines, Real page_height, bool ragged);
+  Page_spacing_result space_systems_on_2_pages (vsize configuration_index, vsize first_page_num);
+  Page_spacing_result finalize_spacing_result (vsize configuration_index, Page_spacing_result);
   void create_system_list ();
   void find_chunks_and_breaks (Break_predicate);
 };

diff --git a/lily/include/page-spacing-result.hh b/lily/include/page-spacing-result.hh
new file mode 100644 (file)
index 0000000..7b8ae88
--- /dev/null
+++ b/lily/include/page-spacing-result.hh
@@ -0,0 +1,26 @@
+/* 
+  page-spacing-result.hh -- declare  Page_spacing_result
+  
+  source file of the GNU LilyPond music typesetter
+  
+  (c) 2007 Han-Wen Nienhuys <hanwen@lilypond.org>
+  
+*/
+
+#ifndef PAGE_SPACING_RESULT_HH
+#define PAGE_SPACING_RESULT_HH
+
+#include "std-vector.hh"
+#include "lily-proto.hh"
+
+struct Page_spacing_result {
+  vector<vsize> systems_per_page_;
+  vector<Real> force_;
+  Real penalty_;
+  Real demerits_;
+
+  vsize system_count () const;  
+  Page_spacing_result ();
+};
+
+#endif /* PAGE_SPACING_RESULT_HH */

diff --git a/lily/include/page-spacing.hh b/lily/include/page-spacing.hh
index 7dba158c84929bfd8fa182dd39afa5415d29ddbd..fc4c15f55e0662862d2d3558dde17e17f5c96a88 100644 (file)
--- a/lily/include/page-spacing.hh
+++ b/lily/include/page-spacing.hh
@@ -11,32 +11,18 @@
 #define PAGE_SPACING_HH
 
 #include "constrained-breaking.hh"
+#include "page-spacing-result.hh"
 
-struct Spacing_result {
-  vector<vsize> systems_per_page_;
-  vector<Real> force_;
-  Real penalty_;
-  Real demerits_;
-
-  Spacing_result ()
-  {
-    penalty_ = 0;
-    demerits_ = infinity_f;
-  }
-};
 
 /* for page_count > 2, we use a dynamic algorithm similar to
    constrained-breaking -- we have a class that stores the intermediate
    calculations so they can be reused for querying different page counts.
 */
-
-class Page_breaking;
-
 class Page_spacer
 {
 public:
   Page_spacer (vector<Line_details> const &lines, vsize first_page_num, Page_breaking const*);
-  Spacing_result solve (vsize page_count);
+  Page_spacing_result solve (vsize page_count);
 
 private:
   struct Page_spacing_node

diff --git a/lily/optimal-page-breaking.cc b/lily/optimal-page-breaking.cc
index 4f82c2d1aec0ae86a8bd17c660d9e79295535428..a0ba883396d5874e0f7cd397660c2ac166b3b9eb 100644 (file)
--- a/lily/optimal-page-breaking.cc
+++ b/lily/optimal-page-breaking.cc
@@ -37,29 +37,21 @@ SCM
 Optimal_page_breaking::solve ()
 {
   vsize end = last_break_position ();
-  vsize min_sys_count = 0;
-  vsize ideal_sys_count = 0;
   vsize max_sys_count = max_system_count (0, end);
-  vsize page_count = 0;
-  
-  Line_division ideal_line_division;
-  Line_division best_division;
-  Line_division bound;
   vsize first_page_num = robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1);
 
   /* find out the ideal number of pages */
   message (_ ("Finding the ideal number of pages..."));
   set_to_ideal_line_configuration (0, end);
-  ideal_line_division = current_configuration (0);
-
-  Spacing_result best = space_systems_on_best_pages (0, first_page_num);
-  page_count = best.systems_per_page_.size ();
-  best_division = ideal_line_division;
-
-  for (vsize i = 0; i < page_count; i++)
-    ideal_sys_count += best.systems_per_page_[i];
+  
+  Line_division ideal_line_division = current_configuration (0);
+  Page_spacing_result best = space_systems_on_best_pages (0, first_page_num);
+  vsize page_count = best.systems_per_page_.size ();
+  Line_division best_division = ideal_line_division;
 
-  min_sys_count = ideal_sys_count - best.systems_per_page_.back ();
+  vsize ideal_sys_count = best.system_count ();
+  vsize min_sys_count = ideal_sys_count - best.systems_per_page_.back ();
+  
   if (page_count > 1)
     min_sys_count -= best.systems_per_page_[page_count - 2];
 
@@ -69,16 +61,16 @@ Optimal_page_breaking::solve ()
     message (_f ("Fitting music on %d or %d pages...", (int)page_count-1, (int)page_count));
 
   /* try a smaller number of systems than the ideal number for line breaking */
-  bound = ideal_line_division;
+  Line_division bound = ideal_line_division;
   for (vsize sys_count = ideal_sys_count; --sys_count >= min_sys_count;)
     {
-      Spacing_result best_for_this_sys_count;
+      Page_spacing_result best_for_this_sys_count;
       set_current_breakpoints (0, end, sys_count, Line_division (), bound);
 
       for (vsize i = 0; i < current_configuration_count (); i++)
        {
          vsize min_p_count = min_page_count (i, first_page_num);
-         Spacing_result cur;
+         Page_spacing_result cur;
 
          if (min_p_count > page_count)
            continue;
@@ -126,7 +118,7 @@ Optimal_page_breaking::solve ()
       for (vsize i = 0; i < current_configuration_count (); i++)
        {
          vsize min_p_count = min_page_count (i, first_page_num);
-         Spacing_result cur;
+         Page_spacing_result cur;
 
          if (min_p_count > page_count)
            continue;

diff --git a/lily/page-breaking.cc b/lily/page-breaking.cc
index d84c278a900d10ebb97fea9bae9208a046fddd96..1d96f7359fc45aca536405f115d4f469cc27349c 100644 (file)
--- a/lily/page-breaking.cc
+++ b/lily/page-breaking.cc
@@ -91,7 +91,7 @@ Page_breaking::next_system (Break_position const &break_pos) const
     return 0;
   if (system_specs_[sys].pscore_ && !break_pos.score_ender_)
     return sys; /* the score overflows the previous page */
-  return sys + 1; /* this page starts with a new sys */
+  return sys + 1; /* this page starts with a new System_spec */
 }
 
 Page_breaking::Page_breaking (Paper_book *pb, Break_predicate is_break)
@@ -309,13 +309,14 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break)
     {
       if (system_specs_[i].pscore_)
        {
-         vector<Grob*> cols = system_specs_[i].pscore_->root_system ()->used_columns ();
+         vector<Grob*> cols
+           = system_specs_[i].pscore_->root_system ()->used_columns ();
          vector<vsize> line_breaker_columns;
          line_breaker_columns.push_back (0);
 
          for (vsize j = 1; j < cols.size (); j++)
            {
-             bool last = j == cols.size () - 1;
+             bool last = (j == cols.size () - 1);
              bool break_point = is_break (cols[j]);
              bool chunk_end = cols[j]->get_property ("page-break-permission") == force_sym;
              Break_position cur_pos = Break_position (i,
@@ -340,6 +341,9 @@ Page_breaking::find_chunks_and_breaks (Break_predicate is_break)
            breaks_.push_back (Break_position (i));
 
          chunks_.push_back (Break_position (i));
+
+         /* FIXME: shouldn't we push a Null_breaker or similar dummy
+            class? --hwn */
          line_breaking_.push_back (Constrained_breaking (NULL));
        }
     }
@@ -351,8 +355,8 @@ Page_breaking::chunk_list (vsize start_index, vsize end_index)
   Break_position start = breaks_[start_index];
   Break_position end = breaks_[end_index];
 
-  vsize i;
-  for (i = 0; i < chunks_.size () && chunks_[i] <= start; i++)
+  vsize i = 0;
+  for (; i < chunks_.size () && chunks_[i] <= start; i++)
     ;
 
   vector<Break_position> ret;
@@ -638,15 +642,15 @@ Page_breaking::min_page_count (vsize configuration, vsize first_page_num)
   return ret;
 }
 
-Spacing_result
+Page_spacing_result
 Page_breaking::space_systems_on_n_pages (vsize configuration, vsize n, vsize first_page_num)
 {
-  Spacing_result ret;
+  Page_spacing_result ret;
   assert (n >= min_page_count (configuration, first_page_num));
 
   cache_line_details (configuration);
   if (n > cached_line_details_.size ())
-    return Spacing_result ();
+    return Page_spacing_result ();
   if (n == 1)
     ret = space_systems_on_1_page (cached_line_details_,
                                   page_height (first_page_num, is_last ()),
@@ -669,11 +673,11 @@ Page_breaking::blank_page_penalty () const
   return robust_scm2double (book_->paper_->lookup_variable (penalty_sym), 0.0);
 }
 
-Spacing_result
+Page_spacing_result
 Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize n, vsize first_page_num)
 {
-  Spacing_result n_res;
-  Spacing_result m_res;
+  Page_spacing_result n_res;
+  Page_spacing_result m_res;
 
   if (n <= 2)
     {
@@ -701,7 +705,7 @@ Page_breaking::space_systems_on_n_or_one_more_pages (vsize configuration, vsize
   return n_res;
 }
 
-Spacing_result
+Page_spacing_result
 Page_breaking::space_systems_on_best_pages (vsize configuration, vsize first_page_num)
 {
   vsize min_p_count = min_page_count (configuration, first_page_num);
@@ -709,13 +713,13 @@ Page_breaking::space_systems_on_best_pages (vsize configuration, vsize first_pag
 
   cache_line_details (configuration);
   Page_spacer ps (cached_line_details_, first_page_num, this);
-  Spacing_result best = ps.solve (min_p_count);
+  Page_spacing_result best = ps.solve (min_p_count);
   best.force_.back () += (min_p_count % 2) ? odd_pages_penalty : 0;
   best.demerits_ += (min_p_count % 2) ? odd_pages_penalty : 0;
 
   for (vsize i = min_p_count+1; i <= cached_line_details_.size (); i++)
     {
-      Spacing_result cur = ps.solve (i);
+      Page_spacing_result cur = ps.solve (i);
       cur.demerits_ += (i % 2) ? odd_pages_penalty : 0;
       if (cur.demerits_ < best.demerits_)
        best = cur;
@@ -726,8 +730,8 @@ Page_breaking::space_systems_on_best_pages (vsize configuration, vsize first_pag
 
 /* Calculate demerits and fix res.systems_per_page_ so that
    it refers to the original line numbers, not the ones given by compress_lines (). */
-Spacing_result
-Page_breaking::finalize_spacing_result (vsize configuration, Spacing_result res)
+Page_spacing_result
+Page_breaking::finalize_spacing_result (vsize configuration, Page_spacing_result res)
 {
   cache_line_details (configuration);
   res.systems_per_page_ = uncompress_solution (res.systems_per_page_, cached_line_details_);
@@ -769,11 +773,11 @@ Page_breaking::finalize_spacing_result (vsize configuration, Spacing_result res)
    space_systems functions. This is because space_systems_on_1_page is (unlike
    the other space_systems functions) sometimes called on subsets of a full
    configuration. */
-Spacing_result
+Page_spacing_result
 Page_breaking::space_systems_on_1_page (vector<Line_details> const &lines, Real page_height, bool ragged)
 {
   Page_spacing space (page_height);
-  Spacing_result ret;
+  Page_spacing_result ret;
 
   for (vsize i = 0; i < lines.size (); i++)
     space.append_system (lines[i]);
@@ -786,7 +790,7 @@ Page_breaking::space_systems_on_1_page (vector<Line_details> const &lines, Real
   return ret;
 }
 
-Spacing_result
+Page_spacing_result
 Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_num)
 {
   Real page1_height = page_height (first_page_num, false);
@@ -801,8 +805,8 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n
       {
        vector<Line_details> lines1 (cached_line_details_.begin (), cached_line_details_.begin () + i + 1);
        vector<Line_details> lines2 (cached_line_details_.begin () + i + 1, cached_line_details_.end ());
-       Spacing_result p1 = space_systems_on_1_page (lines1, page1_height, ragged1);
-       Spacing_result p2 = space_systems_on_1_page (lines2, page2_height, ragged2);
+       Page_spacing_result p1 = space_systems_on_1_page (lines1, page1_height, ragged1);
+       Page_spacing_result p2 = space_systems_on_1_page (lines2, page2_height, ragged2);
 
        p1.systems_per_page_.push_back (p2.systems_per_page_[0]);
        p1.force_.push_back (p2.force_[0]);
@@ -849,7 +853,7 @@ Page_breaking::space_systems_on_2_pages (vsize configuration, vsize first_page_n
        }
     }
 
-  Spacing_result ret;
+  Page_spacing_result ret;
   ret.systems_per_page_.push_back (best_sys_count);
   ret.systems_per_page_.push_back (cached_line_details_.size () - best_sys_count);
   ret.force_.push_back (page1_force[best_sys_count-1]);

diff --git a/lily/page-spacing-result.cc b/lily/page-spacing-result.cc
new file mode 100644 (file)
index 0000000..9a05ef8
--- /dev/null
+++ b/lily/page-spacing-result.cc
@@ -0,0 +1,26 @@
+/* 
+  page-spacing-result.cc -- implement Page_spacing_result
+  
+  source file of the GNU LilyPond music typesetter
+  
+  (c) 2007 Han-Wen Nienhuys <hanwen@lilypond.org>
+  
+*/
+
+#include "page-spacing-result.hh"
+
+Page_spacing_result::Page_spacing_result ()
+{
+  penalty_ = 0;
+  demerits_ = infinity_f;
+}
+
+vsize
+Page_spacing_result::system_count () const
+{
+  vsize total = 0;
+  for (vsize i = 0; i < systems_per_page_.size(); i++)
+    total += systems_per_page_[i];
+
+  return total;      
+}

diff --git a/lily/page-spacing.cc b/lily/page-spacing.cc
index 60e5174c3b5f0c10e6c1aa0a843f1575e205b996..536e4ff7a002beac3746b573bb8f1f0182979c4e 100644 (file)
--- a/lily/page-spacing.cc
+++ b/lily/page-spacing.cc
@@ -77,13 +77,13 @@ Page_spacer::Page_spacer (vector<Line_details> const &lines, vsize first_page_nu
   ragged_last_ = breaker->is_last () && breaker->ragged_last ();
 }
 
-Spacing_result
+Page_spacing_result
 Page_spacer::solve (vsize page_count)
 {
   if (page_count > max_page_count_)
     resize (page_count);
 
-  Spacing_result ret;
+  Page_spacing_result ret;
   ret.force_.resize (page_count);
   ret.systems_per_page_.resize (page_count);
 
@@ -108,7 +108,7 @@ Page_spacer::solve (vsize page_count)
          system = i;
        }
       else
-       return Spacing_result (); /* couldn't salvage it -- probably going to crash */
+       return Page_spacing_result (); /* couldn't salvage it -- probably going to crash */
     }
 
   ret.penalty_ = state_.at (system, page_count-1).penalty_

diff --git a/lily/page-turn-page-breaking.cc b/lily/page-turn-page-breaking.cc
index d17e6a86a3d34c8d86202729380940d563f9c76f..b818dc09a1cf85ad5b9f3c8408e7928cb64a700b 100644 (file)
--- a/lily/page-turn-page-breaking.cc
+++ b/lily/page-turn-page-breaking.cc
@@ -61,7 +61,7 @@ Page_turn_page_breaking::put_systems_on_pages (vsize start,
      min_p_count has that evenness. (For example, if PAGE-NUMBER is even and
      min_p_count is even, we don't even consider the blank page option). */
 
-  Spacing_result result;
+  Page_spacing_result result;
   if (start == 0 && auto_first)
     {
       if (min_p_count % 2)