void
Stem::set_beaming (Grob*me, int beam_count, Direction d)
{
- SCM pair = me->get_grob_property ("beaming");
+ SCM pair = me->get_property ("beaming");
- if (!gh_pair_p (pair))
+ if (!ly_c_pair_p (pair))
{
- pair = gh_cons (SCM_EOL, SCM_EOL);
- me->set_grob_property ("beaming", pair);
+ pair = scm_cons (SCM_EOL, SCM_EOL);
+ me->set_property ("beaming", pair);
}
SCM l = index_get_cell (pair, d);
- for( int i = 0; i< beam_count; i++)
+ for (int i = 0; i< beam_count; i++)
{
- l = gh_cons (gh_int2scm (i), l);
+ l = scm_cons (scm_int2num (i), l);
}
index_set_cell (pair, d, l);
}
Real
Stem::stem_end_position (Grob*me)
{
- SCM p =me->get_grob_property ("stem-end-position");
+ SCM p =me->get_property ("stem-end-position");
Real pos;
- if (!gh_number_p (p))
+ if (!is_number (p))
{
pos = get_default_stem_end_position (me);
- me->set_grob_property ("stem-end-position", gh_double2scm (pos));
+ me->set_property ("stem-end-position", scm_make_real (pos));
}
else
- pos = gh_scm2double (p);
+ pos = ly_scm2double (p);
return pos;
}
if (d && d * head_positions (me)[get_direction (me)] >= se*d)
me->warning (_ ("Weird stem size; check for narrow beams"));
- me->set_grob_property ("stem-end-position", gh_double2scm (se));
+ me->set_property ("stem-end-position", scm_make_real (se));
}
UGH.
*/
- return unsmob_grob (ly_car (me->get_grob_property ("note-heads")));
+ return unsmob_grob (ly_car (me->get_property ("note-heads")));
}
else
return first_head (me);
Drul_array<Grob *> exthead;
exthead[LEFT] = exthead[RIGHT] =0;
- for (SCM s = me->get_grob_property ("note-heads"); gh_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("note-heads"); ly_c_pair_p (s); s = ly_cdr (s))
{
Grob * n = unsmob_grob (ly_car (s));
- int p = int (Staff_symbol_referencer::get_position (n));
+ int p = Staff_symbol_referencer::get_rounded_position (n);
Direction d = LEFT;
do {
Stem::note_head_positions (Grob *me)
{
Array<int> ps ;
- for (SCM s = me->get_grob_property ("note-heads"); gh_pair_p (s); s = ly_cdr (s))
+ for (SCM s = me->get_property ("note-heads"); ly_c_pair_p (s); s = ly_cdr (s))
{
Grob * n = unsmob_grob (ly_car (s));
- int p = int (Staff_symbol_referencer::get_position (n));
+ int p = Staff_symbol_referencer::get_rounded_position (n);
ps.push (p);
}
void
Stem::add_head (Grob*me, Grob *n)
{
- n->set_grob_property ("stem", me->self_scm ());
+ n->set_property ("stem", me->self_scm ());
n->add_dependency (me);
/*
Stem::is_invisible (Grob*me)
{
return ! (head_count (me)
- && gh_scm2int (me->get_grob_property ("duration-log")) >= 1);
+ && ly_scm2int (me->get_property ("duration-log")) >= 1);
}
Direction
if (sign (ddistance - udistance))
return Direction (sign (ddistance -udistance));
- return to_dir (me->get_grob_property ("neutral-direction"));
+ return to_dir (me->get_property ("neutral-direction"));
}
Real
Real length = 7; // WARNING: IN HALF SPACES
- SCM scm_len = me->get_grob_property ("length");
- if (gh_number_p (scm_len))
+ SCM scm_len = me->get_property ("length");
+ if (is_number (scm_len))
{
- length = gh_scm2double (scm_len);
+ length = ly_scm2double (scm_len);
}
else
{
- s = me->get_grob_property ("lengths");
- if (gh_pair_p (s))
+ s = me->get_property ("lengths");
+ if (ly_c_pair_p (s))
{
- length = 2* gh_scm2double (robust_list_ref (durlog -2, s));
+ length = 2* ly_scm2double (robust_list_ref (durlog -2, s));
}
}
-
-
/* URGURGURG
'set-default-stemlen' sets direction too
*/
set_grob_direction (me, dir);
}
-
/* stems in unnatural (forced) direction should be shortened,
according to [Roush & Gourlay] */
- if (!chord_start_y (me)
- || (get_direction (me) != get_default_dir (me)))
+ if (dir * head_positions (me)[dir] >= 0)
{
-
-
- SCM sshorten = me->get_grob_property ("stem-shorten");
- SCM scm_shorten = gh_pair_p (sshorten) ?
+ SCM sshorten = me->get_property ("stem-shorten");
+ SCM scm_shorten = ly_c_pair_p (sshorten) ?
robust_list_ref ((duration_log (me) - 2) >? 0, sshorten): SCM_EOL;
Real shorten = 2* robust_scm2double (scm_shorten,0);
/* On boundary: shorten only half */
- if (abs (head_positions (me)[get_direction (me)]) <= 1)
+ if (abs (head_positions (me)[dir]) <= 1)
shorten *= 0.5;
length -= shorten;
/*
Tremolo stuff:
*/
- Grob * trem = unsmob_grob (me->get_grob_property ("tremolo-flag"));
- if (trem && !unsmob_grob (me->get_grob_property ("beam")))
+ Grob * trem = unsmob_grob (me->get_property ("tremolo-flag"));
+ if (trem && !unsmob_grob (me->get_property ("beam")))
{
/*
Crude hack: add extra space if tremolo flag is there.
We can't do this for the beam, since we get into a loop
- (Stem_tremolo::raw_stencil() looks at the beam.)
+ (Stem_tremolo::raw_stencil () looks at the beam.)
--hwn
*/
/*
TODO: change name to extend-stems to staff/center/'()
*/
- bool no_extend_b = to_boolean (me->get_grob_property ("no-stem-extend"));
+ bool no_extend_b = to_boolean (me->get_property ("no-stem-extend"));
if (!no_extend_b && dir * st < 0) // junkme?
st = 0.0;
int
Stem::duration_log (Grob*me)
{
- SCM s = me->get_grob_property ("duration-log");
- return (gh_number_p (s)) ? gh_scm2int (s) : 2;
+ SCM s = me->get_property ("duration-log");
+ return (is_number (s)) ? ly_scm2int (s) : 2;
}
void
Real reverse_overlap =0.5;
heads[i]->translate_axis ((l-thick*reverse_overlap) * d, X_AXIS);
- if (is_invisible(me))
+ if (is_invisible (me))
heads[i]->translate_axis (-thick*(2 - reverse_overlap) * d , X_AXIS);
}
else
{
- me->set_grob_property ("print-function", SCM_EOL);
+ me->set_property ("print-function", SCM_EOL);
}
return SCM_UNSPECIFIED;
SCM
Stem::height (SCM smob, SCM ax)
{
- Axis a = (Axis)gh_scm2int (ax);
+ Axis a = (Axis)ly_scm2int (ax);
Grob * me = unsmob_grob (smob);
assert (a == Y_AXIS);
'() or "grace"). */
String flag_style;
- SCM flag_style_scm = me->get_grob_property ("flag-style");
- if (gh_symbol_p (flag_style_scm))
+ SCM flag_style_scm = me->get_property ("flag-style");
+ if (is_symbol (flag_style_scm))
{
flag_style = ly_symbol2string (flag_style_scm);
}
return Stencil ();
}
- bool adjust = to_boolean (me->get_grob_property ("adjust-if-on-staffline"));
+ bool adjust = true;
String staffline_offs;
if (String::compare (flag_style, "mensural") == 0)
{
/* Urrgh! We have to detect wether this stem ends on a staff
line or between two staff lines. But we can not call
- stem_end_position(me) or get_default_stem_end_position(me),
+ stem_end_position (me) or get_default_stem_end_position (me),
since this encounters the flag and hence results in an
infinite recursion. However, in pure mensural notation,
there are no multiple note heads attached to a single stem,
--hwn.
*/
- int p = (int)rint (Staff_symbol_referencer::get_position (first_head (me)));
+ int p = Staff_symbol_referencer::get_rounded_position (me);
staffline_offs = Staff_symbol_referencer::on_staffline (me, p) ?
"1" : "0";
}
me->warning (_f ("flag `%s' not found", font_char));
}
- SCM stroke_style_scm = me->get_grob_property ("stroke-style");
- if (gh_string_p (stroke_style_scm))
+ SCM stroke_style_scm = me->get_property ("stroke-style");
+ if (ly_c_string_p (stroke_style_scm))
{
String stroke_style = ly_scm2string (stroke_style_scm);
if (!stroke_style.is_empty ())
SCM
Stem::dim_callback (SCM e, SCM ax)
{
- Axis a = (Axis) gh_scm2int (ax);
+ Axis a = (Axis) ly_scm2int (ax);
assert (a == X_AXIS);
Grob *me = unsmob_grob (e);
Interval r (0, 0);
- if (unsmob_grob (me->get_grob_property ("beam")) || abs (duration_log (me)) <= 2)
+ if (unsmob_grob (me->get_property ("beam")) || abs (duration_log (me)) <= 2)
; // TODO!
else
{
Real
Stem::thickness (Grob* me)
{
- return gh_scm2double (me->get_grob_property ("thickness"))
+ return ly_scm2double (me->get_property ("thickness"))
* Staff_symbol_referencer::line_thickness (me);
}
This is required to avoid stems passing in tablature chords...
*/
- Grob *lh = to_boolean (me->get_grob_property ("avoid-note-head"))
+ Grob *lh = to_boolean (me->get_property ("avoid-note-head"))
? last_head (me) : lh = first_head (me);
if (!lh)
// URG
Real stem_width = thickness (me);
Real blot =
- me->get_paper ()->get_realvar (ly_symbol2scm ("blotdiameter"));
+ me->get_paper ()->get_dimension (ly_symbol2scm ("blotdiameter"));
Box b = Box (Interval (-stem_width/2, stem_width/2),
Interval (stem_y[DOWN]*dy, stem_y[UP]*dy));
if (head_count (me) == 0)
{
- return gh_double2scm (0.0);
+ return scm_make_real (0.0);
}
if (Grob * f = first_head (me))
{
- Interval head_wid = Note_head::head_extent(f, X_AXIS);
+ Interval head_wid = Note_head::head_extent (f, X_AXIS);
Real attach =0.0;
attach = 0.0;
}
else
- attach = Note_head::stem_attachment_coordinate(f, X_AXIS);
+ attach = Note_head::stem_attachment_coordinate (f, X_AXIS);
Direction d = get_direction (me);
r += - d * rule_thick * 0.5;
}
}
- return gh_double2scm (r);
+ return scm_make_real (r);
}
Grob*
Stem::get_beam (Grob*me)
{
- SCM b= me->get_grob_property ("beam");
+ SCM b= me->get_property ("beam");
return unsmob_grob (b);
}
Stem::get_stem_info (Grob *me)
{
/* Return cached info if available */
- SCM scm_info = me->get_grob_property ("stem-info");
- if (!gh_pair_p (scm_info))
+ SCM scm_info = me->get_property ("stem-info");
+ if (!ly_c_pair_p (scm_info))
{
calc_stem_info (me);
- scm_info = me->get_grob_property ("stem-info");
+ scm_info = me->get_property ("stem-info");
}
Stem_info si;
si.dir_ = get_grob_direction (me);
- si.ideal_y_ = gh_scm2double (gh_car (scm_info));
- si.shortest_y_ = gh_scm2double (gh_cadr (scm_info));
+ si.ideal_y_ = ly_scm2double (ly_car (scm_info));
+ si.shortest_y_ = ly_scm2double (ly_cadr (scm_info));
return si;
}
/* Simple standard stem length */
- SCM lengths = me->get_grob_property ("beamed-lengths");
+ SCM lengths = me->get_property ("beamed-lengths");
Real ideal_length =
- gh_scm2double (robust_list_ref (beam_count - 1,lengths))
+ ly_scm2double (robust_list_ref (beam_count - 1,lengths))
* staff_space
/* stem only extends to center of beam */
- 0.5 * beam_thickness;
/* Condition: sane minimum free stem length (chord to beams) */
- lengths = me->get_grob_property ("beamed-minimum-free-lengths");
+ lengths = me->get_property ("beamed-minimum-free-lengths");
Real ideal_minimum_free =
- gh_scm2double (robust_list_ref (beam_count - 1, lengths))
+ ly_scm2double (robust_list_ref (beam_count - 1, lengths))
* staff_space;
Obviously not for grace beams.
Also, not for knees. Seems to be a good thing. */
- bool no_extend_b = to_boolean (me->get_grob_property ("no-stem-extend"));
- bool is_knee = to_boolean (beam->get_grob_property ("knee"));
+ bool no_extend_b = to_boolean (me->get_property ("no-stem-extend"));
+ bool is_knee = to_boolean (beam->get_property ("knee"));
if (!no_extend_b && !is_knee)
{
/* Highest beam of (UP) beam must never be lower than middle
}
- ideal_y -= robust_scm2double (beam->get_grob_property ("shorten"), 0);
+ ideal_y -= robust_scm2double (beam->get_property ("shorten"), 0);
Real minimum_free =
- gh_scm2double (robust_list_ref
+ ly_scm2double (robust_list_ref
(beam_count - 1,
- me->get_grob_property
+ me->get_property
("beamed-extreme-minimum-free-lengths")))
* staff_space;
ideal_y *= my_dir;
Real shortest_y = minimum_y * my_dir;
- me->set_grob_property ("stem-info",
- scm_list_n (gh_double2scm (ideal_y),
- gh_double2scm (shortest_y),
+ me->set_property ("stem-info",
+ scm_list_n (scm_make_real (ideal_y),
+ scm_make_real (shortest_y),
SCM_UNDEFINED));
}
Slice
Stem::beam_multiplicity (Grob *stem)
{
- SCM beaming= stem->get_grob_property ("beaming");
- Slice l = int_list_to_slice (gh_car (beaming));
- Slice r = int_list_to_slice (gh_cdr (beaming));
+ SCM beaming= stem->get_property ("beaming");
+ Slice l = int_list_to_slice (ly_car (beaming));
+ Slice r = int_list_to_slice (ly_cdr (beaming));
l.unite (r);
return l;
,
"tremolo-flag french-beaming "
- "avoid-note-head adjust-if-on-staffline thickness "
+ "avoid-note-head thickness "
"stem-info beamed-lengths beamed-minimum-free-lengths "
"beamed-extreme-minimum-free-lengths lengths beam stem-shorten "
"duration-log beaming neutral-direction stem-end-position "
/****************************************************************/
-Stem_info::Stem_info()
+Stem_info::Stem_info ()
{
ideal_y_ = shortest_y_ =0;
dir_ = CENTER;
projects / lilypond.git / blobdiff