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)
int first_page_number
= robust_scm2int (book_->paper_->c_variable ("first-page-number"), 1);
SCM ret = SCM_EOL;
+ SCM label_page_table = SCM_EOL;
for (vsize i = 0; i < lines_per_page.size (); i++)
{
scm_list_n (book, lines, page_num,
rag, last, SCM_UNDEFINED));
+ /* collect labels */
+ for (SCM l = lines ; scm_is_pair (l) ; l = scm_cdr (l))
+ {
+ SCM labels = SCM_EOL;
+ if (Grob * line = unsmob_grob (scm_car (l)))
+ {
+ System *system = dynamic_cast<System*> (line);
+ labels = system->get_property ("labels");
+ }
+ else if (Prob *prob = unsmob_prob (scm_car (l)))
+ labels = prob->get_property ("labels");
+
+ for (SCM lbls = labels ; scm_is_pair (lbls) ; lbls = scm_cdr (lbls))
+ label_page_table = scm_cons (scm_cons (scm_car (lbls), page_num),
+ label_page_table);
+ }
+
scm_apply_1 (page_stencil, page, SCM_EOL);
ret = scm_cons (page, ret);
systems = scm_list_tail (systems, line_count);
}
+ book_->paper_->set_variable (ly_symbol2scm ("label-page-table"), label_page_table);
ret = scm_reverse (ret);
return ret;
}
{
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,
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));
}
}
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;
{
if (cached_configuration_index_ != configuration_index)
{
+ cached_configuration_index_ = configuration_index;
SCM padding_scm = book_->paper_->c_variable ("page-breaking-between-system-padding");
if (!scm_is_number (padding_scm))
padding_scm = book_->paper_->c_variable ("between-system-padding");
{
assert (div[i] == 1);
uncompressed_line_details_.push_back (Line_details (system_specs_[sys].prob_));
- uncompressed_line_details_.back ().padding_ = padding;
+ uncompressed_line_details_.back ().padding_ =
+ robust_scm2double (system_specs_[sys].prob_->get_property ("next-padding"),
+ padding);
}
}
cached_line_details_ = compress_lines (uncompressed_line_details_);
Real ext_len = cached_line_details_[i].extent_.length ();
Real next_rod_height = cur_rod_height + ext_len
+ ((cur_rod_height > 0) ? cached_line_details_[i].padding_: 0);
- Real next_spring_height = cur_spring_height + line_space (cached_line_details_[i]);
+ Real next_spring_height = cur_spring_height + cached_line_details_[i].space_;
Real next_height = next_rod_height + (ragged () ? next_spring_height : 0);
&& cached_line_details_[i-1].page_permission_ == ly_symbol2scm ("force")))
{
cur_rod_height = ext_len;
- cur_spring_height = line_space (cached_line_details_[i]);
+ cur_spring_height = cached_line_details_[i].space_;
cur_page_height = page_height (first_page_num + ret, false);
ret++;
}
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 ()),
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)
+ cache_line_details (configuration);
+ vsize min_p_count = min_page_count (configuration, first_page_num);
+
+ if (n == 1)
{
- n_res = space_systems_on_n_pages (configuration, n, first_page_num);
- m_res = space_systems_on_n_pages (configuration, n+1, first_page_num);
+ bool rag = ragged () || (is_last () && ragged_last ());
+ Real height = page_height (first_page_num, is_last ());
+
+ if (1 >= min_p_count)
+ n_res = space_systems_on_1_page (cached_line_details_, height, rag);
+ if (1 < cached_line_details_.size ())
+ m_res = space_systems_on_2_pages (configuration, first_page_num);
}
else
{
- cache_line_details (configuration);
-
- vsize min_p_count = min_page_count (configuration, first_page_num);
Page_spacer ps (cached_line_details_, first_page_num, this);
+
if (n >= min_p_count)
n_res = ps.solve (n);
if (n < cached_line_details_.size ())
m_res = ps.solve (n+1);
}
+ m_res = finalize_spacing_result (configuration, m_res);
+ n_res = finalize_spacing_result (configuration, n_res);
+
Real penalty = blank_page_penalty ();
n_res.demerits_ += penalty;
- n_res.force_.back () += penalty;
- if (m_res.demerits_ < n_res.demerits_)
- return m_res;
- return n_res;
+ if (n_res.force_.size ())
+ n_res.force_.back () += penalty;
+
+ return (m_res.demerits_ < n_res.demerits_) ? m_res : 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);
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;
return finalize_spacing_result (configuration, best);
}
+Page_spacing_result
+Page_breaking::pack_systems_on_least_pages (vsize configuration, vsize first_page_num)
+{
+ Page_spacing_result res;
+ vsize page = 0;
+ vsize page_first_line = 0;
+ Page_spacing space (page_height (first_page_num, false));
+
+ cache_line_details (configuration);
+ for (vsize line = 0; line < cached_line_details_.size (); line++)
+ {
+ Real prev_force = space.force_;
+ space.append_system (cached_line_details_[line]);
+ if ((line > page_first_line)
+ && (isinf (space.force_)
+ || ((line > 0)
+ && (cached_line_details_[line-1].page_permission_ == ly_symbol2scm ("force")))))
+ {
+ res.systems_per_page_.push_back (line - page_first_line);
+ res.force_.push_back (prev_force);
+ res.penalty_ += cached_line_details_[line-1].page_penalty_;
+ page++;
+ space.resize (page_height (first_page_num + page, false));
+ space.clear ();
+ space.append_system (cached_line_details_[line]);
+ page_first_line = line;
+ }
+
+ if (line == cached_line_details_.size () - 1)
+ {
+ /* This is the last line */
+ /* When the last page height was computed, we did not know yet that it
+ * was the last one. If the systems put on it don't fit anymore, the last
+ * system is moved to a new page */
+ space.resize (page_height (first_page_num + page, true));
+ if ((line > page_first_line) && (isinf (space.force_)))
+ {
+ res.systems_per_page_.push_back (line - page_first_line);
+ res.force_.push_back (prev_force);
+ /* the last page containing the last line */
+ space.resize (page_height (first_page_num + page + 1, true));
+ space.clear ();
+ space.append_system (cached_line_details_[line]);
+ res.systems_per_page_.push_back (1);
+ res.force_.push_back (space.force_);
+ res.penalty_ += cached_line_details_[line-1].page_penalty_;
+ res.penalty_ += cached_line_details_[line].page_penalty_;
+ }
+ else
+ {
+ res.systems_per_page_.push_back (line + 1 - page_first_line);
+ res.force_.push_back (space.force_);
+ res.penalty_ += cached_line_details_[line].page_penalty_;
+ }
+ }
+ }
+ return finalize_spacing_result (configuration, res);
+}
+
/* 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)
{
+ if (res.force_.empty ())
+ return res;
+
cache_line_details (configuration);
res.systems_per_page_ = uncompress_solution (res.systems_per_page_, cached_line_details_);
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]);
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);
{
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]);
}
}
- 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]);
projects / lilypond.git / blobdiff