/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 2006--2010 Joe Neeman <joeneeman@gmail.com>
+ Copyright (C) 2006--2011 Joe Neeman <joeneeman@gmail.com>
LilyPond is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
discarded after a call to set_current_breakpoints, since that Line_division
refers to a subset of chunks which might be different from the current
subset of chunks under consideration.
+
+ HOW TO WRITE A PAGE BREAKING ALGORITHM
+ All page breakers supported by this class work more-or-less in the same way.
+ First, they request a particular number of systems by saying
+ set_current_breakpoints (0, last_break_position (), system_count)
+ (never mind what the first two arguments do, I'll get to them later).
+ Alternatively, you can do
+ set_to_ideal_line_configuration (0, last_break_position ()),
+ and the number of systems will be automatically chosen according to what
+ the line breaker wants.
+
+ If there are multiple scores, there will be many different ways to achieve
+ a certain number of lines. You can see how many alternatives are available
+ with current_configuration_count (). For every i from 0 to
+ current_configuration_count ()-1, you can see the line division of the
+ corresponding configuration with current_configuration (i), or you can try
+ out various page configurations with one of the space_systems_xxx or
+ pack_systems_xxx functions. The first argument to each of these functions
+ is the configuration index.
+
+ When you're done trying out configurations and you've picked the one
+ you want, do
+ break_into_pieces (0, last_break_position (), line_division_that_you_want);
+ return make_pages (systems_per_page, systems ());
+ where systems_per_page is a vector of numbers telling how many systems are
+ on each page. You can get your systems_per_page vector by looking inside
+ the Page_spacing_results that are returned by space_systems_xxx or
+ pack_systems_xxx.
+
+ A note on performance: set_current_breakpoints is EXPONENTIALLY SLOW unless
+ you constrain it by giving it a lower or an upper bound on the configurations
+ it looks for. Optimal_page_breaking, for example, works by trying
+ out a bunch of configurations, increasing the system count by one, trying
+ again and so on. Each time we increase the system count, we assume that the
+ best new configurations are going to be elementwise larger than the
+ best configuration for the previous system count (in other words, we're going
+ to get a new configuration just by adding an extra line to sone score
+ and leaving the rest the same). Therefore, we pass the best previous line
+ division as an lower bound to set_current_breakpoints.
+
+ Now you should be in a position to understand Optimal_page_breaking::solve.
+ Go ahead and read that before finding out, in the next paragraph,
+ what the first two arguments to set_current_breakpoints do.
+
+ "BREAKS"
+ Sometimes, it's useful to run this whole page-breaking machinery on a subset
+ of the book. To do this, you can mark certain "breaks" in the book (a poor
+ choice of name, perhaps, since a "break" here is different from a page break)
+ and you can run page breaking between any two breaks. You mark your breaks
+ by providing a Break_predicate (and, if you want, a Prob_break_predicate)
+ to Page_breaking's constructor. You then choose a subset of your book
+ by passing the starting and ending breaks to set_current_breakpoints. You
+ can see an example of this in Page_turn_page_breaking, where there is a break
+ everywhere that a page turn is allowed.
*/
#include "page-breaking.hh"
#include "international.hh"
#include "item.hh"
+#include "line-interface.hh"
#include "output-def.hh"
#include "page-layout-problem.hh"
#include "page-spacing.hh"
#include "paper-book.hh"
#include "paper-score.hh"
#include "paper-system.hh"
+#include "text-interface.hh"
#include "system.hh"
#include "warn.hh"
// compressed.title_ is true if and only if the first of its
// compressed lines was a title.
- compressed.title_ = old.title_;
+ compressed.title_ = old.title_;
+
+ // adds footnotes of one line to the footnotes of another
+ compressed.footnotes_.insert (compressed.footnotes_.begin (),
+ old.footnotes_.begin (), old.footnotes_.end ());
+
ret.back () = compressed;
}
else
min_systems_per_page_ = max (0, robust_scm2int (pb->paper_->c_variable ("min-systems-per-page"), 0));
orphan_penalty_ = robust_scm2int (pb->paper_->c_variable ("orphan-penalty"), 100000);
+ Stencil *footnote_separator = Page_layout_problem::get_footnote_separator_stencil (pb->paper_);
+
+ if (footnote_separator)
+ {
+ Interval separator_extent = footnote_separator->extent (Y_AXIS);
+ Real separator_span = separator_extent.length ();
+
+ footnote_separator_stencil_height_ = separator_span;
+ }
+ else
+ footnote_separator_stencil_height_ = 0.0;
+
+ footnote_padding_ = robust_scm2double (pb->paper_->c_variable ("footnote-padding"), 0.0);
+ footnote_footer_padding_ = robust_scm2double (pb->paper_->c_variable ("footnote-footer-padding"), 0.0);
+
+ footnote_number_raise_ = (to_boolean (pb->paper_->c_variable ("footnote-auto-numbering"))
+ ? robust_scm2double (pb->paper_->c_variable ("footnote-number-raise"), 0.0)
+ : 0.0);
+
if (systems_per_page_ && (max_systems_per_page_ || min_systems_per_page_))
{
warning (_f ("ignoring min-systems-per-page and max-systems-per-page because systems-per-page was set"));
return system_count_;
}
+Real
+Page_breaking::footnote_separator_stencil_height () const
+{
+ return footnote_separator_stencil_height_;
+}
+
+Real
+Page_breaking::footnote_padding () const
+{
+ return footnote_padding_;
+}
+
+Real
+Page_breaking::footnote_footer_padding () const
+{
+ return footnote_footer_padding_;
+}
+
+Real
+Page_breaking::footnote_number_raise () const
+{
+ return footnote_number_raise_;
+}
+
bool
Page_breaking::too_many_lines (int line_count) const
{
}
SCM
-Page_breaking::get_page_configuration (SCM systems, int page_num, bool ragged, bool last)
+Page_breaking::get_page_configuration (SCM systems, int page_num, int footnote_count, bool ragged, bool last)
{
SCM dummy_page = make_page (page_num, last);
- Page_layout_problem layout (book_, dummy_page, systems);
+ Page_layout_problem layout (book_, dummy_page, systems, footnote_count);
return scm_is_pair (systems) ? layout.solution (ragged) : SCM_EOL;
}
SCM
-Page_breaking::draw_page (SCM systems, SCM configuration, int page_num, bool last)
+Page_breaking::draw_page (SCM systems, SCM configuration, int page_num, int footnote_num, bool last)
{
// Create a stencil for each system.
SCM paper_systems = SCM_EOL;
Prob *p = unsmob_prob (page);
p->set_property ("lines", paper_systems);
p->set_property ("configuration", configuration);
+
+ Stencil *foot = unsmob_stencil (p->get_property ("foot-stencil"));
+
+ footnote_num = (to_boolean (book_->paper_->c_variable ("reset-footnotes-on-new-page"))
+ ? 0
+ : footnote_num);
+
+ SCM footnotes = Page_layout_problem::get_footnotes_from_lines (systems,
+ footnote_num,
+ book_);
+
+ Page_layout_problem::add_footnotes_to_footer (footnotes, foot, book_);
+
+ p->set_property ("foot-stencil", foot->smobbed_copy ());
scm_apply_1 (page_stencil, page, SCM_EOL);
return page;
// themselves. If this happens before the neighbouring staves have
// been laid out, bad side-effects could happen (in particular,
// Align_interface::align_to_ideal_distances might be called).
- SCM systems_and_configs = SCM_EOL;
-
+ SCM systems_configs_fncounts = SCM_EOL;
+ vsize footnote_count = 0;
+
for (vsize i = 0; i < lines_per_page.size (); i++)
{
int page_num = i + first_page_number;
bool rag = ragged () || (bookpart_last_page && ragged_last ());
SCM line_count = scm_from_int (lines_per_page[i]);
SCM lines = scm_list_head (systems, line_count);
- SCM config = get_page_configuration (lines, page_num, rag, bookpart_last_page);
-
- systems_and_configs = scm_cons (scm_cons (lines, config), systems_and_configs);
+ int fn_lines = Page_layout_problem::get_footnote_count (lines);
+ SCM config = get_page_configuration (lines, page_num, footnote_count, rag, bookpart_last_page);
+
+ systems_configs_fncounts = scm_cons (scm_list_3 (lines, config, scm_from_int ((int)footnote_count)), systems_configs_fncounts);
+ footnote_count += fn_lines;
systems = scm_list_tail (systems, line_count);
}
// Now it's safe to make the pages.
int page_num = first_page_number + lines_per_page.size () - 1;
- for (SCM s = systems_and_configs; scm_is_pair (s); s = scm_cdr (s))
+ for (SCM s = systems_configs_fncounts; scm_is_pair (s); s = scm_cdr (s))
{
SCM lines = scm_caar (s);
- SCM config = scm_cdar (s);
- bool bookpart_last_page = (s == systems_and_configs);
- SCM page = draw_page (lines, config, page_num, bookpart_last_page);
+ SCM config = scm_cadar (s);
+ int footnote_num = scm_to_int (scm_caddar (s));
+ bool bookpart_last_page = (s == systems_configs_fncounts);
+ SCM page = draw_page (lines, config, page_num, footnote_num, bookpart_last_page);
/* collect labels */
SCM page_num_scm = scm_from_int (page_num);
for (SCM l = lines ; scm_is_pair (l) ; l = scm_cdr (l))
ret = scm_cons (page, ret);
--page_num;
}
+
+ // By reversing the table, we ensure that duplicated labels (eg. those
+ // straddling a page turn) will appear in the table with their last
+ // occurence first.
+ label_page_table = scm_reverse_x (label_page_table, SCM_EOL);
book_->top_paper ()->set_variable (ly_symbol2scm ("label-page-table"), label_page_table);
return ret;
}
return ret;
}
+// Returns the minimum number of _non-title_ lines.
vsize
Page_breaking::min_system_count (vsize start, vsize end)
{
return ret;
}
+// Returns the maximum number of _non-title_ lines.
vsize
Page_breaking::max_system_count (vsize start, vsize end)
{
return ret;
}
+// The numbers returned by this function represent either
+// the maximum or minimum number of _non-title_ lines
+// per chunk.
Page_breaking::Line_division
Page_breaking::system_count_bounds (vector<Break_position> const &chunks,
bool min)
assert (chunks.size () >= 2);
Line_division ret;
- ret.resize (chunks.size () - 1, 1);
+ ret.resize (chunks.size () - 1, 0);
for (vsize i = 0; i + 1 < chunks.size (); i++)
{
div.push_back (line_breaking_[sys].best_solution (start, end).size ());
}
else
- div.push_back (1);
+ div.push_back (0);
system_count_ += div.back ();
}
}
else
{
- assert (div[i] == 1);
+ assert (div[i] == 0);
uncompressed_line_details_.push_back (system_specs_[sys].prob_
? Line_details (system_specs_[sys].prob_, book_->paper_)
: Line_details ());
int real_min = max ((int) min_sys[my_index], (int) system_count - others_max);
int real_max = min ((int) max_sys[my_index], (int) system_count - others_min);
- if (real_min > real_max || real_min <= 0)
+ if (real_min > real_max || real_min < 0)
{
/* this should never happen within a recursive call. If it happens
at all, it means that we were called with an unsolvable problem
projects / lilypond.git / blobdiff