/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 1996--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 1996--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
LilyPond is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
If we have a spanner spanning one column, we must break it
anyway because it might provide a parent for another item. */
- Direction d = LEFT;
- do
+ for (LEFT_and_RIGHT (d))
{
Item *bound = left->find_prebroken_piece (d);
if (!bound)
broken_intos_.push_back (span);
}
}
- while ((flip (&d)) != LEFT);
}
else
{
Drul_array<Item *> bounds;
bounds[LEFT] = break_points[i - 1];
bounds[RIGHT] = break_points[i];
- Direction d = LEFT;
- do
+ for (LEFT_and_RIGHT (d))
{
if (!bounds[d]->get_system ())
bounds[d] = bounds[d]->find_prebroken_piece (- d);
}
- while ((flip (&d)) != LEFT);
if (!bounds[LEFT] || ! bounds[RIGHT])
{
- programming_error ("bounds of this piece aren't breakable. ");
+ programming_error ("bounds of this piece aren't breakable.");
continue;
}
if (!ok)
{
- programming_error (to_string ("Spanner `%s' is not fully contained in parent spanner. Ignoring orphaned part",
+ programming_error (to_string ("Spanner `%s' is not fully contained in parent spanner."
+ " Ignoring orphaned part",
name ().c_str ()));
continue;
}
void
Spanner::set_my_columns ()
{
- Direction i = (Direction) LEFT;
- do
+ for (LEFT_and_RIGHT (d))
{
- if (!spanned_drul_[i]->get_system ())
- set_bound (i, spanned_drul_[i]->find_prebroken_piece ((Direction) - i));
+ if (!spanned_drul_[d]->get_system ())
+ set_bound (d, spanned_drul_[d]->find_prebroken_piece ((Direction) - d));
}
- while (flip (&i) != LEFT);
}
Interval_t<int>
/*
Set the items that this spanner spans. If D == LEFT, we also set the
X-axis parent of THIS to S.
+
+ For example, when a slur crosses a line break, it's broken into two
+ pieces. The second piece shouldn't be positioned relative to the
+ original NoteColumn, but rather to the PaperColumn after the break.
*/
void
Spanner::set_bound (Direction d, Grob *s)
We check for System to prevent the column -> line_of_score
-> column -> line_of_score -> etc situation */
if (d == LEFT && !dynamic_cast<System *> (this))
- set_parent (i, X_AXIS);
+ /*
+ If the X-parent is a spanner, it will be split across linebreaks, too,
+ so we shouldn't have to overwrite it with the bound. Also, we need
+ original parent for alignment.
+ This happens e.g. for MultiMeasureRestNumbers and PercentRepeatCounters.
+ */
+ if (!dynamic_cast <Spanner *> (get_parent (X_AXIS)))
+ set_parent (i, X_AXIS);
/*
Signal that this column needs to be kept alive. They need to be
Pointer_group_interface::add_grob (i, ly_symbol2scm ("bounded-by-me"), this);
}
+Preinit_Spanner::Preinit_Spanner ()
+{
+ spanned_drul_.set (0, 0);
+ pure_property_cache_ = SCM_UNDEFINED;
+}
+
Spanner::Spanner (SCM s)
: Grob (s)
{
break_index_ = 0;
- spanned_drul_.set (0, 0);
- pure_property_cache_ = SCM_UNDEFINED;
}
Spanner::Spanner (Spanner const &s)
: Grob (s)
{
- spanned_drul_.set (0, 0);
- pure_property_cache_ = SCM_UNDEFINED;
+ break_index_ = 0;
}
+/*
+ Certain spanners have pre-computed X values that lie either in
+ X-positions or the X key of the alists returned for left-bound-info
+ and right-bound-info. These are calculated to give the real length
+ of a spanner (which, because of various padding or overhang properties,
+ can extend pass or arrive short of a given bound). If possible, we
+ use these to calculate the spanner's length, and otherwise, we use
+ the bound.
+
+ For those writing a new spanner, DO NOT use both X-positions and
+ left-bound-info/right-bound-info.
+*/
Real
Spanner::spanner_length () const
{
- Interval lr;
+ Interval lr = robust_scm2interval (get_property ("X-positions"),
+ Interval (1, -1));
- Drul_array<SCM> bounds (get_property ("left-bound-info"),
- get_property ("right-bound-info"));
+ if (lr.is_empty ())
+ {
+ Drul_array<SCM> bounds (get_property ("left-bound-info"),
+ get_property ("right-bound-info"));
- Direction d = LEFT;
- do
- lr[d] = robust_scm2double (ly_assoc_get (ly_symbol2scm ("X"),
- bounds[d], SCM_BOOL_F), -d);
- while (flip (&d) != LEFT);
+ for (LEFT_and_RIGHT (d))
+ lr[d] = robust_scm2double (ly_assoc_get (ly_symbol2scm ("X"),
+ bounds[d], SCM_BOOL_F), -d);
+ }
if (lr.is_empty ())
{
- do
+ for (LEFT_and_RIGHT (d))
lr[d] = spanned_drul_[d]->relative_coordinate (0, X_AXIS);
- while (flip (&d) != LEFT);
}
if (lr.is_empty ())
return broken_intos_.size ();
}
-/*
- If this is a broken spanner, return the amount the left end is to be
- shifted horizontally so that the spanner starts after the initial
- clef and key on the staves. This is necessary for ties, slurs,
- crescendo and decrescendo signs, for example.
-*/
-Real
-Spanner::get_broken_left_end_align () const
-{
- Paper_column *sc = dynamic_cast<Paper_column *> (spanned_drul_[LEFT]->get_column ());
-
- // Relevant only if left span point is first column in line
- if (sc != NULL
- && sc->break_status_dir () == RIGHT)
- {
- /*
- We used to do a full search for the Break_align_item.
- But that doesn't make a difference, since the Paper_column
- is likely to contain only a Break_align_item.
- */
- return sc->extent (sc, X_AXIS)[RIGHT];
- }
-
- return 0.0;
-}
-
void
Spanner::derived_mark () const
{
scm_gc_mark (pure_property_cache_);
- Direction d = LEFT;
- do
+ for (LEFT_and_RIGHT (d))
if (spanned_drul_[d])
scm_gc_mark (spanned_drul_[d]->self_scm ());
- while (flip (&d) != LEFT)
- ;
+ ;
- for (vsize i = broken_intos_.size (); i--;)
- scm_gc_mark (broken_intos_[i]->self_scm ());
+ // If break_index_ is -1, broken_intos_ might not yet have run its
+ // constructor and any access might break things.
+ if (break_index_ != (vsize)-1)
+ for (vsize i = broken_intos_.size (); i--;)
+ scm_gc_mark (broken_intos_[i]->self_scm ());
}
/*
SCM
Spanner::set_spacing_rods (SCM smob)
{
- Grob *me = unsmob_grob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM num_length = me->get_property ("minimum-length");
- if (scm_is_number (num_length))
+ SCM broken_length = me->get_property ("minimum-length-after-break");
+ if (scm_is_number (num_length)
+ || scm_is_number (broken_length))
{
- Rod r;
Spanner *sp = dynamic_cast<Spanner *> (me);
System *root = get_root_system (me);
Drul_array<Item *> bounds (sp->get_bound (LEFT),
r.item_drul_[LEFT] = cols.back ()->find_prebroken_piece (RIGHT);
r.item_drul_[RIGHT] = sp->get_bound (RIGHT);
+ if (scm_is_number (broken_length))
+ /*
+ r.distance_ may have been modified by add_to_cols ()
+ above. For treatment of minimum-distance-after-break
+ consistent with minimum-distance (which will use the
+ changed value), we cannot directly reset r.distance_ to
+ broken_length.
+ */
+ r.distance_ += robust_scm2double (broken_length, 0) -
+ robust_scm2double (num_length, 0);
r.add_to_cols ();
}
+ Rod r;
+ /*
+ As r is a fresh rod, we can set distance_ with no complication.
+ */
r.distance_ = robust_scm2double (num_length, 0);
r.item_drul_[LEFT] = sp->get_bound (LEFT);
r.item_drul_[RIGHT] = sp->get_bound (RIGHT);
r.add_to_cols ();
+
+ /*
+ We do not know yet if the spanner is going to have a bound that is
+ broken. To account for this uncertainty, we add the rod twice:
+ once for the central column (see above) and once for the left column
+ (see below). As end_rods_ are never used when rods_ are used and vice
+ versa, this rod will only be accessed once for each spacing
+ configuraiton before line breaking. Then, as a grob never exists in
+ both unbroken and broken forms after line breaking, only one of these
+ two rods will be in the column vector used for spacing in
+ simple-spacer.cc get_line_confugration.
+ */
+ if (Item *left_pbp = sp->get_bound (RIGHT)->find_prebroken_piece (LEFT))
+ {
+ r.item_drul_[RIGHT] = left_pbp;
+ r.add_to_cols ();
+ }
}
return SCM_UNSPECIFIED;
SCM
Spanner::calc_normalized_endpoints (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = unsmob<Spanner> (smob);
SCM result = SCM_EOL;
Spanner *orig = dynamic_cast<Spanner *> (me->original ());
Real total_width = 0.0;
vector<Real> span_data;
- if (!orig->is_broken ())
- span_data.push_back (orig->spanner_length ());
- else
- for (vsize i = 0; i < orig->broken_intos_.size (); i++)
- span_data.push_back (orig->broken_intos_[i]->spanner_length ());
+ for (vsize i = 0; i < orig->broken_intos_.size (); i++)
+ span_data.push_back (orig->broken_intos_[i]->spanner_length ());
vector<Interval> unnormalized_endpoints;
return result;
}
-Spanner *
-unsmob_spanner (SCM s)
-{
- return dynamic_cast<Spanner *> (unsmob_grob (s));
-}
-
MAKE_SCHEME_CALLBACK (Spanner, bounds_width, 1);
SCM
Spanner::bounds_width (SCM grob)
{
- Spanner *me = unsmob_spanner (grob);
+ Spanner *me = unsmob<Spanner> (grob);
Grob *common = me->get_bound (LEFT)->common_refpoint (me->get_bound (RIGHT), X_AXIS);
SCM
Spanner::kill_zero_spanned_time (SCM grob)
{
- Spanner *me = unsmob_spanner (grob);
+ Spanner *me = unsmob<Spanner> (grob);
/*
Remove the line or hairpin at the start of the line. For
piano voice indicators, it makes no sense to have them at
// The pure property cache is indexed by (name start . end), where name is
// a symbol, and start and end are numbers referring to the starting and
// ending column ranks of the current line.
- if (scm_hash_table_p (pure_property_cache_) == SCM_BOOL_F)
+ if (scm_is_false (scm_hash_table_p (pure_property_cache_)))
return SCM_UNDEFINED;
SCM key = scm_cons (sym, scm_cons (scm_from_int (start), scm_from_int (end)));
void
Spanner::cache_pure_property (SCM sym, int start, int end, SCM val)
{
- if (scm_hash_table_p (pure_property_cache_) == SCM_BOOL_F)
+ if (scm_is_false (scm_hash_table_p (pure_property_cache_)))
pure_property_cache_ = scm_c_make_hash_table (17);
SCM key = scm_cons (sym, scm_cons (scm_from_int (start), scm_from_int (end)));
/* properties */
"normalized-endpoints "
"minimum-length "
+ "minimum-length-after-break "
"spanner-broken "
"spanner-id "
"to-barline "