Stream_event *note = accidentals_[i].melodic_;
Context *origin = accidentals_[i].origin_;
- Pitch *pitch = Pitch::unsmob (note->get_property ("pitch"));
+ Pitch *pitch = unsmob<Pitch> (note->get_property ("pitch"));
if (!pitch)
continue;
Grob *a = trans->make_item ("AccidentalSuggestion", note_head->self_scm ());
Side_position_interface::add_support (a, note_head);
- if (Grob *stem = Grob::unsmob (a->get_object ("stem")))
+ if (Grob *stem = unsmob<Grob> (a->get_object ("stem")))
Side_position_interface::add_support (a, stem);
a->set_parent (note_head, X_AXIS);
{
// Don't mark accidentals as "tied" when the pitch is not
// actually the same. This is relevant for enharmonic ties.
- Stream_event *le = Stream_event::unsmob (l->get_property ("cause"));
- Stream_event *re = Stream_event::unsmob (r->get_property ("cause"));
+ Stream_event *le = unsmob<Stream_event> (l->get_property ("cause"));
+ Stream_event *re = unsmob<Stream_event> (r->get_property ("cause"));
if (le && re
&& !ly_is_equal (le->get_property ("pitch"), re->get_property ("pitch")))
continue;
int barnum = measure_number (origin);
- Pitch *pitch = Pitch::unsmob (note->get_property ("pitch"));
+ Pitch *pitch = unsmob<Pitch> (note->get_property ("pitch"));
if (!pitch)
continue;
SCM key = scm_cons (scm_from_int (o), scm_from_int (n));
Moment end_mp = measure_position (context (),
- Duration::unsmob (note->get_property ("duration")));
+ unsmob<Duration> (note->get_property ("duration")));
SCM position = scm_cons (scm_from_int (barnum), end_mp.smobbed_copy ());
SCM localsig = SCM_EOL;
{
SCM cause = acc->get_parent (Y_AXIS)->get_property ("cause");
- Stream_event *mcause = Stream_event::unsmob (cause);
+ Stream_event *mcause = unsmob<Stream_event> (cause);
if (!mcause)
{
programming_error ("note head has no event cause");
return 0;
}
- return Pitch::unsmob (mcause->get_property ("pitch"));
+ return unsmob<Pitch> (mcause->get_property ("pitch"));
}
void
acs = scm_cdr (acs))
for (SCM s = scm_cdar (acs); scm_is_pair (s); s = scm_cdr (s))
{
- Grob *a = Grob::unsmob (scm_car (s));
+ Grob *a = unsmob<Grob> (scm_car (s));
- if (Grob::is_smob (a->get_object ("tie"))
+ if (unsmob<Grob> (a->get_object ("tie"))
&& !to_boolean (a->get_property ("forced")))
break_reminder->push_back (a);
else
Accidental_placement_entry *ape = new Accidental_placement_entry;
for (SCM t = scm_cdar (s); scm_is_pair (t); t = scm_cdr (t))
- ape->grobs_.push_back (Grob::unsmob (scm_car (t)));
+ ape->grobs_.push_back (unsmob<Grob> (scm_car (t)));
apes.push_back (ape);
}
offset -= a->extent (a, X_AXIS).length () + padding;
}
- if (Skyline_pair *sky = Skyline_pair::unsmob (a->get_property ("horizontal-skylines")))
+ if (Skyline_pair *sky = unsmob<Skyline_pair> (a->get_property ("horizontal-skylines")))
{
Skyline_pair copy (*sky);
copy.raise (a->relative_coordinate (common[X_AXIS], X_AXIS));
SCM
Accidental_placement::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
if (!me->is_live ())
return SCM_BOOL_T;
SCM
Accidental_interface::horizontal_skylines (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
if (!me->is_live ())
return Skyline_pair ().smobbed_copy ();
- Stencil *my_stencil = Stencil::unsmob (me->get_property ("stencil"));
+ Stencil *my_stencil = unsmob<Stencil> (me->get_property ("stencil"));
if (!my_stencil)
return Skyline_pair ().smobbed_copy ();
Skyline_pair *sky =
- Skyline_pair::unsmob
+ unsmob<Skyline_pair>
(Stencil::skylines_from_stencil
(my_stencil->smobbed_copy (), 0.0, Y_AXIS));
SCM
Accidental_interface::height (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- Grob *tie = Grob::unsmob (me->get_object ("tie"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *tie = unsmob<Grob> (me->get_object ("tie"));
if (tie
&& !to_boolean (me->get_property ("forced"))
SCM
Accidental_interface::remove_tied (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- Grob *tie = Grob::unsmob (me->get_object ("tie"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *tie = unsmob<Grob> (me->get_object ("tie"));
if (tie
&& !to_boolean (me->get_property ("forced"))
SCM
Accidental_interface::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return get_stencil (me);
}
SCM
Align_interface::align_to_minimum_distances (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
me->set_property ("positioning-done", SCM_BOOL_T);
SCM
Align_interface::align_to_ideal_distances (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
me->set_property ("positioning-done", SCM_BOOL_T);
if (!pure)
{
- Skyline_pair *skys = Skyline_pair::unsmob (g->get_property (a == Y_AXIS
+ Skyline_pair *skys = unsmob<Skyline_pair> (g->get_property (a == Y_AXIS
? "vertical-skylines"
: "horizontal-skylines"));
if (skys)
Align_interface::set_ordered (Grob *me)
{
SCM ga_scm = me->get_object ("elements");
- Grob_array *ga = Grob_array::unsmob (ga_scm);
+ Grob_array *ga = unsmob<Grob_array> (ga_scm);
if (!ga)
{
ga_scm = Grob_array::make_array ();
- ga = Grob_array::unsmob (ga_scm);
+ ga = unsmob<Grob_array> (ga_scm);
me->set_object ("elements", ga_scm);
}
scm_from_double (1.0));
}
g_free (pango_fn);
- return
derived_unsmob<Pango_font> (val);
+ return unsmob<Pango_font> (val);
}
#endif
debug_output ("]", false);
- Font_metric::unsmob (val)->file_name_ = file_name;
+ unsmob<Font_metric> (val)->file_name_ = file_name;
SCM name_string = ly_string2scm (name);
- Font_metric::unsmob (val)->description_ = scm_cons (name_string,
+ unsmob<Font_metric> (val)->description_ = scm_cons (name_string,
scm_from_double (1.0));
otf_dict_->set (sname, val);
- Font_metric::unsmob (val)->unprotect ();
+ unsmob<Font_metric> (val)->unprotect ();
}
- return derived_unsmob<Open_type_font> (val);
+ return unsmob<Open_type_font> (val);
}
Font_metric *
If the engraver is added to a percussion context,
filter out unpitched note heads.
*/
- if (!Pitch::is_smob (p))
+ if (!unsmob<Pitch> (p))
return;
- Pitch pitch = *Pitch::unsmob (p);
+ Pitch pitch = *unsmob<Pitch> (p);
Drul_array<bool> expands = pitch_interval_.add_point (pitch);
if (expands[UP])
causes_[UP] = nr;
SCM
Arpeggio::calc_cross_staff (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
extract_grob_set (me, "stems", stems);
Grob *vag = 0;
SCM
Arpeggio::calc_positions (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
Grob *common = get_common_y (me);
/*
SCM
Arpeggio::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Interval heads = robust_scm2interval (me->get_property ("positions"),
Interval ())
* Staff_symbol_referencer::staff_space (me);
SCM
Arpeggio::brew_chord_bracket (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Interval heads = robust_scm2interval (me->get_property ("positions"),
Interval ())
* Staff_symbol_referencer::staff_space (me);
SCM
Arpeggio::brew_chord_slur (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM dash_definition = me->get_property ("dash-definition");
Interval heads = robust_scm2interval (me->get_property ("positions"),
Interval ())
SCM
Arpeggio::width (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return ly_interval2scm (get_squiggle (me).extent (X_AXIS));
}
SCM
Arpeggio::pure_height (SCM smob, SCM, SCM)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
if (to_boolean (me->get_property ("cross-staff")))
return ly_interval2scm (Interval ());
for (SCM s = event->get_property ("articulations");
!articulation_event && scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *art = Stream_event::unsmob (scm_car (s));
+ Stream_event *art = unsmob<Stream_event> (scm_car (s));
if (art->in_event_class (articulation_name))
articulation_event = art;
return;
}
- int durlog = Duration::unsmob (ev->get_property ("duration"))->duration_log ();
+ int durlog = unsmob<Duration> (ev->get_property ("duration"))->duration_log ();
if (durlog <= 2)
{
if (!is_same_grace_state (beam_start_location_, now))
return;
- Duration *stem_duration = Duration::unsmob (ev->get_property ("duration"));
+ Duration *stem_duration = unsmob<Duration> (ev->get_property ("duration"));
Moment dur = stem_duration->get_length ();
- //Moment dur = Duration::unsmob (ev->get_property ("duration"))->get_length ();
+ //Moment dur = unsmob<Duration> (ev->get_property ("duration"))->get_length ();
Moment measure_now = measure_position (context ());
bool recheck_needed = false;
for (; scm_is_pair (split_list_); split_list_ = scm_cdr (split_list_))
{
- splitm = Moment::unsmob (scm_caar (split_list_));
+ splitm = unsmob<Moment> (scm_caar (split_list_));
if ((*splitm + start_moment_) > now)
break;
if (!staffline_ && active_)
{
staffline_ = get_spanner ();
- Grob *it = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *it = unsmob<Grob> (get_property ("currentCommandColumn"));
staffline_->set_bound (LEFT, it);
}
interesting_ = get_property ("keepAliveInterfaces");
{
if (staffline_)
{
- Grob *it = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *it = unsmob<Grob> (get_property ("currentCommandColumn"));
staffline_->set_bound (RIGHT, it);
Pointer_group_interface::set_ordered (staffline_, ly_symbol2scm ("elements"), false);
for (vsize i = 0; i < elts_.size (); i++)
{
- if (!Grob::is_smob (elts_[i]->get_object ("axis-group-parent-Y")))
+ if (!unsmob<Grob> (elts_[i]->get_object ("axis-group-parent-Y")))
{
if (staffline_->get_parent (Y_AXIS)
&& staffline_->get_parent (Y_AXIS) == elts_[i])
"Determine the extent of @var{elements} relative to @var{common} in the"
" @var{axis} direction.")
{
- Grob_array *ga = Grob_array::unsmob (elements);
+ Grob_array *ga = unsmob<Grob_array> (elements);
SCM_ASSERT_TYPE (ga || scm_is_pair (elements), elements, SCM_ARG1, __FUNCTION__, "list or Grob_array");
LY_ASSERT_SMOB (Grob, common, 2);
if (!ga)
{
for (SCM s = elements; scm_is_pair (s); s = scm_cdr (s))
- elts.push_back (Grob::unsmob (scm_car (s)));
+ elts.push_back (unsmob<Grob> (scm_car (s)));
}
Interval ext = Axis_group_interface::relative_group_extent (ga ? ga->array () : elts,
- Grob::unsmob (common),
+ unsmob<Grob> (common),
(Axis) scm_to_int (axis));
return ly_interval2scm (ext);
}
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_SMOB (Grob, common, 2);
- Interval ext = Axis_group_interface::generic_bound_extent (Grob::unsmob (grob), Grob::unsmob (common), X_AXIS);
+ Interval ext = Axis_group_interface::generic_bound_extent (unsmob<Grob> (grob), unsmob<Grob> (common), X_AXIS);
return ly_interval2scm (ext);
}
{
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_SMOB (Grob, grob_element, 2);
- Axis_group_interface::add_element (Grob::unsmob (grob), Grob::unsmob (grob_element));
+ Axis_group_interface::add_element (unsmob<Grob> (grob), unsmob<Grob> (grob_element));
return SCM_UNSPECIFIED;
}
SCM
Axis_group_interface::adjacent_pure_heights (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
- Grob *common = Grob::unsmob (me->get_object ("pure-Y-common"));
+ Grob *common = unsmob<Grob> (me->get_object ("pure-Y-common"));
extract_grob_set (me, "pure-relevant-grobs", elts);
Paper_score *ps = get_root_system (me)->paper_score ();
if (p && Align_interface::has_interface (p))
return Axis_group_interface::sum_partial_pure_heights (me, start, end);
- Grob *common = Grob::unsmob (me->get_object ("pure-Y-common"));
+ Grob *common = unsmob<Grob> (me->get_object ("pure-Y-common"));
extract_grob_set (me, "pure-relevant-grobs", elts);
Interval r;
SCM
Axis_group_interface::width (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return generic_group_extent (me, X_AXIS);
}
SCM
Axis_group_interface::height (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return generic_group_extent (me, Y_AXIS);
}
{
int start = robust_scm2int (start_scm, 0);
int end = robust_scm2int (end_scm, INT_MAX);
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
/* Maybe we are in the second pass of a two-pass spacing run. In that
case, the Y-extent of a system is already given to us */
SCM
Axis_group_interface::calc_skylines (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Skyline_pair skylines = skyline_spacing (me);
return skylines.smobbed_copy ();
}
SCM
Axis_group_interface::combine_skylines (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "elements", elements);
Grob *y_common = common_refpoint_of_array (elements, me, Y_AXIS);
Grob *x_common = common_refpoint_of_array (elements, me, X_AXIS);
for (vsize i = 0; i < elements.size (); i++)
{
SCM skyline_scm = elements[i]->get_property ("vertical-skylines");
- if (Skyline_pair::is_smob (skyline_scm))
+ if (unsmob<Skyline_pair> (skyline_scm))
{
Real offset = elements[i]->relative_coordinate (y_common, Y_AXIS);
- Skyline_pair other = *Skyline_pair::unsmob (skyline_scm);
+ Skyline_pair other = *unsmob<Skyline_pair> (skyline_scm);
other.raise (offset);
other.shift (elements[i]->relative_coordinate (x_common, X_AXIS));
ret.merge (other);
SCM
Axis_group_interface::calc_pure_relevant_grobs (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
/* TODO: Filter out elements that belong to a different Axis_group,
such as the tie in
<< \new Staff=A { c'1~ \change Staff=B c'}
vector_sort (relevant_grobs, pure_staff_priority_less);
SCM grobs_scm = Grob_array::make_array ();
- Grob_array::unsmob (grobs_scm)->set_array (relevant_grobs);
+ unsmob<Grob_array> (grobs_scm)->set_array (relevant_grobs);
return grobs_scm;
}
SCM
Axis_group_interface::calc_pure_y_common (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "pure-relevant-grobs", elts);
Grob *common = common_refpoint_of_array (elts, me, Y_AXIS);
SCM
Axis_group_interface::calc_x_common (SCM grob)
{
- return calc_common (Grob::unsmob (grob), X_AXIS);
+ return calc_common (unsmob<Grob> (grob), X_AXIS);
}
MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_y_common, 1);
SCM
Axis_group_interface::calc_y_common (SCM grob)
{
- return calc_common (Grob::unsmob (grob), Y_AXIS);
+ return calc_common (unsmob<Grob> (grob), Y_AXIS);
}
Interval
Axis_group_interface::pure_group_height (Grob *me, int start, int end)
{
- Grob *common = Grob::unsmob (me->get_object ("pure-Y-common"));
+ Grob *common = unsmob<Grob> (me->get_object ("pure-Y-common"));
if (!common)
{
static void
add_interior_skylines (Grob *me, Grob *x_common, Grob *y_common, vector<Skyline_pair> *skylines)
{
- if (Grob_array *elements = Grob_array::unsmob (me->get_object ("elements")))
+ if (Grob_array *elements = unsmob<Grob_array> (me->get_object ("elements")))
{
for (vsize i = 0; i < elements->size (); i++)
add_interior_skylines (elements->grob (i), x_common, y_common, skylines);
else if (!scm_is_number (me->get_property ("outside-staff-priority"))
&& !to_boolean (me->get_property ("cross-staff")))
{
- Skyline_pair *maybe_pair = Skyline_pair::unsmob (me->get_property ("vertical-skylines"));
+ Skyline_pair *maybe_pair = unsmob<Skyline_pair> (me->get_property ("vertical-skylines"));
if (!maybe_pair)
return;
if (maybe_pair->is_empty ())
}
last_end[dir] = x_extent[RIGHT];
- Skyline_pair *v_orig = Skyline_pair::unsmob (elt->get_property ("vertical-skylines"));
+ Skyline_pair *v_orig = unsmob<Skyline_pair> (elt->get_property ("vertical-skylines"));
if (v_orig->is_empty ())
continue;
for (GrobMapIterator j = range.first; j != range.second; j++)
{
Grob *rider = j->second;
- Skyline_pair *v_rider = Skyline_pair::unsmob (rider->get_property ("vertical-skylines"));
+ Skyline_pair *v_rider = unsmob<Skyline_pair> (rider->get_property ("vertical-skylines"));
if (v_rider)
{
Skyline_pair copy (*v_rider);
Skyline_pair
Axis_group_interface::skyline_spacing (Grob *me)
{
- extract_grob_set (me, Grob_array::unsmob (me->get_object ("vertical-skyline-elements")) ? "vertical-skyline-elements" : "elements", fakeelements);
+ extract_grob_set (me, unsmob<Grob_array> (me->get_object ("vertical-skyline-elements")) ? "vertical-skyline-elements" : "elements", fakeelements);
vector<Grob *> elements (fakeelements);
for (vsize i = 0; i < elements.size (); i++)
/*
if (!debug_skylines)
return SCM_BOOL_F;
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Stencil ret;
- if (Skyline_pair *s = Skyline_pair::unsmob (me->get_property ("vertical-skylines")))
+ if (Skyline_pair *s = unsmob<Skyline_pair> (me->get_property ("vertical-skylines")))
{
ret.add_stencil (Lookup::points_to_line_stencil (0.1, (*s)[UP].to_points (X_AXIS))
.in_color (255, 0, 255));
SCM
Axis_group_interface::calc_pure_staff_staff_spacing (SCM smob, SCM start, SCM end)
{
- return calc_maybe_pure_staff_staff_spacing (Grob::unsmob (smob),
+ return calc_maybe_pure_staff_staff_spacing (unsmob<Grob> (smob),
true,
scm_to_int (start),
scm_to_int (end));
SCM
Axis_group_interface::calc_staff_staff_spacing (SCM smob)
{
- return calc_maybe_pure_staff_staff_spacing (Grob::unsmob (smob),
+ return calc_maybe_pure_staff_staff_spacing (unsmob<Grob> (smob),
false,
0,
INT_MAX);
SCM
Axis_group_interface::calc_maybe_pure_staff_staff_spacing (Grob *me, bool pure, int start, int end)
{
- Grob *grouper = Grob::unsmob (me->get_object ("staff-grouper"));
+ Grob *grouper = unsmob<Grob> (me->get_object ("staff-grouper"));
if (grouper)
{
SCM arts = cause ? cause->get_property ("articulations") : SCM_EOL;
for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *e = Stream_event::unsmob (scm_car (s));
+ Stream_event *e = unsmob<Stream_event> (scm_car (s));
if (e->in_event_class ("annotate-output-event"))
{
balloonify (info.grob (), e);
SCM
Balloon_interface::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
if (Item *item = dynamic_cast<Item *> (me))
if (!Item::break_visible (item))
SCM
Balloon_interface::print_spanner (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Spanner *orig = dynamic_cast<Spanner *> (me->original ());
if (orig)
SCM chain = Font_interface::text_font_alist_chain (me);
SCM stencil = Text_interface::interpret_markup (me->layout ()->self_scm (),
chain, bt);
- Stencil *text_stil = Stencil::unsmob (stencil);
+ Stencil *text_stil = unsmob<Stencil> (stencil);
Offset z1;
SCM mp = tr->get_property ("measurePosition");
SCM sync = tr->get_property ("barCheckSynchronize");
- Moment *where = Moment::unsmob (mp);
+ Moment *where = unsmob<Moment> (mp);
if (!where)
return;
else
{
SCM lf = tr->get_property ("barCheckLastFail");
- if (Moment::is_smob (lf)
- && *Moment::unsmob (lf) == *where)
+ if (unsmob<Moment> (lf)
+ && *unsmob<Moment> (lf) == *where)
warn = false;
else
tr->set_property ("barCheckLastFail", mp);
{
// Do not consider note heads attached to the beam.
if (Stem::has_interface (covered_grob))
- if (Grob::is_smob (covered_grob->get_object ("beam")))
+ if (unsmob<Grob> (covered_grob->get_object ("beam")))
continue;
- if (Grob *stem = Grob::unsmob (covered_grob->get_object ("stem")))
- if (Grob *beam = Grob::unsmob (stem->get_object ("beam")))
+ if (Grob *stem = unsmob<Grob> (covered_grob->get_object ("stem")))
+ if (Grob *beam = unsmob<Grob> (stem->get_object ("beam")))
if (beam == beam_grob)
continue;
last_stem_added_at_ = now;
- Duration *stem_duration = Duration::unsmob (ev->get_property ("duration"));
+ Duration *stem_duration = unsmob<Duration> (ev->get_property ("duration"));
int durlog = stem_duration->duration_log ();
- //int durlog = Duration::unsmob (ev->get_property ("duration"))->duration_log ();
+ //int durlog = unsmob<Duration> (ev->get_property ("duration"))->duration_log ();
if (durlog <= 2)
{
ev->origin ()->warning (_ ("stem does not fit in beam"));
for (LEFT_and_RIGHT (d))
add_collision (b[X_AXIS][d], b[Y_AXIS], width_factor);
- Grob *stem = Grob::unsmob (collisions[j]->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (collisions[j]->get_object ("stem"));
if (stem && Stem::has_interface (stem) && Stem::is_normal_stem (stem))
{
colliding_stems.insert (stem);
- my_y;
Real factor = parameters_.STEM_COLLISION_FACTOR;
- if (!Grob::is_smob (s->get_object ("beam")))
+ if (!unsmob<Grob> (s->get_object ("beam")))
factor = 1.0;
add_collision (x, y, factor);
}
SCM
Beam::calc_normal_stems (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "stems", stems);
SCM val = Grob_array::make_array ();
- Grob_array *ga = Grob_array::unsmob (val);
+ Grob_array *ga = unsmob<Grob_array> (val);
for (vsize i = 0; i < stems.size (); i++)
if (Stem::is_normal_stem (stems[i]))
ga->add (stems[i]);
SCM
Beam::calc_direction (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
/* Beams with less than 2 two stems don't make much sense, but could happen
when you do
SCM
Beam::calc_beaming (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "stems", stems);
{
/* ugh, this has a side-effect that we need to ensure that
Stem #'beaming is correct */
- Grob *me_grob = Grob::unsmob (smob);
+ Grob *me_grob = unsmob<Grob> (smob);
(void) me_grob->get_property ("beaming");
Spanner *me = dynamic_cast<Spanner *> (me_grob);
SCM
Beam::calc_x_positions (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
SCM segments = me->get_property ("beam-segments");
Interval x_positions;
x_positions.set_empty ();
SCM
Beam::print (SCM grob)
{
- Spanner *me = Spanner::unsmob (grob);
+ Spanner *me = unsmob<Spanner> (grob);
/*
TODO - mild code dup for all the commonx calls.
Some use just common_refpoint_of_array, some (in print and
Direction stem_dir = stems.size () ? to_dir (stems[0]->get_property ("direction")) : UP;
- Stencil score = *Stencil::unsmob (Text_interface::interpret_markup
+ Stencil score = *unsmob<Stencil> (Text_interface::interpret_markup
(me->layout ()->self_scm (), properties, annotation));
if (!score.is_empty ())
SCM
Beam::calc_stem_shorten (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
/*
shortening looks silly for x staff beams
SCM
Beam::quanting (SCM smob, SCM ys_scm, SCM align_broken_intos)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Drul_array<Real> ys = robust_scm2drul (ys_scm, Drul_array<Real> (infinity_f, -infinity_f));
bool cbs = to_boolean (align_broken_intos);
SCM
Beam::set_stem_lengths (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
/* trigger callbacks. */
(void) me->get_property ("direction");
SCM
Beam::rest_collision_callback (SCM smob, SCM prev_offset)
{
- Grob *rest = Grob::unsmob (smob);
+ Grob *rest = unsmob<Grob> (smob);
if (scm_is_number (rest->get_property ("staff-position")))
return scm_from_int (0);
Real offset = robust_scm2double (prev_offset, 0.0);
- Grob *st = Grob::unsmob (rest->get_object ("stem"));
+ Grob *st = unsmob<Grob> (rest->get_object ("stem"));
Grob *stem = st;
if (!stem)
return scm_from_double (0.0);
- Grob *beam = Grob::unsmob (stem->get_object ("beam"));
+ Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
if (!beam
|| !Beam::has_interface (beam)
|| !Beam::normal_stem_count (beam))
{
Real previous = robust_scm2double (prev_offset, 0.0);
- Grob *me = Grob::unsmob (smob);
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
if (!stem)
return scm_from_double (previous);
- Grob *beam = Grob::unsmob (stem->get_object ("beam"));
+ Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
if (!beam
|| !Beam::normal_stem_count (beam)
|| !is_direction (beam->get_property_data ("direction")))
SCM
Beam::calc_cross_staff (SCM smob)
{
- return scm_from_bool (is_cross_staff (Grob::unsmob (smob)));
+ return scm_from_bool (is_cross_staff (unsmob<Grob> (smob)));
}
int
// We shouldn't end a spanner on the last musical column of a piece because then
// it would extend past the last breakable column of the piece.
if (last_fall_)
- last_fall_->set_bound (RIGHT, Grob::unsmob (get_property ("currentCommandColumn")));
+ last_fall_->set_bound (RIGHT, unsmob<Grob> (get_property ("currentCommandColumn")));
}
void
{
bool bar = scm_is_string (get_property ("whichBar"));
- fall_->set_bound (RIGHT, Grob::unsmob (bar
+ fall_->set_bound (RIGHT, unsmob<Grob> (bar
? get_property ("currentCommandColumn")
: get_property ("currentMusicalColumn")));
last_fall_ = fall_;
"Make a @code{\\book} of @var{paper} and @var{header}"
" (which may be @code{#f} as well) containing @code{\\scores}.")
{
- Output_def *odef = Output_def::unsmob (paper);
+ Output_def *odef = unsmob<Output_def> (paper);
LY_ASSERT_SMOB (Output_def, paper, 1);
Book *book = new Book;
" For example, it may be a string (for file based outputs)"
" or a socket (for network based output).")
{
- Book *book = Book::unsmob (book_smob);
+ Book *book = unsmob<Book> (book_smob);
LY_ASSERT_SMOB (Book, book_smob, 1);
LY_ASSERT_SMOB (Output_def, default_paper, 2);
LY_ASSERT_SMOB (Output_def, default_layout, 3);
- Paper_book *pb = book->process (Output_def::unsmob (default_paper),
- Output_def::unsmob (default_layout));
+ Paper_book *pb = book->process (unsmob<Output_def> (default_paper),
+ unsmob<Output_def> (default_layout));
if (pb)
{
pb->output (output);
LY_ASSERT_SMOB (Output_def, default_paper, 2);
LY_ASSERT_SMOB (Output_def, default_layout, 3);
- Book *book = Book::unsmob (book_smob);
+ Book *book = unsmob<Book> (book_smob);
- Paper_book *pb = book->process (Output_def::unsmob (default_paper),
- Output_def::unsmob (default_layout));
+ Paper_book *pb = book->process (unsmob<Output_def> (default_paper),
+ unsmob<Output_def> (default_layout));
if (pb)
{
pb->classic_output (output);
"Add @var{score} to @var{book-smob} score list.")
{
LY_ASSERT_SMOB (Book, book_smob, 1);
- Book *book = Book::unsmob (book_smob);
+ Book *book = unsmob<Book> (book_smob);
book->add_score (score);
return SCM_UNSPECIFIED;
}
"Add @var{book-part} to @var{book-smob} book part list.")
{
LY_ASSERT_SMOB (Book, book_smob, 1);
- Book *book = Book::unsmob (book_smob);
+ Book *book = unsmob<Book> (book_smob);
book->add_bookpart (book_part);
return SCM_UNSPECIFIED;
}
"Return book parts in @var{book}.")
{
LY_ASSERT_SMOB (Book, book, 1);
- Book *b = Book::unsmob (book);
+ Book *b = unsmob<Book> (book);
return b->bookparts_;
}
"Return paper in @var{book}.")
{
LY_ASSERT_SMOB (Book, book, 1);
- Book *b = Book::unsmob (book);
+ Book *b = unsmob<Book> (book);
return b->paper_ ? b->paper_->self_scm () : SCM_BOOL_F;
}
"Return header in @var{book}.")
{
LY_ASSERT_SMOB (Book, book, 1);
- Book *b = Book::unsmob (book);
+ Book *b = unsmob<Book> (book);
return b->header_ ? b->header_ : SCM_BOOL_F;
}
SCM_ASSERT_TYPE (ly_is_module (module), module, SCM_ARG2, __FUNCTION__,
"module");
- Book *b = Book::unsmob (book);
+ Book *b = unsmob<Book> (book);
b->header_ = (module);
return SCM_UNSPECIFIED;
}
"Return scores in @var{book}.")
{
LY_ASSERT_SMOB (Book, book, 1);
- Book *b = Book::unsmob (book);
+ Book *b = unsmob<Book> (book);
return b->scores_;
}
{
SCM entry = scm_car (p);
- if (Score *newscore = Score::unsmob (entry))
+ if (Score *newscore = unsmob<Score> (entry))
* t = scm_cons (newscore->clone ()->unprotect (), SCM_EOL);
- else if (Page_marker *marker = Page_marker::unsmob (entry))
+ else if (Page_marker *marker = unsmob<Page_marker> (entry))
* t = scm_cons (marker->clone ()->unprotect (), SCM_EOL);
else
{
t = &bookparts_;
for (SCM p = s.bookparts_; scm_is_pair (p); p = scm_cdr (p))
{
- Book *newpart = Book::unsmob (scm_car (p))->clone ();
+ Book *newpart = unsmob<Book> (scm_car (p))->clone ();
*t = scm_cons (newpart->self_scm (), SCM_EOL);
t = SCM_CDRLOC (*t);
Input *
Book::origin () const
{
- return Input::unsmob (input_location_);
+ return unsmob<Input> (input_location_);
}
Book::~Book ()
Book::add_bookpart (SCM b)
{
add_scores_to_bookpart ();
- Book *part = Book::unsmob (b);
+ Book *part = unsmob<Book> (b);
part->set_parent (this);
bookparts_ = scm_cons (b, bookparts_);
}
Book::error_found ()
{
for (SCM s = scores_; scm_is_pair (s); s = scm_cdr (s))
- if (Score *score = Score::unsmob (scm_car (s)))
+ if (Score *score = unsmob<Score> (scm_car (s)))
if (score->error_found_)
return true;
for (SCM part = bookparts_; scm_is_pair (part); part = scm_cdr (part))
- if (Book *bookpart = Book::unsmob (scm_car (part)))
+ if (Book *bookpart = unsmob<Book> (scm_car (part)))
if (bookpart->error_found ())
return true;
add_scores_to_bookpart ();
for (SCM p = scm_reverse (bookparts_); scm_is_pair (p); p = scm_cdr (p))
{
- if (Book *book = Book::unsmob (scm_car (p)))
+ if (Book *book = unsmob<Book> (scm_car (p)))
{
Paper_book *paper_book_part = book->process (paper, layout, output_paper_book);
if (paper_book_part)
void
Book::process_score (SCM s, Paper_book *output_paper_book, Output_def *layout)
{
- if (Score *score = Score::unsmob (scm_car (s)))
+ if (Score *score = unsmob<Score> (scm_car (s)))
{
SCM outputs = score
->book_rendering (output_paper_book->paper_, layout);
while (scm_is_pair (outputs))
{
- Music_output *output = Music_output::unsmob (scm_car (outputs));
+ Music_output *output = unsmob<Music_output> (scm_car (outputs));
if (Performance *perf = dynamic_cast<Performance *> (output))
output_paper_book->add_performance (perf->self_scm ());
}
}
else if (Text_interface::is_markup_list (scm_car (s))
- || Page_marker::is_smob (scm_car (s)))
+ || unsmob<Page_marker> (scm_car (s)))
output_paper_book->add_score (scm_car (s));
else
assert (0);
Context *origin = inf.origin_contexts (this)[0];
Translator_group *tg = origin->implementation ();
- Engraver *random_source = Engraver::unsmob (scm_car (tg->get_simple_trans_list ()));
+ Engraver *random_source = unsmob<Engraver> (scm_car (tg->get_simple_trans_list ()));
if (!random_source)
random_source = this;
if (scm_is_true (s))
{
- Grob *e = Grob::unsmob (scm_cdr (s));
+ Grob *e = unsmob<Grob> (scm_cdr (s));
group = dynamic_cast<Item *> (e);
}
else
SCM
Break_alignment_interface::calc_positioning_done (SCM smob)
{
- Grob *grob = Grob::unsmob (smob);
+ Grob *grob = unsmob<Grob> (smob);
Item *me = dynamic_cast<Item *> (grob);
me->set_property ("positioning-done", SCM_BOOL_T);
sym_string = ly_symbol2string (rsym);
string orig_string;
- if (Grob::is_smob (l->get_property ("cause")))
- orig_string = Grob::unsmob (l->get_property ("cause"))->name ();
+ if (unsmob<Grob> (l->get_property ("cause")))
+ orig_string = unsmob<Grob> (l->get_property ("cause"))->name ();
programming_error (to_string ("No spacing entry from %s to `%s'",
orig_string.c_str (),
SCM
Break_alignable_interface::self_align_callback (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
Item *alignment = dynamic_cast<Item *> (me->get_parent (X_AXIS));
if (!Break_alignment_interface::has_interface (alignment))
return scm_from_int (0);
SCM
Break_aligned_interface::calc_average_anchor (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
Real avg = 0.0;
int count = 0;
SCM
Break_aligned_interface::calc_extent_aligned_anchor (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real alignment = robust_scm2double (me->get_property ("break-align-anchor-alignment"), 0.0);
Interval iv = me->extent (me, X_AXIS);
Break_aligned_interface::calc_break_visibility (SCM smob)
{
/* a BreakAlignGroup is break-visible if it has one element that is break-visible */
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM ret = scm_c_make_vector (3, SCM_EOL);
extract_grob_set (me, "elements", elts);
for (int dir = 0; dir <= 2; dir++)
else
{
System *line
- = derived_unsmob<System> (break_criterion);
+ = unsmob<System> (break_criterion);
if (sc->get_system () != line)
sc = sc->find_broken_piece (line);
{
again:
- if (Grob::is_smob (src))
+ if (unsmob<Grob> (src))
{
- Grob *new_ptr = substitute_grob (Grob::unsmob (src));
+ Grob *new_ptr = substitute_grob (unsmob<Grob> (src));
return new_ptr ? new_ptr->self_scm () : SCM_UNDEFINED;
}
else if (scm_is_vector (src))
set_break_subsititution (l ? l->self_scm () : SCM_UNDEFINED);
SCM newval = sc->internal_get_object (sym);
- if (!Grob_array::is_smob (newval))
+ if (!unsmob<Grob_array> (newval))
{
newval = Grob_array::make_array ();
sc->set_object (sym, newval);
}
- Grob_array *new_array = Grob_array::unsmob (newval);
+ Grob_array *new_array = unsmob<Grob_array> (newval);
for (int k = 0; k < 2; k++)
for (int j = (*arrs[k])[i][LEFT]; j <= (*arrs[k])[i][RIGHT]; j++)
{
SCM sym = scm_caar (s);
SCM val = scm_cdar (s);
- if (Grob_array *orig = Grob_array::unsmob (val))
+ if (Grob_array *orig = unsmob<Grob_array> (val))
{
SCM handle = scm_assq (sym, dest);
SCM newval
? scm_cdr (handle)
: Grob_array::make_array ();
- Grob_array *new_arr = Grob_array::unsmob (newval);
+ Grob_array *new_arr = unsmob<Grob_array> (newval);
substitute_grob_array (orig, new_arr);
val = newval;
Spanner *s = this;
bool fast_done = false;
- Grob_array *grob_array = Grob_array::unsmob (val);
+ Grob_array *grob_array = unsmob<Grob_array> (val);
if (grob_array)
fast_done = s->fast_substitute_grob_array (sym, grob_array);
if (grob_array)
{
SCM newval = sc->internal_get_object (sym);
- if (!Grob_array::is_smob (newval))
+ if (!unsmob<Grob_array> (newval))
{
newval = Grob_array::make_array ();
sc->set_object (sym, newval);
}
- substitute_grob_array (grob_array, Grob_array::unsmob (newval));
+ substitute_grob_array (grob_array, unsmob<Grob_array> (newval));
}
else
{
SCM
Breathing_sign::divisio_minima (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real staff_space = Staff_symbol_referencer::staff_space (me);
Real thickness = Staff_symbol_referencer::line_thickness (me);
SCM
Breathing_sign::divisio_maior (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real thickness = Staff_symbol_referencer::line_thickness (me);
thickness *= robust_scm2double (me->get_property ("thickness"), 1.0);
SCM
Breathing_sign::divisio_maxima (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real staff_space = Staff_symbol_referencer::staff_space (me);
Real thickness = Staff_symbol_referencer::line_thickness (me);
thickness *= robust_scm2double (me->get_property ("thickness"), 1.0);
SCM
Breathing_sign::finalis (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real staff_space = Staff_symbol_referencer::staff_space (me);
Real thickness = Staff_symbol_referencer::line_thickness (me);
thickness *= robust_scm2double (me->get_property ("thickness"), 1.0);
SCM
Breathing_sign::offset_callback (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Direction d = get_grob_direction (me);
if (!d)
{
Stream_event *n = notes_[i];
SCM p = n->get_property ("pitch");
- if (!Pitch::is_smob (p))
+ if (!unsmob<Pitch> (p))
continue;
if (to_boolean (n->get_property ("bass")))
SCM oct = n->get_property ("octavation");
if (scm_is_number (oct))
{
- Pitch orig = Pitch::unsmob (p)->transposed (Pitch (-scm_to_int (oct), 0));
+ Pitch orig = unsmob<Pitch> (p)->transposed (Pitch (-scm_to_int (oct), 0));
pitches = scm_cons (orig.smobbed_copy (), pitches);
}
else
SCM
Chord_name::after_line_breaking (SCM smob)
{
- Item *me = Item::unsmob (smob);
+ Item *me = unsmob<Item> (smob);
assert (me);
SCM s = me->get_property ("begin-of-line-visible");
scm_call_1 (fun, context->self_scm ());
for (SCM s = context->children_contexts ();
scm_is_pair (s); s = scm_cdr (s))
- apply_on_children (Context::unsmob (scm_car (s)), fun);
+ apply_on_children (unsmob<Context> (scm_car (s)), fun);
}
void
SCM
Clef_modifier::calc_parent_alignment (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *clef = me->get_parent (X_AXIS);
string full_clef_name = ly_scm2string (clef->get_property ("glyph"));
string clef_name = replace_all(&full_clef_name, "clefs.", "");
SCM
Clef::calc_glyph_name (SCM smob)
{
- Item *s = Item::unsmob (smob);
+ Item *s = unsmob<Item> (smob);
SCM glyph = s->get_property ("glyph");
if (scm_is_string (glyph))
SCM
Clef::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM glyph_scm = me->get_property ("glyph-name");
if (!scm_is_string (glyph_scm))
return SCM_EOL;
for (vsize i = 0; i < cluster_notes_.size (); i++)
{
- Pitch *pit = Pitch::unsmob (cluster_notes_[i]->get_property ("pitch"));
+ Pitch *pit = unsmob<Pitch> (cluster_notes_[i]->get_property ("pitch"));
int p = (pit ? pit->steps () : 0) + c0;
SCM
Cluster::calc_cross_staff (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "columns", cols);
Grob *commony = common_refpoint_of_array (cols, me, Y_AXIS);
SCM
Cluster::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Spanner *spanner = dynamic_cast<Spanner *> (me);
if (!spanner)
SCM
Cluster_beacon::height (SCM g)
{
- Grob *me = Grob::unsmob (g);
+ Grob *me = unsmob<Grob> (g);
Interval v = robust_scm2interval (me->get_property ("positions"),
Interval (0, 0));
return ly_interval2scm (Staff_symbol_referencer::staff_space (me) * 0.5 * v);
primitive = dynamic_cast<Item *> (primitives[i].grob ());
Stream_event *cause = primitives[i].event_cause ();
int pitch
- = Pitch::unsmob (cause->get_property ("pitch"))->steps ();
+ = unsmob<Pitch> (cause->get_property ("pitch"))->steps ();
if (prev_primitive)
{
delta_pitch = pitch - prev_pitch;
Moment
Completion_heads_engraver::next_moment (Rational const ¬e_len)
{
- Moment *e = Moment::unsmob (get_property ("measurePosition"));
- Moment *l = Moment::unsmob (get_property ("measureLength"));
+ Moment *e = unsmob<Moment> (get_property ("measurePosition"));
+ Moment *l = unsmob<Moment> (get_property ("measureLength"));
if (!e || !l || !to_boolean (get_property ("timing")))
{
return Moment (0, 0);
+ e->to_string () + " of " + l->to_string ());
return 0;
}
- Moment const *unit = Moment::unsmob (get_property ("completionUnit"));
+ Moment const *unit = unsmob<Moment> (get_property ("completionUnit"));
if (unit)
{
Completion_heads_engraver::make_note_head (Stream_event *ev)
{
Item *note = make_item ("NoteHead", ev->self_scm ());
- Pitch *pit = Pitch::unsmob (ev->get_property ("pitch"));
+ Pitch *pit = unsmob<Pitch> (ev->get_property ("pitch"));
int pos = pit->steps ();
SCM c0 = get_property ("middleCPosition");
}
else
{
- orig = Duration::unsmob (note_events_[0]->get_property ("duration"));
+ orig = unsmob<Duration> (note_events_[0]->get_property ("duration"));
note_dur = *orig;
SCM factor = get_property ("completionFactor");
if (ly_is_procedure (factor))
Moment
Completion_rest_engraver::next_moment (Rational const ¬e_len)
{
- Moment *e = Moment::unsmob (get_property ("measurePosition"));
- Moment *l = Moment::unsmob (get_property ("measureLength"));
+ Moment *e = unsmob<Moment> (get_property ("measurePosition"));
+ Moment *l = unsmob<Moment> (get_property ("measureLength"));
if (!e || !l || !to_boolean (get_property ("timing")))
{
return Moment (0, 0);
}
Moment result = *l - *e;
- Moment const *unit = Moment::unsmob (get_property ("completionUnit"));
+ Moment const *unit = unsmob<Moment> (get_property ("completionUnit"));
if (unit)
{
Completion_rest_engraver::make_rest (Stream_event *ev)
{
Item *rest = make_item ("Rest", ev->self_scm ());
- if (Pitch *p = Pitch::unsmob (ev->get_property ("pitch")))
+ if (Pitch *p = unsmob<Pitch> (ev->get_property ("pitch")))
{
int pos = p->steps ();
SCM c0 = get_property ("middleCPosition");
}
else
{
- orig = Duration::unsmob (rest_events_[0]->get_property ("duration"));
+ orig = unsmob<Duration> (rest_events_[0]->get_property ("duration"));
rest_dur = *orig;
SCM factor = get_property ("completionFactor");
if (ly_is_procedure (factor))
if (scm_is_pair (footnotes))
for (SCM s = footnotes; scm_is_pair (s); s = scm_cdr (s))
{
- Stencil *sten = Stencil::unsmob (scm_caddar (s));
+ Stencil *sten = unsmob<Stencil> (scm_caddar (s));
if (!sten)
{
programming_error ("expecting stencil, got empty pointer");
last_column_ = 0;
force_ = 0;
- Stencil *st = Stencil::unsmob (pb->get_property ("stencil"));
+ Stencil *st = unsmob<Stencil> (pb->get_property ("stencil"));
Interval stencil_extent = st->is_empty (Y_AXIS) ? Interval (0, 0)
: st->extent (Y_AXIS);
shape_ = Line_shape (stencil_extent, stencil_extent); // pretend it goes all the way across
Input *
Context_def::origin () const
{
- return Input::unsmob (input_location_);
+ return unsmob<Input> (input_location_);
}
Context_def::Context_def (Context_def const &s)
vector<Context_def *> accepteds;
for (SCM s = accepted; scm_is_pair (s); s = scm_cdr (s))
- if (Context_def *t = Context_def::unsmob (find_context_def (odef,
+ if (Context_def *t = unsmob<Context_def> (find_context_def (odef,
scm_car (s))))
accepteds.push_back (t);
" @samp{property-ops}, @samp{context-name}, @samp{group-type}.")
{
LY_ASSERT_SMOB (Context_def, def, 1);
- Context_def *cd = Context_def::unsmob (def);
+ Context_def *cd = unsmob<Context_def> (def);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
SCM res = cd->lookup (sym);
LY_ASSERT_SMOB (Context_def, def, 1);
LY_ASSERT_SMOB (Context_mod, mod, 2);
- Context_def *cd = Context_def::unsmob (def)->clone ();
+ Context_def *cd = unsmob<Context_def> (def)->clone ();
- for (SCM s = Context_mod::unsmob (mod)->get_mods ();
+ for (SCM s = unsmob<Context_mod> (mod)->get_mods ();
scm_is_pair (s);
s = scm_cdr (s))
cd->add_context_mod (scm_car (s));
"Returns the list of context modifications stored in"
" @var{contextmod}.")
{
- Context_mod *tr = Context_mod::unsmob (contextmod);
+ Context_mod *tr = unsmob<Context_mod> (contextmod);
LY_ASSERT_SMOB (Context_mod, contextmod, 1);
return tr->get_mods ();
}
"Adds the given context @var{modification} to the list"
" @var{contextmods} of context modifications.")
{
- Context_mod *ctxmod = Context_mod::unsmob (contextmods);
+ Context_mod *ctxmod = unsmob<Context_mod> (contextmods);
LY_ASSERT_SMOB (Context_mod, contextmods, 1);
ctxmod->add_context_mod (modification);
return SCM_UNSPECIFIED;
LY_ASSERT_SMOB (Context, context, 1);
LY_ASSERT_SMOB (Context_mod, mod, 2);
- apply_property_operations (Context::unsmob (context),
- Context_mod::unsmob (mod)->get_mods ());
+ apply_property_operations (unsmob<Context> (context),
+ unsmob<Context_mod> (mod)->get_mods ());
scm_remember_upto_here_1 (context);
return SCM_UNSPECIFIED;
}
bool
typecheck_grob (SCM symbol, SCM value)
{
- if (Unpure_pure_container *upc = Unpure_pure_container::unsmob (value))
+ if (Unpure_pure_container *upc = unsmob<Unpure_pure_container> (value))
return typecheck_grob (symbol, upc->unpure_part ())
&& typecheck_grob (symbol, upc->pure_part ());
return ly_is_procedure (value)
- || Simple_closure::is_smob (value)
+ || unsmob<Simple_closure> (value)
|| type_check_assignment (symbol, value, ly_symbol2scm ("backend-type?"));
}
SCM res = SCM_UNDEFINED;
if (Context *c = context_->where_defined (symbol_, &res))
if (c != context_)
- return Grob_property_info (c, symbol_, Grob_properties::unsmob (res));
- props_ = Grob_properties::unsmob (res);
+ return Grob_property_info (c, symbol_, unsmob<Grob_properties> (res));
+ props_ = unsmob<Grob_properties> (res);
return *this;
}
return true;
SCM res = SCM_UNDEFINED;
if (context_->here_defined (symbol_, &res))
- props_ = Grob_properties::unsmob (res);
+ props_ = unsmob<Grob_properties> (res);
return props_;
}
|| !g->here_defined (symbol_, ¤t_context_val))
return false;
- Grob_properties *def = Grob_properties::unsmob (current_context_val);
+ Grob_properties *def = unsmob<Grob_properties> (current_context_val);
if (!def)
{
// any, they will be factored in when `updated' is being called.
SCM props = Grob_properties (def->alist_, def->alist_).smobbed_copy ();
context_->set_property (symbol_, props);
- props_ = Grob_properties::unsmob (props);
+ props_ = unsmob<Grob_properties> (props);
return props_;
}
1, 0, 0, (SCM context),
"Return the current moment of @var{context}.")
{
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
LY_ASSERT_SMOB (Context, context, 1);
" i.e., for @code{\\context Voice = \"one\" @dots{}}"
" return the string @code{one}.")
{
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
LY_ASSERT_SMOB (Context, context, 1);
{
LY_ASSERT_SMOB (Context, context, 1);
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
return ly_symbol2scm (tr->context_name ().c_str ());
}
"Return the definition of @var{name} (a symbol) within"
" @var{context} as an alist.")
{
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
LY_ASSERT_SMOB (Context, context, 1);
LY_ASSERT_TYPE (ly_is_symbol, name, 2);
" with @var{eltprop} (if @var{val} is specified) or reverted"
" (if unspecified).")
{
- Context *tg = Context::unsmob (context);
+ Context *tg = unsmob<Context> (context);
LY_ASSERT_SMOB (Context, context, 1);
LY_ASSERT_TYPE (ly_is_symbol, grob, 2);
LY_ASSERT_SMOB (Context, context, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
- Context *t = Context::unsmob (context);
+ Context *t = unsmob<Context> (context);
SCM result = t->get_property (sym);
return !SCM_UNBNDP (def) && scm_is_null (result) ? def : result;
}
LY_ASSERT_SMOB (Context, context, 1);
LY_ASSERT_TYPE (ly_is_symbol, name, 2);
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
tr->set_property (name, val);
LY_ASSERT_SMOB (Context, context, 1);
LY_ASSERT_TYPE (ly_is_symbol, name, 2);
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
SCM val;
tr = tr->where_defined (name, &val);
{
LY_ASSERT_SMOB (Context, context, 1);
LY_ASSERT_TYPE (ly_is_symbol, name, 2);
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
tr->unset_property (name);
return SCM_UNSPECIFIED;
"Return the parent of @var{context}, @code{#f} if none.")
{
LY_ASSERT_SMOB (Context, context, 1);
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
tr = tr->get_parent_context ();
if (tr)
{
LY_ASSERT_SMOB (Context, context, 1);
LY_ASSERT_TYPE (ly_is_symbol, name, 2);
- Context *tr = Context::unsmob (context);
+ Context *tr = unsmob<Context> (context);
while (tr)
{
"Return @code{now-moment} of context @var{context}.")
{
LY_ASSERT_SMOB (Context, context, 1);
- Context *ctx = Context::unsmob (context);
+ Context *ctx = unsmob<Context> (context);
return ctx->now_mom ().smobbed_copy ();
}
"Return @code{event-source} of context @var{context}.")
{
LY_ASSERT_SMOB (Context, context, 1);
- Context *ctx = Context::unsmob (context);
+ Context *ctx = unsmob<Context> (context);
return ctx->event_source ()->self_scm ();
}
" from @var{context} and all its subcontexts.")
{
LY_ASSERT_SMOB (Context, context, 1);
- Context *ctx = Context::unsmob (context);
+ Context *ctx = unsmob<Context> (context);
return ctx->events_below ()->self_scm ();
}
{
for (SCM p = context_list_; scm_is_pair (p); p = scm_cdr (p))
{
- Context *ctx = Context::unsmob (scm_car (p));
+ Context *ctx = unsmob<Context> (scm_car (p));
ctx->check_removal ();
if (ctx->is_removable ())
Scheme_hash_table *
Context::properties_dict () const
{
- return Scheme_hash_table::unsmob (properties_scm_);
+ return unsmob<Scheme_hash_table> (properties_scm_);
}
void
SCM score_name = default_child_context_name ();
SCM score_def = find_context_def (get_output_def (), score_name);
- if (Context_def *cd = Context_def::unsmob (score_def))
+ if (Context_def *cd = unsmob<Context_def> (score_def))
{
if (cd->is_alias (n))
return create_context (cd, id, operations);
void
Context::acknowledge_infant (SCM sev)
{
- infant_event_ = Stream_event::unsmob (sev);
+ infant_event_ = unsmob<Stream_event> (sev);
}
void
Context::set_property_from_event (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
SCM sym = ev->get_property ("symbol");
if (scm_is_symbol (sym))
void
Context::unset_property_from_event (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
SCM sym = ev->get_property ("symbol");
type_check_assignment (sym, SCM_EOL, ly_symbol2scm ("translation-type?"));
void
Context::create_context_from_event (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
string id = ly_scm2string (ev->get_property ("id"));
SCM ops = ev->get_property ("ops");
new_context->unprotect ();
- Context_def *td = Context_def::unsmob (new_context->definition_);
+ Context_def *td = unsmob<Context_def> (new_context->definition_);
/* This cannot move before add_context (), because \override
operations require that we are in the hierarchy. */
accepts = scm_cons (elt, accepts);
}
- return Context_def::unsmob (definition_)->path_to_acceptable_context (name,
+ return unsmob<Context_def> (definition_)->path_to_acceptable_context (name,
get_output_def (),
scm_reverse_x (accepts, SCM_EOL));
assert (infant_event_);
SCM infant_scm = infant_event_->get_property ("context");
- Context *infant = Context::unsmob (infant_scm);
+ Context *infant = unsmob<Context> (infant_scm);
if (!infant || infant->get_parent_context () != this)
{
SCM st = find_context_def (get_output_def (), nm);
string name = ly_symbol2string (nm);
- Context_def *t = Context_def::unsmob (st);
+ Context_def *t = unsmob<Context_def> (st);
if (!t)
{
warning (_f ("cannot find or create: `%s'", name.c_str ()));
- t = Context_def::unsmob (this->definition_);
+ t = unsmob<Context_def> (this->definition_);
}
if (scm_is_symbol (t->get_default_child (SCM_EOL)))
{
void
Context::change_parent (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
- Context *to = Context::unsmob (ev->get_property ("context"));
+ Stream_event *ev = unsmob<Stream_event> (sev);
+ Context *to = unsmob<Context> (ev->get_property ("context"));
disconnect_from_parent ();
to->add_context (this);
for (SCM s = where->children_contexts ();
!found && scm_is_pair (s); s = scm_cdr (s))
{
- Context *tr = Context::unsmob (scm_car (s));
+ Context *tr = unsmob<Context> (scm_car (s));
found = find_context_below (tr, type, id);
}
SCM
Context::context_name_symbol () const
{
- Context_def *td = Context_def::unsmob (definition_);
+ Context_def *td = unsmob<Context_def> (definition_);
return td->get_context_name ();
}
{
scm_puts ("#<", port);
scm_puts (class_name (), port);
- if (Context_def *d = Context_def::unsmob (definition_))
+ if (Context_def *d = unsmob<Context_def> (definition_))
{
scm_puts (" ", port);
scm_display (d->get_context_name (), port);
{
SCM l = context->get_property ("measureLength");
Rational length (1);
- if (Moment::is_smob (l))
- length = Moment::unsmob (l)->main_part_;
+ if (unsmob<Moment> (l))
+ length = unsmob<Moment> (l)->main_part_;
return length;
}
SCM sm = context->get_property ("measurePosition");
Moment m = 0;
- if (Moment::is_smob (sm))
+ if (unsmob<Moment> (sm))
{
- m = *Moment::unsmob (sm);
+ m = *unsmob<Moment> (sm);
if (m.main_part_ < Rational (0))
{
trans->set_property (sym, ly_deep_copy (val));
for (SCM p = trans->children_contexts (); scm_is_pair (p); p = scm_cdr (p))
{
- Context *trg = Context::unsmob (scm_car (p));
+ Context *trg = unsmob<Context> (scm_car (p));
set_context_property_on_children (trg, sym, ly_deep_copy (val));
}
}
// to true.
do {
- if (!melisma_busy (Context::unsmob (scm_car (ch))))
+ if (!melisma_busy (unsmob<Context> (scm_car (ch))))
return false;
ch = scm_cdr (ch);
} while (scm_is_pair (ch));
don't look at the staff-position, since we can't be sure
whether Clef_engraver already applied a vertical shift.
*/
- pitches_.push_back (*Pitch::unsmob (ev->get_property ("pitch")));
+ pitches_.push_back (*unsmob<Pitch> (ev->get_property ("pitch")));
}
}
SCM
Custos::print (SCM smob)
{
- Item *me = (Item *)Grob::unsmob (smob);
+ Item *me = (Item *)unsmob<Grob> (smob);
SCM scm_style = me->get_property ("style");
string style;
2, 0, 0, (SCM to, SCM from),
"Make the dispatcher @var{to} listen to events from @var{from}.")
{
- Dispatcher *t = Dispatcher::unsmob (to);
- Dispatcher *f = Dispatcher::unsmob (from);
+ Dispatcher *t = unsmob<Dispatcher> (to);
+ Dispatcher *f = unsmob<Dispatcher> (from);
LY_ASSERT_SMOB (Dispatcher, to, 1);
LY_ASSERT_SMOB (Dispatcher, from, 2);
" to the dispatcher @var{disp}. Whenever @var{disp} hears"
" an event of class @var{cl}, it calls @var{callback} with it.")
{
- Dispatcher *d = Dispatcher::unsmob (disp);
+ Dispatcher *d = unsmob<Dispatcher> (disp);
LY_ASSERT_TYPE (ly_is_procedure, callback, 1);
LY_ASSERT_SMOB (Dispatcher, disp, 2);
{
LY_ASSERT_SMOB (Dispatcher, disp, 1);
- SCM result = Dispatcher::unsmob (disp)->listened_types ();
+ SCM result = unsmob<Dispatcher> (disp)->listened_types ();
scm_remember_upto_here_1 (disp);
LY_ASSERT_SMOB (Dispatcher, disp, 1);
LY_ASSERT_TYPE (scm_is_pair, cl, 2);
- bool result = Dispatcher::unsmob (disp)->is_listened_class (cl);
+ bool result = unsmob<Dispatcher> (disp)->is_listened_class (cl);
scm_remember_upto_here_1 (disp);
2, 0, 0, (SCM disp, SCM ev),
"Send the stream event @var{ev} to the dispatcher @var{disp}.")
{
- Dispatcher *d = Dispatcher::unsmob (disp);
- Stream_event *e = Stream_event::unsmob (ev);
+ Dispatcher *d = unsmob<Dispatcher> (disp);
+ Stream_event *e = unsmob<Stream_event> (ev);
LY_ASSERT_SMOB (Dispatcher, disp, 1);
void
Dispatcher::dispatch (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
SCM class_list = ev->get_property ("class");
if (!scm_is_pair (class_list))
{
for (SCM disp = dispatchers_; scm_is_pair (disp); disp = scm_cdr (disp))
{
int priority = scm_to_int (scm_cdar (disp));
- Dispatcher *d = Dispatcher::unsmob (scm_caar (disp));
+ Dispatcher *d = unsmob<Dispatcher> (scm_caar (disp));
d->internal_add_listener (GET_LISTENER (Dispatcher, dispatch).smobbed_copy (),
ev_class, priority);
}
SCM dummy = scm_cons (SCM_EOL, list);
SCM e = dummy;
while (scm_is_pair (scm_cdr (e)))
- if (*Listener::unsmob (scm_cdadr (e)) == l && first)
+ if (*unsmob<Listener> (scm_cdadr (e)) == l && first)
{
scm_set_cdr_x (e, scm_cddr (e));
first = false;
/* Unregister with all dispatchers. */
for (SCM disp = dispatchers_; scm_is_pair (disp); disp = scm_cdr (disp))
{
- Dispatcher *d = Dispatcher::unsmob (scm_caar (disp));
+ Dispatcher *d = unsmob<Dispatcher> (scm_caar (disp));
d->remove_listener (GET_LISTENER (Dispatcher, dispatch), ev_class);
}
listen_classes_ = scm_delq_x (ev_class, listen_classes_);
void
Dot_column_engraver::acknowledge_rhythmic_head (Grob_info info)
{
- Grob *d = Grob::unsmob (info.grob ()->get_object ("dot"));
+ Grob *d = unsmob<Grob> (info.grob ()->get_object ("dot"));
if (d)
{
if (!dotcol_)
SCM
Dot_column::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
/*
Trigger note collision resolution first, since that may kill off
dots when merging.
*/
- if (Grob *collision = Grob::unsmob (me->get_object ("note-collision")))
+ if (Grob *collision = unsmob<Grob> (me->get_object ("note-collision")))
(void) collision->get_property ("positioning-done");
me->set_property ("positioning-done", SCM_BOOL_T);
Grob *n = dots[i]->get_parent (Y_AXIS);
commonx = n->common_refpoint (commonx, X_AXIS);
- if (Grob *stem = Grob::unsmob (n->get_object ("stem")))
+ if (Grob *stem = unsmob<Grob> (n->get_object ("stem")))
{
commonx = stem->common_refpoint (commonx, X_AXIS);
Box b (s->extent (commonx, X_AXIS), y);
boxes.push_back (b);
- if (Grob *stem = Grob::unsmob (s->get_object ("stem")))
+ if (Grob *stem = unsmob<Grob> (s->get_object ("stem")))
stems.insert (stem);
}
// Sort dots by stem, then check for dots above the limit for each stem
vector <vector <Grob *> > dots_each_stem (parent_stems.size ());
for (vsize i = 0; i < dots.size (); i++)
- if (Grob *stem = Grob::unsmob (dots[i]->get_parent (Y_AXIS)
+ if (Grob *stem = unsmob<Grob> (dots[i]->get_parent (Y_AXIS)
-> get_object ("stem")))
for (vsize j = 0; j < parent_stems.size (); j++)
if (stem == parent_stems[j])
void
Dot_column::add_head (Grob *me, Grob *head)
{
- Grob *d = Grob::unsmob (head->get_object ("dot"));
+ Grob *d = unsmob<Grob> (head->get_object ("dot"));
if (d)
{
Side_position_interface::add_support (me, head);
return;
Grob *note = gi.grob ();
- if (Grob::is_smob (note->get_object ("dot")))
+ if (unsmob<Grob> (note->get_object ("dot")))
return;
- Duration *dur = Duration::unsmob (cause->get_property ("duration"));
+ Duration *dur = unsmob<Duration> (cause->get_property ("duration"));
if (dur && dur->dot_count ())
{
Item *d = make_item ("Dots", note->self_scm ());
SCM
Dots::print (SCM d)
{
- Grob *sc = Grob::unsmob (d);
+ Grob *sc = unsmob<Grob> (d);
Stencil mol;
SCM c = sc->get_property ("dot-count");
&& to_boolean (scm_hash_table_p (tab)))
defn = scm_hashq_ref (tab, sym, SCM_EOL);
- if (Pitch *pit = Pitch::unsmob (defn))
+ if (Pitch *pit = unsmob<Pitch> (defn))
{
SCM articulations = n->get_property ("articulations");
Stream_event *tie_event = 0;
int velocity = 0;
for (SCM s = articulations; scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *ev = Stream_event::unsmob (scm_car (s));
+ Stream_event *ev = unsmob<Stream_event> (scm_car (s));
if (!ev)
continue;
SCM
Duration::less_p (SCM p1, SCM p2)
{
- Duration *a = Duration::unsmob (p1);
- Duration *b = Duration::unsmob (p2);
+ Duration *a = unsmob<Duration> (p1);
+ Duration *b = unsmob<Duration> (p2);
if (compare (*a, *b) < 0)
return SCM_BOOL_T;
LY_ASSERT_SMOB (Duration, p1, 1);
LY_ASSERT_SMOB (Duration, p2, 2);
- Duration *a = Duration::unsmob (p1);
- Duration *b = Duration::unsmob (p2);
+ Duration *a = unsmob<Duration> (p1);
+ Duration *b = unsmob<Duration> (p2);
if (Duration::compare (*a, *b) < 0)
return SCM_BOOL_T;
"Extract the duration log from @var{dur}.")
{
LY_ASSERT_SMOB (Duration, dur, 1);
- return scm_from_int (Duration::unsmob (dur)->duration_log ());
+ return scm_from_int (unsmob<Duration> (dur)->duration_log ());
}
LY_DEFINE (ly_duration_dot_count, "ly:duration-dot-count",
"Extract the dot count from @var{dur}.")
{
LY_ASSERT_SMOB (Duration, dur, 1);
- return scm_from_int (Duration::unsmob (dur)->dot_count ());
+ return scm_from_int (unsmob<Duration> (dur)->dot_count ());
}
LY_DEFINE (ly_intlog2, "ly:intlog2",
"The length of the duration as a @code{moment}.")
{
LY_ASSERT_SMOB (Duration, dur, 1);
- return Moment (Duration::unsmob (dur)->get_length ()).smobbed_copy ();
+ return Moment (unsmob<Duration> (dur)->get_length ()).smobbed_copy ();
}
LY_DEFINE (ly_duration_2_string, "ly:duration->string",
"Convert @var{dur} to a string.")
{
LY_ASSERT_SMOB (Duration, dur, 1);
- return ly_string2scm (Duration::unsmob (dur)->to_string ());
+ return ly_string2scm (unsmob<Duration> (dur)->to_string ());
}
LY_DEFINE (ly_duration_factor, "ly:duration-factor",
" Return it as a pair.")
{
LY_ASSERT_SMOB (Duration, dur, 1);
- Rational r = Duration::unsmob (dur)->factor ();
+ Rational r = unsmob<Duration> (dur)->factor ();
return scm_cons (scm_from_int64 (r.num ()), scm_from_int64 (r.den ()));
}
" Return it as a rational.")
{
LY_ASSERT_SMOB (Duration, dur, 1);
- Rational r = Duration::unsmob (dur)->factor ();
+ Rational r = unsmob<Duration> (dur)->factor ();
return ly_rational2scm (r);
}
bound = spanners[0]->get_bound (d);
else
{
- bound = Grob::unsmob (get_property ("currentMusicalColumn"));
+ bound = unsmob<Grob> (get_property ("currentMusicalColumn"));
programming_error ("started DynamicLineSpanner but have no left bound");
}
if (finished_spanner_ && !finished_spanner_->get_bound (RIGHT))
finished_spanner_
->set_bound (RIGHT,
- Grob::unsmob (get_property ("currentMusicalColumn")));
+ unsmob<Grob> (get_property ("currentMusicalColumn")));
if (current_spanner_ && !current_spanner_->get_bound (LEFT))
current_spanner_
->set_bound (LEFT,
- Grob::unsmob (get_property ("currentMusicalColumn")));
+ unsmob<Grob> (get_property ("currentMusicalColumn")));
script_ = 0;
script_event_ = 0;
accepted_spanevents_drul_.set (0, 0);
*/
Grob *x_parent = (heads.size ()
? info.grob ()
- : Grob::unsmob (info.grob ()->get_object ("rest")));
+ : unsmob<Grob> (info.grob ()->get_object ("rest")));
if (x_parent)
script_->set_parent (x_parent, X_AXIS);
}
/*
UGH. cut & paste code.
*/
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
extract_grob_set (me, "elements", elements);
if (elements.empty ())
{
SCM
Enclosing_bracket::print (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
extract_grob_set (me, "elements", elements);
if (elements.empty ())
{
void
Engraver_group::override (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
Grob_property_info (context (), ev->get_property ("symbol"))
.push (ev->get_property ("property-path"),
void
Engraver_group::revert (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
Grob_property_info (context (), ev->get_property ("symbol"))
.pop (ev->get_property ("property-path"));
}
Engraver_dispatch_list *dispatch
- = Engraver_dispatch_list::unsmob (acklist);
+ = unsmob<Engraver_dispatch_list> (acklist);
if (dispatch)
dispatch->apply (info);
for (SCM s = context_->children_contexts ();
scm_is_pair (s); s = scm_cdr (s))
{
- Context *c = Context::unsmob (scm_car (s));
+ Context *c = unsmob<Context> (scm_car (s));
Engraver_group *group
= dynamic_cast<Engraver_group *> (c->implementation ());
for (SCM s = context ()->children_contexts ();
scm_is_pair (s); s = scm_cdr (s))
{
- Context *c = Context::unsmob (scm_car (s));
+ Context *c = unsmob<Context> (scm_car (s));
Engraver_group *group
= dynamic_cast<Engraver_group *> (c->implementation ());
if (group)
LY_ASSERT_TYPE (ly_is_symbol, grob_name, 2);
LY_ASSERT_TYPE (ly_is_grob_cause, cause, 3);
- Grob *g = Engraver::unsmob (engraver)->
+ Grob *g = unsmob<Engraver> (engraver)->
internal_make_grob (grob_name, cause,
ly_symbol2string (grob_name).c_str (),
"scheme", 0, "scheme");
LY_ASSERT_SMOB (Grob, grob, 2);
LY_ASSERT_TYPE (ly_is_grob_cause, cause, 3);
- Engraver::unsmob (engraver)->
- announce_end_grob (Grob::unsmob (grob), cause);
+ unsmob<Engraver> (engraver)->
+ announce_end_grob (unsmob<Grob> (grob), cause);
return SCM_UNSPECIFIED;
}
Engraver::make_grob_info (Grob *e, SCM cause)
{
/* TODO: Remove Music code when it's no longer needed */
- if (Music *m = Music::unsmob (cause))
+ if (Music *m = unsmob<Music> (cause))
{
cause = m->to_event ()->unprotect ();
}
if (scm_is_null (e->get_property ("cause"))
- && (Stream_event::is_smob (cause) || Grob::is_smob (cause)))
+ && (unsmob<Stream_event> (cause) || unsmob<Grob> (cause)))
e->set_property ("cause", cause);
return Grob_info (this, e);
bool
ly_is_grob_cause (SCM obj)
{
- return Grob::is_smob (obj) || Stream_event::is_smob (obj) || scm_is_null (obj);
+ return unsmob<Grob> (obj) || unsmob<Stream_event> (obj) || scm_is_null (obj);
}
#include "translator.icc"
{
Grob *col = (note_columns_.size ()
? note_columns_.back ()
- : Grob::unsmob (get_property ("currentMusicalColumn")));
+ : unsmob<Grob> (get_property ("currentMusicalColumn")));
finished_->set_bound (RIGHT, col);
}
finished_ = 0;
{
Grob *col = (note_columns_.size ()
? note_columns_.front ()
- : Grob::unsmob (get_property ("currentMusicalColumn")));
+ : unsmob<Grob> (get_property ("currentMusicalColumn")));
span_->set_bound (LEFT, col);
}
for (SCM s = get_music ()->get_property ("elements");
scm_is_pair (s); s = scm_cdr (s))
{
- Music *mus = Music::unsmob (scm_car (s));
+ Music *mus = unsmob<Music> (scm_car (s));
report_event (mus);
}
for (SCM s = get_music ()->get_property ("articulations");
scm_is_pair (s); s = scm_cdr (s))
{
- Music *mus = Music::unsmob (scm_car (s));
+ Music *mus = unsmob<Music> (scm_car (s));
report_event (mus);
}
}
SCM
Figured_bass_continuation::center_on_figures (SCM grob)
{
- Spanner *me = Spanner::unsmob (grob);
+ Spanner *me = unsmob<Spanner> (grob);
extract_grob_set (me, "figures", figures);
if (figures.empty ())
return scm_from_double (0.0);
SCM
Figured_bass_continuation::print (SCM grob)
{
- Spanner *me = Spanner::unsmob (grob);
+ Spanner *me = unsmob<Spanner> (grob);
Real thick
= me->layout ()->get_dimension (ly_symbol2scm ("line-thickness"))
left_figs.push_back (consecutive_lines[j]->get_bound (LEFT));
SCM ga = Grob_array::make_array ();
- Grob_array::unsmob (ga)->set_array (left_figs);
+ unsmob<Grob_array> (ga)->set_array (left_figs);
for (vsize j = consecutive_lines.size (); j--;)
consecutive_lines[j]->set_object ("figures",
- Grob_array::unsmob (ga)->smobbed_copy ());
+ unsmob<Grob_array> (ga)->smobbed_copy ());
}
void
Figured_bass_engraver::create_grobs ()
{
Grob *muscol
- = Item::unsmob (get_property ("currentMusicalColumn"));
+ = unsmob<Item> (get_property ("currentMusicalColumn"));
if (!alignment_)
{
alignment_ = make_spanner ("BassFigureAlignment", SCM_EOL);
SCM
Fingering_column::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
if (!me->is_live ())
return SCM_BOOL_T;
junkme.
*/
SCM pitch = r->get_property ("pitch");
- if (Pitch::is_smob (pitch))
+ if (unsmob<Pitch> (pitch))
fingering->set_property ("pitch", pitch);
/*
SCM
Flag::width (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- Stencil *sten = Stencil::unsmob (me->get_property ("stencil"));
+ Grob *me = unsmob<Grob> (smob);
+ Stencil *sten = unsmob<Stencil> (me->get_property ("stencil"));
if (!sten)
return ly_interval2scm (Interval (0.0, 0.0));
SCM
Flag::glyph_name (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *stem = me->get_parent (X_AXIS);
Direction d = get_grob_direction (stem);
SCM
Flag::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *stem = me->get_parent (X_AXIS);
Direction d = get_grob_direction (stem);
SCM
Flag::internal_calc_y_offset (SCM smob, bool pure)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *stem = me->get_parent (X_AXIS);
Direction d = get_grob_direction (stem);
SCM
Flag::calc_x_offset (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *stem = me->get_parent (X_AXIS);
return scm_from_double (stem->extent (stem, X_AXIS)[RIGHT]);
}
Font_metric *
Font_interface::get_default_font (Grob *me)
{
- Font_metric *fm = Font_metric::unsmob (me->get_property ("font"));
+ Font_metric *fm = unsmob<Font_metric> (me->get_property ("font"));
if (!fm)
{
SCM chain = music_font_alist_chain (me);
" to the font encodings @code{fetaMusic} and @code{fetaBraces},"
" respectively.")
{
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
LY_ASSERT_SMOB (Font_metric, font, 1);
LY_ASSERT_TYPE (scm_is_string, name, 2);
" to the font encodings @code{fetaMusic} and @code{fetaBraces},"
" respectively.")
{
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
LY_ASSERT_SMOB (Font_metric, font, 1);
LY_ASSERT_TYPE (scm_is_string, name, 2);
" to the font encodings @code{fetaMusic} and @code{fetaBraces},"
" respectively.")
{
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
LY_ASSERT_SMOB (Font_metric, font, 1);
LY_ASSERT_TYPE (scm_is_integer, index, 2);
" to the font encodings @code{fetaMusic} and @code{fetaBraces},"
" respectively.")
{
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
LY_ASSERT_SMOB (Font_metric, font, 1);
LY_ASSERT_TYPE (scm_is_string, name, 2);
{
LY_ASSERT_SMOB (Font_metric, font, 1);
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
SCM name = fm->font_file_name ();
return name;
" return the corresponding name.")
{
LY_ASSERT_SMOB (Font_metric, font, 1);
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
return ly_string2scm (fm->font_name ());
}
{
LY_ASSERT_SMOB (Font_metric, font, 1);
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
return scm_cdr (fm->description_);
}
{
LY_ASSERT_SMOB (Font_metric, font, 1);
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
return scm_from_double (fm->design_size ());
}
if (to_boolean (scm_promise_p (entry)))
{
- Font_metric *fm = Font_metric::unsmob (scm_force (entry));
+ Font_metric *fm = unsmob<Font_metric> (scm_force (entry));
size = fm->design_size ();
}
#if HAVE_PANGO_FT2
#endif
}
else
- fm = Font_metric::unsmob (scm_force (scm_c_vector_ref (font_vector, i)));
+ fm = unsmob<Font_metric> (scm_force (scm_c_vector_ref (font_vector, i)));
return find_scaled_font (layout, fm, requested / size);
}
Spanner *b = make_spanner ("FootnoteSpanner", cause);
b->set_parent (s, Y_AXIS);
b->set_parent (s, X_AXIS);
- Grob *bound = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *bound = unsmob<Grob> (get_property ("currentMusicalColumn"));
b->set_bound (LEFT, bound);
annotated_spanners_.push_back (Drul_array<Spanner *> (s, b));
}
void
Footnote_engraver::acknowledge_grob (Grob_info info)
{
- Music *mus = Music::unsmob (info.grob ()->get_property ("footnote-music"));
+ Music *mus = unsmob<Music> (info.grob ()->get_property ("footnote-music"));
if (mus)
{
{
if (annotated_spanners_[i][LEFT] == s)
{
- Grob *bound = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *bound = unsmob<Grob> (get_property ("currentMusicalColumn"));
annotated_spanners_[i][RIGHT]->set_bound (RIGHT, bound);
break;
}
SCM busy = get_property ("busyGrobs");
Moment now = now_mom ();
- while (scm_is_pair (busy) && Moment::unsmob (scm_caar (busy))->main_part_ == now.main_part_)
+ while (scm_is_pair (busy) && unsmob<Moment> (scm_caar (busy))->main_part_ == now.main_part_)
busy = scm_cdr (busy);
while (scm_is_pair (busy))
{
- Grob *g = Grob::unsmob (scm_cdar (busy));
+ Grob *g = unsmob<Grob> (scm_cdar (busy));
if (g->internal_has_interface (ly_symbol2scm ("rhythmic-grob-interface")))
context ()->get_score_context ()->set_property ("forbidBreak", SCM_BOOL_T);
busy = scm_cdr (busy);
ly_add_type_predicate ((void *) &is_direction, "direction");
ly_add_type_predicate ((void *) &ly_is_port, "port");
ly_add_type_predicate ((void *) &ly_cheap_is_list, "list");
- ly_add_type_predicate ((void *) &Global_context::is_smob, "Global_context");
- ly_add_type_predicate ((void *) &Paper_score::is_smob, "Paper_score");
- ly_add_type_predicate ((void *) &Performance::is_smob, "Performance");
+ ly_add_type_predicate ((void *) &unsmob<Global_context>, "Global_context");
+ ly_add_type_predicate ((void *) &unsmob<Paper_score>, "Paper_score");
+ ly_add_type_predicate ((void *) &unsmob<Performance>, "Performance");
ly_add_type_predicate ((void *) &is_axis, "axis");
ly_add_type_predicate ((void *) &is_number_pair, "number pair");
ly_add_type_predicate ((void *) &ly_is_list, "list");
ly_add_type_predicate ((void *) &scm_is_rational, "rational");
ly_add_type_predicate ((void *) &scm_is_string, "string");
ly_add_type_predicate ((void *) &scm_is_vector, "vector");
- ly_add_type_predicate ((void *) &Item::is_smob, "Item");
- ly_add_type_predicate ((void *) &Music::is_smob, "Music");
- ly_add_type_predicate ((void *) &Spanner::is_smob, "Spanner");
- ly_add_type_predicate ((void *) &Stream_event::is_smob, "Stream_event");
+ ly_add_type_predicate ((void *) &unsmob<Item>, "Item");
+ ly_add_type_predicate ((void *) &unsmob<Music>, "Music");
+ ly_add_type_predicate ((void *) &unsmob<Spanner>, "Spanner");
+ ly_add_type_predicate ((void *) &unsmob<Stream_event>, "Stream_event");
}
ADD_SCM_INIT_FUNC (func_doc, init_func_doc);
" process it and return the @code{Music_output} object"
" in its final state.")
{
- Global_context *g = Global_context::unsmob (context);
+ Global_context *g = unsmob<Global_context> (context);
LY_ASSERT_SMOB (Global_context, context, 1);
SCM output = g->get_output ();
progress_indication ("\n");
- if (Music_output *od = Music_output::unsmob (output))
+ if (Music_output *od = unsmob<Music_output> (output))
od->process ();
return output;
"Create a translator group and connect it to the global context"
" @var{global}. The translator group is returned.")
{
- Global_context *g = Global_context::unsmob (global);
+ Global_context *g = unsmob<Global_context> (global);
LY_ASSERT_SMOB (Global_context, global, 1);
Translator_group *tg = new Translator_group ();
" block @var{output-def}. The context is returned.")
{
LY_ASSERT_SMOB (Output_def, output_def, 1);
- Output_def *odef = Output_def::unsmob (output_def);
+ Output_def *odef = unsmob<Output_def> (output_def);
Global_context *glob = new Global_context (odef);
LY_ASSERT_SMOB (Music, mus, 1);
LY_ASSERT_SMOB (Global_context, ctx, 2);
- Music *music = Music::unsmob (mus);
+ Music *music = unsmob<Music> (mus);
if (!music)
{
warning (_ ("no music found in score"));
return SCM_BOOL_F;
}
- Global_context *g = Global_context::unsmob (ctx);
+ Global_context *g = unsmob<Global_context> (ctx);
Cpu_timer timer;
message (_ ("Interpreting music..."));
SCM protected_iter = Music_iterator::get_static_get_iterator (music);
- Music_iterator *iter = Music_iterator::unsmob (protected_iter);
+ Music_iterator *iter = unsmob<Music_iterator> (protected_iter);
iter->init_context (music, g);
iter->construct_children ();
ly_symbol2scm ("Prepare"));
events_below ()->register_as_listener (event_source_);
- Context_def *globaldef = Context_def::unsmob (definition_);
+ Context_def *globaldef = unsmob<Context_def> (definition_);
if (!globaldef)
programming_error ("no `Global' context found");
else
void
Global_context::prepare (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
- Moment *mom = Moment::unsmob (ev->get_property ("moment"));
+ Stream_event *ev = unsmob<Stream_event> (sev);
+ Moment *mom = unsmob<Moment> (ev->get_property ("moment"));
assert (mom);
Global_context::get_score_context () const
{
return (scm_is_pair (context_list_))
- ? Context::unsmob (scm_car (context_list_))
+ ? unsmob<Context> (scm_car (context_list_))
: 0;
}
SCM grob = scm_cadr (elt);
SCM cell = scm_cddr (elt);
- Grob_property_info (Context::unsmob (context), grob).matched_pop (cell);
+ Grob_property_info (unsmob<Context> (context), grob).matched_pop (cell);
}
grace_settings_ = SCM_EOL;
}
SCM
Grace_music::start_callback (SCM m)
{
- Moment *l = Moment::unsmob (Music_wrapper::length_callback (m));
+ Moment *l = unsmob<Moment> (Music_wrapper::length_callback (m));
Moment gl;
gl.grace_part_ = -(l->main_part_ + l->grace_part_);
return gl.smobbed_copy ();
if (grace_spacing_ && (now.grace_part_ || last_moment_.grace_part_))
{
- Grob *column = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *column = unsmob<Grob> (get_property ("currentMusicalColumn"));
Pointer_group_interface::add_grob (grace_spacing_,
ly_symbol2scm ("columns"),
column);
Grob *primitive = primitives[i].grob ();
Stream_event *event_cause = primitives[i].event_cause ();
int context_info = 0;
- int pitch = Pitch::unsmob (event_cause->get_property ("pitch"))->steps ();
+ int pitch = unsmob<Pitch> (event_cause->get_property ("pitch"))->steps ();
int prefix_set = scm_to_int (primitive->get_property ("prefix-set"));
if (prefix_set & PES_OR_FLEXA)
SCM
Grid_line_interface::print (SCM smobbed_me)
{
- Grob *me = Grob::unsmob (smobbed_me);
+ Grob *me = unsmob<Grob> (smobbed_me);
extract_grob_set (me, "elements", elts);
/* compute common refpoint of elements */
SCM
Grid_line_interface::width (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real staffline = me->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
Real thick = robust_scm2double (me->get_property ("thickness"), 1.0)
Grid_point_engraver::process_music ()
{
SCM grid_interval = get_property ("gridInterval");
- if (Moment *mom = Moment::unsmob (grid_interval))
+ if (Moment *mom = unsmob<Moment> (grid_interval))
{
Moment now = now_mom ();
{
LY_ASSERT_SMOB (Grob_array, grob_arr, 1);
- Grob_array *me = Grob_array::unsmob (grob_arr);
+ Grob_array *me = unsmob<Grob_array> (grob_arr);
return scm_from_int (me->size ());
}
(SCM grob_arr, SCM index),
"Retrieve the @var{index}th element of @var{grob-arr}.")
{
- Grob_array *me = Grob_array::unsmob (grob_arr);
+ Grob_array *me = unsmob<Grob_array> (grob_arr);
LY_ASSERT_SMOB (Grob_array, grob_arr, 1);
LY_ASSERT_TYPE (scm_is_integer, index, 2);
(SCM grob_arr),
"Return the elements of @var{grob-arr} as a Scheme list.")
{
- Grob_array *me = Grob_array::unsmob (grob_arr);
+ Grob_array *me = unsmob<Grob_array> (grob_arr);
LY_ASSERT_SMOB (Grob_array, grob_arr, 1);
return grob_array_to_list (me);
grob_list_to_grob_array (SCM lst)
{
SCM arr_scm = Grob_array::make_array ();
- Grob_array *ga = Grob_array::unsmob (arr_scm);
+ Grob_array *ga = unsmob<Grob_array> (arr_scm);
for (SCM s = lst; scm_is_pair (s); s = scm_cdr (s))
- ga->add (Grob::unsmob (scm_car (s)));
+ ga->add (unsmob<Grob> (scm_car (s)));
return arr_scm;
}
SCM data = g->get_property_data (axis_offset_symbol (a));
if (!scm_is_number (data)
&& !ly_is_procedure (data)
- && !Simple_closure::is_smob (data))
+ && !unsmob<Simple_closure> (data))
{
g->set_property (axis_offset_symbol (a), proc);
return;
}
- if (ly_is_procedure (data) || Unpure_pure_container::is_smob (data))
+ if (ly_is_procedure (data) || unsmob<Unpure_pure_container> (data))
data = Simple_closure::make_smob (scm_list_1 (data));
- else if (Simple_closure *sc = Simple_closure::unsmob (data))
+ else if (Simple_closure *sc = unsmob<Simple_closure> (data))
data = sc->expression ();
SCM plus = ly_lily_module_constant ("+");
{
SCM data = g->get_property_data (sym);
- if (ly_is_procedure (data) || Unpure_pure_container::is_smob (data))
+ if (ly_is_procedure (data) || unsmob<Unpure_pure_container> (data))
data = Simple_closure::make_smob (scm_list_1 (data));
- else if (Simple_closure *sc = Simple_closure::unsmob (data))
+ else if (Simple_closure *sc = unsmob<Simple_closure> (data))
data = sc->expression ();
else
/*
Grob_info::event_cause () const
{
SCM cause = grob_->get_property ("cause");
- return Stream_event::unsmob (cause);
+ return unsmob<Stream_event> (cause);
}
vector<Context *>
Grob_info::ultimate_event_cause () const
{
SCM cause = grob_->self_scm ();
- while (Grob::is_smob (cause))
+ while (unsmob<Grob> (cause))
{
- cause = Grob::unsmob (cause)->get_property ("cause");
+ cause = unsmob<Grob> (cause)->get_property ("cause");
}
- return Stream_event::unsmob (cause);
+ return unsmob<Stream_event> (cause);
}
bool
"Compare two grob priority queue entries."
" This is an internal function.")
{
- if (Moment::compare (*Moment::unsmob (scm_car (a)),
- *Moment::unsmob (scm_car (b))) < 0)
+ if (Moment::compare (*unsmob<Moment> (scm_car (a)),
+ *unsmob<Moment> (scm_car (b))) < 0)
return SCM_BOOL_T;
else
return SCM_BOOL_F;
Moment now = now_mom ();
SCM start_busy = get_property ("busyGrobs");
SCM busy = start_busy;
- while (scm_is_pair (busy) && *Moment::unsmob (scm_caar (busy)) == now)
+ while (scm_is_pair (busy) && *unsmob<Moment> (scm_caar (busy)) == now)
busy = scm_cdr (busy);
}
SCM start_busy = get_property ("busyGrobs");
SCM busy = start_busy;
- while (scm_is_pair (busy) && *Moment::unsmob (scm_caar (busy)) < now)
+ while (scm_is_pair (busy) && *unsmob<Moment> (scm_caar (busy)) < now)
{
/*
The grob-pq-engraver is not water tight, and stuff like
if (do_internal_type_checking_global)
{
if (!ly_is_procedure (v)
- && !Simple_closure::is_smob (v)
- && !Unpure_pure_container::is_smob (v)
+ && !unsmob<Simple_closure> (v)
+ && !unsmob<Unpure_pure_container> (v)
&& !scm_is_eq (v, ly_symbol2scm ("calculation-in-progress")))
type_check_assignment (sym, v, ly_symbol2scm ("backend-type?"));
if (do_internal_type_checking_global && scm_is_pair (handle))
{
SCM val = scm_cdr (handle);
- if (!ly_is_procedure (val) && !Simple_closure::is_smob (val)
- && !Unpure_pure_container::is_smob (val))
+ if (!ly_is_procedure (val) && !unsmob<Simple_closure> (val)
+ && !unsmob<Unpure_pure_container> (val))
type_check_assignment (sym, val, ly_symbol2scm ("backend-type?"));
check_interfaces_for_property (this, sym);
}
#endif
- if (Unpure_pure_container *upc = Unpure_pure_container::unsmob (val))
+ if (Unpure_pure_container *upc = unsmob<Unpure_pure_container> (val))
val = upc->unpure_part ();
if (ly_is_procedure (val)
- || Simple_closure::is_smob (val))
+ || unsmob<Simple_closure> (val))
{
Grob *me = ((Grob *)this);
val = me->try_callback_on_alist (&me->mutable_property_alist_, sym, val);
if (ly_is_procedure (val))
return call_pure_function (val, scm_list_1 (self_scm ()), start, end);
- if (Unpure_pure_container *upc = Unpure_pure_container::unsmob (val)) {
+ if (Unpure_pure_container *upc = unsmob<Unpure_pure_container> (val)) {
// Do cache, if the function ignores 'start' and 'end'
if (upc->is_unchanging ())
return internal_get_property (sym);
return call_pure_function (val, scm_list_1 (self_scm ()), start, end);
}
- if (Simple_closure *sc = Simple_closure::unsmob (val))
+ if (Simple_closure *sc = unsmob<Simple_closure> (val))
return evaluate_with_simple_closure (self_scm (),
sc->expression (),
true, start, end);
SCM value = SCM_EOL;
if (ly_is_procedure (proc))
value = scm_call_1 (proc, self_scm ());
- else if (Simple_closure *sc = Simple_closure::unsmob (proc))
+ else if (Simple_closure *sc = unsmob<Simple_closure> (proc))
{
value = evaluate_with_simple_closure (self_scm (),
sc->expression (),
{
SCM val = scm_cdr (s);
if (ly_is_procedure (val)
- || Simple_closure::is_smob (val)
- || Unpure_pure_container::is_smob (val))
+ || unsmob<Simple_closure> (val)
+ || unsmob<Unpure_pure_container> (val))
{
Grob *me = ((Grob *)this);
val = me->try_callback_on_alist (&me->object_alist_, sym, val);
SCM
call_pure_function (SCM unpure, SCM args, int start, int end)
{
- if (Unpure_pure_container *upc = Unpure_pure_container::unsmob (unpure))
+ if (Unpure_pure_container *upc = unsmob<Unpure_pure_container> (unpure))
{
SCM pure = upc->pure_part ();
- if (Simple_closure *sc = Simple_closure::unsmob (pure))
+ if (Simple_closure *sc = unsmob<Simple_closure> (pure))
{
SCM expr = sc->expression ();
return evaluate_with_simple_closure (scm_car (args), expr, true, start, end);
return pure;
}
- if (Simple_closure *sc = Simple_closure::unsmob (unpure))
+ if (Simple_closure *sc = unsmob<Simple_closure> (unpure))
{
SCM expr = sc->expression ();
return evaluate_with_simple_closure (scm_car (args), expr, true, start, end);
"Return the value for property @var{sym} of @var{grob},"
" but do not process callbacks.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
3, 0, 0, (SCM grob, SCM sym, SCM val),
"Set @var{sym} in grob @var{grob} to value @var{val}.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
if (!ly_is_procedure (val)
- && !Simple_closure::is_smob (val)
+ && !unsmob<Simple_closure> (val)
&& !type_check_assignment (sym, val, ly_symbol2scm ("backend-type?")))
error ("typecheck failed");
3, 0, 0, (SCM grob, SCM symlist, SCM val),
"Set nested property @var{symlist} in grob @var{grob} to value @var{val}.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
" If no value is found, return @var{val} or @code{'()}"
" if @var{val} is not specified.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
" If no value is found, return @var{val} or @code{'()}"
" if @var{val} is not specified.")
{
- Grob *sc = Grob::unsmob (grob);
- Grob *ref = Grob::unsmob (refp);
+ Grob *sc = unsmob<Grob> (grob);
+ Grob *ref = unsmob<Grob> (refp);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_SMOB (Grob, refp, 2);
" If no value is found, return @var{val} or @code{'()}"
" if @var{val} is not specified.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
1, 0, 0, (SCM grob),
"Return the interfaces list of grob @var{grob}.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
" @var{sym}. It returns @code{'()} (end-of-list) if @var{sym}"
" is undefined in @var{grob}.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
3, 0, 0, (SCM grob, SCM sym, SCM val),
"Set @var{sym} in grob @var{grob} to value @var{val}.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
1, 0, 0, (SCM grob),
"Get @code{\\layout} definition from grob @var{grob}.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
" the global default. If unspecified, @code{font-defaults}"
" from the layout block is taken.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
"Get the extent in @var{axis} direction of @var{grob} relative to"
" the grob @var{refp}.")
{
- Grob *sc = Grob::unsmob (grob);
- Grob *ref = Grob::unsmob (refp);
+ Grob *sc = unsmob<Grob> (grob);
+ Grob *ref = unsmob<Grob> (refp);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_SMOB (Grob, refp, 2);
"Get the extent in @var{axis} direction of @var{grob} relative to"
" the grob @var{refp}, or @code{(0,0)} if empty.")
{
- Grob *sc = Grob::unsmob (grob);
- Grob *ref = Grob::unsmob (refp);
+ Grob *sc = unsmob<Grob> (grob);
+ Grob *ref = unsmob<Grob> (refp);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_SMOB (Grob, refp, 2);
"Get the coordinate in @var{axis} direction of @var{grob} relative"
" to the grob @var{refp}.")
{
- Grob *sc = Grob::unsmob (grob);
- Grob *ref = Grob::unsmob (refp);
+ Grob *sc = unsmob<Grob> (grob);
+ Grob *ref = unsmob<Grob> (refp);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_SMOB (Grob, refp, 2);
"Get the parent of @var{grob}. @var{axis} is 0 for the X-axis,"
" 1@tie{}for the Y-axis.")
{
- Grob *sc = Grob::unsmob (grob);
+ Grob *sc = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (is_axis, axis, 2);
3, 0, 0, (SCM grob, SCM axis, SCM parent_grob),
"Set @var{parent-grob} the parent of grob @var{grob} in axis @var{axis}.")
{
- Grob *gr = Grob::unsmob (grob);
- Grob *parent = Grob::unsmob (parent_grob);
+ Grob *gr = unsmob<Grob> (grob);
+ Grob *parent = unsmob<Grob> (parent_grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (is_axis, axis, 2);
1, 0, 0, (SCM grob),
"Get the mutable properties of @var{grob}.")
{
- Grob *g = Grob::unsmob (grob);
+ Grob *g = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
1, 0, 0, (SCM grob),
"Get the immutable properties of @var{grob}.")
{
- Grob *g = Grob::unsmob (grob);
+ Grob *g = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
1, 0, 0, (SCM grob),
"Return the system grob of @var{grob}.")
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
1, 0, 0, (SCM grob),
"Return the unbroken original grob of @var{grob}.")
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
return me->original () ? me->original ()->self_scm () : me->self_scm ();
1, 0, 0, (SCM grob),
"Kill @var{grob}.")
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
"Translate @var{grob} on axis@tie{}@var{a} over"
" distance@tie{}@var{d}.")
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_TYPE (scm_is_number, d, 2);
1, 0, 0, (SCM grob),
"Return the default font for grob @var{grob}.")
{
- Grob *gr = Grob::unsmob (grob);
+ Grob *gr = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
" for @var{axis}.")
{
- Grob *gr = Grob::unsmob (grob);
+ Grob *gr = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_SMOB (Grob, other, 2);
- Grob *o = Grob::unsmob (other);
+ Grob *o = unsmob<Grob> (other);
LY_ASSERT_TYPE (is_axis, axis, 3);
"Find the common refpoint of @var{grob} and @var{others}"
" (a grob-array) for @var{axis}.")
{
- Grob *gr = Grob::unsmob (grob);
+ Grob *gr = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
LY_ASSERT_SMOB (Grob_array, others, 2);
- Grob_array *ga = Grob_array::unsmob (others);
+ Grob_array *ga = unsmob<Grob_array> (others);
LY_ASSERT_TYPE (is_axis, axis, 3);
Grob *refp = common_refpoint_of_array (ga->array (), gr, Axis (scm_to_int (axis)));
" to the head of this, meaning that it is called"
" using @var{grob} and the previous callback's result.")
{
- Grob *gr = Grob::unsmob (grob);
+ Grob *gr = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
- SCM_ASSERT_TYPE (ly_is_procedure (proc) || Unpure_pure_container::is_smob (proc), proc, SCM_ARG2, __FUNCTION__, "procedure or unpure pure container");
+ SCM_ASSERT_TYPE (ly_is_procedure (proc) || unsmob<Unpure_pure_container> (proc), proc, SCM_ARG2, __FUNCTION__, "procedure or unpure pure container");
LY_ASSERT_TYPE (ly_is_symbol, sym, 3);
chain_callback (gr, proc, sym);
LY_ASSERT_SMOB (Grob, a, 1);
LY_ASSERT_SMOB (Grob, b, 2);
- Grob *ga = Grob::unsmob (a);
- Grob *gb = Grob::unsmob (b);
+ Grob *ga = unsmob<Grob> (a);
+ Grob *gb = unsmob<Grob> (b);
return ly_bool2scm (Grob::vertical_less (ga, gb));
}
"Get the index of the vertical axis group the grob @var{grob} belongs to;"
" return @code{-1} if none is found.")
{
- Grob *gr = Grob::unsmob (grob);
+ Grob *gr = unsmob<Grob> (grob);
LY_ASSERT_SMOB (Grob, grob, 1);
return 0;
SCM stil = get_property ("stencil");
- return Stencil::unsmob (stil);
+ return unsmob<Stencil> (stil);
}
Stencil
SCM stil = get_property ("stencil");
Stencil retval;
- if (Stencil *m = Stencil::unsmob (stil))
+ if (Stencil *m = unsmob<Stencil> (stil))
{
retval = *m;
bool transparent = to_boolean (get_property ("transparent"));
/* Call the scheme procedure stencil-whiteout in scm/stencils.scm */
/* to add a round-filled-box stencil to the stencil list */
retval
- = *Stencil::unsmob (scm_call_1 (ly_lily_module_constant ("stencil-whiteout"),
+ = *unsmob<Stencil> (scm_call_1 (ly_lily_module_constant ("stencil-whiteout"),
retval.smobbed_copy ()));
}
Grob::programming_error (const string &s) const
{
SCM cause = self_scm ();
- while (Grob *g = Grob::unsmob (cause))
+ while (Grob *g = unsmob<Grob> (cause))
cause = g->get_property ("cause");
/* ES TODO: cause can't be Music*/
- if (Music *m = Music::unsmob (cause))
+ if (Music *m = unsmob<Music> (cause))
m->origin ()->programming_error (s);
- else if (Stream_event *ev = Stream_event::unsmob (cause))
+ else if (Stream_event *ev = unsmob<Stream_event> (cause))
ev->origin ()->programming_error (s);
else
::programming_error (s);
Grob::warning (const string &s) const
{
SCM cause = self_scm ();
- while (Grob *g = Grob::unsmob (cause))
+ while (Grob *g = unsmob<Grob> (cause))
cause = g->get_property ("cause");
/* ES TODO: cause can't be Music*/
- if (Music *m = Music::unsmob (cause))
+ if (Music *m = unsmob<Music> (cause))
m->origin ()->warning (s);
- else if (Stream_event *ev = Stream_event::unsmob (cause))
+ else if (Stream_event *ev = unsmob<Stream_event> (cause))
ev->origin ()->warning (s);
else
::warning (s);
SCM
Grob::stencil_height (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return grob_stencil_extent (me, Y_AXIS);
}
SCM
Grob::pure_stencil_height (SCM smob, SCM /* beg */, SCM /* end */)
{
- Grob *me = Grob::unsmob (smob);
- if (Stencil::is_smob (me->get_property_data ("stencil")))
+ Grob *me = unsmob<Grob> (smob);
+ if (unsmob<Stencil> (me->get_property_data ("stencil")))
return grob_stencil_extent (me, Y_AXIS);
return ly_interval2scm (Interval ());
SCM
Grob::y_parent_positioning (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *par = me->get_parent (Y_AXIS);
if (par)
(void) par->get_property ("positioning-done");
SCM
Grob::x_parent_positioning (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *par = me->get_parent (X_AXIS);
if (par)
SCM
Grob::stencil_width (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return grob_stencil_extent (me, X_AXIS);
}
common_refpoint_of_list (SCM elist, Grob *common, Axis a)
{
for (; scm_is_pair (elist); elist = scm_cdr (elist))
- if (Grob *s = Grob::unsmob (scm_car (elist)))
+ if (Grob *s = unsmob<Grob> (scm_car (elist)))
{
if (common)
common = common->common_refpoint (s, a);
SCM
Hairpin::pure_height (SCM smob, SCM, SCM)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real height = robust_scm2double (me->get_property ("height"), 0.0)
* Staff_symbol_referencer::staff_space (me);
SCM
Hairpin::broken_bound_padding (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Item *r_bound = me->get_bound (RIGHT);
if (r_bound->break_status_dir () != -1)
{
if (!scm_is_pair (hsb))
break;
- span_bars[d] = Grob::unsmob ((d == UP ? scm_car : scm_cdr) (hsb));
+ span_bars[d] = unsmob<Grob> ((d == UP ? scm_car : scm_cdr) (hsb));
break;
}
SCM
Hairpin::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
SCM s = me->get_property ("grow-direction");
if (!is_direction (s))
SCM
Hara_kiri_group_spanner::y_extent (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
consider_suicide (me);
return Axis_group_interface::generic_group_extent (me, Y_AXIS);
}
SCM
Hara_kiri_group_spanner::calc_skylines (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
consider_suicide (me);
return Axis_group_interface::calc_skylines (smob);
}
SCM
Hara_kiri_group_spanner::pure_height (SCM smob, SCM start_scm, SCM end_scm)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
int start = robust_scm2int (start_scm, 0);
int end = robust_scm2int (end_scm, INT_MAX);
SCM
Hara_kiri_group_spanner::force_hara_kiri_callback (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
consider_suicide (me);
return scm_from_double (0.0);
}
SCM
Hara_kiri_group_spanner::force_hara_kiri_in_y_parent_callback (SCM smob)
{
- Grob *daughter = Grob::unsmob (smob);
+ Grob *daughter = unsmob<Grob> (smob);
force_hara_kiri_callback (daughter->get_parent (Y_AXIS)->self_scm ());
return scm_from_double (0.0);
}
SCM
Horizontal_bracket::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
extract_grob_set (me, "columns", gs);
vector<Grob *> enclosed = gs;
override other ctor
*/
TRANSLATOR_DECLARATIONS (Engraver);
- static Engraver *unsmob (SCM eng) {
- return dynamic_cast<Engraver *> (Translator::unsmob (eng));
- }
- static bool is_smob (SCM eng) {
- return Translator::is_smob (eng) && unsmob (eng);
- }
};
#define make_item(x, cause) internal_make_item (ly_symbol2scm (x), cause, x, __FILE__, __LINE__, __FUNCTION__)
virtual Moment now_mom () const;
virtual Context *get_default_interpreter (const string &context_id = "");
- static Global_context *unsmob (SCM x) {
- return dynamic_cast<Global_context *> (Context::unsmob (x));
- }
- static bool is_smob (SCM x) {
- return Context::is_smob (x) && unsmob (x);
- }
-
Moment previous_moment () const;
protected:
Moment prev_mom_;
Item (SCM);
Item (Item const &);
- static Item *unsmob (SCM g) {
- return dynamic_cast <Item *> (Grob::unsmob (g));
- }
- static bool is_smob (SCM g) {
- return Grob::is_smob (g) && unsmob (g);
- }
-
virtual Grob *clone () const;
static bool is_non_musical (Grob *);
} \
}
+template <class T>
+T *unsmob (SCM var);
+
void ly_wrong_smob_arg (bool pred (SCM), SCM var, int number, const char *fun);
+// Do not call this directly.
+// Use LY_ASSERT_SMOB() which supplies the function name automatically.
+template <class T>
+inline T *ly_assert_smob (SCM var, int number, const char *fun)
+{
+ T *smob = unsmob<T> (var);
+ if (smob)
+ return smob;
+
+ ly_wrong_smob_arg (T::is_smob, var, number, fun);
+ return 0;
+}
+
// Could be just implemented using LY_ASSERT_TYPE, but this variant
// saves a slight amount of code
#define LY_ASSERT_SMOB(klass, var, number) \
- { \
- if (!klass::is_smob (var)) \
- ly_wrong_smob_arg (klass::is_smob, var, number, __FUNCTION__); \
- }
-
-// This variant is for the case where klass::unsmob might actually be
-// situated in a base class of klass
-#define LY_ASSERT_DERIVED_SMOB(klass, var, number) \
- { \
- if (!derived_unsmob<klass> (var)) \
- ly_wrong_smob_arg (klass::is_smob, var, number, __FUNCTION__); \
- }
+ ly_assert_smob<klass> (var, number, __FUNCTION__)
#endif /* LILY_GUILE_MACROS_HH */
static SCM equal_p (SCM a, SCM b)
{
- return *Listener::unsmob (a) == *Listener::unsmob (b)
+ return *unchecked_unsmob (a) == *unchecked_unsmob (b)
? SCM_BOOL_T : SCM_BOOL_F;
}
};
template <class T, void (T::*callback)(SCM)>
static void trampoline (SCM target, SCM ev)
{
- T *t = derived_unsmob<T> (target);
- LY_ASSERT_DERIVED_SMOB (T, target, 1);
+ T *t = unsmob<T> (target);
+ LY_ASSERT_SMOB (T, target, 1);
(t->*callback) (ev);
}
// The same, but for callbacks for translator listeners which get
// the unpacked event which, in turn, gets protected previously
- T *t = derived_unsmob<T> (target);
- LY_ASSERT_DERIVED_SMOB (T, target, 1);
+ T *t = unsmob<T> (target);
+ LY_ASSERT_SMOB (T, target, 1);
LY_ASSERT_SMOB (Stream_event, event, 2);
t->protect_event (event);
- (t->*callback) (Stream_event::unsmob (event));
+ (t->*callback) (unsmob<Stream_event> (event));
}
Callback_wrapper (void (*trampoline) (SCM, SCM)) : trampoline_ (trampoline)
Moment get_length () const;
Moment start_mom () const;
void print () const;
- static Music *unsmob (SCM m) {
- return dynamic_cast <Music *> (Prob::unsmob (m));
- }
- static bool is_smob (SCM m) {
- return Prob::is_smob (m) && unsmob (m);
- }
/// Transpose, with the interval central C to #p#
void transpose (Pitch p);
DECLARE_CLASSNAME (Paper_score);
- static Paper_score *unsmob (SCM ps) {
- return dynamic_cast <Paper_score *> (Music_output::unsmob (ps));
- }
- static bool is_smob (SCM ps) {
- return Music_output::is_smob (ps) && unsmob (ps);
- }
-
Output_def *layout () const;
System *root_system () const;
~Performance ();
DECLARE_CLASSNAME (Performance);
- static Performance *unsmob (SCM p) {
- return dynamic_cast <Performance *> (Music_output::unsmob (p));
- }
- static bool is_smob (SCM p) {
- return Music_output::is_smob (p) && unsmob (p);
- }
-
void add_element (Audio_element *p);
virtual void process ();
void remap_grace_durations ();
VIRTUAL_COPY_CONSTRUCTOR (Translator, Performer);
friend class Performer_group;
Performer_group *get_daddy_performer () const;
- static Performer *unsmob (SCM perf) {
- return dynamic_cast <Performer *> (Translator::unsmob (perf));
- }
- static bool is_smob (SCM perf) {
- return Translator::is_smob (perf) && unsmob (perf);
- }
protected:
virtual void announce_element (Audio_element_info);
CALLING INTERFACE
- Common public methods to C++ smob objects:
+ Common global functions for accessing C++ smob objects:
- - unsmob (SCM x) - unpacks X and returns pointer to the C++ object,
- or 0 if it has the wrong type. This can be used as a boolean
- condition at C++ level.
- - smob_p (SCM x) returns #t or #f at Scheme level.
+ - unsmob<T> (SCM x) - unpack X and return a pointer to the C++ object,
+ or 0 if it has the wrong type.
IMPLEMENTATION
static Scm_init scm_init_;
static void init (void);
static string smob_name_;
+protected:
static Super *unchecked_unsmob (SCM s)
{
return reinterpret_cast<Super *> (SCM_SMOB_DATA (s));
}
-protected:
// reference scm_init_ in smob_tag which is sure to be called. The
// constructor, in contrast, may not be called at all in classes
// like Smob1.
return (Super::unchecked_unsmob (self)->*pmf)(arg1, arg2, arg3);
}
-public:
static bool is_smob (SCM s)
{
return SCM_SMOB_PREDICATE (smob_tag (), s);
{
return is_smob (s) ? SCM_BOOL_T : SCM_BOOL_F;
}
- static Super *unsmob (SCM s)
- {
- return is_smob (s) ? Super::unchecked_unsmob (s) : 0;
- }
-};
-// derived_unsmob includes a dynamic_cast:
+ template <class T>
+ friend T *unsmob (SCM s);
+
+ template <class T>
+ friend T *ly_assert_smob (SCM s, int number, const char *fun);
+};
template <class T>
-inline T *derived_unsmob (SCM arg)
+inline T *unsmob (SCM s)
{
- return dynamic_cast<T *> (T::unsmob (arg));
+ return T::is_smob (s) ? dynamic_cast<T *> (T::unchecked_unsmob (s)) : 0;
}
// Simple smobs
SCM
Smob_base<Super>::mark_trampoline (SCM arg)
{
- Super *ptr = Super::unsmob (arg);
+ Super *ptr = unsmob<Super> (arg);
if (ptr)
return ptr->mark_smob ();
return SCM_UNDEFINED;
int
Smob_base<Super>::print_trampoline (SCM arg, SCM port, scm_print_state *p)
{
- Super *ptr = Super::unsmob (arg);
+ Super *ptr = unsmob<Super> (arg);
if (ptr)
return ptr->print_smob (port, p);
return 0;
DECLARE_SCHEME_CALLBACK (bounds_width, (SCM));
DECLARE_SCHEME_CALLBACK (kill_zero_spanned_time, (SCM));
- static Spanner *unsmob (SCM s) {
- return dynamic_cast <Spanner *> (Grob::unsmob (s));
- }
- static bool is_smob (SCM s) {
- return Grob::is_smob (s) && unsmob (s);
- }
-
vector<Spanner *> broken_intos_;
vsize get_break_index () const;
efficient to add "fresh" stencils to what you're going to build.
* Do not create Stencil objects on the heap. That includes passing
- around Stencil* which are produced by Stencil::unsmob(). Either
+ around Stencil* which are produced by unsmob<Stencil>(). Either
copy Stencil objects, or use SCM references.
* Empty stencils have empty dimensions. If add_at_edge is used to
Stream_event ();
VIRTUAL_COPY_CONSTRUCTOR (Stream_event, Stream_event);
- static Stream_event *unsmob (SCM s) {
- return dynamic_cast <Stream_event *> (Prob::unsmob (s));
- }
- static bool is_smob (SCM s) {
- return Prob::is_smob (s) && unsmob (s);
- }
-
Stream_event (SCM event_class, SCM immutable_props = SCM_EOL);
Stream_event (SCM class_name, Input *);
" to the location in @var{sip}. @var{msg} is interpreted"
" similar to @code{format}'s argument, using @var{rest}.")
{
- Input *ip = Input::unsmob (sip);
+ Input *ip = unsmob<Input> (sip);
LY_ASSERT_SMOB (Input, sip, 1);
LY_ASSERT_TYPE (scm_is_string, msg, 2);
" to the location in @var{sip}. @var{msg} is interpreted"
" similar to @code{format}'s argument, using @var{rest}.")
{
- Input *ip = Input::unsmob (sip);
+ Input *ip = unsmob<Input> (sip);
LY_ASSERT_SMOB (Input, sip, 1);
LY_ASSERT_TYPE (scm_is_string, msg, 2);
" @code{(file-name line char column)}.")
{
LY_ASSERT_SMOB (Input, sip, 1);
- Input *ip = Input::unsmob (sip);
+ Input *ip = unsmob<Input> (sip);
int l, ch, col, offset = 0;
ip->get_counts (&l, &ch, &col, &offset);
{
LY_ASSERT_SMOB (Input, sip, 1);
- Input *ip = Input::unsmob (sip);
+ Input *ip = unsmob<Input> (sip);
return scm_list_5 (ly_string2scm (ip->file_string ()),
scm_from_int (ip->line_number ()),
SCM
Input::equal_p (SCM sa, SCM sb)
{
- Input *a = unsmob (sa);
- Input *b = unsmob (sb);
+ Input *a = unsmob<Input> (sa);
+ Input *b = unsmob<Input> (sb);
if (a->get_source_file () == b->get_source_file ()
&& a->start () == b->start ()
&& a->end () == b->end ())
{
text_spanner_ = make_spanner ("InstrumentName", SCM_EOL);
- Grob *col = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *col = unsmob<Grob> (get_property ("currentCommandColumn"));
text_spanner_->set_bound (LEFT, col);
text_spanner_->set_property ("text", short_text_);
text_spanner_->set_property ("long-text", long_text_);
/*
UGH, should handle this in Score_engraver.
*/
- Grob *system = Grob::unsmob (get_property ("rootSystem"));
+ Grob *system = unsmob<Grob> (get_property ("rootSystem"));
if (system)
Axis_group_interface::add_element (system, text_spanner_);
else
axis_groups_[i]);
text_spanner_->set_bound (RIGHT,
- Grob::unsmob (get_property ("currentCommandColumn")));
+ unsmob<Grob> (get_property ("currentCommandColumn")));
Pointer_group_interface::set_ordered (text_spanner_,
ly_symbol2scm ("elements"),
1, 0, 0, (SCM g),
"Is @var{g} an @code{Item} object?")
{
- Grob *me = Grob::unsmob (g);
+ Grob *me = unsmob<Grob> (g);
bool b = dynamic_cast<Item *> (me);
return ly_bool2scm (b);
}
" @code{1}@tie{}beginning of line.")
{
LY_ASSERT_SMOB (Item, it, 1);
- Item *me = Item::unsmob (it);
+ Item *me = unsmob<Item> (it);
return scm_from_int (me->break_status_dir ());
}
" associated with this @code{Item}.")
{
LY_ASSERT_SMOB (Item, it, 1);
- Item *me = Item::unsmob (it);
+ Item *me = unsmob<Item> (it);
if (Paper_column *col = me->get_column ())
return col->self_scm ();
continue;
SCM live_scm = Grob_array::make_array ();
- Grob_array *live = Grob_array::unsmob (live_scm);
+ Grob_array *live = unsmob<Grob_array> (live_scm);
SCM dead_scm = Grob_array::make_array ();
- Grob_array *dead = Grob_array::unsmob (dead_scm);
+ Grob_array *dead = unsmob<Grob_array> (dead_scm);
for (vsize j = 0; j < group_spanners_.size (); ++j)
{
SCM
Key_signature_interface::print (SCM smob)
{
- Item *me = Item::unsmob (smob);
+ Item *me = unsmob<Item> (smob);
Real inter = Staff_symbol_referencer::staff_space (me) / 2.0;
first = current;
// must keep track of accidentals in spacing problem
- Grob *acc_gr = Grob::unsmob (current->get_object ("accidental-grob"));
+ Grob *acc_gr = unsmob<Grob> (current->get_object ("accidental-grob"));
if (acc_gr && i > 0)
{
Interval acc_ext = acc_gr->extent (acc_gr, X_AXIS);
if (i < primitives.size () - 1)
{
Item *next = dynamic_cast<Item *> (primitives[i + 1].grob ());
- Grob *acc_gr = Grob::unsmob (next->get_object ("accidental-grob"));
+ Grob *acc_gr = unsmob<Grob> (next->get_object ("accidental-grob"));
if (acc_gr)
{
Interval acc_ext = acc_gr->extent (acc_gr, X_AXIS);
* a single note head (attached as an articulation inside a chord) */
Stream_event *tie_ev = event_;
Grob *head = inf.grob ();
- Stream_event *note_ev = Stream_event::unsmob (head->get_property ("cause"));
+ Stream_event *note_ev = unsmob<Stream_event> (head->get_property ("cause"));
if (!tie_ev && note_ev && note_ev->in_event_class ("note-event"))
{
SCM articulations = note_ev->get_property ("articulations");
for (SCM s = articulations; !tie_ev && scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *ev = Stream_event::unsmob (scm_car (s));
+ Stream_event *ev = unsmob<Stream_event> (scm_car (s));
if (ev && ev->in_event_class ("laissez-vibrer-event"))
tie_ev = ev;
}
Pointer_group_interface::add_grob (lv_column_, ly_symbol2scm ("ties"),
lv_tie);
- if (is_direction (Stream_event::unsmob (cause)->get_property ("direction")))
+ if (is_direction (unsmob<Stream_event> (cause)->get_property ("direction")))
{
- Direction d = to_dir (Stream_event::unsmob (cause)->get_property ("direction"));
+ Direction d = to_dir (unsmob<Stream_event> (cause)->get_property ("direction"));
lv_tie->set_property ("direction", scm_from_int (d));
}
assert (!span_);
span_ = make_spanner ("LedgerLineSpanner", SCM_EOL);
- span_->set_bound (LEFT, Grob::unsmob (get_property ("currentCommandColumn")));
+ span_->set_bound (LEFT, unsmob<Grob> (get_property ("currentCommandColumn")));
}
void
{
if (span_)
{
- span_->set_bound (RIGHT, Grob::unsmob (get_property ("currentCommandColumn")));
+ span_->set_bound (RIGHT, unsmob<Grob> (get_property ("currentCommandColumn")));
span_ = 0;
}
}
SCM
Ledger_line_spanner::set_spacing_rods (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
// find size of note heads.
Grob *staff = Staff_symbol_referencer::get_staff_symbol (me);
SCM
Ledger_line_spanner::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
extract_grob_set (me, "note-heads", heads);
Axis a = Axis (i);
common[a] = common_refpoint_of_array (heads, me, a);
for (vsize i = heads.size (); i--;)
- if (Grob *g = Grob::unsmob (me->get_object ("accidental-grob")))
+ if (Grob *g = unsmob<Grob> (me->get_object ("accidental-grob")))
common[a] = common[a]->common_refpoint (g, a);
}
Interval x_extent = ledger_size;
if (i == 0)
- if (Grob *g = Grob::unsmob (h->get_object ("accidental-grob")))
+ if (Grob *g = unsmob<Grob> (h->get_object ("accidental-grob")))
{
Interval accidental_size = g->extent (common[X_AXIS], X_AXIS);
Real d
return -1;
/* produce requested token */
- yylloc = *Input::unsmob (scm_caar (extra_tokens_));
+ yylloc = *unsmob<Input> (scm_caar (extra_tokens_));
int type = scm_to_int (scm_cadar (extra_tokens_));
yylval = scm_cddar (extra_tokens_);
extra_tokens_ = scm_cdr (extra_tokens_);
return i;
SCM sid = lookup_identifier (str);
- if (Music *m = Music::unsmob (sid))
+ if (Music *m = unsmob<Music> (sid))
{
m->set_spot (override_input (here_input ()));
}
Lily_lexer::scan_shorthand (const string &str)
{
SCM sid = lookup_identifier (str);
- if (Music *m = Music::unsmob (sid))
+ if (Music *m = unsmob<Music> (sid))
{
m->set_spot (override_input (here_input ()));
}
int
Lily_lexer::scan_scm_id (SCM sid)
{
- if (Music_function *fun = Music_function::unsmob (sid))
+ if (Music_function *fun = unsmob<Music_function> (sid))
{
int funtype = SCM_FUNCTION;
if (scm_is_pair (handle)) {
yylval = scm_cdr (handle);
- if (Pitch::is_smob (yylval))
+ if (unsmob<Pitch> (yylval))
return (YYSTATE == notes) ? NOTENAME_PITCH : TONICNAME_PITCH;
else if (scm_is_symbol (yylval))
return DRUM_PITCH;
p = scm_cdr (p))
{
SCM v = scm_car (p);
- if (Music *m = Music::unsmob (v))
+ if (Music *m = unsmob<Music> (v))
{
- if (!Input::is_smob (m->get_property ("origin")))
+ if (!unsmob<Input> (m->get_property ("origin")))
m->set_spot (override_input (here_input ()));
}
sval = SCM_UNSPECIFIED;
}
- if (Music *m = Music::unsmob (sval))
+ if (Music *m = unsmob<Music> (sval))
{
- if (!Input::is_smob (m->get_property ("origin")))
+ if (!unsmob<Input> (m->get_property ("origin")))
m->set_spot (override_input (here_input ()));
}
primitives_.clear ();
ligature_ = 0;
}
- last_bound_ = Grob::unsmob (get_property ("currentMusicalColumn"));
+ last_bound_ = unsmob<Grob> (get_property ("currentMusicalColumn"));
if (ligature_)
{
prev_start_event_ = events_drul_[START];
ligature_ = create_ligature_spanner ();
- Grob *bound = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *bound = unsmob<Grob> (get_property ("currentMusicalColumn"));
if (!bound)
events_drul_[START]->origin ()->warning (_ ("no left bound"));
else
string type = predicate_to_typename ((void *) pred);
if (pred (var))
{
- // Uh oh. derived_unsmob <T> delivered 0, yet
- // T::is_smob delivers true. This means that T::is_smob is a
+ // Uh oh. unsmob<T> delivered 0, yet
+ // unsmob<T> delivers true. This means that unsmob<T> is a
// matching check from a base class of T, but var is of an
// incompatible derived type.
type = string (_ ("Wrong kind of ")).append (type);
{
LY_ASSERT_SMOB (Lily_lexer, lexer, 1);
- Lily_lexer *lex = Lily_lexer::unsmob (lexer);
+ Lily_lexer *lex = unsmob<Lily_lexer> (lexer);
return lex->keyword_list ();
}
main_input_level_ = 0;
extra_tokens_ = SCM_EOL;
- if (Input::is_smob (override_input))
- override_input_ = *Input::unsmob (override_input);
+ if (unsmob<Input> (override_input))
+ override_input_ = *unsmob<Input> (override_input);
smobify_self ();
1, 0, 0, (SCM parser_smob),
"Return the lexer for @var{parser-smob}.")
{
- Lily_parser *parser = Lily_parser::unsmob (parser_smob);
+ Lily_parser *parser = unsmob<Lily_parser> (parser_smob);
return parser->lexer_->self_scm ();
}
" it becomes the source of all music expressions inside.")
{
LY_ASSERT_SMOB (Lily_parser, parser_smob, 1);
- Lily_parser *parser = Lily_parser::unsmob (parser_smob);
+ Lily_parser *parser = unsmob<Lily_parser> (parser_smob);
if (SCM_UNBNDP (closures))
closures = SCM_EOL;
else
{
LY_ASSERT_SMOB (Lily_parser, parser_smob, 1);
- Lily_parser *parser = Lily_parser::unsmob (parser_smob);
+ Lily_parser *parser = unsmob<Lily_parser> (parser_smob);
LY_ASSERT_TYPE (ly_is_symbol, symbol, 2);
{
LY_ASSERT_SMOB (Lily_parser, parser_smob, 1);
- Lily_parser *parser = Lily_parser::unsmob (parser_smob);
+ Lily_parser *parser = unsmob<Lily_parser> (parser_smob);
LY_ASSERT_TYPE (ly_is_symbol, symbol, 2);
" Upon failure, throw @code{ly-file-failed} key.")
{
LY_ASSERT_SMOB (Lily_parser, parser_smob, 1);
- Lily_parser *parser = Lily_parser::unsmob (parser_smob);
+ Lily_parser *parser = unsmob<Lily_parser> (parser_smob);
LY_ASSERT_TYPE (scm_is_string, ly_code, 2);
if (!parser->lexer_->is_clean ())
" @var{filename} and @var{line} are optional source indicators.")
{
LY_ASSERT_SMOB (Lily_parser, parser_smob, 1);
- Lily_parser *parser = Lily_parser::unsmob (parser_smob);
+ Lily_parser *parser = unsmob<Lily_parser> (parser_smob);
LY_ASSERT_TYPE (scm_is_string, ly_code, 2);
string fn;
if (SCM_UNBNDP (filename) || !scm_is_string (filename))
" Scheme expressions (@code{$} instead of @code{#}).")
{
LY_ASSERT_SMOB (Lily_parser, parser_smob, 1);
- Lily_parser *parser = Lily_parser::unsmob (parser_smob);
+ Lily_parser *parser = unsmob<Lily_parser> (parser_smob);
LY_ASSERT_TYPE (scm_is_string, ly_code, 2);
parser->include_string (ly_scm2string (ly_code));
" if the current mode is notes.")
{
LY_ASSERT_SMOB (Lily_parser, parser, 1);
- Lily_parser *p = Lily_parser::unsmob (parser);
+ Lily_parser *p = unsmob<Lily_parser> (parser);
if (p->lexer_->is_note_state ())
{
"Return the base name of the output file.")
{
LY_ASSERT_SMOB (Lily_parser, parser, 1);
- Lily_parser *p = Lily_parser::unsmob (parser);
+ Lily_parser *p = unsmob<Lily_parser> (parser);
return ly_string2scm (p->output_basename_);
}
"Display an error message and make the parser fail.")
{
LY_ASSERT_SMOB (Lily_parser, parser, 1);
- Lily_parser *p = Lily_parser::unsmob (parser);
+ Lily_parser *p = unsmob<Lily_parser> (parser);
LY_ASSERT_TYPE (scm_is_string, msg, 2);
string s = ly_scm2string (msg);
- Input *i = Input::unsmob (input);
+ Input *i = unsmob<Input> (input);
if (i)
p->parser_error (*i, s);
else
"Clear the error flag for the parser.")
{
LY_ASSERT_SMOB (Lily_parser, parser, 1);
- Lily_parser *p = Lily_parser::unsmob (parser);
+ Lily_parser *p = unsmob<Lily_parser> (parser);
p->error_level_ = 0;
p->lexer_->error_level_ = 0;
"Does @var{parser} have an error flag?")
{
LY_ASSERT_SMOB (Lily_parser, parser, 1);
- Lily_parser *p = Lily_parser::unsmob (parser);
+ Lily_parser *p = unsmob<Lily_parser> (parser);
return scm_from_bool (p->error_level_ || p->lexer_->error_level_);
}
get_layout (Lily_parser *parser)
{
SCM id = parser->lexer_->lookup_identifier ("$defaultlayout");
- Output_def *layout = Output_def::unsmob (id);
+ Output_def *layout = unsmob<Output_def> (id);
layout = layout ? layout->clone () : new Output_def;
layout->set_variable (ly_symbol2scm ("is-layout"), SCM_BOOL_T);
get_midi (Lily_parser *parser)
{
SCM id = parser->lexer_->lookup_identifier ("$defaultmidi");
- Output_def *layout = Output_def::unsmob (id);
+ Output_def *layout = unsmob<Output_def> (id);
layout = layout ? layout->clone () : new Output_def;
layout->set_variable (ly_symbol2scm ("is-midi"), SCM_BOOL_T);
return layout;
{
SCM papers = parser->lexer_->lookup_identifier ("$papers");
Output_def *layout = (SCM_UNBNDP (papers) || scm_is_null (papers))
- ? 0 : Output_def::unsmob (scm_car (papers));
+ ? 0 : unsmob<Output_def> (scm_car (papers));
SCM default_paper = parser->lexer_->lookup_identifier ("$defaultpaper");
- layout = layout ? layout : Output_def::unsmob (default_paper);
+ layout = layout ? layout : unsmob<Output_def> (default_paper);
layout = layout ? dynamic_cast<Output_def *> (layout->clone ()) : new Output_def;
layout->set_variable (ly_symbol2scm ("is-paper"), SCM_BOOL_T);
SCM
Line_spanner::calc_bound_info (SCM smob, Direction dir)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Grob *commonx = me->get_bound (LEFT)->common_refpoint (me->get_bound (RIGHT), X_AXIS);
commonx = me->common_refpoint (commonx, X_AXIS);
? Axis_group_interface::generic_bound_extent (bound_grob, commonx, X_AXIS)
: robust_relative_extent (bound_grob, commonx, X_AXIS)).linear_combination (attach);
- Grob *acc = Grob::unsmob (bound_grob->get_object ("accidental-grob"));
+ Grob *acc = unsmob<Grob> (bound_grob->get_object ("accidental-grob"));
if (acc && to_boolean (ly_assoc_get (ly_symbol2scm ("end-on-accidental"), details, SCM_BOOL_F)))
x_coord = robust_relative_extent (acc, commonx, X_AXIS).linear_combination (attach);
- Grob *dot = Grob::unsmob (bound_grob->get_object ("dot"));
+ Grob *dot = unsmob<Grob> (bound_grob->get_object ("dot"));
if (dot && to_boolean (ly_assoc_get (ly_symbol2scm ("start-at-dot"), details, SCM_BOOL_F)))
x_coord = robust_relative_extent (dot, commonx, X_AXIS).linear_combination (attach);
SCM
Line_spanner::calc_cross_staff (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
if (!me)
return SCM_BOOL_F;
Line_spanner::calc_left_bound_info_and_text (SCM smob)
{
SCM alist = Line_spanner::calc_bound_info (smob, LEFT);
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
SCM text = me->get_property ("text");
if (Text_interface::is_markup (text)
SCM
Line_spanner::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
// Triggers simple-Y calculations
bool simple_y = to_boolean (me->get_property ("simple-Y")) && !to_boolean (me->get_property ("cross-staff"));
bounds[d], SCM_BOOL_F), 0.0);
arrows[d] = to_boolean (ly_assoc_get (ly_symbol2scm ("arrow"),
bounds[d], SCM_BOOL_F));
- stencils[d] = Stencil::unsmob (ly_assoc_get (ly_symbol2scm ("stencil"),
+ stencils[d] = unsmob<Stencil> (ly_assoc_get (ly_symbol2scm ("stencil"),
bounds[d], SCM_BOOL_F));
- common_y[d] = Grob::unsmob (ly_assoc_get (ly_symbol2scm ("common-Y"),
+ common_y[d] = unsmob<Grob> (ly_assoc_get (ly_symbol2scm ("common-Y"),
bounds[d], SCM_BOOL_F));
if (!common_y[d])
common_y[d] = me;
void
Lyric_combine_music_iterator::set_busy (SCM se)
{
- Stream_event *e = Stream_event::unsmob (se);
+ Stream_event *e = unsmob<Stream_event> (se);
if ((e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
&& music_context_)
void
Lyric_combine_music_iterator::construct_children ()
{
- Music *m = Music::unsmob (get_music ()->get_property ("element"));
- lyric_iter_ = Music_iterator::unsmob (get_iterator (m));
+ Music *m = unsmob<Music> (get_music ()->get_property ("element"));
+ lyric_iter_ = unsmob<Music_iterator> (get_iterator (m));
if (!lyric_iter_)
return;
lyrics_context_ = find_context_below (lyric_iter_->get_outlet (),
SCM
Lyric_combine_music::length_callback (SCM m)
{
- Music *me = Music::unsmob (m);
- Music *melody = Music::unsmob (scm_car (me->get_property ("elements")));
+ Music *me = unsmob<Music> (m);
+ Music *melody = unsmob<Music> (scm_car (me->get_property ("elements")));
return melody->get_length ().smobbed_copy ();
}
bool searchForVoice = to_boolean (lyrics->get_property ("searchForVoice"));
SCM avc = lyrics->get_property ("associatedVoiceContext");
- if (Context *c = Context::unsmob (avc))
+ if (Context *c = unsmob<Context> (avc))
return c;
SCM voice_name = lyrics->get_property ("associatedVoice");
for (SCM s = voice->get_property ("busyGrobs");
scm_is_pair (s); s = scm_cdr (s))
{
- Grob *g = Grob::unsmob (scm_cdar (s));;
- Moment *end_mom = Moment::unsmob (scm_caar (s));
+ Grob *g = unsmob<Grob> (scm_cdar (s));;
+ Moment *end_mom = unsmob<Moment> (scm_caar (s));
if (!end_mom || !g)
{
programming_error ("busyGrobs invalid");
// It's a bit irritating that we just have the length and
// duration of the Grob.
Moment end_from_now =
- get_event_length (Stream_event::unsmob (g->get_property ("cause")), now)
+ get_event_length (unsmob<Stream_event> (g->get_property ("cause")), now)
+ now;
// We cannot actually include more than a single grace note
// using busyGrobs on ungraced lyrics since a grob ending on
SCM
Lyric_extender::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Item *left_edge = me->get_bound (LEFT);
- Item *right_text = Item::unsmob (me->get_object ("next"));
+ Item *right_text = unsmob<Item> (me->get_object ("next"));
Grob *common = left_edge;
SCM
Lyric_hyphen::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Drul_array<Item *> bounds (me->get_bound (LEFT),
me->get_bound (RIGHT));
SCM
Lyric_hyphen::set_spacing_rods (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Rod r;
Spanner *sp = dynamic_cast<Spanner *> (me);
{
if (grouping_)
{
- grouping_->set_bound (RIGHT, Grob::unsmob (get_property ("currentCommandColumn")));
+ grouping_->set_bound (RIGHT, unsmob<Grob> (get_property ("currentCommandColumn")));
grouping_->suicide ();
grouping_ = 0;
}
if (grouping_ && now.main_part_ >= stop_grouping_mom_ && !now.grace_part_)
{
grouping_->set_bound (RIGHT,
- Grob::unsmob (get_property ("currentMusicalColumn")));
+ unsmob<Grob> (get_property ("currentMusicalColumn")));
grouping_ = 0;
}
SCM grouping = get_property ("beatStructure");
if (scm_is_pair (grouping))
{
- Moment *measpos = Moment::unsmob (get_property ("measurePosition"));
+ Moment *measpos = unsmob<Moment> (get_property ("measurePosition"));
Rational mp = measpos->main_part_;
- Moment *base_mom = Moment::unsmob (get_property ("baseMoment"));
+ Moment *base_mom = unsmob<Moment> (get_property ("baseMoment"));
Rational base_moment = base_mom->main_part_;
Rational where (0);
if (grouplen > 1)
{
grouping_ = make_spanner ("MeasureGrouping", SCM_EOL);
- grouping_->set_bound (LEFT, Grob::unsmob (get_property ("currentMusicalColumn")));
+ grouping_->set_bound (LEFT, unsmob<Grob> (get_property ("currentMusicalColumn")));
stop_grouping_mom_ = now.main_part_ + Rational (grouplen - 1) * base_moment;
get_global_context ()->add_moment_to_process (Moment (stop_grouping_mom_));
SCM
Measure_grouping::print (SCM grob)
{
- Spanner *me = Spanner::unsmob (grob);
+ Spanner *me = unsmob<Spanner> (grob);
SCM which = me->get_property ("style");
Real height = robust_scm2double (me->get_property ("height"), 1);
SCM
Melody_spanner::calc_neutral_stem_direction (SCM smob)
{
- Grob *stem = Grob::unsmob (smob);
- Grob *me = Grob::unsmob (stem->get_object ("melody-spanner"));
+ Grob *stem = unsmob<Grob> (smob);
+ Grob *me = unsmob<Grob> (stem->get_object ("melody-spanner"));
if (!me || !me->is_live ())
return scm_from_int (DOWN);
continue;
}
- int pitch = Pitch::unsmob (nr->get_property ("pitch"))->steps ();
+ int pitch = unsmob<Pitch> (nr->get_property ("pitch"))->steps ();
int prim = 0;
if (at_beginning)
}
// b. descendens longa or brevis
else if (i < s - 1
- && (Pitch::unsmob (primitives[i + 1].event_cause ()
+ && (unsmob<Pitch> (primitives[i + 1].event_cause ()
->get_property ("pitch"))->steps () < pitch)
&& duration_log > -3)
{
/*
breve: check whether descending
*/
- int const next_pitch = Pitch::unsmob
+ int const next_pitch = unsmob<Pitch>
(next_info.event_cause ()->get_property ("pitch"))->steps ();
if (next_pitch < pitch)
/*
SCM
Mensural_ligature::brew_ligature_primitive (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return internal_brew_primitive (me).smobbed_copy ();
}
first notational element of the measure if no time
signature is present in that measure).
*/
- if (Grob *mc = Grob::unsmob (get_property ("currentMusicalColumn")))
+ if (Grob *mc = unsmob<Grob> (get_property ("currentMusicalColumn")))
text_->set_parent (mc, X_AXIS);
- else if (Grob *cc = Grob::unsmob (get_property ("currentCommandColumn")))
+ else if (Grob *cc = unsmob<Grob> (get_property ("currentCommandColumn")))
text_->set_parent (cc, X_AXIS);
}
text_->set_object ("side-support-elements",
void
Midi_control_function_performer::announce_function_value_change (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
SCM sym = ev->get_property ("symbol");
if (!scm_is_symbol (sym))
return;
LY_ASSERT_SMOB (Moment, a, 1);
LY_ASSERT_SMOB (Moment, b, 2);
- Moment *ma = Moment::unsmob (a);
- Moment *mb = Moment::unsmob (b);
+ Moment *ma = unsmob<Moment> (a);
+ Moment *mb = unsmob<Moment> (b);
return (*ma - *mb).smobbed_copy ();
}
LY_ASSERT_SMOB (Moment, a, 1);
LY_ASSERT_SMOB (Moment, b, 2);
- Moment *ma = Moment::unsmob (a);
- Moment *mb = Moment::unsmob (b);
+ Moment *ma = unsmob<Moment> (a);
+ Moment *mb = unsmob<Moment> (b);
return (*ma + *mb).smobbed_copy ();
}
LY_ASSERT_SMOB (Moment, a, 1);
LY_ASSERT_SMOB (Moment, b, 2);
- Moment *ma = Moment::unsmob (a);
- Moment *mb = Moment::unsmob (b);
+ Moment *ma = unsmob<Moment> (a);
+ Moment *mb = unsmob<Moment> (b);
return (*ma * * mb).smobbed_copy ();
}
LY_ASSERT_SMOB (Moment, a, 1);
LY_ASSERT_SMOB (Moment, b, 2);
- Moment *ma = Moment::unsmob (a);
- Moment *mb = Moment::unsmob (b);
+ Moment *ma = unsmob<Moment> (a);
+ Moment *mb = unsmob<Moment> (b);
return (*ma / * mb).smobbed_copy ();
}
LY_ASSERT_SMOB (Moment, a, 1);
LY_ASSERT_SMOB (Moment, b, 2);
- Moment *ma = Moment::unsmob (a);
- Moment *mb = Moment::unsmob (b);
+ Moment *ma = unsmob<Moment> (a);
+ Moment *mb = unsmob<Moment> (b);
return (*ma % * mb).smobbed_copy ();
}
{
LY_ASSERT_SMOB (Moment, mom, 1);
- return ly_rational2scm (Moment::unsmob (mom)->grace_part_);
+ return ly_rational2scm (unsmob<Moment> (mom)->grace_part_);
}
LY_DEFINE (ly_moment_grace_numerator, "ly:moment-grace-numerator",
{
LY_ASSERT_SMOB (Moment, mom, 1);
- Moment *ma = Moment::unsmob (mom);
+ Moment *ma = unsmob<Moment> (mom);
return scm_from_int64 (ma->grace_part_.numerator ());
}
"Extract denominator from grace timing.")
{
LY_ASSERT_SMOB (Moment, mom, 1);
- Moment *ma = Moment::unsmob (mom);
+ Moment *ma = unsmob<Moment> (mom);
return scm_from_int64 (ma->grace_part_.denominator ());
}
{
LY_ASSERT_SMOB (Moment, mom, 1);
- return ly_rational2scm (Moment::unsmob (mom)->main_part_);
+ return ly_rational2scm (unsmob<Moment> (mom)->main_part_);
}
LY_DEFINE (ly_moment_main_numerator, "ly:moment-main-numerator",
"Extract numerator from main timing.")
{
LY_ASSERT_SMOB (Moment, mom, 1);
- Moment *ma = Moment::unsmob (mom);
+ Moment *ma = unsmob<Moment> (mom);
return scm_from_int64 (ma->main_part_.numerator ());
}
"Extract denominator from main timing.")
{
LY_ASSERT_SMOB (Moment, mom, 1);
- Moment *ma = Moment::unsmob (mom);
+ Moment *ma = unsmob<Moment> (mom);
return scm_from_int64 (ma->main_part_.denominator ());
}
LY_ASSERT_SMOB (Moment, a, 1);
LY_ASSERT_SMOB (Moment, b, 2);
- Moment *ma = Moment::unsmob (a);
- Moment *mb = Moment::unsmob (b);
+ Moment *ma = unsmob<Moment> (a);
+ Moment *mb = unsmob<Moment> (b);
return ly_bool2scm (*ma < *mb);
}
SCM
Moment::equal_p (SCM a, SCM b)
{
- Moment *m1 = Moment::unsmob (a);
- Moment *m2 = Moment::unsmob (b);
+ Moment *m1 = unsmob<Moment> (a);
+ Moment *m2 = unsmob<Moment> (b);
return (*m1 == *m2) ? SCM_BOOL_T : SCM_BOOL_F;
}
Moment
robust_scm2moment (SCM m, Moment d)
{
- Moment *p = Moment::unsmob (m);
+ Moment *p = unsmob<Moment> (m);
if (!p)
return d;
else
bool
moment_less (SCM a, SCM b)
{
- return *Moment::unsmob (a) < *Moment::unsmob (b);
+ return *unsmob<Moment> (a) < *unsmob<Moment> (b);
}
-- jneem */
if (bar_seen_)
{
- Grob *cmc = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *cmc = unsmob<Grob> (get_property ("currentCommandColumn"));
/* Ugh, this is a kludge - need this for multi-measure-rest-grace.ly */
last_command_item_ = dynamic_cast<Item *> (cmc);
SCM
Multi_measure_rest::percent (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Spanner *sp = dynamic_cast<Spanner *> (me);
Stencil r = Percent_repeat_item_interface::x_percent (me, 1);
SCM
Multi_measure_rest::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Spanner *sp = dynamic_cast<Spanner *> (me);
Interval sp_iv = bar_width (sp);
SCM
Multi_measure_rest::height (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real space = 1000000; // something very large...
{
SCM sml = dynamic_cast<Spanner *> (me)->get_bound (LEFT)
->get_property ("measure-length");
- Rational ml = (Moment::is_smob (sml)) ? Moment::unsmob (sml)->main_part_
+ Rational ml = (unsmob<Moment> (sml)) ? unsmob<Moment> (sml)->main_part_
: Rational (1);
double measure_duration = ml.Rational::to_double ();
bool force_round_up = to_boolean (scm_list_p (scm_member (scm_cons (scm_from_int64 (ml.numerator ()),
Stencil mol;
for (SCM s = mols; scm_is_pair (s); s = scm_cdr (s))
- mol.add_at_edge (X_AXIS, LEFT, *Stencil::unsmob (scm_car (s)),
+ mol.add_at_edge (X_AXIS, LEFT, *unsmob<Stencil> (scm_car (s)),
inner_padding);
mol.align_to (X_AXIS, LEFT);
mol.translate_axis (outer_padding_factor * inner_padding, X_AXIS);
Item *lb = li->find_prebroken_piece (RIGHT);
Item *rb = ri->find_prebroken_piece (LEFT);
- Grob *spacing = Grob::unsmob (li->get_object ("spacing"));
+ Grob *spacing = unsmob<Grob> (li->get_object ("spacing"));
if (!spacing)
- spacing = Grob::unsmob (ri->get_object ("spacing"));
+ spacing = unsmob<Grob> (ri->get_object ("spacing"));
if (spacing)
{
Spacing_options options;
SCM
Multi_measure_rest::set_spacing_rods (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real sym_width = symbol_stencil (me, 0.0).extent (X_AXIS).length ();
calculate_spacing_rods (me, sym_width);
SCM
Multi_measure_rest::set_text_rods (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Stencil *stil = me->get_stencil ();
/* FIXME uncached */
{
LY_ASSERT_SMOB (Music_function, x, 1);
- return Music_function::unsmob (x)->get_function ();
+ return unsmob<Music_function> (x)->get_function ();
}
LY_DEFINE (ly_music_function_signature, "ly:music-function-signature", 1, 0, 0,
{
LY_ASSERT_SMOB (Music_function, x, 1);
- return Music_function::unsmob (x)->get_signature ();
+ return unsmob<Music_function> (x)->get_signature ();
}
LY_DEFINE (ly_make_music_function, "ly:make-music-function", 2, 0, 0,
if (ly_is_procedure (ctor))
{
iter = scm_call_0 (ctor);
- p = Music_iterator::unsmob (iter);
+ p = unsmob<Music_iterator> (iter);
}
else
{
Music_iterator::get_iterator (Music *m) const
{
SCM ip = get_static_get_iterator (m);
- Music_iterator *p = Music_iterator::unsmob (ip);
+ Music_iterator *p = unsmob<Music_iterator> (ip);
p->init_context (m, get_outlet ());
" it as a @code{Moment} object.")
{
LY_ASSERT_SMOB (Music, mus, 1);
- Music *sc = Music::unsmob (mus);
+ Music *sc = unsmob<Music> (mus);
return sc->get_length ().smobbed_copy ();
}
1, 0, 0, (SCM obj),
"Is @var{obj} a music object?")
{
- return ly_bool2scm (Music::is_smob (obj));
+ return ly_bool2scm (unsmob<Music> (obj));
}
LY_DEFINE (ly_event_p, "ly:event?",
1, 0, 0, (SCM obj),
"Is @var{obj} a proper (non-rhythmic) event object?")
{
- if (Music *m = Music::unsmob (obj))
+ if (Music *m = unsmob<Music> (obj))
{
return scm_from_bool (m->is_mus_type ("post-event"));
}
" constant and initialized by the @code{make-music} function.")
{
LY_ASSERT_SMOB (Music, mus, 1);
- Music *m = Music::unsmob (mus);
+ Music *m = unsmob<Music> (mus);
return m->get_property_alist (true);
}
while (scm_is_pair (lst))
{
- if (!Music::is_smob (scm_car (lst)))
+ if (!unsmob<Music> (scm_car (lst)))
return SCM_BOOL_F;
lst = scm_cdr (lst);
}
" @var{m} may be an arbitrary type; cons cells and music"
" are copied recursively.")
{
- if (Music::is_smob (m))
- return Music::unsmob (m)->clone ()->unprotect ();
+ if (unsmob<Music> (m))
+ return unsmob<Music> (m)->clone ()->unprotect ();
if (scm_is_pair (m))
{
SCM copy = SCM_EOL;
LY_ASSERT_SMOB (Music, m, 1);
LY_ASSERT_SMOB (Pitch, p, 2);
- Music *sc = Music::unsmob (m);
- Pitch *sp = Pitch::unsmob (p);
+ Music *sc = unsmob<Music> (m);
+ Pitch *sp = unsmob<Pitch> (p);
sc->transpose (*sp);
// SCM_UNDEFINED ?
LY_ASSERT_SMOB (Music, m, 1);
LY_ASSERT_SMOB (Moment, factor, 2);
- Music *sc = Music::unsmob (m);
- sc->compress (*Moment::unsmob (factor));
+ Music *sc = unsmob<Music> (m);
+ sc->compress (*unsmob<Moment> (factor));
return sc->self_scm ();
}
LY_ASSERT_SMOB (Music, music, 1);
LY_ASSERT_SMOB (Pitch, pitch, 2);
- Pitch start = *Pitch::unsmob (pitch);
- Music *m = Music::unsmob (music);
+ Pitch start = *unsmob<Pitch> (pitch);
+ Music *m = unsmob<Music> (music);
Pitch last = m->to_relative_octave (start);
return last.smobbed_copy ();
" length.")
{
LY_ASSERT_SMOB (Music, mus, 1);
- Music *m = Music::unsmob (mus);
+ Music *m = unsmob<Music> (mus);
- Duration *d = Duration::unsmob (m->get_property ("duration"));
+ Duration *d = unsmob<Duration> (m->get_property ("duration"));
Moment len;
if (d)
LY_ASSERT_SMOB (Music, mus, 1);
LY_ASSERT_SMOB (Moment, fact, 2);
- Music *m = Music::unsmob (mus);
- Moment *f = Moment::unsmob (fact);
+ Music *m = unsmob<Music> (mus);
+ Moment *f = unsmob<Moment> (fact);
- Duration *d = Duration::unsmob (m->get_property ("duration"));
+ Duration *d = unsmob<Duration> (m->get_property ("duration"));
if (d)
m->set_property ("duration", d->compressed (f->main_part_).smobbed_copy ());
return SCM_UNSPECIFIED;
" pitch @var{pit}.")
{
SCM newlist = SCM_EOL;
- Pitch *p = Pitch::unsmob (pit);
+ Pitch *p = unsmob<Pitch> (pit);
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
{
transpose_music_list (SCM lst, Pitch rq)
{
for (SCM s = lst; scm_is_pair (s); s = scm_cdr (s))
- Music::unsmob (scm_car (s))->transpose (rq);
+ unsmob<Music> (scm_car (s))->transpose (rq);
}
Moment
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
{
- Moment l = Music::unsmob (scm_car (s))->get_length ();
+ Moment l = unsmob<Music> (scm_car (s))->get_length ();
if (last_len.grace_part_ && l.main_part_)
last_len.grace_part_ = Rational (0);
cumulative += last_len;
Moment dur = 0;
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
{
- Music *m = Music::unsmob (scm_car (s));
+ Music *m = unsmob<Music> (scm_car (s));
if (!m)
programming_error ("Music sequence should have music elements");
else
SCM
Music_sequence::maximum_length_callback (SCM m)
{
- Music *me = Music::unsmob (m);
+ Music *me = unsmob<Music> (m);
return maximum_length (me->get_property ("elements")).smobbed_copy ();
}
SCM
Music_sequence::event_chord_length_callback (SCM m)
{
- Music *me = Music::unsmob (m);
- Duration *d = Duration::unsmob (me->get_property ("duration"));
+ Music *me = unsmob<Music> (m);
+ Duration *d = unsmob<Duration> (me->get_property ("duration"));
// Preset duration is used in chord repetitions.
if (d)
{
SCM
Music_sequence::cumulative_length_callback (SCM m)
{
- Music *me = Music::unsmob (m);
+ Music *me = unsmob<Music> (m);
return cumulative_length (me->get_property ("elements")).smobbed_copy ();
}
SCM
Music_sequence::minimum_start_callback (SCM m)
{
- Music *me = Music::unsmob (m);
+ Music *me = unsmob<Music> (m);
return minimum_start (me->get_property ("elements")).smobbed_copy ();
}
SCM
Music_sequence::first_start_callback (SCM m)
{
- Music *me = Music::unsmob (m);
+ Music *me = unsmob<Music> (m);
return first_start (me->get_property ("elements")).smobbed_copy ();
}
Pitch last = p;
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
{
- if (Music *m = Music::unsmob (scm_car (s)))
+ if (Music *m = unsmob<Music> (scm_car (s)))
{
last = m->to_relative_octave (last);
if (!count++)
compress_music_list (SCM l, Moment m)
{
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
- Music::unsmob (scm_car (s))->compress (m);
+ unsmob<Music> (scm_car (s))->compress (m);
}
Moment
Moment m;
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
- m = min (m, Music::unsmob (scm_car (s))->start_mom ());
+ m = min (m, unsmob<Music> (scm_car (s))->start_mom ());
return m;
}
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
{
- Music *mus = Music::unsmob (scm_car (s));
+ Music *mus = unsmob<Music> (scm_car (s));
Moment start = mus->start_mom ();
if (mus->get_length ().to_bool () || start.to_bool ())
return start;
SCM
Music_sequence::simultaneous_relative_callback (SCM music, SCM pitch)
{
- Music *me = Music::unsmob (music);
- Pitch p = *Pitch::unsmob (pitch);
+ Music *me = unsmob<Music> (music);
+ Pitch p = *unsmob<Pitch> (pitch);
return music_list_to_relative (me->get_property ("elements"),
p, false).smobbed_copy ();
}
SCM
Music_sequence::event_chord_relative_callback (SCM music, SCM pitch)
{
- Music *me = Music::unsmob (music);
- Pitch p = *Pitch::unsmob (pitch);
+ Music *me = unsmob<Music> (music);
+ Pitch p = *unsmob<Pitch> (pitch);
return music_list_to_relative (me->get_property ("elements"),
p, true).smobbed_copy ();
}
Music_wrapper_iterator::construct_children ()
{
Music *my_music = get_music ();
- Music *child = Music::unsmob (my_music->get_property ("element"));
+ Music *child = unsmob<Music> (my_music->get_property ("element"));
child_iter_ = (child)
- ? Music_iterator::unsmob (get_iterator (child))
+ ? unsmob<Music_iterator> (get_iterator (child))
: 0;
}
SCM
Music_wrapper::start_callback (SCM m)
{
- Music *me = Music::unsmob (m);
- Music *elt = Music::unsmob (me->get_property ("element"));
+ Music *me = unsmob<Music> (m);
+ Music *elt = unsmob<Music> (me->get_property ("element"));
if (elt)
return elt->start_mom ().smobbed_copy ();
else
SCM
Music_wrapper::length_callback (SCM m)
{
- Music *me = Music::unsmob (m);
- Music *elt = Music::unsmob (me->get_property ("element"));
+ Music *me = unsmob<Music> (m);
+ Music *elt = unsmob<Music> (me->get_property ("element"));
if (elt)
return elt->get_length ().smobbed_copy ();
else
Music::get_length () const
{
SCM lst = get_property ("length");
- if (Moment::is_smob (lst))
- return *Moment::unsmob (lst);
+ if (unsmob<Moment> (lst))
+ return *unsmob<Moment> (lst);
if (ly_is_procedure (length_callback_))
{
SCM res = scm_call_1 (length_callback_, self_scm ());
- return *Moment::unsmob (res);
+ return *unsmob<Moment> (res);
}
return Moment (0);
if (ly_is_procedure (lst))
{
SCM res = scm_call_1 (lst, self_scm ());
- return *Moment::unsmob (res);
+ return *unsmob<Moment> (res);
}
Moment m;
Music::generic_to_relative_octave (Pitch last)
{
SCM elt = get_property ("element");
- Pitch *old_pit = Pitch::unsmob (get_property ("pitch"));
+ Pitch *old_pit = unsmob<Pitch> (get_property ("pitch"));
if (old_pit)
{
Pitch new_pit = *old_pit;
last = new_pit;
}
- if (Music *m = Music::unsmob (elt))
+ if (Music *m = unsmob<Music> (elt))
last = m->to_relative_octave (last);
(void) music_list_to_relative (get_property ("articulations"), last, true);
SCM callback = get_property ("to-relative-callback");
if (ly_is_procedure (callback))
{
- Pitch *p = Pitch::unsmob (scm_call_2 (callback, self_scm (),
+ Pitch *p = unsmob<Pitch> (scm_call_2 (callback, self_scm (),
last.smobbed_copy ()));
return *p;
}
{
SCM elt = get_property ("element");
- if (Music *m = Music::unsmob (elt))
+ if (Music *m = unsmob<Music> (elt))
m->compress (factor);
compress_music_list (get_property ("elements"), factor);
- Duration *d = Duration::unsmob (get_property ("duration"));
+ Duration *d = unsmob<Duration> (get_property ("duration"));
if (d)
set_property ("duration",
d->compressed (factor.main_part_).smobbed_copy ());
SCM val = scm_cdr (entry);
SCM new_val = val;
- if (Pitch *p = Pitch::unsmob (val))
+ if (Pitch *p = unsmob<Pitch> (val))
{
Pitch transposed = p->transposed (delta);
}
else if (scm_is_eq (prop, ly_symbol2scm ("element")))
{
- if (Music *m = Music::unsmob (val))
+ if (Music *m = unsmob<Music> (val))
m->transpose (delta);
}
else if (scm_is_eq (prop, ly_symbol2scm ("elements"))
Input *
Music::origin () const
{
- Input *ip = Input::unsmob (get_property ("origin"));
+ Input *ip = unsmob<Input> (get_property ("origin"));
return ip ? ip : &dummy_input_global;
}
SCM art_ev = SCM_EOL;
for (; scm_is_pair (art_mus); art_mus = scm_cdr (art_mus))
{
- Music *m = Music::unsmob (scm_car (art_mus));
+ Music *m = unsmob<Music> (scm_car (art_mus));
art_ev = scm_cons (m->to_event ()->unprotect (), art_ev);
}
e->set_property ("articulations", scm_reverse_x (art_ev, SCM_EOL));
SCM rv = scm_call_1 (make_music_proc, sym);
/* UGH. */
- Music *m = Music::unsmob (rv);
+ Music *m = unsmob<Music> (rv);
m->protect ();
return m;
}
SCM
Music::duration_length_callback (SCM m)
{
- Music *me = Music::unsmob (m);
- Duration *d = Duration::unsmob (me->get_property ("duration"));
+ Music *me = unsmob<Music> (m);
+ Duration *d = unsmob<Duration> (me->get_property ("duration"));
Moment mom;
if (d)
for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *ev = Stream_event::unsmob (scm_car (s));
+ Stream_event *ev = unsmob<Stream_event> (scm_car (s));
if (!ev)
continue;
else if (ev->in_event_class ("harmonic-event"))
{
inf.grob ()->set_property ("style", ly_symbol2scm ("harmonic"));
- Grob *d = Grob::unsmob (inf.grob ()->get_object ("dot"));
+ Grob *d = unsmob<Grob> (inf.grob ()->get_object ("dot"));
if (d && !to_boolean (get_property ("harmonicDots")))
d->suicide ();
}
if (stem_)
{
Side_position_interface::add_support (scripts->at (i).script_, stem_);
- if (Grob *flag = Grob::unsmob (stem_->get_object ("flag")))
+ if (Grob *flag = unsmob<Grob> (stem_->get_object ("flag")))
Side_position_interface::add_support (scripts->at (i).script_, flag);
}
f->set_parent (ft.head_, Y_AXIS);
f->set_property ("avoid-slur", ly_symbol2scm ("inside"));
if (hordir == LEFT
- && Grob::is_smob (ft.head_->get_object ("accidental-grob")))
+ && unsmob<Grob> (ft.head_->get_object ("accidental-grob")))
Side_position_interface::add_support (f,
- Grob::unsmob (ft.head_->get_object ("accidental-grob")));
- else if (Grob::is_smob (ft.head_->get_object ("dot")))
+ unsmob<Grob> (ft.head_->get_object ("accidental-grob")));
+ else if (unsmob<Grob> (ft.head_->get_object ("dot")))
Side_position_interface::add_support (f,
- Grob::unsmob (ft.head_->get_object ("dot")));
+ unsmob<Grob> (ft.head_->get_object ("dot")));
Self_alignment_interface::set_aligned_on_parent (f, Y_AXIS);
Side_position_interface::set_axis (f, X_AXIS);
if (dot_wipe_head)
{
- if (Grob *d = Grob::unsmob (dot_wipe_head->get_object ("dot")))
+ if (Grob *d = unsmob<Grob> (dot_wipe_head->get_object ("dot")))
d->suicide ();
}
if (shift_amount < -1e-6
&& Rhythmic_head::dot_count (head_up))
{
- Grob *d = Grob::unsmob (head_up->get_object ("dot"));
+ Grob *d = unsmob<Grob> (head_up->get_object ("dot"));
Grob *parent = d->get_parent (X_AXIS);
if (Dot_column::has_interface (parent))
Side_position_interface::add_support (parent, head_down);
}
else if (Rhythmic_head::dot_count (head_down))
{
- Grob *d = Grob::unsmob (head_down->get_object ("dot"));
+ Grob *d = unsmob<Grob> (head_down->get_object ("dot"));
Grob *parent = d->get_parent (X_AXIS);
if (Dot_column::has_interface (parent))
{
- Grob *stem = Grob::unsmob (head_up->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (head_up->get_object ("stem"));
// Loop over all heads on an up-pointing-stem to see if dots
// need to clear any heads suspended on its right side.
extract_grob_set (stem, "note-heads", heads);
if (shift_amount > 1e-6
&& Rhythmic_head::dot_count (head_down))
{
- Grob *dot_down = Grob::unsmob (head_down->get_object ("dot"));
+ Grob *dot_down = unsmob<Grob> (head_down->get_object ("dot"));
Grob *col_down = dot_down->get_parent (X_AXIS);
Direction dir = UP;
if (Rhythmic_head::dot_count (head_up))
{
- Grob *dot_up = Grob::unsmob (head_up->get_object ("dot"));
+ Grob *dot_up = unsmob<Grob> (head_up->get_object ("dot"));
Grob *col_up = dot_up->get_parent (X_AXIS);
if (col_up == col_down) // let the common DotColumn arrange dots
dir = CENTER;
}
if (dir != CENTER)
{
- Grob *stem = Grob::unsmob (head_down->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (head_down->get_object ("stem"));
extract_grob_set (stem, "note-heads", heads);
for (vsize i = 0; i < heads.size (); i++)
- if (Grob *dot = Grob::unsmob (heads[i]->get_object ("dot")))
+ if (Grob *dot = unsmob<Grob> (heads[i]->get_object ("dot")))
dot->set_property ("direction", scm_from_int (dir));
}
}
SCM
Note_collision_interface::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
me->set_property ("positioning-done", SCM_BOOL_T);
Drul_array<vector<Grob *> > clash_groups = get_clash_groups (me);
vector<Real> amounts;
for (; scm_is_pair (hand); hand = scm_cdr (hand))
{
- Grob *s = Grob::unsmob (scm_caar (hand));
+ Grob *s = unsmob<Grob> (scm_caar (hand));
Real amount = scm_to_double (scm_cdar (hand)) * wid;
done.push_back (s);
}
for (; scm_is_pair (autos); autos = scm_cdr (autos))
{
- Grob *s = Grob::unsmob (scm_caar (autos));
+ Grob *s = unsmob<Grob> (scm_caar (autos));
Real amount = scm_to_double (scm_cdar (autos)) * wid;
vsize x = find (done, s) - done.begin ();
vector<int> out;
extract_grob_set (me, "elements", elts);
for (vsize i = 0; i < elts.size (); i++)
- if (Grob *stem = Grob::unsmob (elts[i]->get_object ("stem")))
+ if (Grob *stem = unsmob<Grob> (elts[i]->get_object ("stem")))
{
vector<int> nhp = Stem::note_head_positions (stem);
out.insert (out.end (), nhp.begin (), nhp.end ());
"Return the @code{AccidentalPlacement} grob from @var{note-column}"
" if any, or @code{SCM_EOL} otherwise.")
{
- Grob *grob = Grob::unsmob (note_column);
+ Grob *grob = unsmob<Grob> (note_column);
LY_ASSERT_SMOB (Grob, note_column, 1);
Grob *acc = Note_column::accidentals (grob);
if (acc)
"Return the @code{DotColumn} grob from @var{note-column}"
" if any, or @code{SCM_EOL} otherwise.")
{
- Grob *grob = Grob::unsmob (note_column);
+ Grob *grob = unsmob<Grob> (note_column);
LY_ASSERT_SMOB (Grob, note_column, 1);
Grob *dot_column = Note_column::dot_column (grob);
if (dot_column)
bool
Note_column::has_rests (Grob *me)
{
- return Grob::is_smob (me->get_object ("rest"));
+ return unsmob<Grob> (me->get_object ("rest"));
}
bool
Note_column::get_stem (Grob *me)
{
SCM s = me->get_object ("stem");
- return Item::unsmob (s);
+ return unsmob<Item> (s);
}
Item *
if (stem)
{
SCM s = stem->get_object ("flag");
- return Item::unsmob (s);
+ return unsmob<Item> (s);
}
return 0;
}
Direction
Note_column::dir (Grob *me)
{
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
if (stem && Stem::has_interface (stem))
return get_grob_direction (stem);
else
Grob *
Note_column::get_rest (Grob *me)
{
- return Grob::unsmob (me->get_object ("rest"));
+ return unsmob<Grob> (me->get_object ("rest"));
}
void
}
else if (Note_head::has_interface (h))
{
- if (Grob::is_smob (me->get_object ("rest")))
+ if (unsmob<Grob> (me->get_object ("rest")))
both = true;
Pointer_group_interface::add_grob (me, ly_symbol2scm ("note-heads"), h);
}
}
Grob *main_item = main_head
? main_head
- : Grob::unsmob (me->get_object ("rest"));
+ : unsmob<Grob> (me->get_object ("rest"));
return main_item
? main_item->extent (me, X_AXIS)
for (vsize i = 0; i < heads.size (); i++)
{
Grob *h = heads[i];
- acc = h ? Grob::unsmob (h->get_object ("accidental-grob")) : 0;
+ acc = h ? unsmob<Grob> (h->get_object ("accidental-grob")) : 0;
if (acc)
break;
}
extract_grob_set (me, "note-heads", heads);
for (vsize i = 0; i < heads.size (); i++)
{
- Grob *dots = Grob::unsmob (heads[i]->get_object ("dot"));
+ Grob *dots = unsmob<Grob> (heads[i]->get_object ("dot"));
if (dots)
return dots->get_parent (X_AXIS);
}
" notehead @var{glyph-name}.")
{
LY_ASSERT_SMOB (Font_metric, font_metric, 1);
- Font_metric *fm = Font_metric::unsmob (font_metric);
+ Font_metric *fm = unsmob<Font_metric> (font_metric);
LY_ASSERT_TYPE (scm_is_string, glyph_name, 2);
return ly_offset2scm (Note_head::get_stem_attachment (fm, ly_scm2string (glyph_name)));
Stencil out = fm->find_by_name (idx_either + suffix);
if (out.is_empty ())
{
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
Direction stem_dir = stem ? get_grob_direction (stem) : CENTER;
if (stem_dir == CENTER)
if (style == "kievan"
&& 3 == robust_scm2int (me->get_property ("duration-log"), 2))
{
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
- Grob *beam = Grob::unsmob (stem->get_object ("beam"));
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
+ Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
if (beam)
out = fm->find_by_name (idx_either + "2kievan");
}
SCM
Note_head::stem_x_shift (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
if (stem)
(void) stem->get_property ("positioning-done");
SCM
Note_head::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
string idx;
return internal_print (me, &idx).smobbed_copy ();
SCM
Note_head::include_ledger_line_height (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *staff = Staff_symbol_referencer::get_staff_symbol (me);
if (staff)
SCM
Note_head::calc_stem_attachment (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Font_metric *fm = Font_interface::get_default_font (me);
string key;
internal_print (me, &key);
Stream_event *ev = note_evs_[i];
Item *note = make_item ("NoteHead", ev->self_scm ());
- Pitch *pit = Pitch::unsmob (ev->get_property ("pitch"));
+ Pitch *pit = unsmob<Pitch> (ev->get_property ("pitch"));
#if 0 /* TODO: should have a mechanism to switch off these warnings. */
{
SCM scm_tonic = get_property ("tonic");
Pitch tonic;
- if (Pitch::is_smob (scm_tonic))
- tonic = *Pitch::unsmob (scm_tonic);
+ if (unsmob<Pitch> (scm_tonic))
+ tonic = *unsmob<Pitch> (scm_tonic);
unsigned int delta = (pit->get_notename () - tonic.get_notename () + 7) % 7;
{
if (i)
s += " ";
- Pitch p = *Pitch::unsmob (events_[i]->get_property ("pitch"));
+ Pitch p = *unsmob<Pitch> (events_[i]->get_property ("pitch"));
if (!to_boolean (get_property ("printOctaveNames")))
p = Pitch (-1, p.get_notename (), p.get_alteration ());
Pitch transposing;
SCM prop = get_property ("instrumentTransposition");
- if (Pitch::is_smob (prop))
- transposing = *Pitch::unsmob (prop);
+ if (unsmob<Pitch> (prop))
+ transposing = *unsmob<Pitch> (prop);
for (vsize i = 0; i < note_evs_.size (); i++)
{
Stream_event *n = note_evs_[i];
SCM pit = n->get_property ("pitch");
- if (Pitch *pitp = Pitch::unsmob (pit))
+ if (Pitch *pitp = unsmob<Pitch> (pit))
{
SCM articulations = n->get_property ("articulations");
Stream_event *tie_event = 0;
int velocity = 0;
for (SCM s = articulations; scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *ev = Stream_event::unsmob (scm_car (s));
+ Stream_event *ev = unsmob<Stream_event> (scm_car (s));
if (!ev)
continue;
Grob *last_spacing = last_spacings_[parent];
if (last_spacing
- && !Grob_array::is_smob (last_spacing->get_object ("right-items")))
+ && !unsmob<Grob_array> (last_spacing->get_object ("right-items")))
{
- Grob *col = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *col = unsmob<Grob> (get_property ("currentCommandColumn"));
Pointer_group_interface::add_grob (last_spacing,
ly_symbol2scm ("right-items"),
if (last_spacing
&& to_boolean (get_property ("hasStaffSpacing")))
{
- Grob *col = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *col = unsmob<Grob> (get_property ("currentCommandColumn"));
Pointer_group_interface::add_grob (last_spacing,
ly_symbol2scm ("right-items"),
col);
for (vsize i = 0; i < note_columns.size (); i++)
{
SCM r = note_columns[i]->get_object ("rest");
- Grob *g = Grob::unsmob (r);
+ Grob *g = unsmob<Grob> (r);
Grob *col = note_columns[i]->get_column ();
if (!g)
{
LY_ASSERT_SMOB (Font_metric, font, 1);
- Font_metric *fm = Font_metric::unsmob (font);
+ Font_metric *fm = unsmob<Font_metric> (font);
return fm->sub_fonts ();
}
" information about named glyph @var{glyph} (a string).")
{
Modified_font_metric *fm
- = derived_unsmob<Modified_font_metric> (font);
+ = unsmob<Modified_font_metric> (font);
Open_type_font *otf = fm
? dynamic_cast<Open_type_font *> (fm->original_font ())
- : derived_unsmob<Open_type_font> (font);
+ : unsmob<Open_type_font> (font);
SCM_ASSERT_TYPE (otf, font, SCM_ARG1, __FUNCTION__, "OpenType font");
LY_ASSERT_TYPE (scm_is_string, glyph, 2);
" for non-existent @var{tag}.")
{
Modified_font_metric *fm
- = derived_unsmob<Modified_font_metric> (font);
+ = unsmob<Modified_font_metric> (font);
Open_type_font *otf = fm
? dynamic_cast<Open_type_font *> (fm->original_font ())
- : derived_unsmob<Open_type_font> (font);
+ : unsmob<Open_type_font> (font);
SCM_ASSERT_TYPE (otf, font, SCM_ARG1, __FUNCTION__, "OpenType font");
LY_ASSERT_TYPE (scm_is_string, tag, 2);
"Is @var{font} an OpenType font?")
{
Modified_font_metric *fm
- = derived_unsmob<Modified_font_metric> (font);
+ = unsmob<Modified_font_metric> (font);
Open_type_font *otf = fm
? dynamic_cast<Open_type_font *> (fm->original_font ())
- : derived_unsmob<Open_type_font> (font);
+ : unsmob<Open_type_font> (font);
return scm_from_bool (otf);
}
"Return the number of glyphs in @var{font}.")
{
Modified_font_metric *fm
- = derived_unsmob<Modified_font_metric> (font);
+ = unsmob<Modified_font_metric> (font);
Open_type_font *otf = fm
? dynamic_cast<Open_type_font *> (fm->original_font ())
- : derived_unsmob<Open_type_font> (font);
+ : unsmob<Open_type_font> (font);
SCM_ASSERT_TYPE (otf, font, SCM_ARG1, __FUNCTION__, "OpenType font");
"Return a list of glyph names for @var{font}.")
{
Modified_font_metric *fm
- = derived_unsmob<Modified_font_metric> (font);
+ = unsmob<Modified_font_metric> (font);
Open_type_font *otf = fm
? dynamic_cast<Open_type_font *> (fm->original_font ())
- : derived_unsmob<Open_type_font> (font);
+ : unsmob<Open_type_font> (font);
SCM_ASSERT_TYPE (otf, font, SCM_ARG1, __FUNCTION__, "OpenType font");
{
SCM box = scm_hashq_ref (lily_index_to_bbox_table_,
scm_from_unsigned_integer (signed_idx), SCM_BOOL_F);
- Box *box_ptr = Box::unsmob (box);
+ Box *box_ptr = unsmob<Box> (box);
if (box_ptr)
return *box_ptr;
}
SCM
Ottava_bracket::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Interval span_points;
Grob *common = me->get_bound (LEFT)->common_refpoint (me->get_bound (RIGHT), X_AXIS);
SCM markup = me->get_property ("text");
Stencil text;
if (Text_interface::is_markup (markup))
- text = *Stencil::unsmob (Text_interface::interpret_markup (layout->self_scm (),
+ text = *unsmob<Stencil> (Text_interface::interpret_markup (layout->self_scm (),
properties, markup));
Drul_array<Real> shorten = robust_scm2interval (me->get_property ("shorten-pair"),
{
if (!finished_->get_bound (RIGHT))
{
- Grob *e = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *e = unsmob<Grob> (get_property ("currentMusicalColumn"));
finished_->set_bound (d, e);
}
}
{
if (span_ && !span_->get_bound (LEFT))
{
- Grob *e = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *e = unsmob<Grob> (get_property ("currentMusicalColumn"));
span_->set_bound (LEFT, e);
}
" @var{val} or @code{'()} if @var{val} is undefined.")
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *op = Output_def::unsmob (def);
+ Output_def *op = unsmob<Output_def> (def);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
SCM answer = op->lookup_variable (sym);
"Return the variable scope inside @var{def}.")
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *op = Output_def::unsmob (def);
+ Output_def *op = unsmob<Output_def> (def);
return op->scope_;
}
"Return the parent output definition of @var{def}.")
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *op = Output_def::unsmob (def);
+ Output_def *op = unsmob<Output_def> (def);
return op->parent_ ? op->parent_->self_scm () : SCM_EOL;
}
"Set an output definition @var{def} variable @var{sym} to @var{val}.")
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *output_def = Output_def::unsmob (def);
+ Output_def *output_def = unsmob<Output_def> (def);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
output_def->set_variable (sym, val);
return SCM_UNSPECIFIED;
"Clone output definition @var{def}.")
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *op = Output_def::unsmob (def);
+ Output_def *op = unsmob<Output_def> (def);
Output_def *clone = op->clone ();
return clone->unprotect ();
{
LY_ASSERT_SMOB (Output_def, output_def, 1);
- Output_def *id = Output_def::unsmob (output_def);
+ Output_def *id = unsmob<Output_def> (output_def);
SCM al = ly_module_2_alist (id->scope_);
SCM ell = SCM_EOL;
for (SCM s = al; scm_is_pair (s); s = scm_cdr (s))
{
- Context_def *td = Context_def::unsmob (scm_cdar (s));
+ Context_def *td = unsmob<Context_def> (scm_cdar (s));
SCM key = scm_caar (s);
if (td && key == td->get_context_name ())
ell = scm_cons (scm_cons (key, td->to_alist ()), ell);
if (!SCM_UNBNDP (context_name))
LY_ASSERT_TYPE (ly_is_symbol, context_name, 2);
- Output_def *id = Output_def::unsmob (output_def);
+ Output_def *id = unsmob<Output_def> (output_def);
SCM al = ly_module_2_alist (id->scope_);
SCM ell = SCM_EOL;
for (SCM s = al; scm_is_pair (s); s = scm_cdr (s))
{
SCM p = scm_car (s);
- Context_def *td = Context_def::unsmob (scm_cdr (p));
+ Context_def *td = unsmob<Context_def> (scm_cdr (p));
if (td && scm_is_eq (scm_car (p), td->get_context_name ())
&& (SCM_UNBNDP (context_name) || td->is_alias (context_name)))
ell = scm_cons (p, ell);
"Return the output-scale for output definition @var{def}.")
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *b = Output_def::unsmob (def);
+ Output_def *b = unsmob<Output_def> (def);
return scm_from_double (output_scale (b));
}
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *paper = Output_def::unsmob (def);
+ Output_def *paper = unsmob<Output_def> (def);
Font_metric *fm = select_font (paper, chain);
return fm->self_scm ();
}
" @var{def} as a double.")
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *layout = Output_def::unsmob (def);
+ Output_def *layout = unsmob<Output_def> (def);
return scm_from_double (layout->get_dimension (sym));
}
" @var{def} (e.g., @code{\\paper}).")
{
LY_ASSERT_SMOB (Output_def, def, 1);
- Output_def *b = Output_def::unsmob (def);
+ Output_def *b = unsmob<Output_def> (def);
SCM tab1 = b->lookup_variable (ly_symbol2scm ("scaled-fonts"));
SCM tab2 = b->lookup_variable (ly_symbol2scm ("pango-fonts"));
{
SCM entry = scm_car (s);
- Font_metric *fm = Font_metric::unsmob (entry);
+ Font_metric *fm = unsmob<Font_metric> (entry);
if (dynamic_cast<Modified_font_metric *> (fm)
|| dynamic_cast<Pango_font *> (fm))
void
assign_context_def (Output_def * m, SCM transdef)
{
- Context_def *tp = Context_def::unsmob (transdef);
+ Context_def *tp = unsmob<Context_def> (transdef);
assert (tp);
if (tp)
SCM
find_context_def (Output_def const *m, SCM name)
{
- Context_def *cd = Context_def::unsmob (m->lookup_variable (name));
+ Context_def *cd = unsmob<Context_def> (m->lookup_variable (name));
return cd ? cd->self_scm () : SCM_EOL;
}
" @var{pb} such that page turns only happen in specified places,"
" returning its pages.")
{
- Page_turn_page_breaking b (Paper_book::unsmob (pb));
+ Page_turn_page_breaking b (unsmob<Paper_book> (pb));
return b.solve ();
}
" @var{pb} to minimize badness in bother vertical and horizontal"
" spacing.")
{
- Optimal_page_breaking b (Paper_book::unsmob (pb));
+ Optimal_page_breaking b (unsmob<Paper_book> (pb));
return b.solve ();
}
" without looking for optimal spacing: stack as many lines on"
" a page before moving to the next one.")
{
- Minimal_page_breaking b (Paper_book::unsmob (pb));
+ Minimal_page_breaking b (unsmob<Paper_book> (pb));
return b.solve ();
}
" page. The paper-width setting will be modified so that"
" every page will be wider than the widest line.")
{
- One_line_page_breaking b (Paper_book::unsmob (pb));
+ One_line_page_breaking b (unsmob<Paper_book> (pb));
return b.solve ();
}
for (SCM s = systems; scm_is_pair (s); s = scm_cdr (s))
{
SCM paper_system = scm_car (s);
- if (Grob *g = Grob::unsmob (scm_car (s)))
+ if (Grob *g = unsmob<Grob> (scm_car (s)))
{
System *sys = dynamic_cast<System *> (g);
paper_system = sys->get_paper_system ();
// Create the page and draw it.
SCM page = make_page (page_num, last);
- Prob *p = Prob::unsmob (page);
+ Prob *p = unsmob<Prob> (page);
p->set_property ("lines", paper_systems);
p->set_property ("configuration", configuration);
- Stencil *foot_p = Stencil::unsmob (p->get_property ("foot-stencil"));
+ Stencil *foot_p = unsmob<Stencil> (p->get_property ("foot-stencil"));
Stencil foot = foot_p ? *foot_p : Stencil ();
SCM footnotes = Page_layout_problem::get_footnotes_from_lines (systems);
for (SCM l = lines; scm_is_pair (l); l = scm_cdr (l))
{
SCM labels = SCM_EOL;
- if (Grob *line = Grob::unsmob (scm_car (l)))
+ if (Grob *line = unsmob<Grob> (scm_car (l)))
{
System *system = dynamic_cast<System *> (line);
labels = system->get_property ("labels");
}
- else if (Prob *prob = Prob::unsmob (scm_car (l)))
+ else if (Prob *prob = unsmob<Prob> (scm_car (l)))
labels = prob->get_property ("labels");
for (SCM lbls = labels; scm_is_pair (lbls); lbls = scm_cdr (lbls))
SCM specs = book_->get_system_specs ();
for (SCM s = specs; scm_is_pair (s); s = scm_cdr (s))
{
- if (Paper_score *ps = Paper_score::unsmob (scm_car (s)))
+ if (Paper_score *ps = unsmob<Paper_score> (scm_car (s)))
{
system_specs_.push_back (System_spec (ps));
}
else
{
- Prob *pb = Prob::unsmob (scm_car (s));
+ Prob *pb = unsmob<Prob> (scm_car (s));
assert (pb);
pb->protect ();
LY_ASSERT_SMOB (Grob, from_scm, 1);
LY_ASSERT_SMOB (Grob, to_scm, 2);
- Grob *from = Grob::unsmob (from_scm);
- Grob *to = Grob::unsmob (to_scm);
+ Grob *from = unsmob<Grob> (from_scm);
+ Grob *to = unsmob<Grob> (to_scm);
return Page_layout_problem::get_spacing_spec (from, to, false, 0, 0);
}
vector<Grob *> footnotes;
for (SCM s = lines; scm_is_pair (s); s = scm_cdr (s))
{
- if (Grob *g = Grob::unsmob (scm_car (s)))
+ if (Grob *g = unsmob<Grob> (scm_car (s)))
{
System *sys = dynamic_cast<System *> (g);
if (!sys)
extract_grob_set (sys, "footnotes-after-line-breaking", footnote_grobs);
footnotes.insert (footnotes.end (), footnote_grobs.begin (), footnote_grobs.end ());
}
- else if (Prob *p = Prob::unsmob (scm_car (s)))
+ else if (Prob *p = unsmob<Prob> (scm_car (s)))
{
SCM stencils = p->get_property ("footnotes");
if (scm_is_null (stencils))
return SCM_EOL;
bool footnotes_added;
- if (Grob *g = Grob::unsmob (scm_car (lines)))
+ if (Grob *g = unsmob<Grob> (scm_car (lines)))
footnotes_added = !scm_is_null (g->get_property ("footnote-stencil"));
- else if (Prob *p = Prob::unsmob (scm_car (lines)))
+ else if (Prob *p = unsmob<Prob> (scm_car (lines)))
footnotes_added = !scm_is_null (p->get_property ("footnote-stencil"));
else
{
SCM out = SCM_EOL;
for (SCM s = lines; scm_is_pair (s); s = scm_cdr (s))
{
- if (Grob *g = Grob::unsmob (scm_car (s)))
+ if (Grob *g = unsmob<Grob> (scm_car (s)))
out = scm_cons (g->get_property ("footnote-stencil"), out);
- else if (Prob *p = Prob::unsmob (scm_car (s)))
+ else if (Prob *p = unsmob<Prob> (scm_car (s)))
out = scm_cons (p->get_property ("footnote-stencil"), out);
else
programming_error ("Systems on a page must be a prob or grob.");
}
SCM markup = scm_call_1 (numbering_function, scm_from_int (counter));
SCM stencil = Text_interface::interpret_markup (layout, props, markup);
- Stencil *st = Stencil::unsmob (stencil);
+ Stencil *st = unsmob<Stencil> (stencil);
if (!st)
{
programming_error ("Your numbering function needs to return a stencil.");
markup = SCM_EOL;
stencil = Stencil (Box (Interval (0, 0), Interval (0, 0)), SCM_EOL).smobbed_copy ();
- st = Stencil::unsmob (stencil);
+ st = unsmob<Stencil> (stencil);
}
in_text_numbers = scm_cons (markup, in_text_numbers);
numbers = scm_cons (stencil, numbers);
for (SCM p = numbers; scm_is_pair (p); p = scm_cdr (p))
{
- Stencil *st = Stencil::unsmob (scm_car (p));
+ Stencil *st = unsmob<Stencil> (scm_car (p));
if (!st->extent (X_AXIS).is_empty ())
st->translate_axis ((max_length - st->extent (X_AXIS)[RIGHT]),
X_AXIS);
for (SCM s = lines; scm_is_pair (s); s = scm_cdr (s))
{
// Take care of musical systems.
- if (Grob *g = Grob::unsmob (scm_car (s)))
+ if (Grob *g = unsmob<Grob> (scm_car (s)))
{
System *sys = dynamic_cast<System *> (g);
if (!sys)
SCM footnote_stl = Text_interface::interpret_markup (paper->self_scm (),
props, footnote_markup);
- Stencil footnote_stencil = *Stencil::unsmob (footnote_stl);
+ Stencil footnote_stencil = *unsmob<Stencil> (footnote_stl);
bool do_numbering = to_boolean (footnote->get_property ("automatically-numbered"));
if (Spanner *orig = dynamic_cast<Spanner *>(footnote))
{
orig->broken_intos_[i]->set_property ("text", annotation_scm);
}
- Stencil annotation = *Stencil::unsmob (scm_car (numbers));
+ Stencil annotation = *unsmob<Stencil> (scm_car (numbers));
annotation.translate_axis ((footnote_stencil.extent (Y_AXIS)[UP]
+ number_raise
- annotation.extent (Y_AXIS)[UP]),
sys->set_property ("footnote-stencil", mol.smobbed_copy ());
}
// Take care of top-level markups
- else if (Prob *p = Prob::unsmob (scm_car (s)))
+ else if (Prob *p = unsmob<Prob> (scm_car (s)))
{
SCM stencils = p->get_property ("footnotes");
Stencil mol;
for (SCM st = stencils; scm_is_pair (st); st = scm_cdr (st))
{
- Stencil footnote_stencil = *Stencil::unsmob (scm_caddar (st));
+ Stencil footnote_stencil = *unsmob<Stencil> (scm_caddar (st));
bool do_numbering = to_boolean (scm_cadar (st));
SCM in_text_stencil = Stencil ().smobbed_copy ();
if (do_numbering)
{
- Stencil annotation = *Stencil::unsmob (scm_car (numbers));
+ Stencil annotation = *unsmob<Stencil> (scm_car (numbers));
SCM in_text_annotation = scm_car (in_text_numbers);
in_text_stencil = Text_interface::interpret_markup (layout,
props,
in_text_annotation);
- if (!Stencil::is_smob (in_text_stencil))
+ if (!unsmob<Stencil> (in_text_stencil))
in_text_stencil = SCM_EOL;
annotation.translate_axis ((footnote_stencil.extent (Y_AXIS)[UP]
+ number_raise
SCM footnote_stencil = Text_interface::interpret_markup (paper->self_scm (),
props, markup);
- Stencil *footnote_separator = Stencil::unsmob (footnote_stencil);
+ Stencil *footnote_separator = unsmob<Stencil> (footnote_stencil);
return footnote_separator ? *footnote_separator : Stencil ();
}
for (SCM s = footnotes; scm_is_pair (s); s = scm_cdr (s))
{
- Stencil *stencil = Stencil::unsmob (scm_car (s));
+ Stencil *stencil = unsmob<Stencil> (scm_car (s));
if (!stencil)
continue;
Page_layout_problem::Page_layout_problem (Paper_book *pb, SCM page_scm, SCM systems)
: bottom_skyline_ (DOWN)
{
- Prob *page = Prob::unsmob (page_scm);
+ Prob *page = unsmob<Prob> (page_scm);
bottom_loose_baseline_ = 0;
header_height_ = 0;
footer_height_ = 0;
if (page)
{
- Stencil *head = Stencil::unsmob (page->get_property ("head-stencil"));
- Stencil *foot = Stencil::unsmob (page->get_property ("foot-stencil"));
+ Stencil *head = unsmob<Stencil> (page->get_property ("head-stencil"));
+ Stencil *foot = unsmob<Stencil> (page->get_property ("foot-stencil"));
Stencil foot_stencil = foot ? *foot : Stencil ();
markup_markup_spacing = paper->c_variable ("markup-markup-spacing");
last_bottom_spacing = paper->c_variable ("last-bottom-spacing");
top_system_spacing = paper->c_variable ("top-system-spacing");
- if (scm_is_pair (systems) && Prob::is_smob (scm_car (systems)))
+ if (scm_is_pair (systems) && unsmob<Prob> (scm_car (systems)))
top_system_spacing = paper->c_variable ("top-markup-spacing");
// Note: the page height here does _not_ reserve space for headers and
{
bool first = (s == systems);
- if (Grob *g = Grob::unsmob (scm_car (s)))
+ if (Grob *g = unsmob<Grob> (scm_car (s)))
{
System *sys = dynamic_cast<System *> (g);
if (!sys)
append_system (sys, spring, indent, padding);
last_system_was_title = false;
}
- else if (Prob *p = Prob::unsmob (scm_car (s)))
+ else if (Prob *p = unsmob<Prob> (scm_car (s)))
{
SCM spec = first ? top_system_spacing
: (last_system_was_title ? markup_markup_spacing : score_markup_spacing);
void
Page_layout_problem::append_system (System *sys, Spring const &spring, Real indent, Real padding)
{
- Grob *align = Grob::unsmob (sys->get_object ("vertical-alignment"));
+ Grob *align = unsmob<Grob> (sys->get_object ("vertical-alignment"));
if (!align)
return;
build_system_skyline (elts, minimum_offsets_with_min_dist, &up_skyline, &down_skyline);
up_skyline.shift (indent);
down_skyline.shift (indent);
- Stencil *in_note_stencil = Stencil::unsmob (sys->get_property ("in-note-stencil"));
+ Stencil *in_note_stencil = unsmob<Stencil> (sys->get_property ("in-note-stencil"));
if (in_note_stencil && in_note_stencil->extent (Y_AXIS).length () > 0)
{
// store the minimum distance, considering relative indents,
// for a loose line
Skyline first_skyline (UP);
- Skyline_pair *sky = Skyline_pair::unsmob (elts[0]->get_property ("vertical-skylines"));
+ Skyline_pair *sky = unsmob<Skyline_pair> (elts[0]->get_property ("vertical-skylines"));
if (sky)
first_skyline.merge ((*sky)[UP]);
first_skyline.shift (indent);
void
Page_layout_problem::append_prob (Prob *prob, Spring const &spring, Real padding)
{
- Skyline_pair *sky = Skyline_pair::unsmob (prob->get_property ("vertical-skylines"));
+ Skyline_pair *sky = unsmob<Skyline_pair> (prob->get_property ("vertical-skylines"));
Real minimum_distance = 0;
bool tight_spacing = to_boolean (prob->get_property ("tight-spacing"));
bottom_loose_baseline_);
bottom_skyline_ = (*sky)[DOWN];
}
- else if (Stencil *sten = Stencil::unsmob (prob->get_property ("stencil")))
+ else if (Stencil *sten = unsmob<Stencil> (prob->get_property ("stencil")))
{
Interval iv = sten->extent (Y_AXIS);
minimum_distance = iv[UP] - bottom_skyline_.max_height ();
{
*tail = scm_cons (scm_from_double (solution_[spring_idx]), SCM_EOL);
tail = SCM_CDRLOC (*tail);
- Interval prob_extent = Stencil::unsmob (elements_[i].prob->get_property ("stencil"))->extent (Y_AXIS);
+ Interval prob_extent = unsmob<Stencil> (elements_[i].prob->get_property ("stencil"))->extent (Y_AXIS);
// Lay out any non-spaceable lines between this line and
// the last one.
{
Real dy = minimum_translations[i] - first_translation;
Grob *g = staves[i];
- Skyline_pair *sky = Skyline_pair::unsmob (g->get_property ("vertical-skylines"));
+ Skyline_pair *sky = unsmob<Skyline_pair> (g->get_property ("vertical-skylines"));
if (sky)
{
up->raise (-dy);
Interval
Page_layout_problem::prob_extent (Prob *p)
{
- Stencil *sten = Stencil::unsmob (p->get_property ("stencil"));
+ Stencil *sten = unsmob<Stencil> (p->get_property ("stencil"));
return sten ? sten->extent (Y_AXIS) : Interval (0, 0);
}
Stream_event *cause = gi.event_cause ();
Duration *dur_ptr = cause
- ? Duration::unsmob (cause->get_property ("duration"))
+ ? unsmob<Duration> (cause->get_property ("duration"))
: 0;
if (!dur_ptr)
void
Page_turn_engraver::stop_translation_timestep ()
{
- Grob *pc = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *pc = unsmob<Grob> (get_property ("currentCommandColumn"));
if (pc)
{
{
Rational now = now_mom ().main_part_;
Real pen = penalty ((now_mom () - rest_begin_).main_part_ + repeat_begin_rest_length_);
- Moment *m = Moment::unsmob (get_property ("minimumRepeatLengthForPageTurn"));
+ Moment *m = unsmob<Moment> (get_property ("minimumRepeatLengthForPageTurn"));
if (m && *m > (now_mom () - repeat_begin_))
pen = infinity_f;
(SCM f),
"Is @var{f} a pango font?")
{
- return scm_from_bool (
derived_unsmob<Pango_font> (f));
+ return scm_from_bool (unsmob<Pango_font> (f));
}
LY_DEFINE (ly_pango_font_physical_fonts, "ly:pango-font-physical-fonts",
"Return alist of @code{(ps-name file-name font-index)} lists"
" for Pango font@tie{}@var{f}.")
{
- Pango_font *pf =
derived_unsmob<Pango_font> (f);
+ Pango_font *pf = unsmob<Pango_font> (f);
SCM alist = SCM_EOL;
if (pf)
"Return pages in @code{Paper_book} object @var{pb}.")
{
LY_ASSERT_SMOB (Paper_book, pb, 1);
- return Paper_book::unsmob (pb)->pages ();
+ return unsmob<Paper_book> (pb)->pages ();
}
LY_DEFINE (ly_paper_book_scopes, "ly:paper-book-scopes",
"Return scopes in @code{Paper_book} object @var{pb}.")
{
LY_ASSERT_SMOB (Paper_book, pb, 1);
- Paper_book *book = Paper_book::unsmob (pb);
+ Paper_book *book = unsmob<Paper_book> (pb);
SCM scopes = SCM_EOL;
if (book->parent_)
"Return performances in @code{Paper_book} object @var{pb}.")
{
LY_ASSERT_SMOB (Paper_book, pb, 1);
- return Paper_book::unsmob (pb)->performances ();
+ return unsmob<Paper_book> (pb)->performances ();
}
LY_DEFINE (ly_paper_book_systems, "ly:paper-book-systems",
"Return systems in @code{Paper_book} object @var{pb}.")
{
LY_ASSERT_SMOB (Paper_book, pb, 1);
- return Paper_book::unsmob (pb)->systems ();
+ return unsmob<Paper_book> (pb)->systems ();
}
LY_DEFINE (ly_paper_book_paper, "ly:paper-book-paper",
" in @code{Paper_book} object @var{pb}.")
{
LY_ASSERT_SMOB (Paper_book, pb, 1);
- Paper_book *pbook = Paper_book::unsmob (pb);
+ Paper_book *pbook = unsmob<Paper_book> (pb);
return pbook->paper_->self_scm ();
}
" in @code{Paper_book} object @var{pb}.")
{
LY_ASSERT_SMOB (Paper_book, pb, 1);
- Paper_book *pbook = Paper_book::unsmob (pb);
+ Paper_book *pbook = unsmob<Paper_book> (pb);
return pbook->header_;
}
if (scm_is_pair (bookparts_))
{
for (SCM p = bookparts_; scm_is_pair (p); p = scm_cdr (p))
- if (Paper_book *pbookpart = Paper_book::unsmob (scm_car (p)))
+ if (Paper_book *pbookpart = unsmob<Paper_book> (scm_car (p)))
{
bool is_last_part = (is_last && !scm_is_pair (scm_cdr (p)));
page_nb += pbookpart->output_aux (output_channel,
paper_->self_scm (),
scopes);
- if (Stencil::is_smob (tit))
- title = *Stencil::unsmob (tit);
+ if (unsmob<Stencil> (tit))
+ title = *unsmob<Stencil> (tit);
if (!title.is_empty ())
title.align_to (Y_AXIS, UP);
paper_->self_scm (),
scopes);
- if (Stencil::is_smob (tit))
- title = *Stencil::unsmob (tit);
+ if (unsmob<Stencil> (tit))
+ title = *unsmob<Stencil> (tit);
if (!title.is_empty ())
title.align_to (Y_AXIS, UP);
void
set_page_permission (SCM sys, SCM symbol, SCM permission)
{
- if (Paper_score *ps = Paper_score::unsmob (sys))
+ if (Paper_score *ps = unsmob<Paper_score> (sys))
{
vector<Grob *> cols = ps->get_columns ();
if (cols.size ())
col->find_prebroken_piece (LEFT)->set_property (symbol, permission);
}
}
- else if (Prob *pb = Prob::unsmob (sys))
+ else if (Prob *pb = unsmob<Prob> (sys))
pb->set_property (symbol, permission);
}
void
set_labels (SCM sys, SCM labels)
{
- if (Paper_score *ps = Paper_score::unsmob (sys))
+ if (Paper_score *ps = unsmob<Paper_score> (sys))
{
vector<Grob *> cols = ps->get_columns ();
if (cols.size ())
labels)));
}
}
- else if (Prob *pb = Prob::unsmob (sys))
+ else if (Prob *pb = unsmob<Prob> (sys))
pb->set_property ("labels",
scm_append_x (scm_list_2 (pb->get_property ("labels"),
labels)));
if (scm_is_null (header_0_))
header_0_ = header;
}
- else if (Page_marker *page_marker = Page_marker::unsmob (scm_car (s)))
+ else if (Page_marker *page_marker = unsmob<Page_marker> (scm_car (s)))
{
/* page markers are used to set page breaking/turning permission,
or to place bookmarking labels */
labels = scm_cons (page_marker->label (), labels);
}
}
- else if (Music_output *mop = Music_output::unsmob (scm_car (s)))
+ else if (Music_output *mop = unsmob<Music_output> (scm_car (s)))
{
if (Paper_score *pscore = dynamic_cast<Paper_score *> (mop))
{
if (scm_is_pair (system_specs))
set_system_penalty (scm_car (system_specs), header);
- if (Prob::is_smob (title))
+ if (unsmob<Prob> (title))
{
system_specs = scm_cons (title, system_specs);
- Prob::unsmob (title)->unprotect ();
+ unsmob<Prob> (title)->unprotect ();
}
header = SCM_EOL;
ps->set_property ("last-markup-line", SCM_BOOL_F);
ps->set_property ("first-markup-line", SCM_BOOL_F);
- paper_system_set_stencil (ps, *Stencil::unsmob (t));
+ paper_system_set_stencil (ps, *unsmob<Stencil> (t));
- SCM footnotes = get_footnotes (Stencil::unsmob (t)->expr ());
+ SCM footnotes = get_footnotes (unsmob<Stencil> (t)->expr ());
ps->set_property ("footnotes", footnotes);
ps->set_property ("is-title", SCM_BOOL_T);
if (list == texts)
{
SCM system_list = SCM_EOL;
for (SCM p = bookparts_; scm_is_pair (p); p = scm_cdr (p))
- if (Paper_book *pbookpart = Paper_book::unsmob (scm_car (p)))
+ if (Paper_book *pbookpart = unsmob<Paper_book> (scm_car (p)))
system_list = scm_cons (pbookpart->systems (), system_list);
systems_ = scm_append (scm_reverse_x (system_list, SCM_EOL));
}
for (SCM s = specs; scm_is_pair (s); s = scm_cdr (s))
{
if (Paper_score * pscore
- = Paper_score::unsmob (scm_car (s)))
+ = unsmob<Paper_score> (scm_car (s)))
{
SCM system_list
= scm_vector_to_list (pscore->get_paper_systems ());
Prob *last = 0;
for (SCM s = systems_; scm_is_pair (s); s = scm_cdr (s))
{
- Prob *ps = Prob::unsmob (scm_car (s));
+ Prob *ps = unsmob<Prob> (scm_car (s));
ps->set_property ("number", scm_from_int (++i));
if (last
if (scm_is_pair (scm_cdr (s)))
{
SCM perm = ps->get_property ("page-break-permission");
- Prob *next = Prob::unsmob (scm_cadr (s));
+ Prob *next = unsmob<Prob> (scm_cadr (s));
if (scm_is_null (perm))
next->set_property ("penalty", scm_from_int (10001));
else if (scm_is_eq (perm, ly_symbol2scm ("force")))
if (scm_is_pair (bookparts_))
{
for (SCM p = bookparts_; scm_is_pair (p); p = scm_cdr (p))
- if (Paper_book *pbookpart = Paper_book::unsmob (scm_car (p)))
+ if (Paper_book *pbookpart = unsmob<Paper_book> (scm_car (p)))
pages_ = scm_cons (pbookpart->pages (), pages_);
pages_ = scm_append (scm_reverse_x (pages_, SCM_EOL));
}
systems_ = SCM_EOL;
for (SCM p = pages_; scm_is_pair (p); p = scm_cdr (p))
{
- Prob *page = Prob::unsmob (scm_car (p));
+ Prob *page = unsmob<Prob> (scm_car (p));
SCM systems = page->get_property ("lines");
systems_ = scm_cons (systems, systems_);
}
void
Paper_column_engraver::initialize ()
{
- system_ = derived_unsmob<System> (get_property ("rootSystem"));
+ system_ = unsmob<System> (get_property ("rootSystem"));
make_columns ();
system_->set_bound (LEFT, command_column_);
if (start_of_measure)
{
Moment mlen = Moment (measure_length (context ()));
- Grob *column = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *column = unsmob<Grob> (get_property ("currentCommandColumn"));
if (column)
column->set_property ("measure-length", mlen.smobbed_copy ());
else
if (!elem->get_parent (X_AXIS))
elem->set_parent (col, X_AXIS);
- if (!Grob::is_smob (elem->get_object ("axis-group-parent-X")))
+ if (!unsmob<Grob> (elem->get_object ("axis-group-parent-X")))
elem->set_object ("axis-group-parent-X", col->self_scm ());
if (Accidental_placement::has_interface (elem)
SCM mpos = get_property ("measurePosition");
SCM barnum = get_property ("internalBarNumber");
- if (Moment::is_smob (mpos)
+ if (unsmob<Moment> (mpos)
&& scm_is_integer (barnum))
{
SCM where = scm_cons (barnum,
Paper_column::when_mom (Grob *me)
{
SCM m = me->get_property ("when");
- if (Moment *when = Moment::unsmob (m))
+ if (Moment *when = unsmob<Moment> (m))
return *when;
return Moment (0);
}
{
SCM m = me->get_property ("shortest-starter-duration");
Moment s (0);
- if (Moment::unsmob (m))
- s = *Moment::unsmob (m);
+ if (unsmob<Moment> (m))
+ s = *unsmob<Moment> (m);
return s != Moment (0);
}
for (LEFT_and_RIGHT (d))
{
- Skyline_pair *sp = Skyline_pair::unsmob (cols[d]->get_property ("horizontal-skylines"));
+ Skyline_pair *sp = unsmob<Skyline_pair> (cols[d]->get_property ("horizontal-skylines"));
if (sp)
skys[d] = (*sp)[-d];
}
SCM
Paper_column::print (SCM p)
{
- Paper_column *me =
derived_unsmob<Paper_column> (p);
+ Paper_column *me = unsmob<Paper_column> (p);
string r = ::to_string (Paper_column::get_rank (me));
- Moment *mom = Moment::unsmob (me->get_property ("when"));
+ Moment *mom = unsmob<Moment> (me->get_property ("when"));
string when = mom ? mom->to_string () : "?/?";
Font_metric *musfont = Font_interface::get_default_font (me);
SCM when_mol = Text_interface::interpret_markup (me->layout ()->self_scm (),
properties,
ly_string2scm (when));
- Stencil t = *Stencil::unsmob (scm_mol);
+ Stencil t = *unsmob<Stencil> (scm_mol);
t.scale (1.2, 1.4);
- t.add_at_edge (Y_AXIS, DOWN, *Stencil::unsmob (when_mol), 0.1);
+ t.add_at_edge (Y_AXIS, DOWN, *unsmob<Stencil> (when_mol), 0.1);
t.align_to (X_AXIS, LEFT);
// compensate for font serifs and half letter-distance
t.translate (Offset (-0.1, 0));
for (SCM s = me->get_object ("ideal-distances");
scm_is_pair (s); s = scm_cdr (s))
{
- Spring *sp = Spring::unsmob (scm_caar (s));
- if (!Grob::is_smob (scm_cdar (s))
- || !Grob::unsmob (scm_cdar (s))->get_system ())
+ Spring *sp = unsmob<Spring> (scm_caar (s));
+ if (!unsmob<Grob> (scm_cdar (s))
+ || !unsmob<Grob> (scm_cdar (s))->get_system ())
continue;
j++;
SCM stil = Text_interface::interpret_markup (me->layout ()->self_scm (),
properties,
ly_string2scm (String_convert::form_string ("%5.2lf", sp->distance ())));
- Stencil *number_stc = Stencil::unsmob (stil);
+ Stencil *number_stc = unsmob<Stencil> (stil);
number_stc->scale (1, 1.1);
Real num_height = number_stc->extent (Y_AXIS).length ();
Real num_len = number_stc->extent (X_AXIS).length ();
scm_is_pair (s); s = scm_cdr (s))
{
Real dist = scm_to_double (scm_cdar (s));
- Grob *other = Grob::unsmob (scm_caar (s));
+ Grob *other = unsmob<Grob> (scm_caar (s));
if (!other || other->get_system () != me->get_system ())
continue;
SCM stil = Text_interface::interpret_markup (me->layout ()->self_scm (),
properties,
ly_string2scm (String_convert::form_string ("%5.2lf", dist)));
- Stencil *number_stc = Stencil::unsmob (stil);
+ Stencil *number_stc = unsmob<Stencil> (stil);
number_stc->scale (1, 1.1);
Real num_height = number_stc->extent (Y_AXIS).length ();
Real num_len = number_stc->extent (X_AXIS).length ();
SCM
Paper_column::before_line_breaking (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
SCM bbm = me->get_object ("bounded-by-me");
- Grob_array *ga = Grob_array::unsmob (bbm);
+ Grob_array *ga = unsmob<Grob_array> (bbm);
if (!ga)
return SCM_UNSPECIFIED;
SCM sizes = scm_hashq_ref (font_table, f->self_scm (), SCM_EOL);
SCM handle = scm_assoc (scm_from_double (lookup_mag), sizes);
if (scm_is_pair (handle))
- return Font_metric::unsmob (scm_cdr (handle));
+ return unsmob<Font_metric> (scm_cdr (handle));
SCM val = Modified_font_metric::make_scaled_font_metric (f, lookup_mag);
sizes = scm_acons (scm_from_double (lookup_mag), val, sizes);
- Font_metric::unsmob (val)->unprotect ();
+ unsmob<Font_metric> (val)->unprotect ();
scm_hashq_set_x (font_table, f->self_scm (), sizes);
- return Font_metric::unsmob (val);
+ return unsmob<Font_metric> (val);
}
Font_metric *
SCM size_key = scm_from_double (factor);
SCM handle = scm_assoc (size_key, sizes);
if (scm_is_pair (handle))
- return Font_metric::unsmob (scm_cdr (handle));
+ return unsmob<Font_metric> (scm_cdr (handle));
PangoFontDescription *description
= pango_font_description_from_string (scm_i_string_chars (descr));
SCM proc = ly_lily_module_constant ("scale-layout");
SCM new_pap = scm_call_2 (proc, o->self_scm (), scm_from_double (amount));
- o = Output_def::unsmob (new_pap);
+ o = unsmob<Output_def> (new_pap);
o->protect ();
return o;
}
LY_ASSERT_SMOB (Paper_outputter, outputter, 1);
LY_ASSERT_SMOB (Stencil, stencil, 2);
- Paper_outputter *po = Paper_outputter::unsmob (outputter);
- Stencil *st = Stencil::unsmob (stencil);
+ Paper_outputter *po = unsmob<Paper_outputter> (outputter);
+ Stencil *st = unsmob<Stencil> (stencil);
po->output_stencil (*st);
return SCM_UNSPECIFIED;
LY_ASSERT_SMOB (Paper_outputter, outputter, 1);
LY_ASSERT_TYPE (scm_is_string, str, 2);
- Paper_outputter *po = Paper_outputter::unsmob (outputter);
+ Paper_outputter *po = unsmob<Paper_outputter> (outputter);
return po->dump_string (str);
}
"Return output port for @var{outputter}.")
{
LY_ASSERT_SMOB (Paper_outputter, outputter, 1);
- Paper_outputter *po = Paper_outputter::unsmob (outputter);
+ Paper_outputter *po = unsmob<Paper_outputter> (outputter);
return po->file ();
}
"Close port of @var{outputter}.")
{
LY_ASSERT_SMOB (Paper_outputter, outputter, 1);
- Paper_outputter *po = Paper_outputter::unsmob (outputter);
+ Paper_outputter *po = unsmob<Paper_outputter> (outputter);
po->close ();
return SCM_UNSPECIFIED;
"Eval @var{expr} in module of @var{outputter}.")
{
LY_ASSERT_SMOB (Paper_outputter, outputter, 1);
- Paper_outputter *po = Paper_outputter::unsmob (outputter);
+ Paper_outputter *po = unsmob<Paper_outputter> (outputter);
po->output_scheme (expr);
{
LY_ASSERT_SMOB (Paper_outputter, outputter, 1);
- Paper_outputter *po = Paper_outputter::unsmob (outputter);
+ Paper_outputter *po = unsmob<Paper_outputter> (outputter);
return po->module ();
}
{
LY_ASSERT_SMOB (Paper_score, paper_score, 1);
- Paper_score *pscore = Paper_score::unsmob (paper_score);
+ Paper_score *pscore = unsmob<Paper_score> (paper_score);
return pscore->get_paper_systems ();
}
" their extents otherwise.")
{
Real ret = 0;
- Prob *p1 = Prob::unsmob (sys1);
- Prob *p2 = Prob::unsmob (sys2);
- Skyline_pair *sky1 = Skyline_pair::unsmob (p1->get_property ("vertical-skylines"));
- Skyline_pair *sky2 = Skyline_pair::unsmob (p2->get_property ("vertical-skylines"));
+ Prob *p1 = unsmob<Prob> (sys1);
+ Prob *p2 = unsmob<Prob> (sys2);
+ Skyline_pair *sky1 = unsmob<Skyline_pair> (p1->get_property ("vertical-skylines"));
+ Skyline_pair *sky2 = unsmob<Skyline_pair> (p2->get_property ("vertical-skylines"));
if (sky1 && sky2)
ret = (*sky1)[DOWN].distance ((*sky2)[UP]);
else
{
- Stencil *s1 = Stencil::unsmob (p1->get_property ("stencil"));
- Stencil *s2 = Stencil::unsmob (p2->get_property ("stencil"));
+ Stencil *s1 = unsmob<Stencil> (p1->get_property ("stencil"));
+ Stencil *s2 = unsmob<Stencil> (p2->get_property ("stencil"));
Interval iv1 = s1->extent (Y_AXIS);
Interval iv2 = s2->extent (Y_AXIS);
ret = iv2[UP] - iv1[DOWN];
}
| BOOK_IDENTIFIER {
SCM proc = parser->lexer_->lookup_identifier
- (Book::unsmob($1)->paper_
+ (unsmob<Book>($1)->paper_
? "toplevel-book-handler"
: "toplevel-bookpart-handler");
scm_call_2 (proc, parser->self_scm (), $1);
{
SCM proc = parser->lexer_->lookup_identifier ("toplevel-text-handler");
scm_call_2 (proc, parser->self_scm (), out);
- } else if (Score::is_smob ($1))
+ } else if (unsmob<Score> ($1))
{
SCM proc = parser->lexer_->lookup_identifier ("toplevel-score-handler");
scm_call_2 (proc, parser->self_scm (), $1);
- } else if (Output_def * od = Output_def::unsmob ($1)) {
+ } else if (Output_def * od = unsmob<Output_def> ($1)) {
SCM id = SCM_EOL;
if (to_boolean (od->c_variable ("is-paper")))
}
| output_def {
SCM id = SCM_EOL;
- Output_def * od = Output_def::unsmob ($1);
+ Output_def * od = unsmob<Output_def> ($1);
if (to_boolean (od->c_variable ("is-paper")))
id = ly_symbol2scm ("$defaultpaper");
| post_event post_events
{
$$ = scm_reverse_x ($2, SCM_EOL);
- if (Music *m = Music::unsmob ($1))
+ if (Music *m = unsmob<Music> ($1))
{
if (m->is_mus_type ("post-event-wrapper"))
$$ = scm_append
| multiplied_duration
| music_embedded music_embedded music_list {
$3 = scm_reverse_x ($3, SCM_EOL);
- if (Music::is_smob ($2))
+ if (unsmob<Music> ($2))
$3 = scm_cons ($2, $3);
- if (Music::is_smob ($1))
+ if (unsmob<Music> ($1))
$3 = scm_cons ($1, $3);
$$ = MAKE_SYNTAX ("sequential-music", @$, $3);
}
| post_event_nofinger post_events
{
$$ = scm_reverse_x ($2, SCM_EOL);
- if (Music *m = Music::unsmob ($1))
+ if (Music *m = unsmob<Music> ($1))
{
if (m->is_mus_type ("post-event-wrapper"))
$$ = scm_append
CONTEXT '{' context_def_spec_body '}'
{
$$ = $3;
- Context_def *td = Context_def::unsmob ($$);
+ Context_def *td = unsmob<Context_def> ($$);
if (!td) {
$$ = Context_def::make_scm ();
- td = Context_def::unsmob ($$);
+ td = unsmob<Context_def> ($$);
}
td->origin ()->set_spot (@$);
}
}
| context_def_spec_body context_mod {
if (!SCM_UNBNDP ($2)) {
- Context_def *td = Context_def::unsmob ($$);
+ Context_def *td = unsmob<Context_def> ($$);
if (!td) {
$$ = Context_def::make_scm ();
- td = Context_def::unsmob ($$);
+ td = unsmob<Context_def> ($$);
}
- Context_def::unsmob ($$)->add_context_mod ($2);
+ unsmob<Context_def> ($$)->add_context_mod ($2);
}
}
| context_def_spec_body context_modification {
- Context_def *td = Context_def::unsmob ($$);
+ Context_def *td = unsmob<Context_def> ($$);
if (!td) {
$$ = Context_def::make_scm ();
- td = Context_def::unsmob ($$);
+ td = unsmob<Context_def> ($$);
}
- SCM new_mods = Context_mod::unsmob ($2)->get_mods ();
+ SCM new_mods = unsmob<Context_mod> ($2)->get_mods ();
for (SCM m = new_mods; scm_is_pair (m); m = scm_cdr (m)) {
td->add_context_mod (scm_car (m));
}
}
| context_def_spec_body context_mod_arg {
- Context_def *td = Context_def::unsmob ($1);
+ Context_def *td = unsmob<Context_def> ($1);
if (scm_is_eq ($2, SCM_UNSPECIFIED))
;
- else if (!td && Context_def::unsmob ($2))
+ else if (!td && unsmob<Context_def> ($2))
$$ = $2;
else {
if (!td) {
$$ = Context_def::make_scm ();
- td = Context_def::unsmob ($$);
+ td = unsmob<Context_def> ($$);
}
- if (Music::is_smob ($2)) {
+ if (unsmob<Music> ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
$2 = scm_call_2 (proc, parser->self_scm (), $2);
}
- if (Context_mod *cm = Context_mod::unsmob ($2)) {
+ if (Context_mod *cm = unsmob<Context_mod> ($2)) {
for (SCM m = cm->get_mods (); scm_is_pair (m); m = scm_cdr (m)) {
td->add_context_mod (scm_car (m));
}
book_block:
BOOK '{' book_body '}' {
$$ = $3;
- Book::unsmob ($$)->origin ()->set_spot (@$);
+ unsmob<Book> ($$)->origin ()->set_spot (@$);
pop_paper (parser);
parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), SCM_BOOL_F);
}
{
Book *book = new Book;
init_papers (parser);
- book->paper_ = dynamic_cast<Output_def*> (Output_def::unsmob (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ());
+ book->paper_ = dynamic_cast<Output_def*> (unsmob<Output_def> (parser->lexer_->lookup_identifier ("$defaultpaper"))->clone ());
book->paper_->unprotect ();
push_paper (parser, book->paper_);
book->header_ = get_header (parser);
parser->lexer_->set_identifier (ly_symbol2scm ("$current-book"), $1);
}
| book_body paper_block {
- Book::unsmob ($1)->paper_ = Output_def::unsmob ($2);
- set_paper (parser, Output_def::unsmob ($2));
+ unsmob<Book> ($1)->paper_ = unsmob<Output_def> ($2);
+ set_paper (parser, unsmob<Output_def> ($2));
}
| book_body bookpart_block {
SCM proc = parser->lexer_->lookup_identifier ("book-bookpart-handler");
{
SCM proc = parser->lexer_->lookup_identifier ("book-text-handler");
scm_call_2 (proc, $1, out);
- } else if (Score::is_smob ($2))
+ } else if (unsmob<Score> ($2))
{
SCM proc = parser->lexer_->lookup_identifier ("book-score-handler");
scm_call_2 (proc, $1, $2);
- } else if (Output_def *od = Output_def::unsmob ($2)) {
+ } else if (Output_def *od = unsmob<Output_def> ($2)) {
SCM id = SCM_EOL;
if (to_boolean (od->c_variable ("is-paper")))
}
| book_body
{
- parser->lexer_->add_scope (Book::unsmob ($1)->header_);
+ parser->lexer_->add_scope (unsmob<Book> ($1)->header_);
} lilypond_header
| book_body error {
- Book *book = Book::unsmob ($1);
+ Book *book = unsmob<Book> ($1);
book->paper_ = 0;
book->scores_ = SCM_EOL;
book->bookparts_ = SCM_EOL;
bookpart_block:
BOOKPART '{' bookpart_body '}' {
$$ = $3;
- Book::unsmob ($$)->origin ()->set_spot (@$);
+ unsmob<Book> ($$)->origin ()->set_spot (@$);
parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), SCM_BOOL_F);
}
;
parser->lexer_->set_identifier (ly_symbol2scm ("$current-bookpart"), $1);
}
| bookpart_body paper_block {
- Book::unsmob ($$)->paper_ = Output_def::unsmob ($2);
+ unsmob<Book> ($$)->paper_ = unsmob<Output_def> ($2);
}
| bookpart_body score_block {
SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
{
SCM proc = parser->lexer_->lookup_identifier ("bookpart-text-handler");
scm_call_2 (proc, $1, out);
- } else if (Score::is_smob ($2))
+ } else if (unsmob<Score> ($2))
{
SCM proc = parser->lexer_->lookup_identifier ("bookpart-score-handler");
scm_call_2 (proc, $1, $2);
- } else if (Output_def *od = Output_def::unsmob ($2)) {
+ } else if (Output_def *od = unsmob<Output_def> ($2)) {
SCM id = SCM_EOL;
if (to_boolean (od->c_variable ("is-paper")))
}
| bookpart_body
{
- Book *book = Book::unsmob ($1);
+ Book *book = unsmob<Book> ($1);
if (!ly_is_module (book->header_))
book->header_ = ly_make_module (false);
parser->lexer_->add_scope (book->header_);
} lilypond_header
| bookpart_body error {
- Book *book = Book::unsmob ($1);
+ Book *book = unsmob<Book> ($1);
book->paper_ = 0;
book->scores_ = SCM_EOL;
}
score_block:
SCORE '{' score_body '}' {
- Score::unsmob ($3)->origin ()->set_spot (@$);
+ unsmob<Score> ($3)->origin ()->set_spot (@$);
$$ = $3;
}
;
score_body:
score_items {
- if (!Score::is_smob ($1)) {
+ if (!unsmob<Score> ($1)) {
parser->parser_error (@1, _("Missing music in \\score"));
$$ = (new Score)->unprotect ();
if (scm_is_pair ($1) && ly_is_module (scm_car ($1)))
{
- Score::unsmob ($$)->set_header (scm_car ($1));
+ unsmob<Score> ($$)->set_header (scm_car ($1));
$1 = scm_cdr ($1);
}
for (SCM p = scm_reverse_x ($1, SCM_EOL);
scm_is_pair (p); p = scm_cdr (p))
{
- Score::unsmob ($$)->
- add_output_def (Output_def::unsmob (scm_car (p)));
+ unsmob<Score> ($$)->
+ add_output_def (unsmob<Output_def> (scm_car (p)));
}
}
}
| score_body error {
- Score::unsmob ($$)->error_found_ = true;
+ unsmob<Score> ($$)->error_found_ = true;
}
;
}
| score_items score_item
{
- Output_def *od = Output_def::unsmob ($2);
+ Output_def *od = unsmob<Output_def> ($2);
if (od) {
if (to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper"))))
{
od = 0;
$2 = SCM_UNSPECIFIED;
}
- } else if (!Score::is_smob ($$)) {
- if (Music::is_smob ($2)) {
+ } else if (!unsmob<Score> ($$)) {
+ if (unsmob<Music> ($2)) {
SCM scorify = ly_lily_module_constant ("scorify-music");
$2 = scm_call_2 (scorify, $2, parser->self_scm ());
}
- if (Score::is_smob ($2))
+ if (unsmob<Score> ($2))
{
$$ = $2;
$2 = SCM_UNSPECIFIED;
}
}
- Score *score = Score::unsmob ($$);
+ Score *score = unsmob<Score> ($$);
if (score && scm_is_pair ($1)) {
if (ly_is_module (scm_car ($1)))
{
for (SCM p = scm_reverse_x ($1, SCM_EOL);
scm_is_pair (p); p = scm_cdr (p))
{
- score->add_output_def (Output_def::unsmob (scm_car (p)));
+ score->add_output_def (unsmob<Output_def> (scm_car (p)));
}
}
if (od) {
}
| score_items
{
- if (Score *score = Score::unsmob ($1)) {
+ if (Score *score = unsmob<Score> ($1)) {
if (!ly_is_module (score->get_header ()))
score->set_header (ly_make_module (false));
parser->lexer_->add_scope (score->get_header ());
paper_block:
output_def {
- Output_def *od = Output_def::unsmob ($1);
+ Output_def *od = unsmob<Output_def> ($1);
if (!to_boolean (od->lookup_variable (ly_symbol2scm ("is-paper"))))
{
output_def_body:
output_def_head_with_mode_switch '{' {
- Output_def::unsmob ($1)->input_origin_.set_spot (@$);
+ unsmob<Output_def> ($1)->input_origin_.set_spot (@$);
// This is a stupid trick to mark the beginning of the
// body for deciding whether to allow
// embedded_scm_active to have an output definition
// definitions.
if (scm_is_pair ($1))
{
- Output_def *o = Output_def::unsmob ($2);
+ Output_def *o = unsmob<Output_def> ($2);
if (o) {
o->input_origin_.set_spot (@$);
$1 = o->self_scm ();
} else
$1 = scm_car ($1);
}
- if (Context_def::is_smob ($2))
- assign_context_def (Output_def::unsmob ($1), $2);
+ if (unsmob<Context_def> ($2))
+ assign_context_def (unsmob<Output_def> ($1), $2);
// Seems unlikely, but let's be complete:
- else if (Music::is_smob ($2))
+ else if (unsmob<Music> ($2))
{
SCM proc = parser->lexer_->lookup_identifier
("output-def-music-handler");
} music_or_context_def
{
parser->lexer_->pop_state ();
- if (Context_def::is_smob ($3))
- assign_context_def (Output_def::unsmob ($1), $3);
+ if (unsmob<Context_def> ($3))
+ assign_context_def (unsmob<Output_def> ($1), $3);
else {
SCM proc = parser->lexer_->lookup_identifier
$$ = SCM_EOL;
}
| music_list music_embedded {
- if (Music::is_smob ($2))
+ if (unsmob<Music> ($2))
$$ = scm_cons ($2, $1);
}
| music_list error {
pitch_or_music
{
$$ = make_music_from_simple (parser, @1, $1);
- if (!Music::is_smob ($$))
+ if (!unsmob<Music> ($$))
{
parser->parser_error (@1, _ ("music expected"));
$$ = MAKE_SYNTAX ("void-music", @$);
music_embedded:
music
{
- if (Music::unsmob ($1)->is_mus_type ("post-event")) {
+ if (unsmob<Music> ($1)->is_mus_type ("post-event")) {
parser->parser_error (@1, _ ("unexpected post-event"));
$$ = SCM_UNSPECIFIED;
}
{
Music *n = MY_MAKE_MUSIC ("NoteEvent", @$);
- parser->default_duration_ = *Duration::unsmob ($1);
+ parser->default_duration_ = *unsmob<Duration> ($1);
n->set_property ("duration", $1);
if (scm_is_pair ($2))
{
if (scm_is_eq ($1, SCM_UNSPECIFIED))
$$ = $1;
- else if (Music *m = Music::unsmob ($1)) {
+ else if (Music *m = unsmob<Music> ($1)) {
if (m->is_mus_type ("post-event")) {
parser->parser_error
(@1, _ ("unexpected post-event"));
}
| WITH context_modification_arg
{
- if (Music::is_smob ($2)) {
+ if (unsmob<Music> ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
$2 = scm_call_2 (proc, parser->self_scm (), $2);
}
- if (Context_mod::is_smob ($2))
+ if (unsmob<Context_mod> ($2))
$$ = $2;
else {
parser->parser_error (@2, _ ("not a context mod"));
}
| context_mod_list context_mod {
if (!SCM_UNBNDP ($2))
- Context_mod::unsmob ($1)->add_context_mod ($2);
+ unsmob<Context_mod> ($1)->add_context_mod ($2);
}
| context_mod_list CONTEXT_MOD_IDENTIFIER {
- Context_mod *md = Context_mod::unsmob ($2);
+ Context_mod *md = unsmob<Context_mod> ($2);
if (md)
- Context_mod::unsmob ($1)->add_context_mods (md->get_mods ());
+ unsmob<Context_mod> ($1)->add_context_mods (md->get_mods ());
}
| context_mod_list context_mod_arg {
if (scm_is_eq ($2, SCM_UNSPECIFIED))
;
- else if (Music::is_smob ($2)) {
+ else if (unsmob<Music> ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
$2 = scm_call_2 (proc, parser->self_scm (), $2);
}
- if (Context_mod::is_smob ($2))
- Context_mod::unsmob ($$)->add_context_mods
- (Context_mod::unsmob ($2)->get_mods ());
+ if (unsmob<Context_mod> ($2))
+ unsmob<Context_mod> ($$)->add_context_mods
+ (unsmob<Context_mod> ($2)->get_mods ());
else {
parser->parser_error (@2, _ ("not a context mod"));
}
context_prefix:
CONTEXT symbol optional_id optional_context_mod {
- Context_mod *ctxmod = Context_mod::unsmob ($4);
+ Context_mod *ctxmod = unsmob<Context_mod> ($4);
SCM mods = SCM_EOL;
if (ctxmod)
mods = ctxmod->get_mods ();
$$ = START_MAKE_SYNTAX ("context-specification", $2, $3, mods, SCM_BOOL_F);
}
| NEWCONTEXT symbol optional_id optional_context_mod {
- Context_mod *ctxmod = Context_mod::unsmob ($4);
+ Context_mod *ctxmod = unsmob<Context_mod> ($4);
SCM mods = SCM_EOL;
if (ctxmod)
mods = ctxmod->get_mods ();
parser->lexer_->pop_state ();
}
| mode_changing_head_with_context optional_context_mod grouped_music_list {
- Context_mod *ctxmod = Context_mod::unsmob ($2);
+ Context_mod *ctxmod = unsmob<Context_mod> ($2);
SCM mods = SCM_EOL;
if (ctxmod)
mods = ctxmod->get_mods ();
simple_element post_events {
// Let the rhythmic music iterator sort this mess out.
if (scm_is_pair ($2)) {
- Music::unsmob ($$)->set_property ("articulations",
+ unsmob<Music> ($$)->set_property ("articulations",
scm_reverse_x ($2, SCM_EOL));
}
} %prec ':'
note_chord_element:
chord_body optional_notemode_duration post_events
{
- Music *m = Music::unsmob ($1);
- SCM dur = Duration::unsmob ($2)->smobbed_copy ();
+ Music *m = unsmob<Music> ($1);
+ SCM dur = unsmob<Duration> ($2)->smobbed_copy ();
SCM es = m->get_property ("elements");
SCM postevs = scm_reverse_x ($3, SCM_EOL);
for (SCM s = es; scm_is_pair (s); s = scm_cdr (s))
- Music::unsmob (scm_car (s))->set_property ("duration", dur);
+ unsmob<Music> (scm_car (s))->set_property ("duration", dur);
es = ly_append2 (es, postevs);
m-> set_property ("elements", es);
}
| music_function_chord_body
{
- Music *m = Music::unsmob ($1);
+ Music *m = unsmob<Music> ($1);
while (m && m->is_mus_type ("music-wrapper-music")) {
$$ = m->get_property ("element");
- m = Music::unsmob ($$);
+ m = unsmob<Music> ($$);
}
if (!(m && m->is_mus_type ("rhythmic-event"))) {
}
| post_events post_event {
$$ = $1;
- if (Music *m = Music::unsmob ($2))
+ if (Music *m = unsmob<Music> ($2))
{
if (m->is_mus_type ("post-event-wrapper"))
{
}
| script_dir music_function_call {
$$ = $2;
- if (!Music::unsmob ($2)->is_mus_type ("post-event")) {
+ if (!unsmob<Music> ($2)->is_mus_type ("post-event")) {
parser->parser_error (@2, _ ("post-event expected"));
$$ = SCM_UNSPECIFIED;
} else if (!SCM_UNBNDP ($1))
{
- Music::unsmob ($$)->set_property ("direction", $1);
+ unsmob<Music> ($$)->set_property ("direction", $1);
}
}
| HYPHEN {
| script_dir direction_reqd_event {
if (!SCM_UNBNDP ($1))
{
- Music *m = Music::unsmob ($2);
+ Music *m = unsmob<Music> ($2);
m->set_property ("direction", $1);
}
$$ = $2;
| script_dir direction_less_event {
if (!SCM_UNBNDP ($1))
{
- Music *m = Music::unsmob ($2);
+ Music *m = unsmob<Music> ($2);
m->set_property ("direction", $1);
}
$$ = $2;
| '^' fingering
{
$$ = $2;
- Music::unsmob ($$)->set_property ("direction", scm_from_int (UP));
+ unsmob<Music> ($$)->set_property ("direction", scm_from_int (UP));
}
| '_' fingering
{
$$ = $2;
- Music::unsmob ($$)->set_property ("direction", scm_from_int (DOWN));
+ unsmob<Music> ($$)->set_property ("direction", scm_from_int (DOWN));
}
;
a->set_property ("articulation-type", s);
$$ = a->unprotect ();
} else {
- Music *original = Music::unsmob (s);
+ Music *original = unsmob<Music> (s);
if (original && original->is_mus_type ("post-event")) {
Music *a = original->clone ();
a->set_spot (parser->lexer_->override_input (@$));
NOTENAME_PITCH quotes {
if (!scm_is_eq (SCM_INUM0, $2))
{
- Pitch p = *Pitch::unsmob ($1);
+ Pitch p = *unsmob<Pitch> ($1);
p = p.transposed (Pitch (scm_to_int ($2), 0));
$$ = p.smobbed_copy ();
}
TONICNAME_PITCH quotes {
if (!scm_is_eq (SCM_INUM0, $2))
{
- Pitch p = *Pitch::unsmob ($1);
+ Pitch p = *unsmob<Pitch> ($1);
p = p.transposed (Pitch (scm_to_int ($2), 0));
$$ = p.smobbed_copy ();
}
| PITCH_IDENTIFIER quotes {
if (!scm_is_eq (SCM_INUM0, $2))
{
- Pitch p = *Pitch::unsmob ($1);
+ Pitch p = *unsmob<Pitch> ($1);
p = p.transposed (Pitch (scm_to_int ($2), 0));
$$ = p.smobbed_copy ();
}
}
| embedded_scm
{
- Music *m = Music::unsmob ($1);
+ Music *m = unsmob<Music> ($1);
if (m && m->is_mus_type ("post-event"))
$$ = $1;
else if (Text_interface::is_markup ($1)) {
} %prec ':'
| multiplied_duration {
$$ = $1;
- parser->default_duration_ = *Duration::unsmob ($$);
+ parser->default_duration_ = *unsmob<Duration> ($$);
}
;
}
}
| DURATION_IDENTIFIER dots {
- Duration *d = Duration::unsmob ($1);
+ Duration *d = unsmob<Duration> ($1);
Duration k (d->duration_log (),
d->dot_count () + scm_to_int ($2));
k = k.compressed (d->factor ());
$$ = $1;
}
| multiplied_duration '*' UNSIGNED {
- $$ = Duration::unsmob ($$)->compressed (scm_to_int ($3)).smobbed_copy ();
+ $$ = unsmob<Duration> ($$)->compressed (scm_to_int ($3)).smobbed_copy ();
}
| multiplied_duration '*' FRACTION {
Rational m (scm_to_int (scm_car ($3)), scm_to_int (scm_cdr ($3)));
- $$ = Duration::unsmob ($$)->compressed (m).smobbed_copy ();
+ $$ = unsmob<Duration> ($$)->compressed (m).smobbed_copy ();
}
;
}
| bass_figure ']' {
$$ = $1;
- Music::unsmob ($1)->set_property ("bracket-stop", SCM_BOOL_T);
+ unsmob<Music> ($1)->set_property ("bracket-stop", SCM_BOOL_T);
}
| bass_figure figured_bass_alteration {
- Music *m = Music::unsmob ($1);
+ Music *m = unsmob<Music> ($1);
if (scm_to_double ($2)) {
SCM salter = m->get_property ("alteration");
SCM alter = scm_is_number (salter) ? salter : scm_from_int (0);
}
}
| bass_figure figured_bass_modification {
- Music *m = Music::unsmob ($1);
+ Music *m = unsmob<Music> ($1);
m->set_property ($2, SCM_BOOL_T);
}
;
}
| '[' bass_figure {
$$ = $2;
- Music::unsmob ($$)->set_property ("bracket-start", SCM_BOOL_T);
+ unsmob<Music> ($$)->set_property ("bracket-start", SCM_BOOL_T);
}
;
if (!parser->lexer_->is_chord_state ())
parser->parser_error (@1, _ ("have to be in Chord mode for chords"));
if (scm_is_pair ($2)) {
- if (Pitch::is_smob ($1))
+ if (unsmob<Pitch> ($1))
$1 = make_chord_elements (@1,
$1,
parser->default_duration_.smobbed_copy (),
SCM elts = ly_append2 ($1, scm_reverse_x ($2, SCM_EOL));
$$ = MAKE_SYNTAX ("event-chord", @1, elts);
- } else if (!Pitch::is_smob ($1))
+ } else if (!unsmob<Pitch> ($1))
$$ = MAKE_SYNTAX ("event-chord", @1, $1);
// A mere pitch drops through.
} %prec ':'
lyric_element optional_notemode_duration post_events {
$$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2);
if (scm_is_pair ($3))
- Music::unsmob ($$)->set_property
+ unsmob<Music> ($$)->set_property
("articulations", scm_reverse_x ($3, SCM_EOL));
} %prec ':'
;
SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
parser->lexer_->push_note_state (nn);
} '{' score_body '}' {
- Score *sc = Score::unsmob ($4);
+ Score *sc = unsmob<Score> ($4);
sc->origin ()->set_spot (@$);
if (sc->defs_.empty ()) {
Output_def *od = get_layout (parser);
SCM nn = parser->lexer_->lookup_identifier ("pitchnames");
parser->lexer_->push_note_state (nn);
} '{' score_body '}' {
- Score *sc = Score::unsmob ($4);
+ Score *sc = unsmob<Score> ($4);
sc->origin ()->set_spot (@$);
if (sc->defs_.empty ()) {
Output_def *od = get_layout (parser);
int
Lily_lexer::try_special_identifiers (SCM *destination, SCM sid)
{
- if (Book::is_smob (sid)) {
- Book *book = Book::unsmob (sid)->clone ();
+ if (unsmob<Book> (sid)) {
+ Book *book = unsmob<Book> (sid)->clone ();
*destination = book->self_scm ();
book->unprotect ();
} else if (scm_is_number (sid)) {
*destination = sid;
return NUMBER_IDENTIFIER;
- } else if (Context_def::is_smob (sid))
+ } else if (unsmob<Context_def> (sid))
{
- *destination = Context_def::unsmob (sid)->clone ()->unprotect ();
+ *destination = unsmob<Context_def> (sid)->clone ()->unprotect ();
return SCM_IDENTIFIER;
- } else if (Context_mod::is_smob (sid)) {
- *destination = Context_mod::unsmob (sid)->smobbed_copy ();
+ } else if (unsmob<Context_mod> (sid)) {
+ *destination = unsmob<Context_mod> (sid)->smobbed_copy ();
return CONTEXT_MOD_IDENTIFIER;
- } else if (Music *mus = Music::unsmob (sid)) {
+ } else if (Music *mus = unsmob<Music> (sid)) {
mus = mus->clone ();
*destination = mus->self_scm ();
bool is_event = mus->is_mus_type ("post-event");
mus->unprotect ();
return is_event ? EVENT_IDENTIFIER : MUSIC_IDENTIFIER;
- } else if (Pitch::is_smob (sid)) {
- *destination = Pitch::unsmob (sid)->smobbed_copy ();
+ } else if (unsmob<Pitch> (sid)) {
+ *destination = unsmob<Pitch> (sid)->smobbed_copy ();
return PITCH_IDENTIFIER;
- } else if (Duration::is_smob (sid)) {
- *destination = Duration::unsmob (sid)->smobbed_copy ();
+ } else if (unsmob<Duration> (sid)) {
+ *destination = unsmob<Duration> (sid)->smobbed_copy ();
return DURATION_IDENTIFIER;
- } else if (Output_def::is_smob (sid)) {
- *destination = Output_def::unsmob (sid)->clone ()->unprotect ();
+ } else if (unsmob<Output_def> (sid)) {
+ *destination = unsmob<Output_def> (sid)->clone ()->unprotect ();
return SCM_IDENTIFIER;
- } else if (Score::is_smob (sid)) {
- *destination = Score::unsmob (sid)->clone ()->unprotect ();
+ } else if (unsmob<Score> (sid)) {
+ *destination = unsmob<Score> (sid)->clone ()->unprotect ();
return SCM_IDENTIFIER;
}
SCM loc_on_music (Input loc, SCM arg)
{
- if (Music *m = Music::unsmob (arg))
+ if (Music *m = unsmob<Music> (arg))
{
m = m->clone ();
m->set_spot (loc);
SCM
make_music_from_simple (Lily_parser *parser, Input loc, SCM simple)
{
- if (Music::is_smob (simple))
+ if (unsmob<Music> (simple))
return simple;
if (parser->lexer_->is_note_state ()) {
if (scm_is_symbol (simple)) {
n->set_property ("drum-type", simple);
return n->unprotect ();
}
- if (Pitch::is_smob (simple)) {
+ if (unsmob<Pitch> (simple)) {
Music *n = MY_MAKE_MUSIC ("NoteEvent", loc);
n->set_property ("duration", parser->default_duration_.smobbed_copy ());
n->set_property ("pitch", simple);
return MAKE_SYNTAX ("lyric-event", loc, simple,
parser->default_duration_.smobbed_copy ());
} else if (parser->lexer_->is_chord_state ()) {
- if (Pitch::is_smob (simple))
+ if (unsmob<Pitch> (simple))
return MAKE_SYNTAX
("event-chord",
loc,
SCM res = scm_call_3 (chord_ctor, pitch, dur, modification_list);
for (SCM s = res; scm_is_pair (s); s = scm_cdr (s))
{
- Music::unsmob (scm_car (s))->set_spot (loc);
+ unsmob<Music> (scm_car (s))->set_spot (loc);
}
return res;
}
SCM lst = get_music ()->get_property ("elements");
Context *one = handles_[CONTEXT_ONE].get_context ();
set_context (one);
- first_iter_ = Music_iterator::unsmob (get_iterator (Music::unsmob (scm_car (lst))));
+ first_iter_ = unsmob<Music_iterator> (get_iterator (unsmob<Music> (scm_car (lst))));
Context *two = handles_[CONTEXT_TWO].get_context ();
set_context (two);
- second_iter_ = Music_iterator::unsmob (get_iterator (Music::unsmob (scm_cadr (lst))));
+ second_iter_ = unsmob<Music_iterator> (get_iterator (unsmob<Music> (scm_cadr (lst))));
Context *shared = handles_[CONTEXT_SHARED].get_context ();
set_context (shared);
}
if (!notice_busy_)
return;
- Stream_event *e = Stream_event::unsmob (se);
+ Stream_event *e = unsmob<Stream_event> (se);
if (e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
busy_ = true;
for (; scm_is_pair (split_list_); split_list_ = scm_cdr (split_list_))
{
- splitm = Moment::unsmob (scm_caar (split_list_));
+ splitm = unsmob<Moment> (scm_caar (split_list_));
if (splitm && *splitm + start_moment_ > now)
break;
Partial_iterator::process (Moment m)
{
if (Duration * dur
- = Duration::unsmob (get_music ()->get_property ("duration")))
+ = unsmob<Duration> (get_music ()->get_property ("duration")))
{
Moment length = Moment (dur->get_length ());
// work since the Timing_translator does not set
// measurePosition when initializing.
- Context *timing = Context::unsmob
+ Context *timing = unsmob<Context>
(scm_call_2 (ly_lily_module_constant ("ly:context-find"),
get_outlet ()->self_scm (),
ly_symbol2scm ("Timing")));
{
LY_ASSERT_SMOB (Context, ctx, 1);
LY_ASSERT_SMOB (Moment, length, 2);
- Context *timing = Context::unsmob
+ Context *timing = unsmob<Context>
(scm_call_2 (ly_lily_module_constant ("ly:context-find"),
ctx,
ly_symbol2scm ("Timing")));
Rational (0));
mp.main_part_ = measure_length (timing);
timing->set_property ("measurePosition",
- (mp - *Moment::unsmob (length)).smobbed_copy ());
+ (mp - *unsmob<Moment> (length)).smobbed_copy ());
timing->unset_property (ly_symbol2scm ("partialBusy"));
return SCM_UNSPECIFIED;
if (now_mom ().main_part_ != command_moment_.main_part_)
{
first_command_column_
- = Grob::unsmob (get_property ("currentCommandColumn"));
+ = unsmob<Grob> (get_property ("currentCommandColumn"));
command_moment_ = now_mom ();
}
SCM
Percent_repeat_item_interface::double_percent (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
Stencil m = x_percent (me, 2);
m.translate_axis (-m.extent (X_AXIS).center (), X_AXIS);
return m.smobbed_copy ();
SCM
Percent_repeat_item_interface::beat_slash (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
- Stream_event *cause = Stream_event::unsmob (me->get_property ("cause"));
+ Grob *me = unsmob<Grob> (grob);
+ Stream_event *cause = unsmob<Stream_event> (me->get_property ("cause"));
int count = robust_scm2int (cause->get_property ("slash-count"), 1);
Stencil m;
LY_ASSERT_SMOB (Performance, performance, 1);
LY_ASSERT_TYPE (scm_is_string, filename, 2);
- Performance::unsmob (performance)->write_output (ly_scm2string (filename));
+ unsmob<Performance> (performance)->write_output (ly_scm2string (filename));
return SCM_UNSPECIFIED;
}
for (SCM p = get_simple_trans_list (); scm_is_pair (p); p = scm_cdr (p))
{
- Translator *t = Translator::unsmob (scm_car (p));
+ Translator *t = unsmob<Translator> (scm_car (p));
Performer *eng = dynamic_cast<Performer *> (t);
if (eng && eng != info.origin_trans_)
eng->acknowledge_audio_element (info);
{
for (SCM p = list; scm_is_pair (p); p = scm_cdr (p))
{
- Performer *e = Performer::unsmob (scm_car (p));
+ Performer *e = unsmob<Performer> (scm_car (p));
if (e)
(e->*method) ();
}
for (SCM s = context ()->children_contexts ();
scm_is_pair (s); s = scm_cdr (s))
{
- Context *c = Context::unsmob (scm_car (s));
+ Context *c = unsmob<Context> (scm_car (s));
Performer_group *group
= dynamic_cast<Performer_group *> (c->implementation ());
if (group)
if (pedal_info_[i].line_spanner_)
{
SCM cc = get_property ("currentCommandColumn");
- Item *c = Item::unsmob (cc);
+ Item *c = unsmob<Item> (cc);
pedal_info_[i].line_spanner_->set_bound (RIGHT, c);
pedal_info_[i].clear ();
SCM
Piano_pedal_bracket::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Spanner *orig = dynamic_cast<Spanner *> (me->original ());
Drul_array<bool> broken (false, false);
Grob *common = me->get_bound (LEFT)
->common_refpoint (me->get_bound (RIGHT), X_AXIS);
- Grob *textbit = Grob::unsmob (me->get_object ("pedal-text"));
+ Grob *textbit = unsmob<Grob> (me->get_object ("pedal-text"));
if (textbit)
common = common->common_refpoint (textbit, X_AXIS);
{
assert (!p->finished_bracket_);
- Grob *cmc = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *cmc = unsmob<Grob> (get_property ("currentMusicalColumn"));
p->bracket_->set_bound (RIGHT, cmc);
/*
if (p->bracket_)
{
SCM cc = get_property ("currentCommandColumn");
- Item *c = Item::unsmob (cc);
+ Item *c = unsmob<Item> (cc);
p->bracket_->set_bound (RIGHT, c);
p->finished_bracket_ = p->bracket_;
typeset_all (p);
if (p->bracket_ && !p->bracket_->get_bound (LEFT))
{
- Grob *cmc = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *cmc = unsmob<Grob> (get_property ("currentMusicalColumn"));
p->bracket_->set_bound (LEFT, cmc);
}
}
{
Grob *r = p->finished_bracket_->get_bound (RIGHT);
if (!r)
- p->finished_bracket_->set_bound (RIGHT, Grob::unsmob (get_property ("currentMusicalColumn")));
+ p->finished_bracket_->set_bound (RIGHT, unsmob<Grob> (get_property ("currentMusicalColumn")));
p->finished_bracket_ = 0;
}
LY_ASSERT_SMOB (Pitch, p, 1);
LY_ASSERT_SMOB (Pitch, delta, 2);
- Pitch *t = Pitch::unsmob (p);
- Pitch *d = Pitch::unsmob (delta);
+ Pitch *t = unsmob<Pitch> (p);
+ Pitch *d = unsmob<Pitch> (delta);
return t->transposed (*d).smobbed_copy ();
}
"Negate @var{p}.")
{
LY_ASSERT_SMOB (Pitch, p, 1);
- Pitch *pp = Pitch::unsmob (p);
+ Pitch *pp = unsmob<Pitch> (p);
return pp->negated ().smobbed_copy ();
}
" pitch@tie{}@var{p}.")
{
LY_ASSERT_SMOB (Pitch, p, 1);
- Pitch *pp = Pitch::unsmob (p);
+ Pitch *pp = unsmob<Pitch> (p);
return scm_from_int (pp->steps ());
}
"Extract the octave from pitch@tie{}@var{pp}.")
{
LY_ASSERT_SMOB (Pitch, pp, 1);
- Pitch *p = Pitch::unsmob (pp);
+ Pitch *p = unsmob<Pitch> (pp);
int q = p->get_octave ();
return scm_from_int (q);
}
"Extract the alteration from pitch@tie{}@var{pp}.")
{
LY_ASSERT_SMOB (Pitch, pp, 1);
- Pitch *p = Pitch::unsmob (pp);
+ Pitch *p = unsmob<Pitch> (pp);
Rational q = p->get_alteration ();
return ly_rational2scm (q);
"Extract the note name from pitch @var{pp}.")
{
LY_ASSERT_SMOB (Pitch, pp, 1);
- Pitch *p = Pitch::unsmob (pp);
+ Pitch *p = unsmob<Pitch> (pp);
int q = p->get_notename ();
return scm_from_int (q);
}
" middle@tie{}C as a rational number.")
{
LY_ASSERT_SMOB (Pitch, pp, 1);
- return ly_rational2scm (Pitch::unsmob (pp)->tone_pitch ());
+ return ly_rational2scm (unsmob<Pitch> (pp)->tone_pitch ());
}
LY_DEFINE (ly_pitch_quartertones, "ly:pitch-quartertones",
" middle@tie{}C.")
{
LY_ASSERT_SMOB (Pitch, pp, 1);
- Pitch *p = Pitch::unsmob (pp);
+ Pitch *p = unsmob<Pitch> (pp);
int q = p->rounded_quartertone_pitch ();
return scm_from_int (q);
}
" middle@tie{}C.")
{
LY_ASSERT_SMOB (Pitch, pp, 1);
- Pitch *p = Pitch::unsmob (pp);
+ Pitch *p = unsmob<Pitch> (pp);
int q = p->rounded_semitone_pitch ();
return scm_from_int (q);
}
LY_ASSERT_SMOB (Pitch, p1, 1);
LY_ASSERT_SMOB (Pitch, p2, 2);
- Pitch *a = Pitch::unsmob (p1);
- Pitch *b = Pitch::unsmob (p2);
+ Pitch *a = unsmob<Pitch> (p1);
+ Pitch *b = unsmob<Pitch> (p2);
if (Pitch::compare (*a, *b) < 0)
return SCM_BOOL_T;
LY_ASSERT_SMOB (Pitch, pitch, 1);
LY_ASSERT_SMOB (Pitch, root, 2);
- Pitch *p = Pitch::unsmob (pitch);
- Pitch *r = Pitch::unsmob (root);
+ Pitch *p = unsmob<Pitch> (pitch);
+ Pitch *r = unsmob<Pitch> (root);
return pitch_interval (*r, *p).smobbed_copy ();
}
{
LY_ASSERT_SMOB (Context, context, 1);
- Context *c = Context::unsmob (context);
+ Context *c = unsmob<Context> (context);
int clef_pos = robust_scm2int (c->get_property ("middleCClefPosition"), 0);
int offset = robust_scm2int (c->get_property ("middleCOffset"), 0);
/* middleCCuePosition overrides the clef! */
SCM
Pitch::less_p (SCM p1, SCM p2)
{
- Pitch *a = Pitch::unsmob (p1);
- Pitch *b = Pitch::unsmob (p2);
+ Pitch *a = unsmob<Pitch> (p1);
+ Pitch *b = unsmob<Pitch> (p2);
if (compare (*a, *b) < 0)
return SCM_BOOL_T;
if (ev
&& ev->in_event_class ("trill-span-event")
&& to_dir (ev->get_property ("span-direction")) == START
- && Pitch::is_smob (ev->get_property ("pitch")))
+ && unsmob<Pitch> (ev->get_property ("pitch")))
make_trill (ev);
}
Pitched_trill_engraver::make_trill (Stream_event *ev)
{
SCM scm_pitch = ev->get_property ("pitch");
- Pitch *p = Pitch::unsmob (scm_pitch);
+ Pitch *p = unsmob<Pitch> (scm_pitch);
SCM keysig = get_property ("localAlterations");
int c0 = scm_is_number (c0scm) ? scm_to_int (c0scm) : 0;
trill_head_->set_property ("staff-position",
- scm_from_int (Pitch::unsmob (scm_pitch)->steps ()
+ scm_from_int (unsmob<Pitch> (scm_pitch)->steps ()
+ c0));
trill_group_ = make_item ("TrillPitchGroup", ev->self_scm ());
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
LY_ASSERT_SMOB (Grob, grob_element, 3);
- Pointer_group_interface::add_grob (Grob::unsmob (grob),
+ Pointer_group_interface::add_grob (unsmob<Grob> (grob),
sym,
- Grob::unsmob (grob_element));
+ unsmob<Grob> (grob_element));
return SCM_UNSPECIFIED;
}
int
Pointer_group_interface::count (Grob *me, SCM sym)
{
- Grob_array *arr = Grob_array::unsmob (me->internal_get_object (sym));
+ Grob_array *arr = unsmob<Grob_array> (me->internal_get_object (sym));
return arr ? arr->size () : 0;
}
void
Pointer_group_interface::add_grob (Grob *me, SCM sym, SCM p)
{
- add_grob (me, sym, Grob::unsmob (p));
+ add_grob (me, sym, unsmob<Grob> (p));
}
void
Pointer_group_interface::get_grob_array (Grob *me, SCM sym)
{
SCM scm_arr = me->internal_get_object (sym);
- Grob_array *arr = Grob_array::unsmob (scm_arr);
+ Grob_array *arr = unsmob<Grob_array> (scm_arr);
if (!arr)
{
scm_arr = Grob_array::make_array ();
- arr = Grob_array::unsmob (scm_arr);
+ arr = unsmob<Grob_array> (scm_arr);
me->set_object (sym, scm_arr);
}
return arr;
vector<Grob *> const &
ly_scm2link_array (SCM x)
{
- Grob_array *arr = Grob_array::unsmob (x);
+ Grob_array *arr = unsmob<Grob_array> (x);
return arr ? arr->array () : empty_array;
}
vector<Item *>
internal_extract_item_array (Grob const *elt, SCM symbol)
{
- Grob_array *arr = Grob_array::unsmob (elt->internal_get_object (symbol));
+ Grob_array *arr = unsmob<Grob_array> (elt->internal_get_object (symbol));
vector<Item *> items;
for (vsize i = 0; arr && i < arr->size (); i++)
items.push_back (arr->item (i));
"Set property @var{sym} of @var{obj} to @var{value}.")
{
LY_ASSERT_SMOB (Prob, obj, 1);
- Prob *ps = Prob::unsmob (obj);
+ Prob *ps = unsmob<Prob> (obj);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
ps->set_property (sym, value);
" @code{'()} if @var{val} is not specified.")
{
LY_ASSERT_SMOB (Prob, prob, 1);
- Prob *ps = Prob::unsmob (prob);
+ Prob *ps = unsmob<Prob> (prob);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
if (SCM_UNBNDP (val))
(SCM obj, SCM type),
"Is @var{obj} the specified prob-type?")
{
- Prob *prob = Prob::unsmob (obj);
+ Prob *prob = unsmob<Prob> (obj);
return scm_from_bool (prob && prob->type () == type);
}
"Retrieve an alist of mutable properties.")
{
LY_ASSERT_SMOB (Prob, prob, 1);
- Prob *ps = Prob::unsmob (prob);
+ Prob *ps = unsmob<Prob> (prob);
return ps->get_property_alist (true);
}
"Retrieve an alist of immutable properties.")
{
LY_ASSERT_SMOB (Prob, prob, 1);
- Prob *ps = Prob::unsmob (prob);
+ Prob *ps = unsmob<Prob> (prob);
return ps->get_property_alist (false);
}
equality; e.g., that two probs are equal iff they can be
distinguished by calls to ly:prob-property.
*/
- Prob *probs[2] = {Prob::unsmob (sa), Prob::unsmob (sb)};
+ Prob *probs[2] = {unsmob<Prob> (sa), unsmob<Prob> (sb)};
SCM props[2][2];
int i;
SCM aval = scm_cdar (aprop);
SCM bval = scm_cdar (bprop);
if (!scm_is_eq (scm_caar (aprop), scm_caar (bprop))
- || (!(Input::is_smob (aval) && Input::is_smob (bval))
+ || (!(unsmob<Input> (aval) && unsmob<Input> (bval))
&& !ly_is_equal (aval, bval)))
return SCM_BOOL_F;
}
SCM
Property_iterator::once_finalization (SCM ctx, SCM music, SCM previous_value)
{
- Music *m = Music::unsmob (music);
- Context *c = Context::unsmob (ctx);
+ Music *m = unsmob<Music> (music);
+ Context *c = unsmob<Context> (ctx);
// Do not use UnsetProperty, which sets the default, but rather
// cache the value before the \once \set command and restore it now
SCM
Push_property_iterator::once_finalization (SCM ctx, SCM music)
{
- Music *mus = Music::unsmob (music);
- Context *c = Context::unsmob (ctx);
+ Music *mus = unsmob<Music> (music);
+ Context *c = unsmob<Context> (ctx);
SCM sym = mus->get_property ("symbol");
if (check_grob (mus, sym))
SCM
Pure_from_neighbor_interface::calc_pure_relevant_grobs (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set ((me->original () && me->original ()->is_live ()
? me->original ()
: me),
new_elts.insert (new_elts.end (), elts.begin (), elts.end ());
SCM neighbors_scm = me->get_object ("neighbors");
- if (Grob_array::is_smob (neighbors_scm))
+ if (unsmob<Grob_array> (neighbors_scm))
{
vector<Grob *> &arr
- = Grob_array::unsmob (neighbors_scm)->array_reference ();
+ = unsmob<Grob_array> (neighbors_scm)->array_reference ();
arr = new_elts;
}
Quote_iterator::vector_moment (int idx) const
{
SCM entry = scm_c_vector_ref (event_vector_, idx);
- return *Moment::unsmob (scm_caar (entry));
+ return *unsmob<Moment> (scm_caar (entry));
}
void
if (quote_ok ())
{
SCM entry = scm_c_vector_ref (event_vector_, event_idx_);
- Pitch *quote_pitch = Pitch::unsmob (scm_cdar (entry));
+ Pitch *quote_pitch = unsmob<Pitch> (scm_cdar (entry));
/*
The pitch that sounds when written central C is played.
*/
Pitch temp_pitch;
- Pitch *me_pitch = Pitch::unsmob (get_music ()->get_property ("quoted-transposition"));
+ Pitch *me_pitch = unsmob<Pitch> (get_music ()->get_property ("quoted-transposition"));
if (!me_pitch)
- me_pitch = Pitch::unsmob (get_outlet ()->get_property ("instrumentTransposition"));
+ me_pitch = unsmob<Pitch> (get_outlet ()->get_property ("instrumentTransposition"));
else
{
// We are not going to win a beauty contest with this one,
{
SCM ev_acc = scm_car (s);
- Stream_event *ev = Stream_event::unsmob (scm_car (ev_acc));
+ Stream_event *ev = unsmob<Stream_event> (scm_car (ev_acc));
if (!ev)
programming_error ("no music found in quote");
else if (accept_music_type (ev, is_cue))
SCM
Relative_octave_check::relative_callback (SCM music, SCM last_pitch)
{
- Pitch p = *Pitch::unsmob (last_pitch);
- Music *m = Music::unsmob (music);
- Pitch *check_p = Pitch::unsmob (m->get_property ("pitch"));
+ Pitch p = *unsmob<Pitch> (last_pitch);
+ Music *m = unsmob<Music> (music);
+ Pitch *check_p = unsmob<Pitch> (m->get_property ("pitch"));
int delta_oct = 0;
if (check_p)
semi_tie->set_parent (semi_tie_column_, Y_AXIS);
semi_ties_.push_back (semi_tie);
- if (is_direction (Stream_event::unsmob (cause)->get_property ("direction")))
+ if (is_direction (unsmob<Stream_event> (cause)->get_property ("direction")))
{
- Direction d = to_dir (Stream_event::unsmob (cause)->get_property ("direction"));
+ Direction d = to_dir (unsmob<Stream_event> (cause)->get_property ("direction"));
semi_tie->set_property ("direction", scm_from_int (d));
}
Music *
Repeated_music::body (Music *me)
{
- return Music::unsmob (me->get_property ("element"));
+ return unsmob<Music> (me->get_property ("element"));
}
SCM
SCM p = alternative_list;
while (scm_is_pair (p) && done < count)
{
- m = m + Music::unsmob (scm_car (p))->get_length ();
+ m = m + unsmob<Music> (scm_car (p))->get_length ();
done++;
if (count - done < len)
p = scm_cdr (p);
Repeated_music::body_get_length (Music *me)
{
Moment m = 0;
- if (Music *body = Music::unsmob (me->get_property ("element")))
+ if (Music *body = unsmob<Music> (me->get_property ("element")))
m = body->get_length ();
return m;
}
SCM
Repeated_music::unfolded_music_length (SCM m)
{
- Music *me = Music::unsmob (m);
+ Music *me = unsmob<Music> (m);
Moment l = Moment (repeat_count (me)) * body_get_length (me) + alternatives_get_length (me, false);
return l.smobbed_copy ();
SCM
Repeated_music::folded_music_length (SCM m)
{
- Music *me = Music::unsmob (m);
+ Music *me = unsmob<Music> (m);
Moment l = body_get_length (me) + alternatives_get_length (me, true);
return l.smobbed_copy ();
SCM
Repeated_music::volta_music_length (SCM m)
{
- Music *me = Music::unsmob (m);
+ Music *me = unsmob<Music> (m);
Moment l = body_get_length (me) + alternatives_volta_get_length (me);
return l.smobbed_copy ();
}
SCM
Repeated_music::minimum_start (SCM m)
{
- Music *me = Music::unsmob (m);
- Music *body = Music::unsmob (me->get_property ("element"));
+ Music *me = unsmob<Music> (m);
+ Music *body = unsmob<Music> (me->get_property ("element"));
if (body)
return body->start_mom ().smobbed_copy ();
SCM
Repeated_music::first_start (SCM m)
{
- Music *me = Music::unsmob (m);
- Music *body = Music::unsmob (me->get_property ("element"));
+ Music *me = unsmob<Music> (m);
+ Music *body = unsmob<Music> (me->get_property ("element"));
Moment rv = (body) ? body->start_mom ()
: Music_sequence::first_start (me->get_property ("elements"));
for (SCM s = get_property ("busyGrobs"); scm_is_pair (s); s = scm_cdr (s))
{
- Grob *g = Grob::unsmob (scm_cdar (s));
- Moment *m = Moment::unsmob (scm_caar (s));
+ Grob *g = unsmob<Grob> (scm_cdar (s));
+ Moment *m = unsmob<Moment> (scm_caar (s));
if (!g || !m)
continue;
SCM
Rest_collision::force_shift_callback_rest (SCM rest, SCM offset)
{
- Grob *rest_grob = Grob::unsmob (rest);
+ Grob *rest_grob = unsmob<Grob> (rest);
Grob *parent = rest_grob->get_parent (X_AXIS);
/*
if (Note_column::has_interface (parent) && Note_column::has_rests (parent))
{
- Grob *collision = Grob::unsmob (parent->get_object ("rest-collision"));
+ Grob *collision = unsmob<Grob> (parent->get_object ("rest-collision"));
if (collision)
(void) collision->get_property ("positioning-done");
p->set_object ("rest-collision", me->self_scm ());
- Grob *rest = Grob::unsmob (p->get_object ("rest"));
+ Grob *rest = unsmob<Grob> (p->get_object ("rest"));
if (rest)
{
chain_offset_callback (rest,
SCM
Rest_collision::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
me->set_property ("positioning-done", SCM_BOOL_T);
Grob *e = elts[i];
if (Note_column::has_interface (e))
{
- if (Grob::unsmob (e->get_object ("rest")))
+ if (unsmob<Grob> (e->get_object ("rest")))
rests.push_back (e);
else
notes.push_back (e);
if (rest_event_ && !rest_)
{
rest_ = make_item ("Rest", rest_event_->self_scm ());
- Pitch *p = Pitch::unsmob (rest_event_->get_property ("pitch"));
+ Pitch *p = unsmob<Pitch> (rest_event_->get_property ("pitch"));
if (p)
{
SCM
Rest::y_offset_callback (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
int duration_log = scm_to_int (me->get_property ("duration-log"));
Real ss = Staff_symbol_referencer::staff_space (me);
SCM
Rest::calc_cross_staff (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
if (!stem)
return SCM_BOOL_F;
SCM
Rest::print (SCM smob)
{
- return brew_internal_stencil (Grob::unsmob (smob), true);
+ return brew_internal_stencil (unsmob<Grob> (smob), true);
}
MAKE_SCHEME_CALLBACK (Rest, width, 1);
SCM
Rest::width (SCM smob)
{
- return generic_extent_callback (Grob::unsmob (smob), X_AXIS);
+ return generic_extent_callback (unsmob<Grob> (smob), X_AXIS);
}
MAKE_SCHEME_CALLBACK (Rest, height, 1);
SCM
Rest::height (SCM smob)
{
- return generic_extent_callback (Grob::unsmob (smob), Y_AXIS);
+ return generic_extent_callback (unsmob<Grob> (smob), Y_AXIS);
}
/*
with ledgered rests.
*/
SCM m = brew_internal_stencil (me, a != X_AXIS);
- return ly_interval2scm (Stencil::unsmob (m)->extent (a));
+ return ly_interval2scm (unsmob<Stencil> (m)->extent (a));
}
MAKE_SCHEME_CALLBACK (Rest, pure_height, 3);
SCM /* start */,
SCM /* end */)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM m = brew_internal_stencil (me, false);
- return ly_interval2scm (Stencil::unsmob (m)->extent (Y_AXIS));
+ return ly_interval2scm (unsmob<Stencil> (m)->extent (Y_AXIS));
}
ADD_INTERFACE (Rest,
Rhythmic_head::get_dots (Grob *me)
{
SCM s = me->get_object ("dot");
- return Item::unsmob (s);
+ return unsmob<Item> (s);
}
Item *
Rhythmic_head::get_stem (Grob *me)
{
SCM s = me->get_object ("stem");
- return Item::unsmob (s);
+ return unsmob<Item> (s);
}
int
SCM art = scm_car (arts);
if (c->event_source ()->is_listened_class
- (Stream_event::unsmob (art)->get_property ("class")))
+ (unsmob<Stream_event> (art)->get_property ("class")))
listened = scm_cons (art, listened);
else
unlistened = scm_cons (art, unlistened);
c->event_source ()->broadcast (ev);
arts = scm_reverse_x (listened, SCM_EOL);
for (; scm_is_pair (arts); arts = scm_cdr (arts))
- c->event_source ()->broadcast (Stream_event::unsmob (scm_car (arts)));
+ c->event_source ()->broadcast (unsmob<Stream_event> (scm_car (arts)));
}
else
c->event_source ()->broadcast (ev);
LY_ASSERT_SMOB (Scale, scale, 1);
default_global_scale_scm = scale;
- default_global_scale = Scale::unsmob (scale);
+ default_global_scale = unsmob<Scale> (scale);
return SCM_UNSPECIFIED;
}
void
Score_performer::prepare (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
SCM sm = ev->get_property ("moment");
- Moment *m = Moment::unsmob (sm);
+ Moment *m = unsmob<Moment> (sm);
audio_column_ = new Audio_column (*m);
announce_element (Audio_element_info (audio_column_, 0));
precomputed_recurse_over_translators (context (), START_TRANSLATION_TIMESTEP, UP);
"All output definitions in a score.")
{
LY_ASSERT_SMOB (Score, score, 1);
- Score *sc = Score::unsmob (score);
+ Score *sc = unsmob<Score> (score);
SCM l = SCM_EOL;
for (vsize i = 0; i < sc->defs_.size (); i++)
{
LY_ASSERT_SMOB (Score, score, 1);
LY_ASSERT_SMOB (Output_def, def, 2);
- Score *sc = Score::unsmob (score);
- Output_def *output_def = Output_def::unsmob (def);
+ Score *sc = unsmob<Score> (score);
+ Output_def *output_def = unsmob<Output_def> (def);
sc->add_output_def (output_def);
return SCM_UNSPECIFIED;
}
"Return score header.")
{
LY_ASSERT_SMOB (Score, score, 1);
- Score *sc = Score::unsmob (score);
+ Score *sc = unsmob<Score> (score);
return sc->get_header ();
}
SCM_ASSERT_TYPE (ly_is_module (module), module, SCM_ARG2, __FUNCTION__,
"module");
- Score *sc = Score::unsmob (score);
+ Score *sc = unsmob<Score> (score);
sc->set_header (module);
return SCM_UNSPECIFIED;
}
"Return score music.")
{
LY_ASSERT_SMOB (Score, score, 1);
- Score *sc = Score::unsmob (score);
+ Score *sc = unsmob<Score> (score);
return sc->get_music ();
}
"Was there an error in the score?")
{
LY_ASSERT_SMOB (Score, score, 1);
- Score *sc = Score::unsmob (score);
+ Score *sc = unsmob<Score> (score);
return scm_from_bool (sc->error_found_);
}
LY_ASSERT_SMOB (Score, score, 1);
LY_ASSERT_SMOB (Output_def, layout, 2);
- Score *sc = Score::unsmob (score);
- Output_def *od = Output_def::unsmob (layout);
+ Score *sc = unsmob<Score> (score);
+ Output_def *od = unsmob<Output_def> (layout);
if (sc->error_found_)
return SCM_EOL;
Input *
Score::origin () const
{
- return Input::unsmob (input_location_);
+ return unsmob<Input> (input_location_);
}
Score::Score ()
smobify_self ();
input_location_ = s.origin ()->smobbed_copy ();
- Music *m = Music::unsmob (s.music_);
+ Music *m = unsmob<Music> (s.music_);
if (m)
{
Music *mclone = m->clone ();
/* TODO: fix or junk --no-layout. */
SCM context = ly_run_translator (music_, scaled);
- if (Global_context::unsmob (context))
+ if (unsmob<Global_context> (context))
{
SCM s = ly_format_output (context);
void
Score::set_music (SCM music)
{
- if (Music::is_smob (music_))
+ if (unsmob<Music> (music_))
{
- Music::unsmob (music)->origin ()->error (_ ("already have music in score"));
- Music::unsmob (music_)->origin ()->error (_ ("this is the previous music"));
+ unsmob<Music> (music)->origin ()->error (_ ("already have music in score"));
+ unsmob<Music> (music_)->origin ()->error (_ ("this is the previous music"));
}
- Music *m = Music::unsmob (music);
+ Music *m = unsmob<Music> (music);
if (m && to_boolean (m->get_property ("error-found")))
{
m->origin ()->error (_ ("errors found, ignoring music expression"));
2, 0, 0, (SCM a, SCM b),
"Compare two grobs by script priority. For internal use.")
{
- Grob *i1 = Grob::unsmob (a);
- Grob *i2 = Grob::unsmob (b);
+ Grob *i1 = unsmob<Grob> (a);
+ Grob *i2 = unsmob<Grob> (b);
SCM p1 = i1->get_property ("script-priority");
SCM p2 = i2->get_property ("script-priority");
SCM
Script_column::row_before_line_breaking (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
vector<Grob *> horizontal_grobs;
extract_grob_set (me, "scripts", scripts);
SCM
Script_column::before_line_breaking (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
vector<Grob *> staff_sided;
extract_grob_set (me, "scripts", scripts);
for (SCM s = ss; scm_is_pair (s);
s = scm_cdr (s), last = g, last_initial_outside_staff = initial_outside_staff)
{
- g = Grob::unsmob (scm_car (s));
+ g = unsmob<Grob> (scm_car (s));
initial_outside_staff = g->get_property ("outside-staff-priority");
if (last) //not the first grob in the list
{
*/
if (!scm_is_number (last_outside_staff))
for (SCM t = ss; !scm_is_eq (t, s); t = scm_cdr (t))
- Side_position_interface::add_support (g, Grob::unsmob (scm_car (t)));
+ Side_position_interface::add_support (g, unsmob<Grob> (scm_car (t)));
/*
if outside_staff_priority is missing or is equal to original
outside_staff_priority of previous grob, set new
SCM
Script_interface::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
if (Grob *par = me->get_parent (X_AXIS))
{
Grob *stem = Note_column::get_stem (par);
relative_dir = to_dir (reldir);
SCM other_elt = me->get_object ("direction-source");
- Grob *e = Grob::unsmob (other_elt);
+ Grob *e = unsmob<Grob> (other_elt);
if (e)
return (Direction) (relative_dir * get_grob_direction (e));
SCM
Script_interface::calc_direction (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Direction d = Script_interface::get_direction (me);
if (!d)
SCM
Script_interface::calc_cross_staff (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *stem = Note_column::get_stem (me->get_parent (X_AXIS));
if (stem && to_boolean (stem->get_property ("cross-staff")))
return SCM_BOOL_T;
- Grob *slur = Grob::unsmob (me->get_object ("slur"));
+ Grob *slur = unsmob<Grob> (me->get_object ("slur"));
SCM avoid_slur = me->get_property ("avoid-slur");
if (slur && to_boolean (slur->get_property ("cross-staff"))
&& (scm_is_eq (avoid_slur, ly_symbol2scm ("outside"))
SCM
Script_interface::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Direction dir = get_grob_direction (me);
SCM
Self_alignment_interface::y_aligned_on_self (SCM element)
{
- return aligned_on_self (Grob::unsmob (element), Y_AXIS, false, 0, 0);
+ return aligned_on_self (unsmob<Grob> (element), Y_AXIS, false, 0, 0);
}
MAKE_SCHEME_CALLBACK (Self_alignment_interface, x_aligned_on_self, 1);
SCM
Self_alignment_interface::x_aligned_on_self (SCM element)
{
- return aligned_on_self (Grob::unsmob (element), X_AXIS, false, 0, 0);
+ return aligned_on_self (unsmob<Grob> (element), X_AXIS, false, 0, 0);
}
MAKE_SCHEME_CALLBACK (Self_alignment_interface, pure_y_aligned_on_self, 3);
SCM
Self_alignment_interface::pure_y_aligned_on_self (SCM smob, SCM start, SCM end)
{
- return aligned_on_self (Grob::unsmob (smob), Y_AXIS, true, robust_scm2int (start, 0), robust_scm2int (end, INT_MAX));
+ return aligned_on_self (unsmob<Grob> (smob), Y_AXIS, true, robust_scm2int (start, 0), robust_scm2int (end, INT_MAX));
}
SCM
SCM
Self_alignment_interface::centered_on_x_parent (SCM smob)
{
- return centered_on_object (Grob::unsmob (smob)->get_parent (X_AXIS), X_AXIS);
+ return centered_on_object (unsmob<Grob> (smob)->get_parent (X_AXIS), X_AXIS);
}
MAKE_SCHEME_CALLBACK (Self_alignment_interface, centered_on_y_parent, 1);
SCM
Self_alignment_interface::centered_on_y_parent (SCM smob)
{
- return centered_on_object (Grob::unsmob (smob)->get_parent (Y_AXIS), Y_AXIS);
+ return centered_on_object (unsmob<Grob> (smob)->get_parent (Y_AXIS), Y_AXIS);
}
MAKE_SCHEME_CALLBACK (Self_alignment_interface, aligned_on_x_parent, 1);
SCM
Self_alignment_interface::aligned_on_x_parent (SCM smob)
{
- return aligned_on_parent (Grob::unsmob (smob), X_AXIS);
+ return aligned_on_parent (unsmob<Grob> (smob), X_AXIS);
}
MAKE_SCHEME_CALLBACK (Self_alignment_interface, aligned_on_y_parent, 1);
SCM
Self_alignment_interface::aligned_on_y_parent (SCM smob)
{
- return aligned_on_parent (Grob::unsmob (smob), Y_AXIS);
+ return aligned_on_parent (unsmob<Grob> (smob), Y_AXIS);
}
SCM
SCM
Semi_tie_column::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
me->set_property ("positioning-done", SCM_BOOL_T);
SCM
Semi_tie_column::calc_head_direction (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "ties", ties);
Direction d = LEFT;
SCM
Semi_tie::calc_control_points (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
(void) me->get_property ("direction");
if (Semi_tie_column::has_interface (me->get_parent (Y_AXIS)))
int
Semi_tie::get_position (Grob *me)
{
- Grob *h = Grob::unsmob (me->get_object ("note-head"));
+ Grob *h = unsmob<Grob> (me->get_object ("note-head"));
return (int) rint (Staff_symbol_referencer::get_position (h));
}
&& !current_spacings_.staff_spacing_
&& to_boolean (get_property ("createSpacing")))
{
- Grob *col = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *col = unsmob<Grob> (get_property ("currentCommandColumn"));
current_spacings_.staff_spacing_ = make_item ("StaffSpacing", SCM_EOL);
context ()->set_property ("hasStaffSpacing", SCM_BOOL_T);
&& last_spacings_.staff_spacing_)
{
SCM ri = last_spacings_.staff_spacing_->get_object ("right-items");
- Grob_array *ga = Grob_array::unsmob (ri);
+ Grob_array *ga = unsmob<Grob_array> (ri);
if (!ga)
{
SCM ga_scm = Grob_array::make_array ();
last_spacings_.staff_spacing_->set_object ("right-items", ga_scm);
- ga = Grob_array::unsmob (ga_scm);
+ ga = unsmob<Grob_array> (ga_scm);
}
ga->clear ();
last_spacings_ = current_spacings_;
if (Item *sp = current_spacings_.staff_spacing_)
- if (Grob *col = Grob::unsmob (get_property ("currentMusicalColumn")))
+ if (Grob *col = unsmob<Grob> (get_property ("currentMusicalColumn")))
Pointer_group_interface::add_grob (sp, ly_symbol2scm ("right-items"), col);
current_spacings_.clear ();
Real
Separation_item::set_distance (Item *l, Item *r, Real padding)
{
- Drul_array<Skyline_pair *> lines (Skyline_pair::unsmob (l->get_property ("horizontal-skylines")),
- Skyline_pair::unsmob (r->get_property ("horizontal-skylines")));
+ Drul_array<Skyline_pair *> lines (unsmob<Skyline_pair> (l->get_property ("horizontal-skylines")),
+ unsmob<Skyline_pair> (r->get_property ("horizontal-skylines")));
Skyline right = conditional_skyline (r, l);
right.merge ((*lines[RIGHT])[LEFT]);
bool
Separation_item::is_empty (Grob *me)
{
- Skyline_pair *sky = Skyline_pair::unsmob (me->get_property ("horizontal-skylines"));
+ Skyline_pair *sky = unsmob<Skyline_pair> (me->get_property ("horizontal-skylines"));
return (!sky || sky->is_empty ());
}
SCM
Separation_item::calc_skylines (SCM smob)
{
- Item *me = Item::unsmob (smob);
+ Item *me = unsmob<Item> (smob);
vector<Box> bs = boxes (me, 0);
Skyline_pair sp (bs, Y_AXIS);
/*
if (!debug_skylines)
return SCM_BOOL_F;
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Stencil ret;
- if (Skyline_pair *s = Skyline_pair::unsmob (me->get_property ("horizontal-skylines")))
+ if (Skyline_pair *s = unsmob<Skyline_pair> (me->get_property ("horizontal-skylines")))
{
ret.add_stencil (Lookup::points_to_line_stencil (0.1, (*s)[LEFT].to_points (Y_AXIS)).in_color (255, 255, 0));
ret.add_stencil (Lookup::points_to_line_stencil (0.1, (*s)[RIGHT].to_points (Y_AXIS)).in_color (0, 255, 255));
if (scm_is_pair (cursor_))
- iter_->music_ == Music::unsmob (scm_car (cursor_))
+ iter_->music_ == unsmob<Music> (scm_car (cursor_))
else
iter_ == 0;
for (; scm_is_pair (cursor); cursor = scm_cdr (cursor))
{
- Music *mus = Music::unsmob (scm_car (cursor));
+ Music *mus = unsmob<Music> (scm_car (cursor));
Moment s = mus->start_mom ();
Moment l = mus->get_length () - s;
iter_ = 0;
if (scm_is_pair (cursor_))
{
- Music *m = Music::unsmob (scm_car (cursor_));
- iter_ = Music_iterator::unsmob (get_iterator (m));
+ Music *m = unsmob<Music> (scm_car (cursor_));
+ iter_ = unsmob<Music_iterator> (get_iterator (m));
}
while (iter_ && !iter_->ok ())
iter_->quit ();
if (scm_is_pair (cursor_))
- iter_ = Music_iterator::unsmob (get_iterator (Music::unsmob (scm_car (cursor_))));
+ iter_ = unsmob<Music_iterator> (get_iterator (unsmob<Music> (scm_car (cursor_))));
else
iter_ = 0;
}
acs = scm_cdr (acs))
for (SCM s = scm_cdar (acs); scm_is_pair (s); s = scm_cdr (s))
{
- Grob *a = Grob::unsmob (scm_car (s));
+ Grob *a = unsmob<Grob> (scm_car (s));
support.insert (a);
}
}
current_off_ptr = &r;
}
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
// We will only ever want widths of spanners after line breaking
// so we can set pure to false
if (dynamic_cast<Spanner *> (me) && a == X_AXIS)
SCM
Side_position_interface::calc_cross_staff (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "side-support-elements", elts);
Direction my_dir = get_grob_direction (me) ;
pure,
start,
end);
- if (Skyline_pair::is_smob (skyp))
+ if (unsmob<Skyline_pair> (skyp))
{
// for spanner pure heights, we don't know horizontal spacing,
// so a spanner can never have a meaningful x coordiante
Real yc = a == X_AXIS
? me->pure_relative_y_coordinate (common[Y_AXIS], start, end)
: me->get_parent (Y_AXIS)->maybe_pure_coordinate (common[Y_AXIS], Y_AXIS, pure, start, end);
- Skyline_pair copy = *Skyline_pair::unsmob (skyp);
+ Skyline_pair copy = *unsmob<Skyline_pair> (skyp);
copy.shift (a == X_AXIS ? yc : xc);
copy.raise (a == X_AXIS ? xc : yc);
my_dim = copy[-dir];
start,
end);
- if (Skyline_pair::is_smob (sp))
+ if (unsmob<Skyline_pair> (sp))
{
Real xc = pure && dynamic_cast<Spanner *> (e)
? e->get_parent (X_AXIS)->relative_coordinate (common[X_AXIS], X_AXIS)
Real yc = a == X_AXIS
? e->pure_relative_y_coordinate (common[Y_AXIS], start, end)
: e->maybe_pure_coordinate (common[Y_AXIS], Y_AXIS, pure, start, end);
- Skyline_pair copy = *Skyline_pair::unsmob (sp);
+ Skyline_pair copy = *unsmob<Skyline_pair> (sp);
if (a == Y_AXIS
&& Stem::has_interface (e)
&& to_boolean (me->get_maybe_pure_property ("add-stem-support", pure, start, end)))
SCM
Side_position_interface::move_to_extremal_staff (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
System *sys = dynamic_cast<System *> (me->get_system ());
Direction dir = get_grob_direction (me);
if (dir != DOWN)
Axis_group_interface::add_element (top_staff, me);
// Remove any cross-staff side-support dependencies
- Grob_array *ga = Grob_array::unsmob (me->get_object ("side-support-elements"));
+ Grob_array *ga = unsmob<Grob_array> (me->get_object ("side-support-elements"));
if (ga)
{
vector<Grob *> const &elts = ga->array ();
int start,
int end)
{
- if (Simple_closure *sc = Simple_closure::unsmob (expr))
+ if (Simple_closure *sc = unsmob<Simple_closure> (expr))
{
SCM inside = sc->expression ();
- SCM proc = !pure && Unpure_pure_container::is_smob (scm_car (inside))
- ? Unpure_pure_container::unsmob (scm_car (inside))->unpure_part ()
+ SCM proc = !pure && unsmob<Unpure_pure_container> (scm_car (inside))
+ ? unsmob<Unpure_pure_container> (scm_car (inside))->unpure_part ()
: scm_car (inside);
SCM args = scm_cons (delayed_argument,
evaluate_args (delayed_argument, scm_cdr (inside),
return expr;
else if (scm_is_eq (scm_car (expr), ly_symbol2scm ("quote")))
return scm_cadr (expr);
- else if (Unpure_pure_container::is_smob (scm_car (expr))
+ else if (unsmob<Unpure_pure_container> (scm_car (expr))
|| ly_is_procedure (scm_car (expr)))
{
- SCM proc = !pure && Unpure_pure_container::is_smob (scm_car (expr))
- ? Unpure_pure_container::unsmob (scm_car (expr))->unpure_part ()
+ SCM proc = !pure && unsmob<Unpure_pure_container> (scm_car (expr))
+ ? unsmob<Unpure_pure_container> (scm_car (expr))->unpure_part ()
: scm_car (expr);
SCM args = evaluate_args (delayed_argument, scm_cdr (expr), pure, start, end);
if (scm_is_eq (args, SCM_UNSPECIFIED))
bool pure = (scm_is_number (scm_start) && scm_is_number (scm_end));
int start = robust_scm2int (scm_start, 0);
int end = robust_scm2int (scm_end, 0);
- SCM expr = Simple_closure::unsmob (closure)->expression ();
+ SCM expr = unsmob<Simple_closure> (closure)->expression ();
return evaluate_with_simple_closure (delayed, expr, pure, start, end);
}
for (SCM s = Spaceable_grob::get_minimum_distances (col);
scm_is_pair (s); s = scm_cdr (s))
{
- Grob *other = Grob::unsmob (scm_caar (s));
+ Grob *other = unsmob<Grob> (scm_caar (s));
vsize j = binary_search (cols, other, Paper_column::less_than, col_index);
if (j != VPOS)
{
Simultaneous_music_iterator::derived_substitute (Context *f, Context *t)
{
for (SCM s = children_list_; scm_is_pair (s); s = scm_cdr (s))
- Music_iterator::unsmob (scm_car (s))->substitute_outlet (f, t);
+ unsmob<Music_iterator> (scm_car (s))->substitute_outlet (f, t);
}
void
SCM *tail = &children_list_;
for (; scm_is_pair (i); i = scm_cdr (i), j++)
{
- Music *mus = Music::unsmob (scm_car (i));
+ Music *mus = unsmob<Music> (scm_car (i));
SCM scm_iter = get_static_get_iterator (mus);
- Music_iterator *mi = Music_iterator::unsmob (scm_iter);
+ Music_iterator *mi = unsmob<Music_iterator> (scm_iter);
/* if create_separate_contexts_ is set, create a new context with the
number number as name */
SCM *proc = &children_list_;
while (scm_is_pair (*proc))
{
- Music_iterator *i = Music_iterator::unsmob (scm_car (*proc));
+ Music_iterator *i = unsmob<Music_iterator> (scm_car (*proc));
bool run_always = i->run_always ();
if (run_always || i->pending_moment () == until)
i->process (until);
if (had_bad && !had_good)
{
for (SCM p = children_list_; scm_is_pair (p); p = scm_cdr (p))
- Music_iterator::unsmob (scm_car (p))->quit ();
+ unsmob<Music_iterator> (scm_car (p))->quit ();
children_list_ = SCM_EOL;
}
}
for (SCM s = children_list_; scm_is_pair (s); s = scm_cdr (s))
{
- Music_iterator *it = Music_iterator::unsmob (scm_car (s));
+ Music_iterator *it = unsmob<Music_iterator> (scm_car (s));
next = min (next, it->pending_moment ());
}
bool run_always_ok = false;
for (SCM s = children_list_; scm_is_pair (s); s = scm_cdr (s))
{
- Music_iterator *it = Music_iterator::unsmob (scm_car (s));
+ Music_iterator *it = unsmob<Music_iterator> (scm_car (s));
if (!it->run_always ())
return true;
else
{
for (SCM s = children_list_; scm_is_pair (s); s = scm_cdr (s))
{
- Music_iterator *it = Music_iterator::unsmob (scm_car (s));
+ Music_iterator *it = unsmob<Music_iterator> (scm_car (s));
if (it->run_always ())
return true;
}
Simultaneous_music_iterator::do_quit ()
{
for (SCM s = children_list_; scm_is_pair (s); s = scm_cdr (s))
- Music_iterator::unsmob (scm_car (s))->quit ();
+ unsmob<Music_iterator> (scm_car (s))->quit ();
}
IMPLEMENT_CTOR_CALLBACK (Simultaneous_music_iterator);
SCM
Skyline_pair::skyline (SCM smob, SCM dir_scm)
{
- Skyline_pair *sp = Skyline_pair::unsmob (smob);
+ Skyline_pair *sp = unsmob<Skyline_pair> (smob);
Direction dir = robust_scm2dir (dir_scm, UP);
if (dir == CENTER)
horizon_padding = scm_to_double (horizon_padding_scm);
}
- Skyline *skyline = Skyline::unsmob (skyline_scm);
- Skyline *other_skyline = Skyline::unsmob (other_skyline_scm);
+ Skyline *skyline = unsmob<Skyline> (skyline_scm);
+ Skyline *other_skyline = unsmob<Skyline> (other_skyline_scm);
return scm_from_double (skyline->touching_point (*other_skyline, horizon_padding));
}
horizon_padding = scm_to_double (horizon_padding_scm);
}
- Skyline *skyline = Skyline::unsmob (skyline_scm);
- Skyline *other_skyline = Skyline::unsmob (other_skyline_scm);
+ Skyline *skyline = unsmob<Skyline> (skyline_scm);
+ Skyline *other_skyline = unsmob<Skyline> (other_skyline_scm);
return scm_from_double (skyline->distance (*other_skyline, horizon_padding));
}
SCM
Skyline::get_max_height (SCM skyline_scm)
{
- return scm_from_double (Skyline::unsmob (skyline_scm)->max_height ());
+ return scm_from_double (unsmob<Skyline> (skyline_scm)->max_height ());
}
MAKE_SCHEME_CALLBACK (Skyline, get_max_height_position, 1)
SCM
Skyline::get_max_height_position (SCM skyline_scm)
{
- return scm_from_double (Skyline::unsmob (skyline_scm)->max_height_position ());
+ return scm_from_double (unsmob<Skyline> (skyline_scm)->max_height_position ());
}
MAKE_SCHEME_CALLBACK (Skyline, get_height, 2)
Skyline::get_height (SCM skyline_scm, SCM x_scm)
{
Real x = robust_scm2double (x_scm, 0.0);
- return scm_from_double (Skyline::unsmob (skyline_scm)->height (x));
+ return scm_from_double (unsmob<Skyline> (skyline_scm)->height (x));
}
LY_DEFINE (ly_skyline_empty_p, "ly:skyline-empty?",
1, 0, 0, (SCM sky),
"Return whether @var{sky} is empty.")
{
- Skyline *s = Skyline::unsmob (sky);
+ Skyline *s = unsmob<Skyline> (sky);
LY_ASSERT_SMOB (Skyline, sky, 1);
return scm_from_bool (s->is_empty ());
}
void
Slur_proto_engraver::create_slur (const string &spanner_id, Stream_event *ev_cause, Grob *g_cause, Direction dir, bool left_broken)
{
- Grob *ccc = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *ccc = unsmob<Grob> (get_property ("currentCommandColumn"));
SCM cause = ev_cause ? ev_cause->self_scm () : g_cause->self_scm ();
Spanner *slur = make_spanner (grob_name_, cause);
slur->set_property ("spanner-id", ly_string2scm (spanner_id));
if (!updown)
return false;
- Stream_event *c = Stream_event::unsmob (slur->get_property ("cause"));
+ Stream_event *c = unsmob<Stream_event> (slur->get_property ("cause"));
if (!c)
{
void
Slur_proto_engraver::stop_translation_timestep ()
{
- if (Grob *g = Grob::unsmob (get_property ("currentCommandColumn")))
+ if (Grob *g = unsmob<Grob> (get_property ("currentCommandColumn")))
{
for (vsize i = 0; i < end_slurs_.size (); i++)
Slur::add_extra_encompass (end_slurs_[i], g);
{
Spanner *s = dynamic_cast<Spanner *> (end_slurs_[i]);
if (!s->get_bound (RIGHT))
- s->set_bound (RIGHT, Grob::unsmob (get_property ("currentMusicalColumn")));
+ s->set_bound (RIGHT, unsmob<Grob> (get_property ("currentMusicalColumn")));
announce_end_grob (s, SCM_EOL);
}
Encompass_info
Slur_score_state::get_encompass_info (Grob *col) const
{
- Grob *stem = Grob::unsmob (col->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (col->get_object ("stem"));
Encompass_info ei;
if (!stem)
SCM
Slur::calc_control_points (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Slur_score_state state;
state.fill (me);
SCM
Slur::calc_direction (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "note-columns", encompasses);
if (encompasses.empty ())
-- adding extra height for scripts that avoid slurs on the inside
-- adding extra height for the "bulge" in a slur above a note head
*/
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
int start = scm_to_int (start_scm);
int end = scm_to_int (end_scm);
Direction dir = get_grob_direction (me);
SCM
Slur::height (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
// FIXME uncached
Stencil *m = me->get_stencil ();
SCM
Slur::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "note-columns", encompasses);
if (encompasses.empty ())
{
properties = scm_cons (scm_acons (ly_symbol2scm ("font-size"), scm_from_int (-6), SCM_EOL),
properties);
- Stencil tm = *Stencil::unsmob (Text_interface::interpret_markup
+ Stencil tm = *unsmob<Stencil> (Text_interface::interpret_markup
(me->layout ()->self_scm (), properties,
annotation));
a.add_at_edge (Y_AXIS, get_grob_direction (me), tm, 1.0);
}
SCM encompass_scm = me->get_object ("encompass-objects");
- if (Grob_array::is_smob (encompass_scm))
+ if (unsmob<Grob_array> (encompass_scm))
{
vector<Grob *> &arr
- = Grob_array::unsmob (encompass_scm)->array_reference ();
+ = unsmob<Grob_array> (encompass_scm)->array_reference ();
arr = new_encompasses;
}
}
{
int start = robust_scm2int (start_scm, 0);
int end = robust_scm2int (end_scm, 0);
- Grob *script = Grob::unsmob (grob);
- Grob *slur = Grob::unsmob (script->get_object ("slur"));
+ Grob *script = unsmob<Grob> (grob);
+ Grob *slur = unsmob<Grob> (script->get_object ("slur"));
if (!slur)
return offset_scm;
SCM
Slur::outside_slur_callback (SCM grob, SCM offset_scm)
{
- Grob *script = Grob::unsmob (grob);
- Grob *slur = Grob::unsmob (script->get_object ("slur"));
+ Grob *script = unsmob<Grob> (grob);
+ Grob *slur = unsmob<Grob> (script->get_object ("slur"));
if (!slur)
return offset_scm;
SCM
Slur::vertical_skylines (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
vector<Box> boxes;
if (!me)
if (to_boolean (previous))
return previous;
- Grob *me = Grob::unsmob (smob);
- Grob *slur = Grob::unsmob (me->get_object ("slur"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *slur = unsmob<Grob> (me->get_object ("slur"));
if (!slur)
return SCM_BOOL_F;
SCM
Slur::calc_cross_staff (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "note-columns", cols);
extract_grob_set (me, "encompass-objects", extras);
s = scm_cdr (s))
{
if (scm_is_pair (scm_car (s))
- && Grob::unsmob (scm_cdar (s)) == next_col
- && Spring::is_smob (scm_caar (s)))
- spring = Spring::unsmob (scm_caar (s));
+ && unsmob<Grob> (scm_cdar (s)) == next_col
+ && unsmob<Spring> (scm_caar (s)))
+ spring = unsmob<Spring> (scm_caar (s));
}
if (!spring)
if (Paper_column::is_breakable (l) && Paper_column::is_breakable (r))
{
- Moment *dt = Moment::unsmob (l->get_property ("measure-length"));
+ Moment *dt = unsmob<Moment> (l->get_property ("measure-length"));
Moment mlen (1);
if (dt)
mlen = *dt;
do
{
- if (Moment *len = Moment::unsmob (cols[col_idx]->get_property ("measure-length")))
+ if (Moment *len = unsmob<Moment> (cols[col_idx]->get_property ("measure-length")))
{
return len;
}
Moment shortest_playing_len = 0;
SCM s = lc->get_property ("shortest-playing-duration");
- if (Moment::is_smob (s))
- shortest_playing_len = *Moment::unsmob (s);
+ if (unsmob<Moment> (s))
+ shortest_playing_len = *unsmob<Moment> (s);
if (! shortest_playing_len.to_bool ())
{
}
else if (delta_t.grace_part_)
{
- Grob *grace_spacing = Grob::unsmob (lc->get_object ("grace-spacing"));
+ Grob *grace_spacing = unsmob<Grob> (lc->get_object ("grace-spacing"));
if (grace_spacing)
{
Spacing_options grace_opts;
*/
- Item *r_neighbor = Item::unsmob (col->get_object ("right-neighbor"));
- Item *l_neighbor = Item::unsmob (col->get_object ("left-neighbor"));
+ Item *r_neighbor = unsmob<Item> (col->get_object ("right-neighbor"));
+ Item *l_neighbor = unsmob<Item> (col->get_object ("left-neighbor"));
if (!l_neighbor || !r_neighbor)
return false;
if (loose)
{
- Grob *right_neighbor = Grob::unsmob (c->get_object ("right-neighbor"));
- Grob *left_neighbor = Grob::unsmob (c->get_object ("left-neighbor"));
+ Grob *right_neighbor = unsmob<Grob> (c->get_object ("right-neighbor"));
+ Grob *left_neighbor = unsmob<Grob> (c->get_object ("left-neighbor"));
/*
Either object can be non existent, if the score ends
min_right_rank = right_rank;
}
- Grob *old_left_neighbor = Grob::unsmob (right_col->get_object ("left-neighbor"));
+ Grob *old_left_neighbor = unsmob<Grob> (right_col->get_object ("left-neighbor"));
if (!old_left_neighbor || left_rank > Paper_column::get_rank (old_left_neighbor))
right_col->set_object ("left-neighbor", left_col->self_scm ());
}
if (!Paper_column::is_breakable (it) && !Paper_column::is_musical (it))
continue;
- if (i && !Grob::is_smob (cols[i]->get_object ("left-neighbor")))
+ if (i && !unsmob<Grob> (cols[i]->get_object ("left-neighbor")))
cols[i]->set_object ("left-neighbor", cols[i - 1]->self_scm ());
- if (i + 1 < cols.size () && !Grob::is_smob (cols[i]->get_object ("right-neighbor")))
+ if (i + 1 < cols.size () && !unsmob<Grob> (cols[i]->get_object ("right-neighbor")))
cols[i]->set_object ("right-neighbor", cols[i + 1]->self_scm ());
}
}
spacing_ = make_spanner ("SpacingSpanner", SCM_EOL);
spacing_->set_bound (LEFT,
- Grob::unsmob (get_property ("currentCommandColumn")));
+ unsmob<Grob> (get_property ("currentCommandColumn")));
}
void
{
if (spacing_)
{
- Grob *p = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *p = unsmob<Grob> (get_property ("currentCommandColumn"));
spacing_->set_bound (RIGHT, p);
spacing_ = 0;
Spacing_engraver::stop_translation_timestep ()
{
Paper_column *musical_column
- =
derived_unsmob<Paper_column> (get_property ("currentMusicalColumn"));
+ = unsmob<Paper_column> (get_property ("currentMusicalColumn"));
if (!spacing_)
start_spanner ();
musical_column->set_object ("spacing", spacing_->self_scm ());
- Grob::unsmob (get_property ("currentCommandColumn"))
+ unsmob<Grob> (get_property ("currentCommandColumn"))
->set_object ("spacing", spacing_->self_scm ());
SCM proportional = get_property ("proportionalNotationDuration");
- if (Moment::is_smob (proportional))
+ if (unsmob<Moment> (proportional))
{
musical_column->set_property ("shortest-playing-duration", proportional);
musical_column->set_property ("shortest-starter-duration", proportional);
if (g && Separation_item::has_interface (g) && g->get_column () == columns[d])
{
SCM sky_scm = g->get_property ("horizontal-skylines");
- Skyline_pair *sky = Skyline_pair::unsmob (sky_scm);
+ Skyline_pair *sky = unsmob<Skyline_pair> (sky_scm);
extract_grob_set (g, "elements", elts);
Grob *ycommon = common_refpoint_of_array (elts, g, Y_AXIS);
if (!me->is_live ())
return 0;
- Grob_array *a = Grob_array::unsmob (me->get_object ("right-items"));
+ Grob_array *a = unsmob<Grob_array> (me->get_object ("right-items"));
Item *mincol = 0;
int min_rank = INT_MAX;
for (vsize i = 0; a && i < a->size (); i++)
if (!loose->get_system ())
break;
- Paper_column *le =
derived_unsmob<Paper_column> (scm_car (between));
- Paper_column *re =
derived_unsmob<Paper_column> (scm_cdr (between));
+ Paper_column *le = unsmob<Paper_column> (scm_car (between));
+ Paper_column *re = unsmob<Paper_column> (scm_cdr (between));
if (! (le && re))
break;
Paper_column *loose_col = dynamic_cast<Paper_column *> (clique[j]);
Paper_column *next_col = dynamic_cast<Paper_column *> (clique[j + 1]);
- Grob *spacing = Grob::unsmob (clique_col->get_object ("spacing"));
- if (Grob *grace_spacing = Grob::unsmob (clique_col->get_object ("grace-spacing")))
+ Grob *spacing = unsmob<Grob> (clique_col->get_object ("spacing"));
+ if (Grob *grace_spacing = unsmob<Grob> (clique_col->get_object ("grace-spacing")))
{
spacing = grace_spacing;
}
SCM
Spacing_spanner::set_springs (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
/*
can't use get_system () ? --hwn.
SCM
Spacing_spanner::calc_common_shortest_duration (SCM grob)
{
- Spanner *me = Spanner::unsmob (grob);
+ Spanner *me = unsmob<Spanner> (grob);
vector<Grob *> cols (get_columns (me));
{
if (Paper_column::is_musical (cols[i]))
{
- Moment *when = Moment::unsmob (cols[i]->get_property ("when"));
+ Moment *when = unsmob<Moment> (cols[i]->get_property ("when"));
/*
ignore grace notes for shortest notes.
continue;
SCM st = cols[i]->get_property ("shortest-starter-duration");
- Moment this_shortest = *Moment::unsmob (st);
+ Moment this_shortest = *unsmob<Moment> (st);
assert (this_shortest.to_bool ());
shortest_in_measure = min (shortest_in_measure, this_shortest.main_part_);
}
SCM bsd = me->get_property ("base-shortest-duration");
Rational d = Rational (1, 8);
- if (Moment *m = Moment::unsmob (bsd))
+ if (Moment *m = unsmob<Moment> (bsd))
d = m->main_part_;
if (max_idx != VPOS)
if (Separation_item::is_empty (r) && (!rb || Separation_item::is_empty (rb)))
continue;
- Skyline_pair *skys = Skyline_pair::unsmob (r->get_property ("horizontal-skylines"));
+ Skyline_pair *skys = unsmob<Skyline_pair> (r->get_property ("horizontal-skylines"));
overhangs[i] = skys ? (*skys)[RIGHT].max_height () : 0.0;
if (0 == i) continue;
if (found_matching_column && Note_spacing::has_interface (wish))
{
Real inc = options->increment_;
- Grob *gsp = Grob::unsmob (left_col->get_object ("grace-spacing"));
+ Grob *gsp = unsmob<Grob> (left_col->get_object ("grace-spacing"));
if (gsp && Paper_column::when_mom (left_col).grace_part_)
{
Spacing_options grace_opts;
Moment dt
= Paper_column::when_mom (next) - Paper_column::when_mom (col);
- Moment *len = Moment::unsmob (left->get_property ("measure-length"));
+ Moment *len = unsmob<Moment> (left->get_property ("measure-length"));
if (!len)
return false;
programming_error ("At least one vertical axis group needs to be created in the first time step.");
return;
}
- Grob *vertical_alignment = Grob::get_root_vertical_alignment (Grob::unsmob (scm_caar (axis_groups_)));
+ Grob *vertical_alignment = Grob::get_root_vertical_alignment (unsmob<Grob> (scm_caar (axis_groups_)));
if (!vertical_alignment) // we are at the beginning of a score, so no need for stubs
return;
vector<bool> keep_extent;
for (SCM s = axis_groups_; scm_is_pair (s); s = scm_cdr (s))
{
- Context *c = Context::unsmob (scm_cdar (s));
- Grob *g = Grob::unsmob (scm_caar (s));
+ Context *c = unsmob<Context> (scm_cdar (s));
+ Grob *g = unsmob<Grob> (scm_caar (s));
if (!c || !g)
continue;
if (c->is_removable ())
SCM axis_groups = SCM_EOL;
for (SCM s = axis_groups_; scm_is_pair (s); s = scm_cdr (s))
{
- Context *c = Context::unsmob (scm_cdar (s));
- Grob *g = Grob::unsmob (scm_caar (s));
+ Context *c = unsmob<Context> (scm_cdar (s));
+ Grob *g = unsmob<Grob> (scm_caar (s));
if (!c || !g)
continue;
if (c->is_removable ())
{
LY_ASSERT_SMOB (Spanner, spanner, 1);
LY_ASSERT_TYPE (is_direction, dir, 2);
- Item *bound = Spanner::unsmob (spanner)->get_bound (to_dir (dir));
+ Item *bound = unsmob<Spanner> (spanner)->get_bound (to_dir (dir));
return bound ? bound->self_scm () : SCM_EOL;
}
LY_ASSERT_TYPE (is_direction, dir, 2);
LY_ASSERT_SMOB (Item, item, 3);
- Spanner::unsmob (spanner)->set_bound (to_dir (dir), Item::unsmob (item));
+ unsmob<Spanner> (spanner)->set_bound (to_dir (dir), unsmob<Item> (item));
return SCM_UNSPECIFIED;
}
1, 0, 0, (SCM spanner),
"Return broken-into list for @var{spanner}.")
{
- LY_ASSERT_TYPE (Spanner::unsmob, spanner, 1);
- Spanner *me = Spanner::unsmob (spanner);
+ LY_ASSERT_TYPE (unsmob<Spanner>, spanner, 1);
+ Spanner *me = unsmob<Spanner> (spanner);
SCM s = SCM_EOL;
for (vsize i = me->broken_intos_.size (); i--;)
1, 0, 0, (SCM g),
"Is @var{g} a spanner object?")
{
- Grob *me = Grob::unsmob (g);
+ Grob *me = unsmob<Grob> (g);
bool b = dynamic_cast<Spanner *> (me);
return ly_bool2scm (b);
SCM
Spanner::set_spacing_rods (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM num_length = me->get_property ("minimum-length");
SCM broken_length = me->get_property ("minimum-length-after-break");
if (scm_is_number (num_length)
SCM
Spanner::calc_normalized_endpoints (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
SCM result = SCM_EOL;
Spanner *orig = dynamic_cast<Spanner *> (me->original ());
SCM
Spanner::bounds_width (SCM grob)
{
- Spanner *me = Spanner::unsmob (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 = Spanner::unsmob (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
LY_ASSERT_SMOB (Spring, spring, 1);
LY_ASSERT_TYPE (scm_is_number, strength, 2);
- Spring *s = Spring::unsmob (spring);
+ Spring *s = unsmob<Spring> (spring);
s->set_inverse_compress_strength (scm_to_double (strength));
return s->smobbed_copy ();
}
LY_ASSERT_SMOB (Spring, spring, 1);
LY_ASSERT_TYPE (scm_is_number, strength, 2);
- Spring *s = Spring::unsmob (spring);
+ Spring *s = unsmob<Spring> (spring);
s->set_inverse_stretch_strength (scm_to_double (strength));
return s->smobbed_copy ();
}
if (Page_layout_problem::is_spaceable (*i)
&& ((pure && !Hara_kiri_group_spanner::request_suicide (*i, start, end))
|| (!pure && (*i)->is_live ())))
- return me == Grob::unsmob ((*i)->get_object ("staff-grouper"));
+ return me == unsmob<Grob> ((*i)->get_object ("staff-grouper"));
// If there was no spaceable, living child after me, I don't
// count as within the group.
{
span_ = make_spanner ("StaffSymbol", SCM_EOL);
span_->set_bound (LEFT,
- Grob::unsmob (get_property ("currentCommandColumn")));
+ unsmob<Grob> (get_property ("currentCommandColumn")));
}
}
return;
if (!finished_span_->get_bound (RIGHT))
- finished_span_->set_bound (RIGHT, Grob::unsmob (get_property ("currentCommandColumn")));
+ finished_span_->set_bound (RIGHT, unsmob<Grob> (get_property ("currentCommandColumn")));
announce_end_grob (finished_span_,
span_events_[STOP]
"Return the Y-position of @var{sg} relative to the staff.")
{
LY_ASSERT_SMOB (Grob, sg, 1);
- Grob *g = Grob::unsmob (sg);
+ Grob *g = unsmob<Grob> (sg);
Real pos = Staff_symbol_referencer::get_position (g);
if (fabs (rint (pos) - pos) < 1e-6) // ugh.
{
LY_ASSERT_SMOB (Grob, sg, 1);
LY_ASSERT_TYPE (scm_is_number, spos, 2);
- Grob *g = Grob::unsmob (sg);
+ Grob *g = unsmob<Grob> (sg);
Grob *st = Staff_symbol_referencer::get_staff_symbol (g);
int pos = scm_to_int (spos);
bool on_line = st ? Staff_symbol::on_line (g, pos) : false;
" current staff-space height.")
{
LY_ASSERT_SMOB (Grob, grob, 1);
- Grob *g = Grob::unsmob (grob);
+ Grob *g = unsmob<Grob> (grob);
Real thickness = Staff_symbol_referencer::line_thickness (g);
return scm_from_double (thickness);
}
" five-line staff.")
{
LY_ASSERT_SMOB (Grob, grob, 1);
- Grob *g = Grob::unsmob (grob);
+ Grob *g = unsmob<Grob> (grob);
Real staff_space = Staff_symbol_referencer::staff_space (g);
return scm_from_double (staff_space);
}
" @var{grob}.")
{
LY_ASSERT_SMOB (Grob, grob, 1);
- Grob *g = Grob::unsmob (grob);
+ Grob *g = unsmob<Grob> (grob);
Real staff_radius = Staff_symbol_referencer::staff_radius (g);
return scm_from_double (staff_radius);
}
return me;
SCM st = me->get_object ("staff-symbol");
- return Grob::unsmob (st);
+ return unsmob<Grob> (st);
}
Real
SCM
Staff_symbol_referencer::callback (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM pos = me->get_property ("staff-position");
Real off = 0.0;
SCM
Staff_symbol::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Spanner *sp = dynamic_cast<Spanner *> (me);
Grob *common
= sp->get_bound (LEFT)->common_refpoint (sp->get_bound (RIGHT), X_AXIS);
SCM
Staff_symbol::height (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real t = me->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
t *= robust_scm2double (me->get_property ("thickness"), 1.0);
for a note head is always <= 2.
*/
Stream_event *ev = gi.event_cause ();
- Duration *dur = Duration::unsmob (ev->get_property ("duration"));
+ Duration *dur = unsmob<Duration> (ev->get_property ("duration"));
int tremolo_flags = intlog2 (requested_type) - 2
- (dur->duration_log () > 2 ? dur->duration_log () - 2 : 0);
Stream_event *cause = gi.event_cause ();
if (!cause)
return;
- Duration *d = Duration::unsmob (cause->get_property ("duration"));
+ Duration *d = unsmob<Duration> (cause->get_property ("duration"));
if (!d)
return;
Stem_engraver::kill_unused_flags ()
{
for (vsize i = 0; i < maybe_flags_.size (); i++)
- if (Grob::is_smob (maybe_flags_[i]->get_parent (X_AXIS)->get_object ("beam")))
+ if (unsmob<Grob> (maybe_flags_[i]->get_parent (X_AXIS)->get_object ("beam")))
maybe_flags_[i]->suicide ();
}
SCM
Stem_tremolo::calc_slope (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
Spanner *beam = Stem::get_beam (stem);
SCM style = me->get_property ("style");
SCM
Stem_tremolo::calc_width (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
Direction dir = get_grob_direction (me);
bool beam = Stem::get_beam (stem);
bool flag = Stem::duration_log (stem) >= 3 && !beam;
SCM
Stem_tremolo::calc_shape (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *me = unsmob<Grob> (smob);
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
Direction dir = get_grob_direction (me);
bool beam = Stem::get_beam (stem);
bool flag = Stem::duration_log (stem) >= 3 && !beam;
Real
Stem_tremolo::get_beam_translation (Grob *me)
{
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
Spanner *beam = Stem::get_beam (stem);
return (beam && beam->is_live ())
SCM
Stem_tremolo::pure_height (SCM smob, SCM, SCM)
{
- Item *me = Item::unsmob (smob);
+ Item *me = unsmob<Item> (smob);
/*
Cannot use the real slope, since it looks at the Beam.
*/
Stencil s1 (untranslated_stencil (me, 0.35));
- Item *stem = Item::unsmob (me->get_object ("stem"));
+ Item *stem = unsmob<Item> (me->get_object ("stem"));
if (!stem)
return ly_interval2scm (s1.extent (Y_AXIS));
SCM
Stem_tremolo::width (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
/*
Cannot use the real slope, since it looks at the Beam.
Stencil
Stem_tremolo::untranslated_stencil (Grob *me, Real slope)
{
- Grob *stem = Grob::unsmob (me->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (me->get_object ("stem"));
if (!stem)
{
programming_error ("no stem for stem-tremolo");
SCM
Stem_tremolo::calc_y_offset (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return scm_from_double (y_offset (me, false));
}
SCM, /* start */
SCM /* end */)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return scm_from_double (y_offset (me, true));
}
SCM
Stem_tremolo::calc_direction (SCM smob)
{
- Item *me = Item::unsmob (smob);
+ Item *me = unsmob<Item> (smob);
- Item *stem = Item::unsmob (me->get_object ("stem"));
+ Item *stem = unsmob<Item> (me->get_object ("stem"));
if (!stem)
return scm_from_int (CENTER);
Real
Stem_tremolo::y_offset (Grob *me, bool pure)
{
- Item *stem = Item::unsmob (me->get_object ("stem"));
+ Item *stem = unsmob<Item> (me->get_object ("stem"));
if (!stem)
return 0.0;
SCM
Stem_tremolo::print (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
Stencil s = untranslated_stencil (me, robust_scm2double (me->get_property ("slope"), 0.25));
return s.smobbed_copy ();
// todo: margins
Direction d = get_grob_direction (me);
- Grob *beam = Grob::unsmob (me->get_object ("beam"));
+ Grob *beam = unsmob<Grob> (me->get_object ("beam"));
if (d && d * head_positions (me)[get_grob_direction (me)] >= se * d)
me->warning (_ ("weird stem size, check for narrow beams"));
SCM /* start */,
SCM /* end */)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return ly_interval2scm (internal_pure_height (me, true));
}
if (!is_normal_stem (me))
return Interval (0.0, 0.0);
- Grob *beam = Grob::unsmob (me->get_object ("beam"));
+ Grob *beam = unsmob<Grob> (me->get_object ("beam"));
Interval iv = internal_height (me, false);
SCM
Stem::calc_stem_end_position (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return scm_from_double (internal_calc_stem_end_position (me, true));
}
SCM, /* start */
SCM /* end */)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return scm_from_double (internal_calc_stem_end_position (me, false));
}
length *= robust_scm2double (me->get_property ("length-fraction"), 1.0);
/* Tremolo stuff. */
- Grob *t_flag = Grob::unsmob (me->get_object ("tremolo-flag"));
- if (t_flag && (!Grob::is_smob (me->get_object ("beam")) || !calc_beam))
+ Grob *t_flag = unsmob<Grob> (me->get_object ("tremolo-flag"));
+ if (t_flag && (!unsmob<Grob> (me->get_object ("beam")) || !calc_beam))
{
/* Crude hack: add extra space if tremolo flag is there.
SCM
Stem::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
if (!head_count (me))
return SCM_BOOL_T;
SCM
Stem::calc_direction (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Direction dir = CENTER;
- if (Grob *beam = Grob::unsmob (me->get_object ("beam")))
+ if (Grob *beam = unsmob<Grob> (me->get_object ("beam")))
{
SCM ignore_me = beam->get_property ("direction");
(void) ignore_me;
SCM
Stem::calc_default_direction (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Direction dir = CENTER;
int staff_center = 0;
SCM
Stem::height (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return ly_interval2scm (internal_height (me, true));
}
Real
Stem::beam_end_corrective (Grob *me)
{
- Grob *beam = Grob::unsmob (me->get_object ("beam"));
+ Grob *beam = unsmob<Grob> (me->get_object ("beam"));
Direction dir = get_grob_direction (me);
if (beam)
{
If there is a beam but no stem, slope calculations depend on this
routine to return where the stem end /would/ be.
*/
- if (calc_beam && !beam && !Stencil::is_smob (me->get_property ("stencil")))
+ if (calc_beam && !beam && !unsmob<Stencil> (me->get_property ("stencil")))
return Interval ();
Real y1 = robust_scm2double ((calc_beam
SCM
Stem::width (SCM e)
{
- Grob *me = Grob::unsmob (e);
+ Grob *me = unsmob<Grob> (e);
Interval r;
SCM
Stem::calc_stem_begin_position (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return scm_from_double (internal_calc_stem_begin_position (me, true));
}
SCM, /* start */
SCM /* end */)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return scm_from_double (internal_calc_stem_begin_position (me, false));
}
SCM
Stem::pure_calc_length (SCM smob, SCM /*start*/, SCM /*end*/)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real beg = robust_scm2double (me->get_pure_property ("stem-begin-position", 0, INT_MAX), 0.0);
Real res = fabs (internal_calc_stem_end_position (me, false) - beg);
return scm_from_double (res);
SCM
Stem::calc_length (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- if (Grob::is_smob (me->get_object ("beam")))
+ Grob *me = unsmob<Grob> (smob);
+ if (unsmob<Grob> (me->get_object ("beam")))
{
me->programming_error ("ly:stem::calc-length called but will not be used for beamed stem.");
return scm_from_double (0.0);
if (!me)
return false;
Grob *lh = get_reference_head (me);
- Grob *beam = Grob::unsmob (me->get_object ("beam"));
+ Grob *beam = unsmob<Grob> (me->get_object ("beam"));
if (!lh && !beam)
return false;
SCM
Stem::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
if (!is_valid_stem (me))
return SCM_EOL;
SCM
Stem::offset_callback (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "rests", rests);
if (rests.size ())
Stem::get_beam (Grob *me)
{
SCM b = me->get_object ("beam");
- return Spanner::unsmob (b);
+ return unsmob<Spanner> (b);
}
Stem_info
SCM
Stem::calc_stem_info (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Direction my_dir = get_grob_direction (me);
if (!my_dir)
: 0.0);
Real height_of_my_trem = 0.0;
- Grob *trem = Grob::unsmob (me->get_object ("tremolo-flag"));
+ Grob *trem = unsmob<Grob> (me->get_object ("tremolo-flag"));
if (trem)
{
height_of_my_trem
bool
Stem::is_cross_staff (Grob *stem)
{
- Grob *beam = Grob::unsmob (stem->get_object ("beam"));
+ Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
return beam && Beam::is_cross_staff (beam);
}
SCM
Stem::calc_cross_staff (SCM smob)
{
- return scm_from_bool (is_cross_staff (Grob::unsmob (smob)));
+ return scm_from_bool (is_cross_staff (unsmob<Grob> (smob)));
}
Grob *
Stem::flag (Grob *me)
{
- return Grob::unsmob (me->get_object ("flag"));
+ return unsmob<Grob> (me->get_object ("flag"));
}
/* FIXME: Too many properties */
make_named_glyph_boxes (vector<Box> &boxes, vector<Drul_array<Offset> > &buildings, PangoMatrix trans, SCM expr)
{
SCM fm_scm = scm_car (expr);
- Font_metric *fm = Font_metric::unsmob (fm_scm);
+ Font_metric *fm = unsmob<Font_metric> (fm_scm);
expr = scm_cdr (expr);
SCM glyph = scm_car (expr);
string glyph_s = ly_scm2string (glyph);
make_glyph_string_boxes (vector<Box> &boxes, vector<Drul_array<Offset> > &buildings, PangoMatrix trans, SCM expr)
{
SCM fm_scm = scm_car (expr);
- Font_metric *fm = Font_metric::unsmob (fm_scm);
+ Font_metric *fm = unsmob<Font_metric> (fm_scm);
expr = scm_cdr (expr);
expr = scm_cdr (expr); // font-name
expr = scm_cdr (expr); // size
SCM
Grob::pure_simple_vertical_skylines_from_extents (SCM smob, SCM begscm, SCM endscm)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
int beg = robust_scm2int (begscm, 0);
int end = robust_scm2int (endscm, INT_MAX);
// We cannot measure the widths before line breaking,
SCM
Grob::simple_vertical_skylines_from_extents (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return maybe_pure_internal_simple_skylines_from_extents (me, X_AXIS, false, 0, 0, false, false);
}
SCM
Grob::pure_simple_horizontal_skylines_from_extents (SCM smob, SCM begscm, SCM endscm)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
int beg = robust_scm2int (begscm, 0);
int end = robust_scm2int (endscm, INT_MAX);
// If the grob is cross staff, we cannot measure its Y-extent before
SCM
Grob::simple_horizontal_skylines_from_extents (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
// See comment in function above.
return maybe_pure_internal_simple_skylines_from_extents (me, Y_AXIS, false, 0, 0, false, to_boolean (me->get_property ("cross-staff")));
}
SCM
Stencil::skylines_from_stencil (SCM sten, Real pad, Axis a)
{
- Stencil *s = Stencil::unsmob (sten);
+ Stencil *s = unsmob<Stencil> (sten);
if (!s)
return Skyline_pair ().smobbed_copy ();
SCM
Grob::vertical_skylines_from_stencil (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real pad = robust_scm2double (me->get_property ("skyline-horizontal-padding"), 0.0);
SCM out = Stencil::skylines_from_stencil (me->get_property ("stencil"), pad, X_AXIS);
SCM
Grob::horizontal_skylines_from_stencil (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Real pad = robust_scm2double (me->get_property ("skyline-vertical-padding"), 0.0);
SCM out = Stencil::skylines_from_stencil (me->get_property ("stencil"), pad, Y_AXIS);
Skyline_pair res;
for (vsize i = 0; i < elts.size (); i++)
{
- Skyline_pair *skyp = Skyline_pair::unsmob (elts[i]->get_maybe_pure_property (a == X_AXIS ? "vertical-skylines" : "horizontal-skylines", pure, beg, end));
+ Skyline_pair *skyp = unsmob<Skyline_pair> (elts[i]->get_maybe_pure_property (a == X_AXIS ? "vertical-skylines" : "horizontal-skylines", pure, beg, end));
if (skyp)
{
/*
SCM
Grob::vertical_skylines_from_element_stencils (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return internal_skylines_from_element_stencils (me, X_AXIS, false, 0, INT_MAX);
}
SCM
Grob::horizontal_skylines_from_element_stencils (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
return internal_skylines_from_element_stencils (me, Y_AXIS, false, 0, INT_MAX);
}
SCM
Grob::pure_vertical_skylines_from_element_stencils (SCM smob, SCM beg_scm, SCM end_scm)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
int beg = robust_scm2int (beg_scm, 0);
int end = robust_scm2int (end_scm, 0);
return internal_skylines_from_element_stencils (me, X_AXIS, true, beg, end);
SCM
Grob::pure_horizontal_skylines_from_element_stencils (SCM smob, SCM beg_scm, SCM end_scm)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
int beg = robust_scm2int (beg_scm, 0);
int end = robust_scm2int (end_scm, 0);
return internal_skylines_from_element_stencils (me, Y_AXIS, true, beg, end);
"Return a copy of @var{stil} but translated by @var{amount}"
" in @var{axis} direction.")
{
- Stencil *s = Stencil::unsmob (stil);
+ Stencil *s = unsmob<Stencil> (stil);
LY_ASSERT_SMOB (Stencil, stil, 1);
LY_ASSERT_TYPE (scm_is_number, amount, 2);
SCM new_s = s->smobbed_copy ();
scm_remember_upto_here_1 (stil);
- Stencil *q = Stencil::unsmob (new_s);
+ Stencil *q = unsmob<Stencil> (new_s);
q->translate_axis (real_amount, Axis (scm_to_int (axis)));
return new_s;
}
"Return a @var{stil}, but translated by @var{offset}"
" (a pair of numbers).")
{
- Stencil *s = Stencil::unsmob (stil);
+ Stencil *s = unsmob<Stencil> (stil);
LY_ASSERT_SMOB (Stencil, stil, 1);
LY_ASSERT_TYPE (is_number_pair, offset, 2);
Offset o = ly_scm2offset (offset);
SCM new_s = s->smobbed_copy ();
scm_remember_upto_here_1 (stil);
- Stencil *q = Stencil::unsmob (new_s);
+ Stencil *q = unsmob<Stencil> (new_s);
q->translate (o);
return new_s;
}
1, 0, 0, (SCM stil),
"Return the expression of @var{stil}.")
{
- Stencil *s = Stencil::unsmob (stil);
+ Stencil *s = unsmob<Stencil> (stil);
LY_ASSERT_SMOB (Stencil, stil, 1);
return s->expr ();
}
" @var{axis} direction (@code{0} or @code{1} for x and"
" y@tie{}axis, respectively).")
{
- Stencil *s = Stencil::unsmob (stil);
+ Stencil *s = unsmob<Stencil> (stil);
LY_ASSERT_SMOB (Stencil, stil, 1);
LY_ASSERT_TYPE (is_axis, axis, 2);
" @var{axis} is supplied, the emptiness check is"
" restricted to that axis.")
{
- Stencil *s = Stencil::unsmob (stil);
+ Stencil *s = unsmob<Stencil> (stil);
LY_ASSERT_SMOB (Stencil, stil, 1);
if (SCM_UNBNDP (axis))
return scm_from_bool (s->is_empty ());
" space. @var{first} and @var{second} may also be @code{'()} or"
" @code{#f}.")
{
- Stencil *s1 = Stencil::unsmob (first);
- Stencil *s2 = Stencil::unsmob (second);
+ Stencil *s1 = unsmob<Stencil> (first);
+ Stencil *s2 = unsmob<Stencil> (second);
Stencil result;
SCM_ASSERT_TYPE (s1 || scm_is_false (first) || scm_is_null (first),
" apart at least by this distance. If either of the stencils"
" is spacing, @var{padding} and @var{mindist} do not apply.")
{
- Stencil *s1 = Stencil::unsmob (first);
- Stencil *s2 = Stencil::unsmob (second);
+ Stencil *s1 = unsmob<Stencil> (first);
+ Stencil *s2 = unsmob<Stencil> (second);
Stencil result;
SCM_ASSERT_TYPE (s1 || scm_is_false (first) || scm_is_null (first),
while (!SCM_NULLP (args))
{
- Stencil *s = Stencil::unsmob (scm_car (args));
+ Stencil *s = unsmob<Stencil> (scm_car (args));
if (!s)
SCM_ASSERT_TYPE (s, scm_car (args), SCM_ARGn, __FUNCTION__, "Stencil");
LY_ASSERT_TYPE (is_axis, axis, 2);
LY_ASSERT_TYPE (scm_is_number, dir, 3);
- Stencil target = *Stencil::unsmob (stil);
+ Stencil target = *unsmob<Stencil> (stil);
target.align_to ((Axis)scm_to_int (axis),
scm_to_double (dir));
" in@tie{}@var{s}.")
{
LY_ASSERT_SMOB (Stencil, s, 1);
- Stencil *stil = Stencil::unsmob (s);
+ Stencil *stil = unsmob<Stencil> (s);
return find_expression_fonts (stil->expr ());
}
"Put @var{stc} in a different color.")
{
LY_ASSERT_SMOB (Stencil, stc, 1);
- Stencil *stil = Stencil::unsmob (stc);
+ Stencil *stil = unsmob<Stencil> (stc);
return Stencil (stil->extent_box (),
scm_list_3 (ly_symbol2scm ("color"),
scm_list_3 (r, g, b),
" the relative offset (@var{x}, @var{y}). E.g., an offset of"
" (-1, 1) will rotate the stencil around the left upper corner.")
{
- Stencil *s = Stencil::unsmob (stil);
+ Stencil *s = unsmob<Stencil> (stil);
LY_ASSERT_SMOB (Stencil, stil, 1);
LY_ASSERT_TYPE (scm_is_number, angle, 2);
LY_ASSERT_TYPE (scm_is_number, x, 3);
Real y_off = scm_to_double (y);
SCM new_s = s->smobbed_copy ();
- Stencil *q = Stencil::unsmob (new_s);
+ Stencil *q = unsmob<Stencil> (new_s);
q->rotate_degrees (a, Offset (x_off, y_off));
return new_s;
}
"Return a stencil @var{stil} rotated @var{angle} degrees around"
" point (@var{x}, @var{y}), given in absolute coordinates.")
{
- Stencil *s = Stencil::unsmob (stil);
+ Stencil *s = unsmob<Stencil> (stil);
LY_ASSERT_SMOB (Stencil, stil, 1);
LY_ASSERT_TYPE (scm_is_number, angle, 2);
LY_ASSERT_TYPE (scm_is_number, x, 3);
Real y_off = scm_to_double (y);
SCM new_s = s->smobbed_copy ();
- Stencil *q = Stencil::unsmob (new_s);
+ Stencil *q = unsmob<Stencil> (new_s);
q->rotate_degrees_absolute (a, Offset (x_off, y_off));
return new_s;
}
" flip or mirror @var{stil} without changing its origin;"
" this may result in collisions unless it is repositioned.")
{
- Stencil *s = Stencil::unsmob (stil);
+ Stencil *s = unsmob<Stencil> (stil);
LY_ASSERT_SMOB (Stencil, stil, 1);
LY_ASSERT_TYPE (scm_is_number, x, 2);
LY_ASSERT_TYPE (scm_is_number, y, 3);
SCM new_s = s->smobbed_copy ();
- Stencil *q = Stencil::unsmob (new_s);
+ Stencil *q = unsmob<Stencil> (new_s);
q->scale (scm_to_double (x), scm_to_double (y));
return new_s;
1, 0, 0, (SCM obj),
"Is @code{@var{obj}} a @code{Stream_event} object?")
{
- return scm_from_bool (Stream_event::is_smob (obj));
+ return scm_from_bool (unsmob<Stream_event> (obj));
}
LY_DEFINE (ly_make_stream_event, "ly:make-stream-event",
" If @var{sym} is undefined, return @var{val} or"
" @code{'()} if @var{val} is not specified.")
{
- LY_ASSERT_SMOB (Stream_event, sev, 1)
+ LY_ASSERT_SMOB (Stream_event, sev, 1);
return ly_prob_property (sev, sym, val);
}
"Copy @var{m} and all sub expressions of@tie{}@var{m}.")
{
SCM copy = m;
- if (Stream_event *ev = Stream_event::unsmob (m))
+ if (Stream_event *ev = unsmob<Stream_event> (m))
{
ev = ev->clone ();
copy = ev->unprotect ();
Input *
Stream_event::origin () const
{
- Input *i = Input::unsmob (get_property ("origin"));
+ Input *i = unsmob<Input> (get_property ("origin"));
return i ? i : &dummy_input_global;
}
SCM prop = scm_car (entry);
SCM val = scm_cdr (entry);
- if ((Pitch::is_smob (val)
- || (scm_is_eq (prop, ly_symbol2scm ("element")) && Music::is_smob (val))
+ if ((unsmob<Pitch> (val)
+ || (scm_is_eq (prop, ly_symbol2scm ("element")) && unsmob<Music> (val))
|| (scm_is_eq (prop, ly_symbol2scm ("elements")) && scm_is_pair (val))
|| (scm_is_eq (prop, ly_symbol2scm ("pitch-alist")) && scm_is_pair (val)))
&& scm_is_false (scm_assq (prop, mutable_property_alist_)))
SCM
Stream_event::dump (SCM self)
{
- Stream_event *ev = Stream_event::unsmob (self);
+ Stream_event *ev = unsmob<Stream_event> (self);
// Reversed alists look prettier.
return scm_cons (scm_reverse (ev->immutable_property_alist_),
scm_reverse (ev->mutable_property_alist_));
SCM
Sustain_pedal::print (SCM smob)
{
- Grob *e = Grob::unsmob (smob);
+ Grob *e = unsmob<Grob> (smob);
Stencil mol;
SCM glyph = e->get_property ("text");
nesting_->from_list (hierarchy);
nesting_->create_grobs (this, delimiter_name);
nesting_->set_bound (LEFT,
- Grob::unsmob (get_property ("currentCommandColumn")));
+ unsmob<Grob> (get_property ("currentCommandColumn")));
}
}
if (nesting_)
{
nesting_->set_bound (RIGHT,
- Grob::unsmob (get_property ("currentCommandColumn")));
+ unsmob<Grob> (get_property ("currentCommandColumn")));
nesting_->set_nesting_support (0);
delete nesting_;
SCM
System_start_delimiter::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
extract_grob_set (me, "elements", elts);
Grob *common = common_refpoint_of_array (elts, me, Y_AXIS);
System::init_elements ()
{
SCM scm_arr = Grob_array::make_array ();
- all_elements_ = Grob_array::unsmob (scm_arr);
+ all_elements_ = unsmob<Grob_array> (scm_arr);
all_elements_->set_ordered (false);
set_object ("all-elements", scm_arr);
}
SCM footnote_stl = Text_interface::interpret_markup (pscore_->layout ()->self_scm (),
props, footnote_markup);
- Stencil *footnote_stencil = Stencil::unsmob (footnote_stl);
+ Stencil *footnote_stencil = unsmob<Stencil> (footnote_stl);
out.push_back (footnote_stencil->extent (Y_AXIS).length ());
}
SCM
System::footnotes_before_line_breaking (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
vector<Grob *> footnotes;
SCM grobs_scm = Grob_array::make_array ();
extract_grob_set (me, "all-elements", elts);
if (elts[i]->internal_has_interface (ly_symbol2scm ("footnote-interface")))
footnotes.push_back (elts[i]);
- Grob_array::unsmob (grobs_scm)->set_array (footnotes);
+ unsmob<Grob_array> (grobs_scm)->set_array (footnotes);
return grobs_scm;
}
SCM
System::footnotes_after_line_breaking (SCM smob)
{
- Spanner *sys_span = Spanner::unsmob (smob);
+ Spanner *sys_span = unsmob<Spanner> (smob);
System *sys = dynamic_cast<System *> (sys_span);
Interval_t<int> sri = sys->spanned_rank_interval ();
vector<Grob *> footnote_grobs = sys->get_footnote_grobs_in_range (sri[LEFT], sri[RIGHT]);
vector_sort (footnote_grobs, grob_2D_less);
SCM grobs_scm = Grob_array::make_array ();
- Grob_array::unsmob (grobs_scm)->set_array (footnote_grobs);
+ unsmob<Grob_array> (grobs_scm)->set_array (footnote_grobs);
return grobs_scm;
}
SCM
System::vertical_skyline_elements (SCM smob)
{
- Grob *me_grob = Grob::unsmob (smob);
+ Grob *me_grob = unsmob<Grob> (smob);
vector<Grob *> vertical_skyline_grobs;
extract_grob_set (me_grob, "elements", my_elts);
for (vsize i = 0; i < my_elts.size (); i++)
vertical_skyline_grobs.push_back (my_elts[i]);
System *me = dynamic_cast<System *> (me_grob);
- Grob *align = Grob::unsmob (me->get_object ("vertical-alignment"));
+ Grob *align = unsmob<Grob> (me->get_object ("vertical-alignment"));
if (!align)
{
SCM grobs_scm = Grob_array::make_array ();
- Grob_array::unsmob (grobs_scm)->set_array (vertical_skyline_grobs);
+ unsmob<Grob_array> (grobs_scm)->set_array (vertical_skyline_grobs);
return grobs_scm;
}
vertical_skyline_grobs.push_back (elts[i]);
SCM grobs_scm = Grob_array::make_array ();
- Grob_array::unsmob (grobs_scm)->set_array (vertical_skyline_grobs);
+ unsmob<Grob_array> (grobs_scm)->set_array (vertical_skyline_grobs);
return grobs_scm;
}
System::add_column (Paper_column *p)
{
Grob *me = this;
- Grob_array *ga = Grob_array::unsmob (me->get_object ("columns"));
+ Grob_array *ga = unsmob<Grob_array> (me->get_object ("columns"));
if (!ga)
{
SCM scm_ga = Grob_array::make_array ();
me->set_object ("columns", scm_ga);
- ga = Grob_array::unsmob (scm_ga);
+ ga = unsmob<Grob_array> (scm_ga);
}
p->set_rank (ga->size ());
exprs));
if (debug_skylines)
{
- Skyline_pair *skylines = Skyline_pair::unsmob (get_property ("vertical-skylines"));
+ Skyline_pair *skylines = unsmob<Skyline_pair> (get_property ("vertical-skylines"));
if (skylines)
{
Stencil up
pl->set_property ("last-in-score", SCM_BOOL_T);
Interval staff_refpoints;
- if (Grob *align = Grob::unsmob (get_object ("vertical-alignment")))
+ if (Grob *align = unsmob<Grob> (get_object ("vertical-alignment")))
{
extract_grob_set (align, "elements", staves);
for (vsize i = 0; i < staves.size (); i++)
SCM
System::get_vertical_alignment (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "elements", elts);
Grob *ret = 0;
for (vsize i = 0; i < elts.size (); i++)
Grob *
System::get_extremal_staff (Direction dir, Interval const &iv)
{
- Grob *align = Grob::unsmob (get_object ("vertical-alignment"));
+ Grob *align = unsmob<Grob> (get_object ("vertical-alignment"));
if (!align)
return 0;
Grob *
System::get_neighboring_staff (Direction dir, Grob *vertical_axis_group, Interval_t<int> bounds)
{
- Grob *align = Grob::unsmob (get_object ("vertical-alignment"));
+ Grob *align = unsmob<Grob> (get_object ("vertical-alignment"));
if (!align)
return 0;
System::pure_refpoint_extent (vsize start, vsize end)
{
Interval ret;
- Grob *alignment = Grob::unsmob (get_object ("vertical-alignment"));
+ Grob *alignment = unsmob<Grob> (get_object ("vertical-alignment"));
if (!alignment)
return Interval ();
Interval
System::part_of_line_pure_height (vsize start, vsize end, bool begin)
{
- Grob *alignment = Grob::unsmob (get_object ("vertical-alignment"));
+ Grob *alignment = unsmob<Grob> (get_object ("vertical-alignment"));
if (!alignment)
return Interval ();
SCM
System::calc_pure_relevant_grobs (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "elements", elts);
vector<Grob *> relevant_grobs;
SCM grobs_scm = Grob_array::make_array ();
- Grob_array::unsmob (grobs_scm)->set_array (relevant_grobs);
+ unsmob<Grob_array> (grobs_scm)->set_array (relevant_grobs);
return grobs_scm;
}
SCM
System::calc_pure_height (SCM smob, SCM start_scm, SCM end_scm)
{
- System *me = derived_unsmob<System> (smob);
+ System *me = unsmob<System> (smob);
int start = scm_to_int (start_scm);
int end = scm_to_int (end_scm);
static SCM
get_maybe_spaceable_staves (SCM smob, int filter)
{
- System *me = derived_unsmob<System> (smob);
- Grob *align = Grob::unsmob (me->get_object ("vertical_alignment"));
+ System *me = unsmob<System> (smob);
+ Grob *align = unsmob<Grob> (me->get_object ("vertical_alignment"));
SCM ret = SCM_EOL;
if (align)
if (left_item)
{
SCM left_cause = left_item->get_property ("cause");
- Item *slur_cause = Item::unsmob (left_cause);
+ Item *slur_cause = unsmob<Item> (left_cause);
if (slur_cause == note_heads_[k])
{
note_heads_[k]->set_property ("span-start", SCM_BOOL_T);
Tempo_performer::process_music ()
{
SCM w = get_property ("tempoWholesPerMinute");
- if (Moment::is_smob (w)
+ if (unsmob<Moment> (w)
&& !ly_is_equal (w, last_tempo_))
{
- Rational r = Moment::unsmob (w)->main_part_;
+ Rational r = unsmob<Moment> (w)->main_part_;
r *= Rational (4, 1);
audio_ = new Audio_tempo (r.to_int ());
extract_grob_set (info.grob (), "note-heads", heads);
Grob *x_parent = (heads.size ()
? info.grob ()
- : Grob::unsmob (info.grob ()->get_object ("rest")));
+ : unsmob<Grob> (info.grob ()->get_object ("rest")));
for (vsize i = 0; i < scripts_.size (); i++)
{
LY_ASSERT_TYPE (scm_is_string, markup, 3);
string str = ly_scm2string (markup);
- Output_def *layout = Output_def::unsmob (layout_smob);
+ Output_def *layout = unsmob<Output_def> (layout_smob);
Font_metric *fm = select_encoded_font (layout, props);
replace_special_characters (str, props);
SCM
Text_interface::print (SCM grob)
{
- Grob *me = Grob::unsmob (grob);
+ Grob *me = unsmob<Grob> (grob);
SCM t = me->get_property ("text");
SCM chain = Font_interface::text_font_alist_chain (me);
{
if (!finished_->get_bound (RIGHT))
{
- Grob *e = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *e = unsmob<Grob> (get_property ("currentMusicalColumn"));
finished_->set_bound (RIGHT, e);
}
finished_ = 0;
{
if (span_ && !span_->get_bound (LEFT))
{
- Grob *e = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *e = unsmob<Grob> (get_property ("currentMusicalColumn"));
span_->set_bound (LEFT, e);
}
SCM
Tie_column::before_line_breaking (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
for (SCM s = me->get_property ("ties"); scm_is_pair (s); s = scm_cdr (s))
{
- Spanner *tie = Spanner::unsmob (scm_car (s));
+ Spanner *tie = unsmob<Spanner> (scm_car (s));
for (LEFT_and_RIGHT (dir))
{
if (dir * tie->get_bound (dir)->get_column ()->get_rank ()
SCM
Tie_column::calc_positioning_done (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "ties", ro_ties);
vector<Grob *> ties (ro_ties);
if (!ties.size ())
for (vsize i = 0; i < heads_to_tie_.size (); i++)
{
Grob *th = heads_to_tie_[i].head_;
- Stream_event *right_ev = Stream_event::unsmob (h->get_property ("cause"));
- Stream_event *left_ev = Stream_event::unsmob (th->get_property ("cause"));
+ Stream_event *right_ev = unsmob<Stream_event> (h->get_property ("cause"));
+ Stream_event *left_ev = unsmob<Stream_event> (th->get_property ("cause"));
/*
maybe should check positions too.
SCM p1 = left_ev->get_property ("pitch");
SCM p2 = right_ev->get_property ("pitch");
if ((enharmonic
- ? (Pitch::is_smob (p1) && Pitch::is_smob (p2) &&
- Pitch::unsmob (p1)->tone_pitch () == Pitch::unsmob (p2)->tone_pitch ())
+ ? (unsmob<Pitch> (p1) && unsmob<Pitch> (p2) &&
+ unsmob<Pitch> (p1)->tone_pitch () == unsmob<Pitch> (p2)->tone_pitch ())
: ly_is_equal (p1, p2))
&& (!Tie_engraver::has_autosplit_end (left_ev)))
{
{
Grob *head = now_heads_[i];
Stream_event *left_ev
- = Stream_event::unsmob (head->get_property ("cause"));
+ = unsmob<Stream_event> (head->get_property ("cause"));
if (!left_ev)
{
!tie_event && !tie_stream_event && scm_is_pair (s);
s = scm_cdr (s))
{
- Stream_event *ev = Stream_event::unsmob (scm_car (s));
+ Stream_event *ev = unsmob<Stream_event> (scm_car (s));
if (!ev)
continue;
continue;
if (!stem)
- stem = Grob::unsmob (head->get_object ("stem"));
+ stem = unsmob<Grob> (head->get_object ("stem"));
Real p = Staff_symbol_referencer::get_position (head);
Interval y ((p - 1) * 0.5 * staff_space,
boxes.push_back (Box (x, y));
}
- Grob *acc = Grob::unsmob (heads[i]->get_object ("accidental-grob"));
+ Grob *acc = unsmob<Grob> (heads[i]->get_object ("accidental-grob"));
if (acc)
acc->get_property ("after-line-breaking"); /* trigger tie-related suicide */
for (vsize i = 0; i < semi_ties.size (); i++)
{
Tie_specification spec;
- Item *head = Item::unsmob (semi_ties[i]->get_object ("note-head"));
+ Item *head = unsmob<Item> (semi_ties[i]->get_object ("note-head"));
if (!head)
programming_error ("LV tie without head?!");
if (!spec.note_head_drul_[d])
continue;
- Grob *stem = Grob::unsmob (spec.note_head_drul_[d]->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (spec.note_head_drul_[d]->get_object ("stem"));
if (stem
&& Stem::is_normal_stem (stem))
stems[d] = stem;
SCM p1 = left_mus->get_property ("pitch");
SCM p2 = right_mus->get_property ("pitch");
- if (Pitch::is_smob (p1) && Pitch::is_smob (p2)
- && Pitch::unsmob (p1)->tone_pitch () == Pitch::unsmob (p2)->tone_pitch ())
+ if (unsmob<Pitch> (p1) && unsmob<Pitch> (p2)
+ && unsmob<Pitch> (p1)->tone_pitch () == unsmob<Pitch> (p2)->tone_pitch ())
{
found = true;
// (*it).moment_ already stores the end of the tied note!
Direction hd = to_dir (me->get_property ("head-direction"));
return (hd == d)
- ? Grob::unsmob (me->get_object ("note-head"))
+ ? unsmob<Grob> (me->get_object ("note-head"))
: 0;
}
SCM
Tie::calc_direction (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *yparent = me->get_parent (Y_AXIS);
if ((Tie_column::has_interface (yparent)
|| Semi_tie_column::has_interface (yparent))
- && Grob_array::is_smob (yparent->get_object ("ties"))
- // && Grob_array::unsmob (yparent->get_object ("ties"))->size () > 1
+ && unsmob<Grob_array> (yparent->get_object ("ties"))
+ // && unsmob<Grob_array> (yparent->get_object ("ties"))->size () > 1
)
{
/* trigger positioning. */
SCM
Tie::calc_control_points (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Grob *yparent = me->get_parent (Y_AXIS);
if ((Tie_column::has_interface (yparent)
|| Semi_tie_column::has_interface (yparent))
- && Grob_array::is_smob (yparent->get_object ("ties")))
+ && unsmob<Grob_array> (yparent->get_object ("ties")))
{
extract_grob_set (yparent, "ties", ties);
if (me->original () && ties.size () == 1
SCM
Tie::print (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM cp = me->get_property ("control-points");
string str;
SCM properties = Font_interface::text_font_alist_chain (me);
- Stencil tm = *Stencil::unsmob (Text_interface::interpret_markup
+ Stencil tm = *unsmob<Stencil> (Text_interface::interpret_markup
(me->layout ()->self_scm (), properties,
annotation));
tm.translate (Offset (b.control_[3][X_AXIS] + 0.5,
{
if (time_signature_ && !scm_is_null (time_cause_))
{
- Moment *mp = Moment::unsmob (get_property ("measurePosition"));
+ Moment *mp = unsmob<Moment> (get_property ("measurePosition"));
if (mp && (mp->main_part_ > Rational (0))
&& !to_boolean (get_property ("partialBusy")))
time_signature_->warning ("mid-measure time signature without \\partial");
void
Timing_translator::initialize ()
{
- Context *timing = Context::unsmob (scm_call_2 (ly_lily_module_constant ("ly:context-find"),
+ Context *timing = unsmob<Context> (scm_call_2 (ly_lily_module_constant ("ly:context-find"),
context ()->self_scm (),
ly_symbol2scm ("Timing")));
if (timing != context ())
SCM measureLength = timing->get_property ("measureLength");
- if (!Moment::is_smob (measureLength))
+ if (!unsmob<Moment> (measureLength))
{
measureLength =
Moment (ly_scm2rational
context ()->set_property ("beamExceptions", beamExceptions);
SCM baseMoment = timing->get_property ("baseMoment");
- if (!Moment::is_smob (baseMoment))
+ if (!unsmob<Moment> (baseMoment))
{
baseMoment =
Moment (ly_scm2rational
{
beatStructure =
scm_call_3 (ly_lily_module_constant ("beat-structure"),
- ly_rational2scm (Moment::unsmob (baseMoment)->main_part_),
+ ly_rational2scm (unsmob<Moment> (baseMoment)->main_part_),
timeSignatureFraction,
timeSignatureSettings);
}
Timing_translator::measure_length () const
{
SCM l = get_property ("measureLength");
- if (Moment::is_smob (l))
- return Moment::unsmob (l)->main_part_;
+ if (unsmob<Moment> (l))
+ return unsmob<Moment> (l)->main_part_;
else
return Rational (1);
}
Moment measposp;
SCM s = get_property ("measurePosition");
- if (Moment::is_smob (s))
- measposp = *Moment::unsmob (s);
+ if (unsmob<Moment> (s))
+ measposp = *unsmob<Moment> (s);
else
{
measposp = now;
return 0;
}
- return Translator::unsmob (v);
+ return unsmob<Translator> (v);
}
SCM iface_list, Direction start_end)
{
SCM retval = Engraver_dispatch_list ().smobbed_copy ();
- Engraver_dispatch_list *list = Engraver_dispatch_list::unsmob (retval);
+ Engraver_dispatch_list *list = unsmob<Engraver_dispatch_list> (retval);
Engraver_dispatch_entry entry;
bool found = false;
for (SCM s = trans_list; scm_is_pair (s); s = scm_cdr (s))
{
Engraver *eng
- = Engraver::unsmob (scm_car (s));
+ = unsmob<Engraver> (scm_car (s));
if (!eng)
continue;
translator_each (SCM list, Translator_method method)
{
for (SCM p = list; scm_is_pair (p); p = scm_cdr (p))
- (Translator::unsmob (scm_car (p))->*method) ();
+ (unsmob<Translator> (scm_car (p))->*method) ();
}
void
ly_symbol2scm ("AnnounceNewContext"));
for (SCM tr_list = simple_trans_list_; scm_is_pair (tr_list); tr_list = scm_cdr (tr_list))
{
- Translator *tr = Translator::unsmob (scm_car (tr_list));
+ Translator *tr = unsmob<Translator> (scm_car (tr_list));
tr->connect_to_context (c);
}
}
{
for (SCM tr_list = simple_trans_list_; scm_is_pair (tr_list); tr_list = scm_cdr (tr_list))
{
- Translator *tr = Translator::unsmob (scm_car (tr_list));
+ Translator *tr = unsmob<Translator> (scm_car (tr_list));
tr->disconnect_from_context (context_);
}
context_->event_source ()->remove_listener (GET_LISTENER (Translator_group, create_child_translator),
Both filter_performers and filter_engravers used to use a direct dynamic_cast
on the unsmobbed translator to be filtered, i.e.,
- if (Performer::unsmob (scm_car (*tail)))
+ if (unsmob<Performer> (scm_car (*tail)))
but this caused mysterious optimisation issues in several GUB builds. See
issue #818 for the background to this change.
SCM *tail = ℓ
for (SCM p = ell; scm_is_pair (p); p = scm_cdr (p))
{
- if (Performer::is_smob (scm_car (*tail)))
+ if (unsmob<Performer> (scm_car (*tail)))
*tail = scm_cdr (*tail);
else
tail = SCM_CDRLOC (*tail);
SCM *tail = ℓ
for (SCM p = ell; scm_is_pair (p); p = scm_cdr (p))
{
- if (Engraver::is_smob (scm_car (*tail)))
+ if (unsmob<Engraver> (scm_car (*tail)))
*tail = scm_cdr (*tail);
else
tail = SCM_CDRLOC (*tail);
void
Translator_group::create_child_translator (SCM sev)
{
- Stream_event *ev = Stream_event::unsmob (sev);
+ Stream_event *ev = unsmob<Stream_event> (sev);
// get from AnnounceNewContext
SCM cs = ev->get_property ("context");
- Context *new_context = Context::unsmob (cs);
- Context_def *def = Context_def::unsmob (new_context->get_definition ());
+ Context *new_context = unsmob<Context> (cs);
+ Context_def *def = unsmob<Context_def> (new_context->get_definition ());
SCM ops = new_context->get_definition_mods ();
SCM trans_names = def->get_translator_names (ops);
for (SCM s = c->children_contexts (); scm_is_pair (s);
s = scm_cdr (s))
- precomputed_recurse_over_translators (Context::unsmob (scm_car (s)), idx, dir);
+ precomputed_recurse_over_translators (unsmob<Context> (scm_car (s)), idx, dir);
if (tg && dir == UP)
{
for (SCM s = c->children_contexts (); scm_is_pair (s);
s = scm_cdr (s))
- recurse_over_translators (Context::unsmob (scm_car (s)), ptr, tg_ptr, dir);
+ recurse_over_translators (unsmob<Context> (scm_car (s)), ptr, tg_ptr, dir);
if (tg && dir == UP)
{
{
for (SCM s = simple_trans_list_; scm_is_pair (s); s = scm_cdr (s))
{
- Translator *tr = Translator::unsmob (scm_car (s));
+ Translator *tr = unsmob<Translator> (scm_car (s));
Translator::Callback ptrs[TRANSLATOR_METHOD_PRECOMPUTE_COUNT];
tr->fetch_precomputable_methods (ptrs);
" The name is a symbol.")
{
LY_ASSERT_SMOB (Translator, trans, 1);
- Translator *tr = Translator::unsmob (trans);
+ Translator *tr = unsmob<Translator> (trans);
char const *nm = tr->class_name ();
return ly_symbol2scm (nm);
}
"Return an alist of properties of translator @var{me}.")
{
LY_ASSERT_SMOB (Translator, me, 1);
- Translator *tr = Translator::unsmob (me);
+ Translator *tr = unsmob<Translator> (me);
return tr->translator_description ();
}
"Return the context of the translator object @var{trans}.")
{
LY_ASSERT_SMOB (Translator, trans, 1);
- Translator *tr = Translator::unsmob (trans);
+ Translator *tr = unsmob<Translator> (trans);
Context *c = tr->context ();
return c ? c->self_scm () : SCM_BOOL_F;
Moment
get_event_length (Stream_event *e)
{
- Moment *m = Moment::unsmob (e->get_property ("length"));
+ Moment *m = unsmob<Moment> (e->get_property ("length"));
if (m)
return *m;
else
{
if (!finished_->get_bound (RIGHT))
{
- Grob *e = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *e = unsmob<Grob> (get_property ("currentMusicalColumn"));
finished_->set_bound (RIGHT, e);
}
finished_ = 0;
{
if (span_ && !span_->get_bound (LEFT))
{
- Grob *e = Grob::unsmob (get_property ("currentMusicalColumn"));
+ Grob *e = unsmob<Grob> (get_property ("currentMusicalColumn"));
span_->set_bound (LEFT, e);
}
typeset_all ();
if (span_)
{
- Grob *e = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *e = unsmob<Grob> (get_property ("currentCommandColumn"));
span_->set_bound (RIGHT, e);
}
}
SCM
Tuplet_bracket::calc_connect_to_neighbors (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Direction dir = get_grob_direction (me);
Drul_array<Item *> bounds (get_x_bound_item (me, LEFT, dir),
SCM
Tuplet_bracket::calc_x_positions (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
extract_grob_set (me, "note-columns", columns);
Grob *commonx = get_common_x (me);
SCM
Tuplet_bracket::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Stencil mol;
extract_grob_set (me, "note-columns", columns);
Output_def *pap = me->layout ();
- Grob *number_grob = Grob::unsmob (me->get_object ("tuplet-number"));
+ Grob *number_grob = unsmob<Grob> (me->get_object ("tuplet-number"));
/*
Don't print the bracket when it would be smaller than the number.
= Text_interface::interpret_markup (pap->self_scm (),
properties, text);
- Stencil *edge_text = Stencil::unsmob (t);
+ Stencil *edge_text = unsmob<Stencil> (t);
edge_text->translate_axis (x_span[d] - x_span[LEFT],
X_AXIS);
edge_stencils[d] = *edge_text;
}
// Check for number-on-bracket collisions
- Grob *number = Grob::unsmob (tuplets[i]->get_object ("tuplet-number"));
+ Grob *number = unsmob<Grob> (tuplets[i]->get_object ("tuplet-number"));
if (number)
points.push_back (Offset (number->extent (commonx, X_AXIS).center () - x0,
number->extent (commony, Y_AXIS)[dir]));
// assume that if a script is avoiding slurs, it should not get placed
// under a tuplet bracket
- if (Grob::is_smob (scripts[i]->get_object ("slur")))
+ if (unsmob<Grob> (scripts[i]->get_object ("slur")))
continue;
Interval script_x (scripts[i]->extent (commonx, X_AXIS));
SCM
Tuplet_bracket::calc_direction (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
Direction dir = Tuplet_bracket::get_default_dir (me);
return scm_from_int (dir);
}
SCM
Tuplet_bracket::calc_positions (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Real dy = 0.0;
Real offset = 0.0;
SCM
Tuplet_bracket::calc_cross_staff (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
extract_grob_set (me, "note-columns", cols);
extract_grob_set (me, "tuplets", tuplets);
for (vsize i = 0; i < cols.size (); i++)
{
- Grob *stem = Grob::unsmob (cols[i]->get_object ("stem"));
+ Grob *stem = unsmob<Grob> (cols[i]->get_object ("stem"));
if (stem && to_boolean (stem->get_property ("cross-staff")))
return SCM_BOOL_T;
}
if (stopped_tuplets_[i].full_length_)
{
Item *col
- = Item::unsmob (stopped_tuplets_[i].full_length_note_
+ = unsmob<Item> (stopped_tuplets_[i].full_length_note_
? get_property ("currentMusicalColumn")
: get_property ("currentCommandColumn"));
if (to_boolean (get_property ("tupletFullLength")))
for (vsize i = 0; i < last_tuplets_.size (); i++)
{
- Item *col = Item::unsmob (get_property ("currentCommandColumn"));
+ Item *col = unsmob<Item> (get_property ("currentCommandColumn"));
last_tuplets_[i]->set_bound (RIGHT, col);
}
}
Music *mus = get_music ();
- Music *ev = Music::unsmob (ev_scm);
+ Music *ev = unsmob<Music> (ev_scm);
ev->set_spot (*mus->origin ());
if (d == START)
{
void
Tuplet_iterator::construct_children ()
{
- if (Duration *d = Duration::unsmob (get_music ()->get_property ("duration")))
+ if (Duration *d = unsmob<Duration> (get_music ()->get_property ("duration")))
spanner_duration_ = d->get_length ();
else if (Moment *mp
- = Moment::unsmob (get_outlet ()->get_property ("tupletSpannerDuration")))
+ = unsmob<Moment> (get_outlet ()->get_property ("tupletSpannerDuration")))
spanner_duration_ = mp->main_part_;
else
spanner_duration_.set_infinite (1);
Tuplet_number::adjacent_note_columns (Grob *me_grob, Grob *ref_stem)
{
Spanner *me = dynamic_cast<Spanner *> (me_grob);
- Spanner *tuplet = Spanner::unsmob (me->get_object ("bracket"));
+ Spanner *tuplet = unsmob<Spanner> (me->get_object ("bracket"));
extract_grob_set (tuplet, "note-columns", columns);
Grob *ref_col = ref_stem->get_parent (X_AXIS); // X-parent of Stem = NoteColumn
Tuplet_number::knee_position_against_beam (Grob *me_grob, Grob *ref_stem)
{
Spanner *me = dynamic_cast<Spanner *> (me_grob);
- Spanner *tuplet = Spanner::unsmob (me->get_object ("bracket"));
+ Spanner *tuplet = unsmob<Spanner> (me->get_object ("bracket"));
bool bracket_visible = to_boolean (me->get_property ("bracket-visibility"))
|| !tuplet->extent (tuplet, Y_AXIS).is_empty ();
SCM
Tuplet_number::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
- Spanner *tuplet = Spanner::unsmob (me->get_object ("bracket"));
+ Spanner *me = unsmob<Spanner> (smob);
+ Spanner *tuplet = unsmob<Spanner> (me->get_object ("bracket"));
if (!tuplet || !tuplet->is_live ())
{
}
SCM stc_scm = Text_interface::print (smob);
- Stencil *stc = Stencil::unsmob (stc_scm);
+ Stencil *stc = unsmob<Stencil> (stc_scm);
stc->align_to (X_AXIS, CENTER);
stc->align_to (Y_AXIS, CENTER);
SCM
Tuplet_number::calc_x_offset (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Item *left_bound = me->get_bound (LEFT);
Item *right_bound = me->get_bound (RIGHT);
Drul_array<Item *> bounds (left_bound, right_bound);
- Spanner *tuplet = Spanner::unsmob (me->get_object ("bracket"));
+ Spanner *tuplet = unsmob<Spanner> (me->get_object ("bracket"));
Grob *commonx = Tuplet_bracket::get_common_x (tuplet);
commonx = commonx->common_refpoint (me, X_AXIS);
SCM
Tuplet_number::calc_y_offset (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
- Spanner *tuplet = Spanner::unsmob (me->get_object ("bracket"));
+ Spanner *me = unsmob<Spanner> (smob);
+ Spanner *tuplet = unsmob<Spanner> (me->get_object ("bracket"));
Drul_array<Real> positions = robust_scm2drul (tuplet->get_property ("positions"),
Drul_array<Real> (0.0, 0.0));
SCM to_bracket = scm_from_double ((positions[LEFT] + positions[RIGHT]) / 2.0);
Interval colliding_acc_ext_y;
for (vsize i = 0; i < heads.size (); i++)
- if (Grob *acc = Grob::unsmob (heads[i]->get_object ("accidental-grob")))
+ if (Grob *acc = unsmob<Grob> (heads[i]->get_object ("accidental-grob")))
{
commony = commony->common_refpoint (acc, Y_AXIS);
Interval acc_ext_y = acc->extent (commony, Y_AXIS);
SCM
Tuplet_number::calc_cross_staff (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
- return Grob::unsmob (me->get_object ("bracket"))->get_property ("cross-staff");
+ Grob *me = unsmob<Grob> (smob);
+ return unsmob<Grob> (me->get_object ("bracket"))->get_property ("cross-staff");
}
ADD_INTERFACE (Tuplet_number,
"Get back object from @var{undead}.")
{
LY_ASSERT_SMOB (Undead, undead, 1);
- return Undead::unsmob (undead)->object ();
+ return unsmob<Undead> (undead)->object ();
}
// '
"Return the unpure part of @var{pc}.")
{
LY_ASSERT_SMOB (Unpure_pure_container, pc, 1);
- return Unpure_pure_container::unsmob (pc)->unpure_part ();
+ return unsmob<Unpure_pure_container> (pc)->unpure_part ();
}
LY_DEFINE (ly_unpure_pure_container_pure_part, "ly:unpure-pure-container-pure-part",
"Return the pure part of @var{pc}.")
{
LY_ASSERT_SMOB (Unpure_pure_container, pc, 1);
- return Unpure_pure_container::unsmob (pc)->pure_part ();
+ return unsmob<Unpure_pure_container> (pc)->pure_part ();
}
int
// bitmask based O (1) test); where n=<number of primitives in the
// ligature> (which is typically small (n<10), though).
Stream_event *new_cause = primitive.event_cause ();
- int new_pitch = Pitch::unsmob (new_cause->get_property ("pitch"))->steps ();
+ int new_pitch = unsmob<Pitch> (new_cause->get_property ("pitch"))->steps ();
for (vsize i = 0; i < augmented_primitives_.size (); i++)
{
Stream_event *cause = augmented_primitives_[i].event_cause ();
- int pitch = Pitch::unsmob (cause->get_property ("pitch"))->steps ();
+ int pitch = unsmob<Pitch> (cause->get_property ("pitch"))->steps ();
if (pitch == new_pitch)
{
primitive.grob ()->
SCM
Vaticana_ligature::brew_ligature_primitive (SCM smob)
{
- Grob *me = Grob::unsmob (smob);
+ Grob *me = unsmob<Grob> (smob);
SCM primitive = vaticana_brew_primitive (me).smobbed_copy ();
return primitive;
}
top_level_ = to_boolean (get_property ("topLevelAlignment"));
valign_ = make_spanner (top_level_ ? "VerticalAlignment" : "StaffGrouper", SCM_EOL);
- valign_->set_bound (LEFT, Grob::unsmob (get_property ("currentCommandColumn")));
+ valign_->set_bound (LEFT, unsmob<Grob> (get_property ("currentCommandColumn")));
Align_interface::set_ordered (valign_);
}
}
{
if (valign_)
{
- valign_->set_bound (RIGHT, Grob::unsmob (get_property ("currentCommandColumn")));
+ valign_->set_bound (RIGHT, unsmob<Grob> (get_property ("currentCommandColumn")));
valign_ = 0;
}
}
SCM before = scm_hash_ref (id_to_group_hashtab_, before_id, SCM_BOOL_F);
SCM after = scm_hash_ref (id_to_group_hashtab_, after_id, SCM_BOOL_F);
- Grob *before_grob = Grob::unsmob (before);
- Grob *after_grob = Grob::unsmob (after);
+ Grob *before_grob = unsmob<Grob> (before);
+ Grob *after_grob = unsmob<Grob> (after);
Align_interface::add_element (valign_, i.grob ());
if (before_grob || after_grob)
{
- Grob_array *ga = Grob_array::unsmob (valign_->get_object ("elements"));
+ Grob_array *ga = unsmob<Grob_array> (valign_->get_object ("elements"));
vector<Grob *> &arr = ga->array_reference ();
Grob *added = arr.back ();
else if (qualifies (i))
{
Pointer_group_interface::add_grob (valign_, ly_symbol2scm ("elements"), i.grob ());
- if (!Grob::is_smob (i.grob ()->get_object ("staff-grouper")))
+ if (!unsmob<Grob> (i.grob ()->get_object ("staff-grouper")))
i.grob ()->set_object ("staff-grouper", valign_->self_scm ());
}
}
SCM
Volta_bracket_interface::print (SCM smob)
{
- Spanner *me = Spanner::unsmob (smob);
+ Spanner *me = unsmob<Spanner> (smob);
Spanner *orig_span = dynamic_cast<Spanner *> (me->original ());
bool broken_first_bracket = orig_span && (orig_span->broken_intos_[0]
== (Spanner *)me);
SCM properties = me->get_property_alist_chain (SCM_EOL);
SCM snum = Text_interface::interpret_markup (layout->self_scm (),
properties, text);
- Stencil num = *Stencil::unsmob (snum);
+ Stencil num = *unsmob<Stencil> (snum);
num.align_to (Y_AXIS, UP);
num.translate_axis (-0.5, Y_AXIS);
total.add_at_edge (X_AXIS, LEFT, num, - num.extent (X_AXIS).length ()
SCM l (get_property ("voltaSpannerDuration"));
Moment now = now_mom ();
- bool early_stop = Moment::is_smob (l)
- && *Moment::unsmob (l) <= now - started_mom_;
+ bool early_stop = unsmob<Moment> (l)
+ && *unsmob<Moment> (l) <= now - started_mom_;
end = end || early_stop;
}
void
Volta_engraver::stop_translation_timestep ()
{
- Grob *cc = Grob::unsmob (get_property ("currentCommandColumn"));
+ Grob *cc = unsmob<Grob> (get_property ("currentCommandColumn"));
Item *ci = dynamic_cast<Item *> (cc);
if (end_volta_bracket_ && !end_volta_bracket_->get_bound (RIGHT))
if (end_volta_bracket_ && !volta_bracket_)
{
for (SCM s = get_property ("stavesFound"); scm_is_pair (s); s = scm_cdr (s))
- Side_position_interface::add_support (volta_spanner_, Grob::unsmob (scm_car (s)));
+ Side_position_interface::add_support (volta_spanner_, unsmob<Grob> (scm_car (s)));
volta_spanner_ = 0;
}
projects / lilypond.git / commitdiff