--- /dev/null
+\version "2.13.54"
+\header {
+ texidoc = "With grobs that have break visibility, footnotes will
+automatically print to the first line of the break. This behavior
+can be overrided."
+}
+
+#(set-default-paper-size "a6")
+
+\book {
+
+\new Staff \with { \consists "Footnote_engraver" }
+{
+ \relative c' {
+ c1
+ \footnoteGrob #'TimeSignature #'(0 . 2) "foo" "bar"
+ \time 3/4
+ \break \pageBreak
+ c2.
+ \once \override Staff . FootnoteItem #'break-visibility = ##(#f #f #t)
+ \footnoteGrob #'TimeSignature #'(0 . 2) "foo" "bar"
+ \time 4/4
+ \break \pageBreak
+ c1 \bar "|."
+}}}
--- /dev/null
+\version "2.13.54"
+\header {
+ texidoc = "Footnotes are annotated at the correct place, and the
+annotation goes to the correct page."
+}
+
+#(set-default-paper-size "a6")
+
+\paper { ragged-last-bottom = ##f }
+
+\book {
+
+\relative c'' {
+\once \override FootnoteSpanner #'spanner-placement = #-0.7
+\footnoteGrob #'Hairpin
+ #'(0.5 . 0.5)
+ \markup { \tiny "1." }
+ \markup { 1. \justify { Goes to the second broken spanner. } }
+b4\< c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a \break \pageBreak
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a\!
+
+\once \override FootnoteSpanner #'spanner-placement = #1.0
+\footnoteGrob #'Hairpin
+ #'(0.5 . 0.5)
+ \markup { \tiny "2." }
+ \markup { 2. \justify { Goes to the last broken spanner. } }
+b4\< c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a \break \pageBreak
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d a
+b c d\!
+}}
--- /dev/null
+\version "2.13.54"
+\header {
+ texidoc = "Lilypond does footnotes."
+}
+
+#(set-default-paper-size "a6")
+\book {
+
+\markup {
+ a \footnote \concat { b \super 1 } "1. c"
+ \footnote \concat { d \super 2 } "2. e"
+ \footnote \line { f \super 3 } "3. g"
+}
+
+\markup { h i }
+
+\relative c' {
+\footnoteGrob #'NoteHead #'(1 . -1) \markup { \tiny 4 } \markup { 4. j }
+a b c d }
+
+\pageBreak
+
+\markup { k \footnote \concat { l \super 5 } \line { 5. m } }
+
+\relative c' { a1 }
+
+\relative c' {
+ d4 e
+ < f a-\footnote #'(1 . -1) \markup { \tiny 6 } \markup { 6. n } c >
+ \footnoteGrob #'Beam #'(1 . 1) \markup { \tiny 7 } \markup { 7. o }
+ \footnoteGrob #'Hairpin #'(1 . 1) \markup { \tiny 8 } \markup { 8. p }
+ a8\< [ b c d\f ] r2. |
+}}
out->title_space_ = system_markup_space_;
out->inverse_hooke_ = out->full_height () + system_system_space_;
+ out->footnotes_ = sys->get_footnotes_in_range (start_rank, end_rank);
+
out->refpoint_extent_ = sys->pure_refpoint_extent (start_rank, end_rank);
if (out->refpoint_extent_.is_empty ())
out->refpoint_extent_ = Interval (0, 0);
Page_layout_problem::read_spacing_spec (spec, &min_distance_, ly_symbol2scm ("minimum-distance"));
Page_layout_problem::read_spacing_spec (title_spec, &title_min_distance_, ly_symbol2scm ("minimum-distance"));
+ SCM footnotes = pb->get_property ("footnotes");
+ if (scm_is_pair (footnotes))
+ for (SCM s = footnotes; scm_is_pair (s); s = scm_cdr (s))
+ footnotes_.push_back (unsmob_stencil (scm_car (s)));
+
last_column_ = 0;
force_ = 0;
Interval stencil_extent = unsmob_stencil (pb->get_property ("stencil"))->extent (Y_AXIS);
DECLARE_TRANSLATOR_LISTENER (break_span);
DECLARE_ACKNOWLEDGER (note_column);
DECLARE_ACKNOWLEDGER (dynamic);
+ DECLARE_ACKNOWLEDGER (footnote_spanner);
DECLARE_END_ACKNOWLEDGER (dynamic);
protected:
ADD_ACKNOWLEDGER (Dynamic_align_engraver, dynamic);
ADD_ACKNOWLEDGER (Dynamic_align_engraver, note_column);
+ADD_ACKNOWLEDGER (Dynamic_align_engraver, footnote_spanner);
ADD_END_ACKNOWLEDGER (Dynamic_align_engraver, dynamic);
void
ended_.push_back (info.spanner ());
}
+void
+Dynamic_align_engraver::acknowledge_footnote_spanner (Grob_info info)
+{
+ Grob *parent = info.grob ()->get_parent (Y_AXIS);
+ if (line_ && parent
+ && parent->internal_has_interface (ly_symbol2scm ("dynamic-interface")))
+ Axis_group_interface::add_element (line_, info.grob ());
+}
+
void
Dynamic_align_engraver::acknowledge_note_column (Grob_info info)
{
--- /dev/null
+/*
+ This file is part of LilyPond, the GNU music typesetter.
+
+ Copyright (C) 2011 Mike Solomon <mike@apollinemike.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
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ LilyPond is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "engraver.hh"
+
+#include "stream-event.hh"
+#include "item.hh"
+#include "pointer-group-interface.hh"
+#include "spanner.hh"
+
+#include "translator.icc"
+
+class Footnote_engraver : public Engraver
+{
+ TRANSLATOR_DECLARATIONS (Footnote_engraver);
+
+ DECLARE_TRANSLATOR_LISTENER (footnote);
+ DECLARE_ACKNOWLEDGER (grob);
+ DECLARE_END_ACKNOWLEDGER (grob);
+ vector<Stream_event *> events_;
+ vector<Drul_array<Spanner *> > annotated_spanners_;
+
+ void stop_translation_timestep ();
+
+ void footnotify (Grob *, Stream_event *);
+};
+
+IMPLEMENT_TRANSLATOR_LISTENER (Footnote_engraver, footnote);
+void
+Footnote_engraver::listen_footnote (Stream_event *ev)
+{
+ events_.push_back (ev);
+}
+
+void
+Footnote_engraver::stop_translation_timestep ()
+{
+ events_.clear ();
+}
+
+Footnote_engraver::Footnote_engraver ()
+{
+}
+
+void
+Footnote_engraver::footnotify (Grob *g, Stream_event *event)
+{
+ Spanner *s = dynamic_cast<Spanner *>(g);
+
+ if (s)
+ {
+ Spanner *b = make_spanner ("FootnoteSpanner", event->self_scm ());
+ b->set_parent (s, Y_AXIS);
+ b->set_parent (s, X_AXIS);
+ Grob *bound = unsmob_grob (get_property ("currentMusicalColumn"));
+ b->set_bound (LEFT, bound);
+ annotated_spanners_.push_back (Drul_array<Spanner *> (s,b));
+ }
+ else
+ {
+ Grob *b = make_item ("FootnoteItem", event->self_scm ());
+ b->set_parent (g, Y_AXIS);
+ b->set_parent (g, X_AXIS);
+ }
+}
+
+void
+Footnote_engraver::acknowledge_grob (Grob_info info)
+{
+ Stream_event *cause = info.event_cause ();
+
+ SCM arts = cause ? cause->get_property ("articulations") : SCM_EOL;
+ for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
+ {
+ Stream_event *e = unsmob_stream_event (scm_car (s));
+ if (e->in_event_class ("footnote-event"))
+ footnotify (info.grob (), e);
+ }
+
+ for (vsize i = 0; i < events_.size (); i++)
+ {
+ if (info.grob ()->name () == ly_symbol2string (events_[i]->get_property ("symbol")))
+ footnotify (info.grob (), events_[i]);
+ }
+}
+
+void
+Footnote_engraver::acknowledge_end_grob (Grob_info info)
+{
+ Spanner *s = dynamic_cast<Spanner *>(info.grob ());
+
+ if (s)
+ for (vsize i = 0; i < annotated_spanners_.size (); i++)
+ {
+ if (annotated_spanners_[i][LEFT] == s)
+ {
+ Grob *bound = unsmob_grob (get_property ("currentMusicalColumn"));
+ annotated_spanners_[i][RIGHT]->set_bound (RIGHT, bound);
+ break;
+ }
+ }
+}
+
+ADD_ACKNOWLEDGER (Footnote_engraver, grob);
+ADD_END_ACKNOWLEDGER (Footnote_engraver, grob);
+
+ADD_TRANSLATOR (Footnote_engraver,
+ /* doc */
+ "Create footnote texts.",
+
+ /* create */
+ "FootnoteItem "
+ "FootnoteSpanner ",
+
+ /*read*/
+ "currentMusicalColumn ",
+
+ /*write*/
+ ""
+ );
Grob *last_column_;
Real force_;
Line_shape shape_;
+ vector<Stencil *> footnotes_; /* The footnotes at the bottom of the
+ page, where each stencil represents
+ a different footnote. */
Interval refpoint_extent_; /* The refpoints of the first and last
spaceable staff in this line. min-distance
should be measured from the bottom
Real page_height (int page_number, bool last) const;
Real paper_height () const;
vsize system_count () const;
+ Real footnote_separator_stencil_height () const;
+ Real footnote_padding () const;
Real line_count_penalty (int line_count) const;
int line_count_status (int line_count) const;
bool too_many_lines (int line_count) const;
void break_into_pieces (vsize start, vsize end, Line_division const &div);
SCM systems ();
+ SCM footnotes ();
void set_current_breakpoints (vsize start,
vsize end,
int max_systems_per_page_;
int min_systems_per_page_;
vsize system_count_;
+ Real footnote_separator_stencil_height_;
+ Real footnote_padding_;
int orphan_penalty_;
vector<Line_division> current_configurations_;
static bool read_spacing_spec (SCM spec, Real* dest, SCM sym);
static bool is_spaceable (Grob *g);
static SCM get_details (Grob *g);
+ static SCM get_footnotes_from_lines (SCM lines, Real padding);
+ static Stencil* get_footnote_separator_stencil (Output_def *paper);
static SCM get_spacing_spec (Grob *before, Grob *after, bool pure, int start, int end);
static Real get_fixed_spacing (Grob *before, Grob *after, int spaceable_index, bool pure, int start, int end);
+ static void add_footnotes_to_footer (SCM footnotes, Stencil *foot, Paper_book *pb);
protected:
void append_system (System*, Spring const&, Real indent, Real padding);
Real rod_height_;
Real spring_len_;
Real inverse_spring_k_;
+ bool has_footnotes_;
Line_details last_line_;
Line_details first_line_;
{
page_height_ = page_height;
breaker_ = breaker;
+ has_footnotes_ = false;
clear ();
}
void calc_force ();
void resize (Real new_height);
+ Real account_for_footnotes (Line_details const &line);
void append_system (const Line_details &line);
void prepend_system (const Line_details &line);
void clear ();
*/
Prob *make_paper_system (SCM immutable_init);
void paper_system_set_stencil (Prob *prob, Stencil s);
+SCM get_footnotes (SCM expr);
#endif /* PAPER_SYSTEM_HH */
void init_elements ();
friend class Paper_score; // ugh.
Paper_score *pscore_; // ugh.
-
+ bool checked_footnotes_;
+ vector<Grob *> footnote_grobs_; // TODO: make this a grob array
+
public:
Paper_score *paper_score () const;
Grob *get_vertical_alignment ();
Grob *get_pure_bound (Direction dir, int start, int end);
Grob *get_maybe_pure_bound (Direction dir, bool pure, int start, int end);
int get_rank () const;
+ vector<Stencil *> get_footnotes_in_range (vsize st, vsize end);
+ void get_footnote_grobs_in_range (vector<Grob *> &out, vsize st, vsize end);
+ Stencil make_footnote_stencil (Real padding);
void do_break_substitution_and_fixup_refpoints ();
void post_processing ();
+ void populate_footnote_grob_vector ();
SCM get_paper_system ();
SCM get_paper_systems ();
SCM get_broken_system_grobs ();
+ SCM get_broken_footnote_stencils ();
DECLARE_SCHEME_CALLBACK (calc_pure_relevant_grobs, (SCM));
DECLARE_SCHEME_CALLBACK (height, (SCM));
#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);
+
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_;
+}
+
bool
Page_breaking::too_many_lines (int line_count) const
{
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"));
+ SCM footnotes = Page_layout_problem::get_footnotes_from_lines (systems, footnote_padding ());
+ Page_layout_problem::add_footnotes_to_footer (footnotes, foot, unsmob_paper_book (p->get_property ("paper-book")));
+
+ p->set_property ("foot-stencil", foot->smobbed_copy ());
scm_apply_1 (page_stencil, page, SCM_EOL);
return page;
{
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);
#include "prob.hh"
#include "skyline-pair.hh"
#include "system.hh"
+#include "text-interface.hh"
+
+/*
+ Returns a stencil for the footnote of each system. This stencil may
+ itself be comprised of several footnotes.
+*/
+
+SCM
+Page_layout_problem::get_footnotes_from_lines (SCM lines, Real padding)
+{
+ SCM footnotes = SCM_EOL;
+ // ugh...code dup from the Page_layout_problem constructor
+ for (SCM s = lines; scm_is_pair (s); s = scm_cdr (s))
+ {
+ if (Grob *g = unsmob_grob (scm_car (s)))
+ {
+ System *sys = dynamic_cast<System *> (g);
+ if (!sys)
+ {
+ programming_error ("got a grob for footnotes that wasn't a System");
+ continue;
+ }
+ footnotes = scm_cons (sys->make_footnote_stencil (padding).smobbed_copy (), footnotes);
+ }
+ else if (Prob *p = unsmob_prob (scm_car (s)))
+ {
+ SCM stencils = p->get_property ("footnotes");
+ if (stencils == SCM_EOL)
+ continue;
+ Stencil footnote_stencil;
+
+ for (SCM st = stencils; scm_is_pair (st); st = scm_cdr (st))
+ footnote_stencil.add_at_edge (Y_AXIS, DOWN, *unsmob_stencil (scm_car (st)), padding);
+ footnotes = scm_cons (footnote_stencil.smobbed_copy (), footnotes);
+ }
+ }
+
+ if (!scm_is_pair (footnotes))
+ return SCM_EOL;
+
+ return scm_reverse (footnotes);
+}
+
+Stencil*
+Page_layout_problem::get_footnote_separator_stencil (Output_def *paper)
+{
+ SCM props = scm_call_1 (ly_lily_module_constant ("layout-extract-page-properties"),
+ paper->self_scm ());
+
+ SCM markup = paper->c_variable ("footnote-separator-markup");
+
+ if (!Text_interface::is_markup (markup))
+ return NULL;
+
+ SCM footnote_stencil = Text_interface::interpret_markup (paper->self_scm (),
+ props, markup);
+
+ Stencil *footnote_separator = unsmob_stencil (footnote_stencil);
+
+ return footnote_separator;
+}
+
+void
+Page_layout_problem::add_footnotes_to_footer (SCM footnotes, Stencil *foot, Paper_book *pb)
+{
+ bool footnotes_found = false;
+ Real footnote_padding = robust_scm2double (pb->paper_->c_variable ("footnote-padding"), 0.0);
+
+ footnotes = scm_reverse (footnotes);
+ for (SCM s = footnotes; scm_is_pair (s); s = scm_cdr (s))
+ {
+ Stencil *stencil = unsmob_stencil (scm_car (s));
+
+ if (!stencil)
+ continue;
+
+ if (!stencil->is_empty ())
+ {
+ foot->add_at_edge (Y_AXIS, UP, *stencil, footnote_padding);
+ footnotes_found = true;
+ }
+ }
+
+ if (footnotes_found)
+ {
+ Stencil *separator = get_footnote_separator_stencil (pb->paper_);
+ if (separator)
+ foot->add_at_edge (Y_AXIS, UP, *separator, footnote_padding);
+ }
+}
Page_layout_problem::Page_layout_problem (Paper_book *pb, SCM page_scm, SCM systems)
: bottom_skyline_ (DOWN)
{
Stencil *head = unsmob_stencil (page->get_property ("head-stencil"));
Stencil *foot = unsmob_stencil (page->get_property ("foot-stencil"));
-
+
+ Real footnote_padding = 0.0;
+ if (pb && pb->paper_)
+ footnote_padding = robust_scm2double (pb->paper_->c_variable ("footnote-padding"), 0.0);
+ SCM footnotes = get_footnotes_from_lines (systems, footnote_padding);
+ add_footnotes_to_footer (footnotes, foot, pb);
+
header_height_ = head ? head->extent (Y_AXIS).length () : 0;
footer_height_ = foot ? foot->extent (Y_AXIS).length () : 0;
page_height_ = robust_scm2double (page->get_property ("paper-height"), 100);
#include "page-spacing.hh"
+#include "international.hh"
#include "matrix.hh"
#include "page-breaking.hh"
#include "warn.hh"
first_line_ = line;
}
+ rod_height_ += account_for_footnotes (line);
inverse_spring_k_ += line.inverse_hooke_;
last_line_ = line;
calc_force ();
}
+Real
+Page_spacing::account_for_footnotes (Line_details const &line)
+{
+ Real footnote_height = 0.0;
+ for (vsize i = 0; i < line.footnotes_.size (); i++)
+ {
+ footnote_height += (has_footnotes_
+ ? 0.0
+ : (breaker_->footnote_separator_stencil_height ()
+ + breaker_->footnote_padding ()));
+
+ has_footnotes_ = true;
+ Interval extent = line.footnotes_[i]->extent (Y_AXIS);
+ footnote_height += extent[UP] - extent[DOWN];
+ footnote_height += breaker_->footnote_padding ();
+ }
+ return footnote_height;
+}
+
void
Page_spacing::prepend_system (const Line_details &line)
{
rod_height_ -= first_line_.full_height ();
rod_height_ += first_line_.tallness_;
rod_height_ += line.full_height();
-
+ rod_height_ += account_for_footnotes (line);
inverse_spring_k_ += line.inverse_hooke_;
first_line_ = line;
{
force_ = rod_height_ = spring_len_ = 0;
inverse_spring_k_ = 0;
+ has_footnotes_ = false;
}
list == texts? SCM_BOOL_T : SCM_BOOL_F);
paper_system_set_stencil (ps, *unsmob_stencil (t));
+
+ SCM footnotes = get_footnotes (unsmob_stencil (t)->expr ());
+ ps->set_property ("footnotes", footnotes);
ps->set_property ("is-title", SCM_BOOL_T);
if (list != texts)
/* For each markup other than the first, place it as closely as
return prob;
}
+/*
+ TODO
+ it might be interesting to split off the footnotes as well, ie.
+
+ get_footnotes(SCM expr, SCM* footnotes, SCM* cleaned)
+
+ by doing it this way and overwriting the old expr in the caller,
+ you can make sure nobody tries to handle footnotes differently
+ downstream.
+*/
+SCM
+get_footnotes (SCM expr)
+{
+ if (!scm_is_pair (expr))
+ return SCM_EOL;
+
+ SCM head = scm_car (expr);
+
+ if (head == ly_symbol2scm ("delay-stencil-evaluation"))
+ {
+ // we likely need to do something here...just don't know what...
+ return SCM_EOL;
+ }
+
+ if (head == ly_symbol2scm ("combine-stencil"))
+ {
+ SCM out = SCM_EOL;
+ SCM *tail = &out;
+
+ for (SCM x = scm_cdr (expr); scm_is_pair (x); x = scm_cdr (x))
+ {
+ SCM footnote = get_footnotes (scm_car (x));
+ if (scm_is_pair (footnote))
+ {
+ for (SCM y = footnote; scm_is_pair (y); y = scm_cdr (y))
+ {
+ *tail = scm_cons (scm_car (y), SCM_EOL);
+ tail = SCM_CDRLOC (*tail);
+ }
+ }
+ else if (SCM_EOL != footnote)
+ {
+ *tail = scm_cons (footnote, SCM_EOL);
+ tail = SCM_CDRLOC (*tail);
+ }
+ }
+ return out;
+ }
+ if (head == ly_symbol2scm ("translate-stencil"))
+ return get_footnotes (scm_caddr (expr));
+
+ if (head == ly_symbol2scm ("footnote"))
+ return scm_cadr (expr);
+
+ return SCM_EOL;
+}
+
+
void
paper_system_set_stencil (Prob *prob, Stencil s)
{
interpret_stencil_expression (scm_force (scm_cadr (expr)), func, func_arg, o);
return;
}
+ if (head == ly_symbol2scm ("footnote"))
+ return;
if (head == ly_symbol2scm ("translate-stencil"))
{
o += ly_scm2offset (scm_cadr (expr));
#include "align-interface.hh"
#include "all-font-metrics.hh"
#include "axis-group-interface.hh"
+#include "break-align-interface.hh"
#include "grob-array.hh"
#include "hara-kiri-group-spanner.hh"
#include "international.hh"
#include "pointer-group-interface.hh"
#include "skyline-pair.hh"
#include "staff-symbol-referencer.hh"
+#include "text-interface.hh"
#include "warn.hh"
System::System (System const &src)
all_elements_ = 0;
pscore_ = 0;
rank_ = 0;
+ checked_footnotes_ = false;
init_elements ();
}
{
all_elements_ = 0;
rank_ = 0;
+ checked_footnotes_ = false;
init_elements ();
}
Grob *g = all_elts[j];
g->fixup_refpoint ();
}
-
+
count += all_elts.size ();
}
return lines;
}
+void
+System::populate_footnote_grob_vector ()
+{
+ extract_grob_set (this, "all-elements", all_elts);
+ for (vsize i = 0; i < all_elts.size (); i++)
+ if (all_elts[i]->internal_has_interface (ly_symbol2scm ("footnote-interface")))
+ footnote_grobs_.push_back (all_elts[i]);
+
+ sort (footnote_grobs_.begin (), footnote_grobs_.end (), Grob::less);
+ checked_footnotes_ = true;
+}
+
+void
+System::get_footnote_grobs_in_range (vector<Grob *> &out, vsize start, vsize end)
+{
+ if (!checked_footnotes_)
+ populate_footnote_grob_vector ();
+
+ for (vsize i = 0; i < footnote_grobs_.size (); i++)
+ {
+ int pos = footnote_grobs_[i]->spanned_rank_interval ()[LEFT];
+ bool end_of_line_visible = true;
+ if (Spanner *s = dynamic_cast<Spanner *>(footnote_grobs_[i]))
+ {
+ Real spanner_placement = robust_scm2double (s->get_property ("spanner-placement"), -1.0);
+ if (spanner_placement < -1.0)
+ spanner_placement = -1.0;
+ if (spanner_placement > 1.0)
+ spanner_placement = 1.0;
+
+ spanner_placement = (spanner_placement + 1.0) / 2.0;
+ int rpos = s->spanned_rank_interval ()[RIGHT];
+ pos = (int)((rpos - pos) * spanner_placement + pos + 0.5);
+ }
+
+ if (Item *item = dynamic_cast<Item *>(footnote_grobs_[i]))
+ {
+ if (!Item::break_visible (item))
+ continue;
+ // safeguard to bring down the column rank so that end of line footnotes show up on the correct line
+ end_of_line_visible = (LEFT == item->break_status_dir ());
+ }
+
+ if (pos < (int)start)
+ continue;
+ if (pos > (int)end)
+ break;
+ if (pos == (int)end && !end_of_line_visible)
+ continue;
+ if (!footnote_grobs_[i]->is_live ())
+ continue;
+
+ out.push_back (footnote_grobs_[i]);
+ }
+}
+
+vector<Stencil *>
+System::get_footnotes_in_range (vsize start, vsize end)
+{
+ vector<Grob *> footnote_grobs;
+ get_footnote_grobs_in_range (footnote_grobs, start, end);
+ vector<Stencil *> out;
+
+ for (vsize i = 0; i < footnote_grobs.size (); i++)
+ {
+ SCM footnote_markup = footnote_grobs[i]->get_property ("footnote-text");
+
+ if (!Text_interface::is_markup (footnote_markup))
+ continue;
+
+ SCM props = scm_call_1 (ly_lily_module_constant ("layout-extract-page-properties"),
+ pscore_->layout ()->self_scm ());
+
+ SCM footnote_stl = Text_interface::interpret_markup (pscore_->layout ()->self_scm (),
+ props, footnote_markup);
+
+ Stencil *footnote_stencil = unsmob_stencil (footnote_stl);
+ out.push_back (footnote_stencil);
+ }
+
+ return out;
+}
+
+Stencil
+System::make_footnote_stencil (Real padding)
+{
+ Stencil mol;
+
+ for (vsize i = 0; i < footnote_grobs_.size (); i++)
+ {
+ SCM footnote_markup = footnote_grobs_[i]->get_property ("footnote-text");
+ if (Spanner *orig = dynamic_cast<Spanner *>(footnote_grobs_[i]))
+ if (orig->is_broken ())
+ footnote_markup = orig->broken_intos_[0]->get_property ("footnote-text");
+
+ if (!Text_interface::is_markup (footnote_markup))
+ continue;
+
+ SCM props = scm_call_1 (ly_lily_module_constant ("layout-extract-page-properties"),
+ pscore_->layout ()->self_scm ());
+
+ SCM footnote_stl = Text_interface::interpret_markup (pscore_->layout ()->self_scm (),
+ props, footnote_markup);
+
+ mol.add_at_edge (Y_AXIS, DOWN, *unsmob_stencil (footnote_stl), padding);
+ }
+
+ return mol;
+}
+
void
System::break_into_pieces (vector<Column_x_positions> const &breaking)
{
Interval iv (pure_height (this, st, end));
system->set_property ("pure-Y-extent", ly_interval2scm (iv));
+ get_footnote_grobs_in_range (system->footnote_grobs_, st, end);
+
system->set_bound (LEFT, c[0]);
system->set_bound (RIGHT, c.back ());
SCM system_labels = SCM_EOL;
\consists "Dots_engraver"
\consists "Rest_engraver"
\consists "Tweak_engraver"
+ \consists "Footnote_engraver"
%% switch on to make stem directions interpolate for the
%% center line.
argument))
-
+footnoteGrob =
+#(define-music-function (parser location grob-name offset text footnote)
+ (symbol? number-pair? markup? markup?)
+ (_i "Attach @var{text} to @var{grob-name} at offset @var{offset},
+ with @var{text} referring to @var{footnote} (use like @code{\\once})")
+ (make-music 'FootnoteEvent
+ 'symbol grob-name
+ 'X-offset (car offset)
+ 'Y-offset (cdr offset)
+ 'text text
+ 'footnote-text footnote))
+
+footnote =
+#(define-music-function (parser location offset text footnote)
+ (number-pair? markup? markup?)
+ (_i "Attach @var{text} at @var{offset} with @var{text} referring
+ to @var{footnote} (use like @code{\\tweak})")
+ (make-music 'FootnoteEvent
+ 'X-offset (car offset)
+ 'Y-offset (cdr offset)
+ 'text text
+ 'footnote-text footnote))
grace =
#(def-grace-function startGraceMusic stopGraceMusic
ragged-bottom = ##f
ragged-last-bottom = ##t % best for shorter scores
-
%%
%% Flexible vertical spacing
%%
page-breaking = #ly:optimal-breaking
+ %%
+ %% Footnotes
+ %%
+ footnote-separator-markup = \markup { \draw-hline }
+ footnote-padding = 0.5\mm
+
+
%%
%% Page numbering
%%
print-first-page-number = ##f
print-page-number = ##t
-
%%
%% Headers, footers, and titles
%%
(RemoveContext ChangeParent Override Revert UnsetProperty
SetProperty music-event OldMusicEvent CreateContext Prepare
OneTimeStep Finish))
- (music-event . (annotate-output-event
+ (music-event . (annotate-output-event footnote-event
arpeggio-event breathing-event extender-event span-event
rhythmic-event dynamic-event break-event label-event percent-event
key-change-event string-number-event stroke-finger-event tie-event
"A fingering instruction."
'())
+(ly:add-interface
+ 'footnote-interface
+ "Make a footnote."
+ '(footnote-text))
+
+(ly:add-interface
+ 'footnote-spanner-interface
+ "Make a footnote spanner."
+ '(footnote-text spanner-placement))
+
(ly:add-interface
'fret-diagram-interface
"A fret diagram"
@code{-1} is smaller, @code{+1} is bigger. Each step of@tie{}1 is
approximately 12% larger; 6@tie{}steps are exactly a factor@tie{}2
larger. Fractional values are allowed.")
+ (footnote-text ,markup? "A footnote for the grob.")
(force-hshift ,number? "This specifies a manual shift for notes
in collisions. The unit is the note head width of the first voice
note. This is used by @rinternals{note-collision-interface}.")
(spacing-wishes ,ly:grob-array? "An array of note spacing or staff spacing
objects.")
(span-start ,boolean? "Is the note head at the start of a spanner?")
+ (spanner-placement ,number? "The place of an annotation on a spanner.
+Note that this number must be between -1 and 1, with -1 representing the
+beginning of the spanner and 1 representing the end. The annotation will
+still be placed at the left or right extremity of the spanner, but this
+number ensures that when line breaking happens, the annotation is assigned
+to the correct broken piece and the footnote is put on the correct page.
+An important caveat is that this number applies to column ranks, not staff
+space. For example, 0 will place the annotation at the middle column of
+its parent's span, which may be to the right or left of the physical middle
+of the spanner.")
(staff-grouper ,ly:grob? "The staff grouper we belong to.")
(staff-symbol ,ly:grob? "The staff symbol grob that we are in.")
(stem ,ly:grob? "A pointer to a @code{Stem} object.")
text-interface
text-script-interface))))))
+ (FootnoteItem
+ . (
+ (break-visibility . ,inherit-y-parent-visibility)
+ (footnote-text . ,(grob::calc-property-by-copy 'footnote-text))
+ (stencil . #f)
+ (text . ,(grob::calc-property-by-copy 'text))
+ (Y-extent . 0.0)
+ (X-offset . ,(grob::calc-property-by-copy 'X-offset))
+ (Y-offset . ,(grob::calc-property-by-copy 'Y-offset))
+ (meta . ((class . Item)
+ (interfaces . (balloon-interface
+ footnote-interface
+ font-interface
+ text-interface))))))
+
+ (FootnoteSpanner
+ . (
+ (footnote-text . ,(grob::calc-property-by-copy 'footnote-text))
+ (spanner-placement . -1.0)
+ (stencil . #f)
+ (text . ,(grob::calc-property-by-copy 'text))
+ (Y-extent . 0.0)
+ (X-offset . ,(grob::calc-property-by-copy 'X-offset))
+ (Y-offset . ,(grob::calc-property-by-copy 'Y-offset))
+ (meta . ((class . Spanner)
+ (interfaces . (balloon-interface
+ footnote-interface
+ footnote-spanner-interface
+ font-interface
+ text-interface))))))
+
(FretBoard
. (
(after-line-breaking . ,ly:chord-name::after-line-breaking)
(y (cdr dest)))
(make-line-stencil th 0 0 x y)))
+(define-markup-command (draw-hline layout props)
+ ()
+ #:category graphic
+ #:properties ((draw-line-markup)
+ (line-width))
+ "
+@cindex drawing a line across a page
+
+Draws a line across a page.
+@lilypond[verbatim,quote]
+\\markup {
+ \\draw-hline
+}
+@end lilypond"
+ (interpret-markup layout props (make-draw-line-markup (cons line-width 0))))
+
(define-markup-command (draw-circle layout props radius thickness filled)
(number? number? boolean?)
#:category graphic
(list markup?))
(interpret-markup layout props (list anonymous-with-signature arg))))
+(define-markup-command (footnote layout props mkup note)
+ (markup? markup?)
+ #:category other
+ "Have footnote @var{note} act as an annotation to the markup @var{mkup}."
+ (ly:stencil-combine-at-edge
+ (interpret-markup layout props mkup)
+ X
+ RIGHT
+ (ly:make-stencil
+ `(footnote ,(interpret-markup layout props note))
+ '(0 . 0)
+ '(0 . 0))
+ 0.0))
+
(define-markup-command (override layout props new-prop arg)
(pair? markup?)
#:category other
"If true, a parsing error was found in this expression.")
(figure ,integer? "A bass figure.")
+ (footnote-text ,markup? "Text to appear in a footnote.")
(force-accidental ,boolean? "If set, a cautionary accidental should
always be printed on this note.")
(forced-type ,symbol? "Override for the part-combiner.")
(types . (general-music fingering-event event))
))
+ (FootnoteEvent
+ . ((description . "Footnote a grob.")
+ (types . (general-music event footnote-event))
+ ))
+
(GlissandoEvent
. ((description . "Start a glissando on this note.")
(types . (general-music glissando-event event))
'(color
combine-stencil
delay-stencil-evaluation
+ footnote
rotate-stencil
scale-stencil
translate-stencil
(define-public (inherit-x-parent-visibility grob)
(let ((parent (ly:grob-parent grob X)))
(ly:grob-property parent 'break-visibility all-invisible)))
+(define-public (inherit-y-parent-visibility grob)
+ (let ((parent (ly:grob-parent grob X)))
+ (ly:grob-property parent 'break-visibility)))
(define-public spanbar-begin-of-line-invisible #(#t #f #f))
projects / lilypond.git / commitdiff