#include <map>
-using std::map;
-using std::string;
-using std::vector;
-
Beam_stem_segment::Beam_stem_segment ()
{
max_connect_ = 1000; // infinity
for (vsize i = 0; i < stems.size (); i++)
{
Grob *stem = stems[i];
- m = std::max (m, (Stem::beam_multiplicity (stem).length () + 1));
+ m = max (m, (Stem::beam_multiplicity (stem).length () + 1));
}
return m;
}
for (SCM s = scm_car (right_beaming); scm_is_pair (s); s = scm_cdr (s))
{
int k = -right_dir * scm_to_int (scm_car (s)) + i;
- if (scm_is_true (scm_c_memq (scm_from_int (k), left_beaming)))
+ if (scm_is_true (ly_memv (scm_from_int (k), left_beaming)))
count++;
}
i != stem_segments.end (); i++)
{
vector<Beam_stem_segment> segs = (*i).second;
- vector_sort (segs, std::less<Beam_stem_segment> ());
+ vector_sort (segs, less<Beam_stem_segment> ());
Beam_segment current;
Grob *neighbor_stem = stems[seg.stem_index_ + event_dir];
Real neighbor_stem_x = neighbor_stem->relative_coordinate (commonx, X_AXIS);
- length = std::min (length,
+ length = min (length,
fabs (neighbor_stem_x - seg.stem_x_) * max_proportion[seg.dir_]);
}
current.horizontal_[event_dir] += event_dir * length;
for (vsize k = 0; k < heads.size (); k++)
current.horizontal_[event_dir]
- = event_dir * std::min (event_dir * current.horizontal_[event_dir],
+ = event_dir * min (event_dir * current.horizontal_[event_dir],
- gap_length / 2
+ event_dir
* heads[k]->extent (commonx,
for (DOWN_and_UP (d))
{
if (sign (positions[d]) == d)
- extremes[d] = d * std::max (d * positions[d], d * extremes[d]);
+ extremes[d] = d * max (d * positions[d], d * extremes[d]);
}
}
if (stem_dir)
{
count[stem_dir]++;
- total[stem_dir] += std::max (int (- stem_dir * Stem::head_positions (s) [-stem_dir]), 0);
+ total[stem_dir] += max (int (- stem_dir * Stem::head_positions (s) [-stem_dir]), 0);
}
}
for (SCM s = scm_car (beaming); scm_is_pair (s); s = scm_cdr (s))
{
- if (scm_is_true (scm_c_memq (scm_car (s), scm_cdr (beaming))))
+ if (scm_is_true (ly_memv (scm_car (s), scm_cdr (beaming))))
l.add_point (scm_to_int (scm_car (s)));
}
if (i > 0
&& i + 1 < stems.size ()
&& Stem::is_invisible (stem))
- count = std::min (count, beaming->beamlet_count (i, -d));
+ count = min (count, beaming->beamlet_count (i, -d));
if ( ((i == 0 && d == LEFT)
|| (i == stems.size () - 1 && d == RIGHT))
SCM
Beam::rest_collision_callback (SCM smob, SCM prev_offset)
{
+ if (!scm_is_number (prev_offset))
+ prev_offset = SCM_INUM0;
+
Grob *rest = unsmob<Grob> (smob);
if (scm_is_number (rest->get_property ("staff-position")))
- return scm_from_int (0);
+ return prev_offset;
- Real offset = robust_scm2double (prev_offset, 0.0);
+ Grob *stem = unsmob<Grob> (rest->get_object ("stem"));
- Grob *st = unsmob<Grob> (rest->get_object ("stem"));
- Grob *stem = st;
if (!stem)
- return scm_from_double (0.0);
+ return prev_offset;
+
Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
if (!beam
|| !has_interface<Beam> (beam)
|| !Beam::normal_stem_count (beam))
- return scm_from_double (0.0);
+ return prev_offset;
Grob *common_y = rest->common_refpoint (beam, Y_AXIS);
+ (beam_count - 1) * beam_translation;
Real beam_y = stem_y - d * height_of_my_beams;
+ Real offset = robust_scm2double (prev_offset, 0.0);
Interval rest_extent = rest->extent (rest, Y_AXIS);
rest_extent.translate (offset + rest->get_parent (Y_AXIS)->relative_coordinate (common_y, Y_AXIS));
= staff_space * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
+ robust_scm2double (rest->get_property ("minimum-distance"), 0.0));
- Real shift = d * std::min (d * (beam_y - d * minimum_distance - rest_dim), 0.0);
+ Real shift = d * min (d * (beam_y - d * minimum_distance - rest_dim), 0.0);
shift /= staff_space;
SCM, /* end */
SCM prev_offset)
{
- Real previous = robust_scm2double (prev_offset, 0.0);
+ if (!scm_is_number (prev_offset))
+ prev_offset = SCM_INUM0;
Grob *me = unsmob<Grob> (smob);
Grob *stem = unsmob<Grob> (me->get_object ("stem"));
if (!stem)
- return scm_from_double (previous);
+ return prev_offset;
Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
if (!beam
|| !Beam::normal_stem_count (beam)
|| !is_direction (beam->get_property_data ("direction")))
- return scm_from_double (previous);
+ return prev_offset;
Real ss = Staff_symbol_referencer::staff_space (me);
Grob *right;
if (idx == (vsize) - 1 || my_stems.size () == 1)
- return scm_from_double (previous);
+ return prev_offset;
else if (idx == 0)
left = right = my_stems[1];
else if (idx == my_stems.size () - 1)
+ Stem::head_positions (right)[beamdir]) / 2.0
+ 4.0 * beamdir; // four staff-positions
/* and that the closest beam never crosses staff center by more than two positions */
- beam_pos = std::max (-2.0, beam_pos * beamdir) * beamdir;
+ beam_pos = max (-2.0, beam_pos * beamdir) * beamdir;
Real minimum_distance
= ss * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
Real offset = beam_pos * ss / 2.0
- minimum_distance * beamdir
- me->extent (me, Y_AXIS)[beamdir];
+ Real previous = robust_scm2double (prev_offset, 0.0);
/* Always move by a whole number of staff spaces, always away from the beam */
- offset = floor (std::min (0.0, (offset - previous) / ss * beamdir))
+ offset = floor (min (0.0, (offset - previous) / ss * beamdir))
* ss * beamdir + previous;
return scm_from_double (offset);
Should we take invisible stems into account?
*/
if (get_grob_direction (stems[i]) == d)
- bc = std::max (bc, (Stem::beam_multiplicity (stems[i]).length () + 1));
+ bc = max (bc, (Stem::beam_multiplicity (stems[i]).length () + 1));
}
return bc;