+2006-05-09 Joe Neeman <joeneeman@gmail.com>
+
+ * scm/define-context-properties.scm:
+ * scm/define-grob-properties.scm:
+ * scm/define-grobs.scm:
+ * scm/define-music-display-methods.scm:
+ * scm/define-music-properties.scm:
+ * scm/define-music-types.scm:
+ * scm/music-functions.scm:
+ * ly/declarations-init.ly:
+ * lily/include/constrained-breaking.hh:
+ * lily/system.cc:
+ * lily/spaceable-grob.cc:
+ * lily/simple-spacer.cc:
+ * lily/paper-score.cc:
+ * lily/paper-column.cc:
+ * lily/paper-column-engraver.cc:
+ * lily/item.cc:
+ * lily/gourlay-breaking.cc:
+ * lily/constrained-breaking.cc:
+ * python/convertrules.py:
+ Change "penalty", "page-penalty" and "breakable" to "line-break-penalty",
+ "page-break-penalty" and "line-break-permission".
+ Add "page-break-permission", "page-turn-permission" and "page-turn-penalty".
+ Replace BreakEvent with LineBreakEvent, PageBreakEvent and PageTurnEvent.
+
+ * lily/bar-engraver.cc:
+ * lily/beam-engraver.cc:
+ * lily/forbid-break-engraver.cc:
+ * lily/ligature-engraver.cc:
+ * lily/paper-column-engraver.cc:
+ * lily/percent-repeat-engraver.cc:
+ * lily/score-engraver.cc:
+ * lily/score-engraver.hh:
+ * lily/paper-column-engraver.hh:
+ Inter-engraver communication regarding line breaks is done through context
+ properties (Score.forbidBreak) instead of function calls.
+
2006-05-08 Han-Wen Nienhuys <hanwen@lilypond.org>
* VERSION (PACKAGE_NAME): release 2.9.4
*/
#include "bar-line.hh"
+#include "context.hh"
+#include "score-context.hh"
#include "score-engraver.hh"
#include "warn.hh"
#include "item.hh"
Bar_engraver::stop_translation_timestep ()
{
if (!bar_)
- /* guh. Use properties! */
- get_score_engraver ()->forbid_breaks ();
+ context ()->get_score_context ()->set_property ("forbidBreak", SCM_BOOL_T);
else
typeset_bar ();
}
/* create */ "BarLine",
/* accept */ "",
/* read */ "whichBar",
- /* write */ "");
+ /* write */ "forbidBreak");
#include "international.hh"
#include "item.hh"
#include "rest.hh"
-#include "score-engraver.hh"
+#include "score-context.hh"
#include "spanner.hh"
#include "stem.hh"
#include "warn.hh"
Beam_engraver::process_music ()
{
if (beam_ && !to_boolean (get_property ("allowBeamBreak")))
- get_score_engraver ()->forbid_breaks ();
+ context ()->get_score_context ()->set_property ("forbidBreak", SCM_BOOL_T);
if (start_ev_)
{
/* create */ "Beam",
/* accept */ "beam-event",
/* read */ "beamMelismaBusy beatLength subdivideBeams",
- /* write */ "");
+ /* write */ "forbidBreak");
class Grace_beam_engraver : public Beam_engraver
{
#include "cpu-timer.hh"
#include "simple-spacer.hh"
-vector<Grob*>
-Break_algorithm::find_breaks () const
-{
- vector<Grob*> all = pscore_->root_system ()->columns ();
- vector<Grob*> retval;
-
- for (vsize i = 0; i < all.size (); i++)
- {
- Item *it = dynamic_cast<Item*> (all[i]);
- if (Item::is_breakable (all[i])
- && (i == 0 || it->find_prebroken_piece (LEFT))
- && (i == all.size () - 1 || it->find_prebroken_piece (RIGHT)))
- retval.push_back (all[i]);
- }
-
- return retval;
-}
-
Break_algorithm::Break_algorithm ()
{
pscore_ = 0;
if (item->get_parent (X_AXIS))
return;
- SCM bp = item->get_property ("breakable");
- bool breakable = (to_boolean (bp));
- if (!breakable)
+ if (!Item::is_non_musical (item))
return;
SCM align_name = item->get_property ("break-align-symbol");
bool last = j == breaks_.size () - 1;
bool ragged = ragged_right || (last && ragged_last);
int k = i*lines_rank_ + j;
- SCM pen = all_[breaks_[j]]->get_property ("penalty");
+ SCM pen = all_[breaks_[j]]->get_property ("line-break-penalty");
if (scm_is_number (pen))
lines_[k].break_penalty_ = scm_to_double (pen);
{
}
-Score_engraver *
-Engraver::get_score_engraver () const
-{
- return dynamic_cast<Score_engraver *> (get_score_context ()->implementation ());
-}
-
#include "translator.icc"
ADD_TRANSLATOR (Engraver,
(c) 2002--_2005 Han-Wen Nienhuys <hanwen@xs4all.nl>
*/
-#include "rhythmic-head.hh"
+#include "duration.hh"
#include "grob.hh"
-#include "score-engraver.hh"
+#include "engraver.hh"
#include "input.hh"
-#include "pitch.hh"
-#include "duration.hh"
#include "moment.hh"
+#include "pitch.hh"
+#include "rhythmic-head.hh"
+#include "score-context.hh"
#include "translator.icc"
{
Grob *g = unsmob_grob (scm_cdar (busy));
if (g->internal_has_interface (ly_symbol2scm ("rhythmic-grob-interface")))
- get_score_engraver ()->forbid_breaks ();
+ context ()->get_score_context ()->set_property ("forbidBreak", SCM_BOOL_T);
busy = scm_cdr (busy);
}
}
/* create */ "",
/* accept */ "",
/* read */ "busyGrobs",
- /* write */ "");
+ /* write */ "forbidBreak");
Grob *pc = this_one.cols_.back ();
if (pc->original ())
{
- SCM pen = pc->get_property ("penalty");
+ SCM pen = pc->get_property ("line-break-penalty");
if (scm_is_number (pen) && fabs (scm_to_double (pen)) < 10000)
break_penalties += scm_to_double (pen);
}
Paper_score *pscore_;
Real linewidth_;
- vector<Grob*> find_breaks () const;
void solve_line (Column_x_positions *) const;
bool feasible (vector<Grob*> const &) const;
#define CONSTRAINED_BREAKING_HH
#include "break-algorithm.hh"
-
-enum Fordfor {
- FORBID = -1,
- DEFAULT = 0,
- FORCE = 1
-};
+#include "lily-guile.hh"
struct Line_details {
Real force_;
Real space_; /* spring length (stretches over extent_ but not over padding_) */
Real inverse_hooke_;
- Fordfor line_break_;
- Fordfor page_break_;
- Fordfor page_turn_;
+ SCM break_permission_;
+ SCM page_permission_;
+ SCM turn_permission_;
Real break_penalty_;
Real page_penalty_;
Real turn_penalty_;
padding_ = 0;
space_ = 0;
inverse_hooke_ = 1;
- line_break_ = DEFAULT;
- page_break_ = DEFAULT;
- page_turn_ = DEFAULT;
+ break_permission_ = ly_symbol2scm ("allow");
+ page_permission_ = ly_symbol2scm ("allow");
+ turn_permission_ = ly_symbol2scm ("allow");
break_penalty_ = 0;
page_penalty_ = 0;
turn_penalty_ = 0;
*/
void announce_grob (Grob *, SCM cause);
- Score_engraver *get_score_engraver () const;
/**
override other ctor
*/
virtual Grob *clone (int count) const;
- static bool is_breakable (Grob *);
+ static bool is_non_musical (Grob *);
bool is_broken () const;
Direction break_status_dir () const;
DECLARE_ACKNOWLEDGER (staff_spacing);
System *system_;
- Music *break_event_;
+ vector<Music*> break_events_;
int breaks_; // used for stat printing
Paper_column *command_column_;
Paper_column *musical_column_;
vector<Item*> items_;
bool first_;
Moment last_moment_;
+
+ Moment last_breakable_moment_;
+ Paper_column *last_breakable_column_;
public:
- // ug.h
- void forbid_breaks ();
};
#endif /* PAPER_COLUMN_ENGRAVER_HH */
static bool is_musical (Grob *);
static Moment when_mom (Grob *);
static bool is_used (Grob *);
+ static bool is_breakable (Grob *);
};
#endif // PAPER_COLUMN_HH
public:
Score_engraver ();
- void forbid_breaks ();
virtual SCM get_output ();
};
}
bool
-Item::is_breakable (Grob *me)
+Item::is_non_musical (Grob *me)
{
if (me->original ())
return false;
- if (!dynamic_cast<Item *> (me))
- me->programming_error ("only items can be breakable.");
-
Item *i = dynamic_cast<Item *> (me->get_parent (X_AXIS));
- return (i) ? Item::is_breakable (i) : to_boolean (me->get_property ("breakable"));
+ return i ? Item::is_non_musical (i) : to_boolean (me->get_property ("non-musical"));
}
Paper_column *
if (is_broken ())
return;
- if (Item::is_breakable (this))
+ if (Item::is_non_musical (this))
copy_breakable_items ();
}
" end-of-line-invisible no yes yes\n"
" center-invisible yes no yes\n"
"@end example\n",
- "no-spacing-rods break-visibility breakable")
+
+ /* properties */
+ "break-visibility "
+ "no-spacing-rods "
+ "non-musical")
#include "international.hh"
#include "note-head.hh"
#include "rest.hh"
-#include "score-engraver.hh"
+#include "score-context.hh"
#include "spanner.hh"
#include "warn.hh"
if (ligature_)
{
// TODO: maybe forbid breaks only if not transcribing
- get_score_engraver ()->forbid_breaks ();
+ context ()->get_score_context ()->set_property ("forbidBreak", SCM_BOOL_T);
}
if (events_drul_[START])
we drop it.
*/
if (!extents[RIGHT].is_empty ()
- && (Item::is_breakable (right_col)
- || right_col->original ()))
+ && (Paper_column::is_breakable (right_col)))
{
/*
This is for the situation
#include "note-spacing.hh"
#include "pointer-group-interface.hh"
#include "context.hh"
+#include "score-context.hh"
#include "axis-group-interface.hh"
#include "warn.hh"
command_column_ = 0;
musical_column_ = 0;
breaks_ = 0;
- break_event_ = 0;
system_ = 0;
first_ = true;
+ last_breakable_column_ = 0;
+ last_breakable_moment_ = Moment (-1);
}
void
if (command_column_)
{
- command_column_->set_property ("breakable", SCM_BOOL_T);
+ command_column_->set_property ("line-break-permission", ly_symbol2scm ("allow"));
system_->set_bound (RIGHT, command_column_);
}
}
make_columns ();
system_->set_bound (LEFT, command_column_);
- command_column_->set_property ("breakable", SCM_BOOL_T);
+ command_column_->set_property ("line-break-permission", ly_symbol2scm ("allow"));
}
void
system_->add_column (musical_column_);
}
-void
-Paper_column_engraver::forbid_breaks ()
-{
- if (command_column_ && !first_)
- command_column_->set_property ("breakable", SCM_EOL);
-}
-
bool
Paper_column_engraver::try_music (Music *m)
{
- break_event_ = m;
+ break_events_.push_back (m);
return true;
}
void
Paper_column_engraver::process_music ()
{
- if (break_event_)
+ for (vsize i = 0; i < break_events_.size (); i++)
{
- SCM pen = command_column_->get_property ("penalty");
- Real total_penalty = scm_is_number (pen) ? scm_to_double (pen) : 0.0;
-
- SCM mpen = break_event_->get_property ("penalty");
- if (scm_is_number (mpen))
- total_penalty += scm_to_double (mpen);
-
- command_column_->set_property ("penalty", scm_from_double (total_penalty));
-
- /* ugh. arbitrary, hardcoded */
- if (total_penalty > 10000.0)
- forbid_breaks ();
+ string prefix;
+ SCM name = break_events_[i]->get_property ("name");
+ if (name == ly_symbol2scm ("LineBreakEvent"))
+ prefix = "line-break";
+ else if (name == ly_symbol2scm ("PageBreakEvent"))
+ prefix = "page-break";
+ else if (name == ly_symbol2scm ("PageTurnEvent"))
+ prefix = "page-turn";
+ else
+ {
+ programming_error ("Paper_column_engraver doesn't know about this break-event");
+ return;
+ }
+ string perm_str = prefix + "-permission";
+ string pen_str = prefix + "-penalty";
- SCM page_pen = command_column_->get_property ("page-penalty");
- Real total_pp = scm_is_number (page_pen) ? scm_to_double (page_pen) : 0.0;
- SCM mpage_pen = break_event_->get_property ("page-penalty");
- if (scm_is_number (mpage_pen))
- total_pp += scm_to_double (mpage_pen);
+ SCM cur_pen = command_column_->get_property (pen_str.c_str ());
+ SCM pen = break_events_[i]->get_property ("break-penalty");
+ SCM perm = break_events_[i]->get_property ("break-permission");
- command_column_->set_property ("page-penalty", scm_from_double (total_pp));
+ if (scm_is_number (pen))
+ {
+ Real new_pen = robust_scm2double (cur_pen, 0.0) + scm_to_double (pen);
+ command_column_->set_property (pen_str.c_str (), scm_from_double (new_pen));
+ command_column_->set_property (perm_str.c_str (), ly_symbol2scm ("allow"));
+ }
+ else
+ command_column_->set_property (perm_str.c_str (), perm);
}
bool start_of_measure = (last_moment_.main_part_ != now_mom ().main_part_
if (!elem->get_parent (X_AXIS)
|| !unsmob_grob (elem->get_object ("axis-group-parent-X")))
{
- bool br = to_boolean (elem->get_property ("breakable"));
+ bool br = Item::is_non_musical (elem);
Axis_group_interface::add_element (br ? command_column_ : musical_column_, elem);
}
}
items_.clear ();
- if (to_boolean (command_column_->get_property ("breakable")))
+ if (to_boolean (get_property ("forbidBreak")))
+ command_column_->set_property ("line-break-permission", SCM_EOL);
+ else if (Paper_column::is_breakable (command_column_))
{
breaks_++;
+ last_breakable_column_ = command_column_;
+ last_breakable_moment_ = now_mom ();
if (! (breaks_%8))
progress_indication ("[" + to_string (breaks_) + "]");
}
+ SCM page_br = get_property ("allowPageTurn");
+ if (scm_is_pair (page_br) && last_breakable_moment_ >= Rational (0))
+ {
+ SCM pen = scm_cdr (page_br);
+ Moment *m = unsmob_moment (scm_car (page_br));
+ if (m && scm_is_number (pen) && *m <= last_breakable_moment_)
+ {
+ last_breakable_column_->set_property ("page-turn-permission", ly_symbol2scm ("allow"));
+ last_breakable_column_->set_property ("page-turn-penalty", pen);
+ }
+ }
+
+ context ()->get_score_context ()->unset_property ( ly_symbol2scm ("forbidBreak"));
+ context ()->get_score_context ()->unset_property ( ly_symbol2scm ("allowPageTurn"));
+
first_ = false;
- break_event_ = 0;
+ break_events_.clear ();
}
void
/* doc */ "Takes care of generating columns."
"\n\n "
"This engraver decides whether a column is breakable. The default is "
- "that a column is always breakable. However, when every Bar_engraver "
- "that does not have a barline at a certain point will call "
- "Score_engraver::forbid_breaks to stop linebreaks. In practice, this "
+ "that a column is always breakable. However, every Bar_engraver "
+ "that does not have a barline at a certain point will set forbidBreaks "
+ "in the score context to stop linebreaks. In practice, this "
"means that you can make a breakpoint by creating a barline (assuming "
"that there are no beams or notes that prevent a breakpoint.) ",
"NonMusicalPaperColumn",
/* accept */ "break-event",
- /* read */ "",
+ /* read */
+ "forbidBreak "
+ "allowPageTurn",
/* write */
+ "forbidBreak "
+ "allowPageTurn "
"currentCommandColumn "
"currentMusicalColumn");
if (bbm.size ())
return true;
- if (Item::is_breakable (me))
+ if (Paper_column::is_breakable (me))
return true;
if (to_boolean (me->get_property ("used")))
return false;
}
+bool
+Paper_column::is_breakable (Grob *me)
+{
+ return scm_is_symbol (me->get_property ("line-break-permission"));
+}
+
/*
Print a vertical line and the rank number, to aid debugging.
*/
"between-cols "
"bounded-by-me "
"line-break-system-details "
- "page-penalty "
+ "line-break-penalty "
+ "line-break-permission "
+ "page-break-penalty "
+ "page-break-permission "
+ "page-turn-penalty "
+ "page-turn-permission "
"shortest-playing-duration "
"shortest-starter-duration "
"used "
for (vsize i = 0; i < all.size (); i++)
{
Item *it = dynamic_cast<Item*> (all[i]);
- if (Item::is_breakable (all[i])
+ if (Paper_column::is_breakable (all[i])
&& (i == 0 || it->find_prebroken_piece (LEFT))
&& (i == all.size () - 1 || it->find_prebroken_piece (RIGHT)))
retval.push_back (i);
doubly, also done in Score_engraver */
vector<Grob*> pc (system_->columns ());
- pc[0]->set_property ("breakable", SCM_BOOL_T);
- pc.back ()->set_property ("breakable", SCM_BOOL_T);
+ pc[0]->set_property ("line-break-permission", ly_symbol2scm ("allow"));
+ pc.back ()->set_property ("line-break-permission", ly_symbol2scm ("allow"));
system_->pre_processing ();
}
#include "misc.hh"
#include "percent-repeat-iterator.hh"
#include "repeated-music.hh"
+#include "score-context.hh"
#include "side-position-interface.hh"
#include "spanner.hh"
#include "warn.hh"
double_percent_counter_->set_parent (double_percent_, X_AXIS);
}
- /*
- forbid breaks on a % line. Should forbid all breaks, really.
-
- Ugh. Why can't this be regular communication between
- contexts?
- */
- get_score_engraver ()->forbid_breaks ();
+ /* forbid breaks on a % line. Should forbid all breaks, really. */
+ context ()->get_score_context ()->set_property ("forbidBreak", SCM_BOOL_T);
}
next_moment_ = next_moment_ + body_length_;
next_moment_.grace_part_ = Rational (0);
"currentCommandColumn "
"countPercentRepeats",
- /* write */ "");
+ /* write */
+ "forbidBreak");
return o->self_scm ();
}
-/*
- UGH UGH
-*/
-void
-Score_engraver::forbid_breaks ()
-{
- for (SCM s = simple_trans_list_; scm_is_pair (s); s = scm_cdr (s))
- {
- Translator *tr = unsmob_translator (scm_car (s));
- if (Paper_column_engraver *pce = dynamic_cast<Paper_column_engraver *> (tr))
- pce->forbid_breaks ();
- }
-}
-
bool
Score_engraver::try_music (Music *m)
{
/* doc */ "Top level engraver. Takes care of generating columns and the complete system (ie. System) "
"\n\n "
"This engraver decides whether a column is breakable. The default is "
- "that a column is always breakable. However, when every Bar_engraver "
- "that does not have a barline at a certain point will call "
- "Score_engraver::forbid_breaks to stop linebreaks. In practice, this "
+ "that a column is always breakable. However, every Bar_engraver "
+ "that does not have a barline at a certain point will set "
+ "forbidBreaks to stop linebreaks. In practice, this "
"means that you can make a breakpoint by creating a barline (assuming "
"that there are no beams or notes that prevent a breakpoint.) ",
/* create */
Item *thing = dynamic_cast<Item *> (inf.grob ());
if (thing)
{
- if (!Item::is_breakable (thing))
+ if (!Item::is_non_musical (thing))
scripts_.push_back (thing);
}
}
return;
}
- bool ib = Item::is_breakable (it);
+ bool ib = Item::is_non_musical (it);
Item *&p_ref_ (ib ? break_item_
: musical_item_);
if (ib)
{
- p_ref_->set_property ("breakable", SCM_BOOL_T);
+ p_ref_->set_property ("non-musical", SCM_BOOL_T);
context ()->set_property ("breakableSeparationItem", p_ref_->self_scm ());
}
vsize i = starting + 1;
for (; i < list.size ()
&& is_loose (list[i])
- && !Item::is_breakable (list[i]);
+ && !Paper_column::is_breakable (list[i]);
i++)
;
return dynamic_cast<Item*> (list[i])->find_prebroken_piece (LEFT);
/*
Check if breaking constraints are met.
*/
- int sz = ret.cols_.size ();
- for (int i = sz; i--;)
+ for (vsize i = 1; i < ret.cols_.size () - 1; i++)
{
- SCM p = ret.cols_[i]->get_property ("penalty");
- if (scm_is_number (p))
- {
- if (scm_to_double (p) < -9999)
- ret.satisfies_constraints_ = ret.satisfies_constraints_ && (i == 0 || i == sz -1);
- if (scm_to_double (p) > 9999)
- ret.satisfies_constraints_ = ret.satisfies_constraints_ && ! (i == 0 || i == sz -1);
- }
+ SCM p = ret.cols_[i]->get_property ("line-break-permission");
+ if (p == ly_symbol2scm ("force"))
+ ret.satisfies_constraints_ = false;
}
return ret;
ADD_INTERFACE (Spaceable_grob, "spaceable-grob-interface",
"A layout object that takes part in the spacing problem. ",
- "measure-length spacing-wishes penalty minimum-distances ideal-distances "
- "keep-inside-line left-neighbors right-neighbors");
+ /* properties */
+ "ideal-distances "
+ "keep-inside-line "
+ "left-neighbors "
+ "measure-length "
+ "minimum-distances "
+ "right-neighbors "
+ "spacing-wishes");
}
while (flip (&d) != LEFT);
- if ((l->is_breakable (l) || l->original ())
- && (r->is_breakable (r) || r->original ()))
+ if (Paper_column::is_breakable (l) && Paper_column::is_breakable (r))
{
Moment *dt = unsmob_moment (l->get_property ("measure-length"));
Moment mlen (1);
return true;
if (Paper_column::is_musical (c)
- || Item::is_breakable (c))
+ || Paper_column::is_breakable (c))
return false;
extract_grob_set (c, "right-neighbors", rns);
some cases (two isolated, consecutive clef changes) won't be
nicely folded, but hey, then don't do that.
*/
- if (! ((Paper_column::is_musical (l_neighbor) || Item::is_breakable (l_neighbor))
- && (Paper_column::is_musical (r_neighbor) || Item::is_breakable (r_neighbor))))
+ if (! ((Paper_column::is_musical (l_neighbor) || Paper_column::is_breakable (l_neighbor))
+ && (Paper_column::is_musical (r_neighbor) || Paper_column::is_breakable (r_neighbor))))
return false;
/*
for (vsize i = 0; i < cols.size (); i++)
{
Item *it = dynamic_cast<Item *> (cols[i]);
- if (!Item::is_breakable (it) && !Paper_column::is_musical (it))
+ if (!Paper_column::is_breakable (it) && !Paper_column::is_musical (it))
continue;
// it->breakable || it->musical
shortest_in_measure = min (shortest_in_measure, this_shortest.main_part_);
}
else if (!shortest_in_measure.is_infinity ()
- && Item::is_breakable (cols[i]))
+ && Paper_column::is_breakable (cols[i]))
{
vsize j = 0;
for (; j < durations.size (); j++)
Kill no longer needed grobs.
*/
Item *it = dynamic_cast<Item *> (g);
- if (it && Item::is_breakable (it))
+ if (it && Item::is_non_musical (it))
{
it->find_prebroken_piece (LEFT)->suicide ();
it->find_prebroken_piece (RIGHT)->suicide ();
SCM prop_init = left_bound->get_property ("line-break-system-details");
Prob *pl = make_paper_system (prop_init);
paper_system_set_stencil (pl, sys_stencil);
- pl->set_property ("penalty",
- left_bound->get_property ("page-penalty"));
+
+ /* backwards-compatibility hack for the old page-breaker */
+ SCM turn_perm = left_bound->get_property ("page-break-permission");
+ if (!scm_is_symbol (turn_perm))
+ pl->set_property ("penalty", scm_from_double (10001.0));
+ else if (turn_perm == ly_symbol2scm ("force"))
+ pl->set_property ("penalty", scm_from_double (-10001.0));
+ else
+ pl->set_property ("penalty", scm_from_double (0.0));
if (!scm_is_pair (pl->get_property ("refpoint-Y-extent")))
{
&& cols[i] != right)
{
Paper_column *c = dynamic_cast<Paper_column *> (cols[i]);
- if (Item::is_breakable (c) && !c->system_)
+ if (Paper_column::is_breakable (c) && !c->system_)
ret.push_back (c);
i++;
}
while (last_breakable--)
{
- if (Item::is_breakable (ro_columns [last_breakable]))
+ if (Paper_column::is_breakable (ro_columns [last_breakable]))
break;
}
%% try \once \set Score.allowBeamBreak = ##t
%% rather name \newline, \pageBreak ?
-break = #(make-event-chord (list (make-penalty-music -10001 0)))
-noBreak = #(make-event-chord (list (make-penalty-music 10001 0)))
-pageBreak = #(make-event-chord (list (make-penalty-music -10001 -10001)))
-noPageBreak = #(make-event-chord (list (make-penalty-music 0 10001)))
+break = #(make-event-chord (list (make-music 'LineBreakEvent 'break-permission 'force)))
+noBreak = #(make-event-chord (list (make-music 'LineBreakEvent 'break-permission '())))
+pageBreak = #(make-event-chord (list
+ (make-music 'LineBreakEvent 'break-permission 'force)
+ (make-music 'PageBreakEvent 'break-permission 'force)))
+noPageBreak = #(make-event-chord (list (make-music 'PageBreakEvent 'break-permission '())))
+pageTurn = #(make-event-chord (list
+ (make-music 'LineBreakEvent 'break-permission 'force)
+ (make-music 'PageBreakEvent 'break-permission 'force)
+ (make-music 'PageTurnEvent 'break-permission 'force)))
+noPageTurn = #(make-event-chord (list (make-music 'PageTurnEvent 'break-permission '())))
+
stopStaff = #(make-event-chord (list (make-span-event 'StaffSpanEvent STOP)))
startStaff = #(make-event-chord (list (make-span-event 'StaffSpanEvent START)))
conversions.append (((2, 7, 40), conv,
"rehearsalMarkAlignSymbol/barNumberAlignSymbol -> break-align-symbol"))
+
+
+def conv (str):
+ str = re.sub ('page-penalty', 'page-break-penalty')
+ str = re.sub ('([^-])penalty', '\1break-penalty')
+ return str
+
+conversions.append (((2, 9, 4), conv, """(page-)penalty -> (page-)break-penalty"""))
"If true, then the accidentals are aligned in bass figure context.")
(allowBeamBreak ,boolean? "If true allow line breaks for beams over bar lines.")
+ (allowPageTurn ,pair? "In the form (moment-start . penalty). Allow a page turn
+at the most recent breakpoint if it was after moment-start.")
(associatedVoice ,string? "Name of the
@code{Voice} that has the melody for this @code{Lyrics} line.")
(autoBeamSettings ,list? "Specifies
(fontSize ,number?
"The relative size of all grobs in a context. ")
+ (forbidBreak ,boolean? "If set to ##t, prevent a line break at this point.")
+
(fingeringOrientations ,list?
"List of symbols, containing
@samp{left}, @samp{right}, @samp{up} and/or @samp{down}. This list
(break-visibility ,vector? "A vector of 3 booleans, #(end-of-line unbroken begin-of-line).
#t means visible, #f means killed.")
- (breakable ,boolean? "Can this object appear at a line break,
-like clefs and bar lines?")
(c0-position ,integer? "An integer indicating the position of
middle C.")
(cautionary-style ,symbol? "How to print cautionary
spacing constraints.")
(no-stem-extend ,boolean? "If set, notes with ledger lines do not
get stems extending to the middle staff line.")
+ (non-musical ,boolean? "True if the grob belongs in a NonMusicalPaperColumn.")
(number-type ,symbol? "Type of numbers to use in label. Choices
include @code{roman-lower}, @code{roman-upper}, and @code{arabic}.")
(packed-spacing ,boolean? "If set, the notes are spaced as
tightly as possible.")
(padding ,ly:dimension? "Add this much extra space between
objects that are next to each other.")
- (page-penalty ,number? "Penalty for page break at
-this column. 10000 or more means forbid linebreak, -10000 or less
-means force page break. Other values influence page breaking decisions
-as a real penalty.")
- (penalty ,number? "Penalty for line break at
-this column. 10000 or more means forbid line break, -10000 or less
-means force line break. Other values influence line breaking decisions
-as a real penalty.")
-
+ (page-break-permission ,symbol? "Instructs the page breaker on whether to
+put a page break at this column. Can be 'force, or 'allow.")
+ (page-turn-permission ,symbol? "Instructs the page breaker on whether to
+put a page turn at this column. Can be 'force, or 'allow.")
+ (line-break-permission ,symbol? "Instructs the line breaker on whether to
+put a line break at this column. Can be 'force, or 'allow.")
+ (page-break-penalty ,number? "Penalty for page break at
+this column. This affects the choices of the page breaker; it will avoid a page
+break at a column with a positive penalty and prefer a page break at a column
+with a negative penalty.")
+ (page-turn-penalty ,number? "Penalty for a page turn at this column.
+This affects the choices of the page breaker; it will avoid a page
+turn at a column with a positive penalty and prefer a page turn at a column
+with a negative penalty.")
+ (line-break-penalty ,number? "Penalty for a line break at this column.
+This affects the choices of the line breaker; it will avoid a line
+break at a column with a positive penalty and prefer a line break at a column
+with a negative penalty.")
(positions ,pair?
"Pair of staff coordinates @code{(@var{left}
. @var{right})}, where both @var{left} and @var{right} are in the
(staff-bar . (extra-space . 0.0))
(time-signature . (extra-space . 0.0))
(first-note . (fixed-space . 0.0))))
- (breakable . #t)
+ (non-musical . #t)
(break-align-symbol . ambitus)
(break-visibility . ,begin-of-line-visible)
(meta . ((class . Item)
(glyph . "|")
(layer . 0)
(break-visibility . ,all-visible)
- (breakable . #t)
+ (non-musical . #t)
(stencil . ,ly:bar-line::print)
(glyph-name . ,bar-line::calc-glyph-name)
(BarNumber
. (
(stencil . ,ly:text-interface::print)
- (breakable . #t)
+ (non-musical . #t)
(break-visibility . ,begin-of-line-visible)
(padding . 1.0)
(direction . ,UP)
(BreakAlignment
. (
- (breakable . #t)
+ (non-musical . #t)
(stacking-dir . 1)
(positioning-done . ,ly:break-align-interface::calc-positioning-done)
(X-extent . ,ly:axis-group-interface::width)
(BreathingSign
. (
(break-align-symbol . breathing-sign)
- (breakable . #t)
+ (non-musical . #t)
(space-alist . (
(ambitus . (extra-space . 2.0))
(custos . (minimum-space . 1.0))
. (
(stencil . ,ly:clef::print)
(glyph-name . ,ly:clef::calc-glyph-name)
- (breakable . #t)
+ (non-musical . #t)
(font-family . music)
(break-align-symbol . clef)
(break-visibility . ,begin-of-line-visible)
(Custos
. (
(break-align-symbol . custos)
- (breakable . #t)
+ (non-musical . #t)
(stencil . ,ly:custos::print)
(break-visibility . ,end-of-line-visible)
(style . vaticana)
(DoublePercentRepeat
. (
(stencil . ,ly:percent-repeat-item-interface::double-percent)
- (breakable . #t)
+ (non-musical . #t)
(slope . 1.0)
(font-encoding . fetaMusic)
(width . 2.0)
(style . line)
(gap . 0.5)
(zigzag-width . 0.75)
- (breakable . #t)
+ (non-musical . #t)
(X-extent . #f)
(Y-extent . #f)
(stencil . ,ly:line-spanner::print)
(Y-offset . ,ly:staff-symbol-referencer::callback)
(break-align-symbol . key-cancellation)
(break-visibility . ,begin-of-line-invisible)
- (breakable . #t)
+ (non-musical . #t)
(meta . ((class . Item)
(interfaces . (key-signature-interface
font-interface
(Y-offset . ,ly:staff-symbol-referencer::callback)
(break-align-symbol . key-signature)
(break-visibility . ,begin-of-line-visible)
- (breakable . #t)
+ (non-musical . #t)
(meta . ((class . Item)
(interfaces . (key-signature-interface
font-interface
. (
(break-align-symbol . left-edge)
(X-extent . (0 . 0))
- (breakable . #t)
+ (non-musical . #t)
(break-visibility . ,center-invisible)
(space-alist . (
(custos . (extra-space . 0.0))
(X-extent . ,ly:axis-group-interface::width)
;; (stencil . ,ly:paper-column::print)
- (breakable . #t)
+ (non-musical . #t)
;; debugging stuff: print column number.
;; (font-size . -6) (font-name . "sans") (Y-extent . #f)
(Y-offset . ,ly:side-position-interface::y-aligned-side)
(self-alignment-X . 0)
(direction . ,UP)
- (breakable . #t)
+ (non-musical . #t)
(font-size . 2)
(baseline-skip . 2)
(break-visibility . ,end-of-line-invisible)
(break-align-symbol . staff-bar)
(Y-extent . ())
(layer . 0)
- (breakable . #t)
+ (non-musical . #t)
(stencil . ,ly:span-bar::print)
(bar-size . ,ly:span-bar::calc-bar-size)
(X-extent . ,ly:span-bar::width)
(StaffSpacing
. (
- (breakable . #t)
+ (non-musical . #t)
(stem-spacing-correction . 0.4)
(meta . ((class . Item)
(interfaces . (spacing-interface
(first-note . (fixed-space . 2.0))
(right-edge . (extra-space . 0.5))
(staff-bar . (minimum-space . 2.0))))
- (breakable . #t)
+ (non-musical . #t)
(style . C)
(meta . ((class . Item)
(interfaces . (time-signature-interface
. (
(style . line)
(gap . 0.5)
- (breakable . #t)
+ (non-musical . #t)
(X-extent . #f)
(Y-extent . #f)
(stencil . ,ly:line-spanner::print)
(define-display-method BarCheck (check)
(format #f "|~a" (new-line->lily-string)))
-(define-display-method BreakEvent (br)
- "\\break") ;; TODO: use page-penalty, penalty properties?
+;; TODO: also display something when there is a penalty?
+(define-display-method LineBreakEvent (br)
+ (if (eq? (ly:music-property br 'break-permission) 'forbid)
+ ("\\noBreak")
+ ("\\break")))
+
+(define-display-method PageBreakEvent (br)
+ (if (eq? (ly:music-property br 'break-permission) 'forbid)
+ ("\\noPageBreak")
+ ("\\pageBreak")))
+
+(define-display-method PageTurnEvent (br)
+ (if (eq? (ly:music-property br 'break-permission) 'forbid)
+ ("\\noPageTurn")
+ ("\\pageTurn")))
(define-display-method PesOrFlexaEvent (expr)
"\\~")
(augmented ,boolean? "This figure is for an augmented figured bass (with +) sign.")
(associated-context ,string? "Name of the Voice context associated with this \\newaddlyrics section")
(bass ,boolean? "Set if this note is a bass note in a chord")
+ (break-penalty ,number? "Penalty for line break hint.")
+ (break-permission ,symbol? "Whether to allow, forbid or force a line break.")
(cautionary ,boolean? "If set, this alteration needs cautionary accidental")
(change-to-id ,string? "name of the context to change to ")
(change-to-type ,symbol? "type of the context to change to.")
(context-id ,string? "name of context")
(context-type ,symbol? "type of context")
(create-new ,boolean? "Create a fresh context.")
- (descend-only ,boolean? "If set, this @code{\\context} will only
-descend in the context tree.")
+ (descend-only ,boolean? "If set, this @code{\\context} will only descend in the context tree.")
(denominator ,integer? "denominator in a time signature")
(digit ,integer? "digit for fingering")
(diminished ,boolean? "This bass figure should be slashed.")
(label ,markup? "label of a mark.")
(last-pitch ,ly:pitch? "The last pitch after relativization.")
(length ,ly:moment? "The duration of this music")
- (length-callback ,procedure? "How to compute the duration of this music. This property
-can only be defined as initializer in @file{define-music-types.scm}.")
+ (length-callback ,procedure? "How to compute the duration of this music. This property can only be defined as initializer in @file{define-music-types.scm}.")
(name ,symbol? "Name of this music object")
(no-continuation ,boolean? "If set, disallow continuation lines")
(numerator ,integer? "numerator of a time signature")
(once ,boolean? "Apply this operation only during one time step?")
- (octavation ,integer?
- "This pitch was octavated by how many octaves?
-For chord inversions, this is negative.")
+ (octavation ,integer? "This pitch was octavated by how many octaves? For chord inversions, this is negative.")
(origin ,ly:input-location? "where was this piece of music defined?")
(parenthesize ,boolean? "Enclose resulting objects in parentheses?")
- (page-penalty ,number? "Penalty for page break hint.")
- (penalty ,number? "Penalty for line break hint.")
(pitch ,ly:pitch? "the pitch of this note")
(pitch-alist ,list? "list of pitches jointly forming the scale of a key signature")
(pop-first ,boolean? "Do a revert before we try to do a override on some grob property.")
(BreakEvent
. (
(description . "Create a line break, Syntax: \\break or page break, Syntax: \\pagebreak.")
-
+
(types . (general-music break-event event))
))
(BreathingSignEvent
(span-type . ligature)
(types . (general-music span-event ligature-event event))
))
-
+ (LineBreakEvent
+ . (
+ (description . "Allow, forbid or force a line break.")
+ (types . (general-music break-event event))
+ ))
(OldLyricCombineMusic
. (
(description . "Align lyrics to the start of notes.
(types . (general-music layout-instruction))
(iterator-ctor . ,ly:push-property-iterator::constructor)
))
+ (PageBreakEvent
+ . (
+ (description . "Allow, forbid or force a page break.")
+ (types . (general-music break-event event))
+ ))
+ (PageTurnEvent
+ . (
+ (description . "Allow, forbid or force a page turn.")
+ (types . (general-music break-event event))
+ ))
(PartCombineMusic
. (
(description . "Combine two parts on a staff, either merged or
(define-public (set-time-signature num den . rest)
(ly:export (apply make-time-signature-set `(,num ,den . ,rest))))
-(define-safe-public (make-penalty-music pen page-pen)
- (make-music 'BreakEvent
- 'penalty pen
- 'page-penalty page-pen))
-
(define-safe-public (make-articulation name)
(make-music 'ArticulationEvent
'articulation-type name))
projects / lilypond.git / commitdiff