*/
#include "stem.hh"
+#include "spanner.hh"
#include <cmath> // rint
using namespace std;
}
SCM lst = index_get_cell (pair, d);
- for (int i = 0; i < beam_count; i++)
- lst = scm_cons (scm_from_int (i), lst);
+ if (beam_count)
+ for (int i = 0; i < beam_count; i++)
+ lst = scm_cons (scm_from_int (i), lst);
+ else
+ lst = SCM_BOOL_F;
+
index_set_cell (pair, d, lst);
}
return 0;
SCM lst = index_get_cell (pair, d);
- return scm_ilength (lst);
+
+ int len = scm_ilength (lst);
+ return max (len, 0);
}
Interval
return exthead;
}
-static int
-integer_compare (int const &a, int const &b)
-{
- return a - b;
-}
-
/* The positions, in ascending order. */
-std::vector<int>
+vector<int>
Stem::note_head_positions (Grob *me)
{
- std::vector<int> ps;
+ vector<int> ps;
extract_grob_set (me, "note-heads", heads);
for (vsize i = heads.size (); i--;)
ps.push_back (p);
}
- vector_sort (ps, integer_compare);
+ vector_sort (ps, less<int> ());
return ps;
}
&& scm_to_int (me->get_property ("duration-log")) >= 1);
}
+MAKE_SCHEME_CALLBACK (Stem, pure_height, 3)
+SCM
+Stem::pure_height (SCM smob, SCM start, SCM end)
+{
+ (void) start;
+ (void) end;
+
+
+ Grob *me = unsmob_grob (smob);
+ Real ss = Staff_symbol_referencer::staff_space (me);
+ Real len = scm_to_double (calc_length (smob)) * ss / 2;
+ Direction dir = get_grob_direction (me);
+
+ Interval iv;
+ Interval hp = head_positions (me);
+ if (dir == UP)
+ iv = Interval (0, len);
+ else
+ iv = Interval (-len, 0);
+
+ if (!hp.is_empty ())
+ iv.translate (hp[dir] * ss / 2);
+
+ return ly_interval2scm (iv);
+}
+
MAKE_SCHEME_CALLBACK (Stem, calc_stem_end_position, 1)
SCM
Stem::calc_stem_end_position (SCM smob)
if (!head_count (me))
return scm_from_double (0.0);
+ if (Grob *beam = get_beam (me))
+ {
+ (void) beam->get_property ("quantized-positions");
+ return me->get_property ("stem-end-position");
+ }
Real ss = Staff_symbol_referencer::staff_space (me);
int durlog = duration_log (me);
- std::vector<Real> a;
+ vector<Real> a;
/* WARNING: IN HALF SPACES */
Real length = robust_scm2double (me->get_property ("length"), 7);
if (dots)
{
Real dp = Staff_symbol_referencer::get_position (dots);
- Real flagy = flag (me).extent (Y_AXIS)[-dir] * 2 / ss;
+ Interval flag_yext = flag (me).extent (Y_AXIS) * (2 / ss) + stem_end;
/* Very gory: add myself to the X-support of the parent,
which should be a dot-column. */
- if (dir * (stem_end + flagy - dp) < 0.5)
+
+ if (flag_yext.distance (dp) < 0.5)
{
Grob *par = dots->get_parent (X_AXIS);
(Stem_tremolo::raw_stencil () looks at the beam.) --hwn */
Real minlen = 1.0
- + 2 * Stem_tremolo::raw_stencil (t_flag).extent (Y_AXIS).length ()
+ + 2 * t_flag->extent (t_flag, Y_AXIS).length ()
/ ss;
+ /* We don't want to add the whole extent of the flag because the trem
+ and the flag can overlap partly. beam_translation gives a good
+ approximation */
if (durlog >= 3)
- {
- Interval flag_ext = flag (me).extent (Y_AXIS);
- if (!flag_ext.is_empty ())
- minlen += 2 * flag_ext.length () / ss;
-
- /* The clash is smaller for down stems (since the tremolo is
- angled up.) */
- if (dir == DOWN)
- minlen -= 1.0;
- }
+ {
+ Real beam_trans = Stem_tremolo::get_beam_translation (t_flag);
+ /* the obvious choice is (durlog - 2) here, but we need a bit more space. */
+ minlen += 2 * (durlog - 1.5) * beam_trans;
+
+ /* up-stems need even a little more space to avoid collisions. This
+ needs to be in sync with the tremolo positioning code in
+ Stem_tremolo::print */
+ if (dir == UP)
+ minlen += beam_trans;
+ }
length = max (length, minlen + 1.0);
}
return SCM_BOOL_T;
extract_grob_set (me, "note-heads", ro_heads);
- Link_array__Grob_ heads (ro_heads);
- vector_sort (heads, compare_position);
+ vector<Grob*> heads (ro_heads);
+ vector_sort (heads, position_less);
Direction dir = get_grob_direction (me);
if (dir < 0)
dir = UP;
set_grob_direction (me, dir);
}
-
+
+ bool is_harmonic_centered = false;
+ for (vsize i = 0; i < heads.size (); i++)
+ is_harmonic_centered = is_harmonic_centered
+ || heads[i]->get_property ("style") == ly_symbol2scm ("harmonic");
+ is_harmonic_centered = is_harmonic_centered && is_invisible (me);
+
Real w = hed->extent (hed, X_AXIS)[dir];
for (vsize i = 0; i < heads.size (); i++)
- heads[i]->translate_axis (w - heads[i]->extent (heads[i], X_AXIS)[dir],
- X_AXIS);
+ {
+ Real amount = w - heads[i]->extent (heads[i], X_AXIS)[dir];
+ if (is_harmonic_centered)
+ amount =
+ hed->extent (hed, X_AXIS).linear_combination (CENTER)
+ - heads[i]->extent (heads[i], X_AXIS).linear_combination (CENTER);
+
+ heads[i]->translate_axis (amount, X_AXIS);
+ }
bool parity = true;
Real lastpos = Real (Staff_symbol_referencer::get_position (heads[0]));
for (vsize i = 1; i < heads.size (); i++)
Grob *beam = get_beam (me);
if (beam)
{
- beam->get_property ("positions");
+ /* trigger set-stem-lengths. */
+ beam->get_property ("quantized-positions");
}
/*
TODO: maybe property stroke-style should take different values,
e.g. "" (i.e. no stroke), "single" and "double" (currently, it's
'() or "grace"). */
- std::string flag_style;
+ string flag_style;
SCM flag_style_scm = me->get_property ("flag-style");
if (scm_is_symbol (flag_style_scm))
bool adjust = true;
- std::string staffline_offs;
+ string staffline_offs;
if (flag_style == "mensural")
/* Mensural notation: For notes on staff lines, use different
flags than for notes between staff lines. The idea is that
staffline_offs = "";
char dir = (get_grob_direction (me) == UP) ? 'u' : 'd';
- std::string font_char = flag_style
+ string font_char = flag_style
+ to_string (dir) + staffline_offs + to_string (log);
Font_metric *fm = Font_interface::get_default_font (me);
Stencil flag = fm->find_by_name ("flags." + font_char);
SCM stroke_style_scm = me->get_property ("stroke-style");
if (scm_is_string (stroke_style_scm))
{
- std::string stroke_style = ly_scm2string (stroke_style_scm);
+ string stroke_style = ly_scm2string (stroke_style_scm);
if (!stroke_style.empty ())
{
- std::string font_char = to_string (dir) + stroke_style;
+ string font_char = to_string (dir) + stroke_style;
Stencil stroke = fm->find_by_name ("flags." + font_char);
if (stroke.is_empty ())
me->warning (_f ("flag stroke `%s' not found", font_char));
Stem::print (SCM smob)
{
Grob *me = unsmob_grob (smob);
+ Grob *beam = get_beam (me);
+
Stencil mol;
Direction d = get_grob_direction (me);
= to_boolean (me->get_property ("avoid-note-head"))
? last_head (me)
: first_head (me);
- Grob *beam = get_beam (me);
if (!lh && !stemlet)
return SCM_EOL;
return si;
}
-/* TODO: add extra space for tremolos! */
MAKE_SCHEME_CALLBACK(Stem, calc_stem_info, 1);
SCM
Stem::calc_stem_info (SCM smob)
* staff_space
* length_fraction;
+ Real height_of_my_trem = 0.0;
+ Grob *trem = unsmob_grob (me->get_object ("tremolo-flag"));
+ if (trem)
+ height_of_my_trem = trem->extent (trem, Y_AXIS).length ()
+ /* hack a bit of space around the trem. */
+ + beam_translation;
+
/* UGH
It seems that also for ideal minimum length, we must use
the maximum beam count (for this direction):
Real ideal_minimum_length = ideal_minimum_free
+ height_of_my_beams
+ + height_of_my_trem
/* stem only extends to center of beam */
- 0.5 * beam_thickness;
* staff_space
* length_fraction;
- Real minimum_length = minimum_free
+ Real minimum_length = max (minimum_free, height_of_my_trem)
+ height_of_my_beams
/* stem only extends to center of beam */
- 0.5 * beam_thickness;
- if (Grob *tremolo = unsmob_grob (me->get_object ("tremolo-flag")))
- {
- Interval y_ext = tremolo->extent (tremolo, Y_AXIS);
- y_ext.widen (0.5); // FIXME. Should be tunable?
- minimum_length = max (minimum_length, y_ext.length ());
- }
-
ideal_y *= my_dir;
Real minimum_y = note_start + minimum_length;
Real shortest_y = minimum_y * my_dir;
}
/* FIXME: Too many properties */
-ADD_INTERFACE (Stem, "stem-interface",
+ADD_INTERFACE (Stem,
"The stem represent the graphical stem. "
"In addition, it internally connects note heads, beams and"
"tremolos. "
"french-beaming "
"length "
"length-fraction "
+ "max-beam-connect "
"neutral-direction "
"no-stem-extend "
"note-heads "
projects / lilypond.git / blobdiff