{
SCM cause = acc->get_parent (Y_AXIS)->get_property ("cause");
- Stream_event *mcause = unsmob_stream_event (cause);
+ Stream_event *mcause = Stream_event::unsmob (cause);
if (!mcause)
{
programming_error ("note head has no event cause");
for (SCM s = event->get_property ("articulations");
!articulation_event && scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *art = unsmob_stream_event (scm_car (s));
+ Stream_event *art = Stream_event::unsmob (scm_car (s));
if (art->in_event_class (articulation_name))
articulation_event = art;
SCM arts = cause ? cause->get_property ("articulations") : SCM_EOL;
for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *e = unsmob_stream_event (scm_car (s));
+ Stream_event *e = Stream_event::unsmob (scm_car (s));
if (e->in_event_class ("annotate-output-event"))
{
balloonify (info.grob (), e);
SCM
Balloon_interface::print_spanner (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Spanner *orig = dynamic_cast<Spanner *> (me->original ());
if (orig)
SCM
Beam::calc_x_positions (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
SCM segments = me->get_property ("beam-segments");
Interval x_positions;
x_positions.set_empty ();
SCM
Beam::print (SCM grob)
{
- Spanner *me = unsmob_spanner (grob);
+ Spanner *me = Spanner::unsmob (grob);
/*
TODO - mild code dup for all the commonx calls.
Some use just common_refpoint_of_array, some (in print and
Input *
Book::origin () const
{
- return unsmob_input (input_location_);
+ return Input::unsmob (input_location_);
}
Book::~Book ()
SCM
Chord_name::after_line_breaking (SCM smob)
{
- Item *me = unsmob_item (smob);
+ Item *me = Item::unsmob (smob);
assert (me);
SCM s = me->get_property ("begin-of-line-visible");
SCM
Clef::calc_glyph_name (SCM smob)
{
- Item *s = unsmob_item (smob);
+ Item *s = Item::unsmob (smob);
SCM glyph = s->get_property ("glyph");
if (scm_is_string (glyph))
Input *
Context_def::origin () const
{
- return unsmob_input (input_location_);
+ return Input::unsmob (input_location_);
}
Context_def::Context_def (Context_def const &s)
void
Context::acknowledge_infant (SCM sev)
{
- infant_event_ = unsmob_stream_event (sev);
+ infant_event_ = Stream_event::unsmob (sev);
}
IMPLEMENT_LISTENER (Context, set_property_from_event);
void
Context::set_property_from_event (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
SCM sym = ev->get_property ("symbol");
if (scm_is_symbol (sym))
void
Context::unset_property_from_event (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (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 = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
string id = ly_scm2string (ev->get_property ("id"));
SCM ops = ev->get_property ("ops");
void
Context::change_parent (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
Context *to = Context::unsmob (ev->get_property ("context"));
disconnect_from_parent ();
"Send the stream event @var{ev} to the dispatcher @var{disp}.")
{
Dispatcher *d = Dispatcher::unsmob (disp);
- Stream_event *e = unsmob_stream_event (ev);
+ Stream_event *e = Stream_event::unsmob (ev);
LY_ASSERT_SMOB (Dispatcher, disp, 1);
void
Dispatcher::dispatch (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
SCM class_list = ev->get_property ("class");
if (!scm_is_pair (class_list))
{
int velocity = 0;
for (SCM s = articulations; scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *ev = unsmob_stream_event (scm_car (s));
+ Stream_event *ev = Stream_event::unsmob (scm_car (s));
if (!ev)
continue;
void
Engraver_group::override (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
sloppy_general_pushpop_property (context (),
ev->get_property ("symbol"),
void
Engraver_group::revert (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
sloppy_general_pushpop_property (context (),
ev->get_property ("symbol"),
" @var{cause} should either be another grob"
" or a music event.")
{
- LY_ASSERT_TYPE (unsmob_engraver, engraver, 1);
+ LY_ASSERT_TYPE (Engraver::unsmob, engraver, 1);
LY_ASSERT_TYPE (ly_is_symbol, grob_name, 2);
LY_ASSERT_TYPE (ly_is_grob_cause, cause, 3);
- Grob *g = unsmob_engraver (engraver)->
+ Grob *g = Engraver::unsmob (engraver)->
internal_make_grob (grob_name, cause,
ly_symbol2string (grob_name).c_str (),
"scheme", 0, "scheme");
" @var{grob} being a grob. @var{cause} should either"
" be another grob or a music event.")
{
- LY_ASSERT_TYPE (unsmob_engraver, engraver, 1);
+ LY_ASSERT_TYPE (Engraver::unsmob, engraver, 1);
LY_ASSERT_SMOB (Grob, grob, 2);
LY_ASSERT_TYPE (ly_is_grob_cause, cause, 3);
- unsmob_engraver (engraver)->
+ Engraver::unsmob (engraver)->
announce_end_grob (Grob::unsmob (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 = unsmob_music (cause))
+ if (Music *m = Music::unsmob (cause))
{
cause = m->to_event ()->unprotect ();
}
if (e->get_property ("cause") == SCM_EOL
- && (unsmob_stream_event (cause) || Grob::unsmob (cause)))
+ && (Stream_event::unsmob (cause) || Grob::unsmob (cause)))
e->set_property ("cause", cause);
return Grob_info (this, e);
}
Engraver *
-unsmob_engraver (SCM eng)
+Engraver::unsmob (SCM eng)
{
return dynamic_cast<Engraver *> (Translator::unsmob (eng));
}
bool
ly_is_grob_cause (SCM obj)
{
- return Grob::unsmob (obj) || unsmob_stream_event (obj) || (obj == SCM_EOL);
+ return Grob::unsmob (obj) || Stream_event::unsmob (obj) || (obj == SCM_EOL);
}
#include "translator.icc"
for (SCM s = get_music ()->get_property ("elements");
scm_is_pair (s); s = scm_cdr (s))
{
- Music *mus = unsmob_music (scm_car (s));
+ Music *mus = Music::unsmob (scm_car (s));
report_event (mus);
}
for (SCM s = get_music ()->get_property ("articulations");
scm_is_pair (s); s = scm_cdr (s))
{
- Music *mus = unsmob_music (scm_car (s));
+ Music *mus = Music::unsmob (scm_car (s));
report_event (mus);
}
}
void
Footnote_engraver::acknowledge_grob (Grob_info info)
{
- Music *mus = unsmob_music (info.grob ()->get_property ("footnote-music"));
+ Music *mus = Music::unsmob (info.grob ()->get_property ("footnote-music"));
if (mus)
{
ly_add_type_predicate ((void *) &is_music_function, "Music_function");
ly_add_type_predicate ((void *) &ly_is_port, "port");
ly_add_type_predicate ((void *) &ly_cheap_is_list, "list");
- ly_add_type_predicate ((void *) &unsmob_global_context, "Global_context");
- ly_add_type_predicate ((void *) &unsmob_input, "Input");
+ ly_add_type_predicate ((void *) &Global_context::unsmob, "Global_context");
+ ly_add_type_predicate ((void *) &Input::unsmob, "Input");
ly_add_type_predicate ((void *) &Moment::unsmob, "Moment");
- ly_add_type_predicate ((void *) &unsmob_paper_score, "Paper_score");
- ly_add_type_predicate ((void *) &unsmob_performance, "Performance");
+ ly_add_type_predicate ((void *) &Paper_score::unsmob, "Paper_score");
+ ly_add_type_predicate ((void *) &Performance::unsmob, "Performance");
ly_add_type_predicate ((void *) &is_unpure_pure_container, "unpure pure container");
ly_add_type_predicate ((void *) &is_axis, "axis");
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 *) &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");
+ ly_add_type_predicate ((void *) &Item::unsmob, "Item");
+ ly_add_type_predicate ((void *) &Music::unsmob, "Music");
+ ly_add_type_predicate ((void *) &Spanner::unsmob, "Spanner");
+ ly_add_type_predicate ((void *) &Stream_event::unsmob, "Stream_event");
}
ADD_SCM_INIT_FUNC (func_doc, init_func_doc);
{
Global_context *g = dynamic_cast<Global_context *> (Context::unsmob (context));
- LY_ASSERT_TYPE (unsmob_global_context, context, 1);
+ LY_ASSERT_TYPE (Global_context::unsmob, context, 1);
SCM output = g->get_output ();
progress_indication ("\n");
" @var{global}. The translator group is returned.")
{
Global_context *g = dynamic_cast<Global_context *> (Context::unsmob (global));
- LY_ASSERT_TYPE (unsmob_global_context, global, 1);
+ LY_ASSERT_TYPE (Global_context::unsmob, global, 1);
Translator_group *tg = new Translator_group ();
tg->connect_to_context (g);
" @var{ctx}. The context is returned in its final state.")
{
LY_ASSERT_SMOB (Music, mus, 1);
- LY_ASSERT_TYPE (unsmob_global_context, ctx, 2);
+ LY_ASSERT_TYPE (Global_context::unsmob, ctx, 2);
- Music *music = unsmob_music (mus);
+ Music *music = Music::unsmob (mus);
if (!music)
{
warning (_ ("no music found in score"));
void
Global_context::prepare (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
Moment *mom = Moment::unsmob (ev->get_property ("moment"));
assert (mom);
}
Global_context *
-unsmob_global_context (SCM x)
+Global_context::unsmob (SCM x)
{
return dynamic_cast<Global_context *> (Context::unsmob (x));
}
Grob_info::event_cause () const
{
SCM cause = grob_->get_property ("cause");
- return unsmob_stream_event (cause);
+ return Stream_event::unsmob (cause);
}
vector<Context *>
{
cause = Grob::unsmob (cause)->get_property ("cause");
}
- return unsmob_stream_event (cause);
+ return Stream_event::unsmob (cause);
}
bool
cause = g->get_property ("cause");
/* ES TODO: cause can't be Music*/
- if (Music *m = unsmob_music (cause))
+ if (Music *m = Music::unsmob (cause))
m->origin ()->programming_error (s);
- else if (Stream_event *ev = unsmob_stream_event (cause))
+ else if (Stream_event *ev = Stream_event::unsmob (cause))
ev->origin ()->programming_error (s);
else
::programming_error (s);
cause = g->get_property ("cause");
/* ES TODO: cause can't be Music*/
- if (Music *m = unsmob_music (cause))
+ if (Music *m = Music::unsmob (cause))
m->origin ()->warning (s);
- else if (Stream_event *ev = unsmob_stream_event (cause))
+ else if (Stream_event *ev = Stream_event::unsmob (cause))
ev->origin ()->warning (s);
else
::warning (s);
SCM
Hairpin::broken_bound_padding (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Item *r_bound = me->get_bound (RIGHT);
if (r_bound->break_status_dir () != -1)
{
SCM
Hairpin::print (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
SCM s = me->get_property ("grow-direction");
if (!is_direction (s))
SCM
Horizontal_bracket::print (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
extract_grob_set (me, "columns", gs);
vector<Grob *> enclosed = gs;
#define make_spanner(x, cause) internal_make_spanner (ly_symbol2scm (x), cause, x, __FILE__, __LINE__, __FUNCTION__)
#define make_paper_column(x) internal_make_column (ly_symbol2scm (x), x, __FILE__, __LINE__, __FUNCTION__)
-Engraver *unsmob_engraver (SCM eng);
+Engraver *Engraver::unsmob (SCM eng);
bool ly_is_grob_cause (SCM obj);
#endif // ENGRAVER_HH
};
SCM ly_format_output (SCM);
-Global_context *unsmob_global_context (SCM x);
+Global_context *Global_context::unsmob (SCM x);
#endif // GLOBAL_CONTEXT_HH
};
/* smob utilities */
-Spanner *unsmob_spanner (SCM);
-Item *unsmob_item (SCM);
+Spanner *Spanner::unsmob (SCM);
+Item *Item::unsmob (SCM);
/* unification */
void uniquify (vector <Grob *> &);
#include "smobs.hh"
SCM make_input (Input spot);
-Input *unsmob_input (SCM);
+Input *Input::unsmob (SCM);
extern Input dummy_input_global;
virtual void process ();
};
-Paper_score *unsmob_paper_score (SCM);
-Performance *unsmob_performance (SCM);
+Paper_score *Paper_score::unsmob (SCM);
+Performance *Performance::unsmob (SCM);
#endif /* MUSIC_OUTPUT_HH */
friend SCM ly_extended_make_music (SCM, SCM);
};
-Music *unsmob_music (SCM);
+Music *Music::unsmob (SCM);
Music *make_music_by_name (SCM sym);
SCM ly_music_deep_copy (SCM);
SCM ly_camel_case_2_lisp_identifier (SCM name_sym);
virtual void create_audio_elements ();
};
-Performer *unsmob_performer (SCM perf);
+Performer *Performer::unsmob (SCM perf);
#endif /* PERFORMER_HH */
#define in_event_class(class_name) internal_in_event_class (ly_symbol2scm (class_name))
-Stream_event *unsmob_stream_event (SCM);
+Stream_event *Stream_event::unsmob (SCM);
SCM ly_event_deep_copy (SCM);
#endif /* STREAM_EVENT_HH */
void \
cl::_listen_scm_ ## m (SCM sev) \
{ \
- Stream_event *ev = unsmob_stream_event (sev); \
+ Stream_event *ev = Stream_event::unsmob (sev); \
protect_event (sev); \
listen_ ## m (ev); \
}
(SCM x),
"Is @var{x} an @code{input-location}?")
{
- return unsmob_input (x) ? SCM_BOOL_T : SCM_BOOL_F;
+ return Input::unsmob (x) ? SCM_BOOL_T : SCM_BOOL_F;
}
LY_DEFINE (ly_input_warning, "ly:input-warning", 2, 0, 1, (SCM sip, SCM msg, SCM rest),
" to the location in @var{sip}. @var{msg} is interpreted"
" similar to @code{format}'s argument, using @var{rest}.")
{
- Input *ip = unsmob_input (sip);
+ Input *ip = Input::unsmob (sip);
- LY_ASSERT_TYPE (unsmob_input, sip, 1);
+ LY_ASSERT_TYPE (Input::unsmob, sip, 1);
LY_ASSERT_TYPE (scm_is_string, msg, 2);
msg = scm_simple_format (SCM_BOOL_F, msg, rest);
" to the location in @var{sip}. @var{msg} is interpreted"
" similar to @code{format}'s argument, using @var{rest}.")
{
- Input *ip = unsmob_input (sip);
+ Input *ip = Input::unsmob (sip);
- LY_ASSERT_TYPE (unsmob_input, sip, 1);
+ LY_ASSERT_TYPE (Input::unsmob, sip, 1);
LY_ASSERT_TYPE (scm_is_string, msg, 2);
msg = scm_simple_format (SCM_BOOL_F, msg, rest);
"Return input location in @var{sip} as"
" @code{(file-name line char column)}.")
{
- LY_ASSERT_TYPE (unsmob_input, sip, 1);
- Input *ip = unsmob_input (sip);
+ LY_ASSERT_TYPE (Input::unsmob, sip, 1);
+ Input *ip = Input::unsmob (sip);
int l, ch, col, offset = 0;
ip->get_counts (&l, &ch, &col, &offset);
" @code{(file-name first-line first-column last-line last-column)}.")
{
- LY_ASSERT_TYPE (unsmob_input, sip, 1);
- Input *ip = unsmob_input (sip);
+ LY_ASSERT_TYPE (Input::unsmob, sip, 1);
+ Input *ip = Input::unsmob (sip);
return scm_list_5 (ly_string2scm (ip->file_string ()),
scm_from_int (ip->line_number ()),
static int
print_smob (SCM s, SCM port, scm_print_state *)
{
- string str = "#<location " + unsmob_input (s)->location_string () + ">";
+ string str = "#<location " + Input::unsmob (s)->location_string () + ">";
scm_puts (str.c_str (), port);
return 1;
}
static size_t
free_smob (SCM s)
{
- delete unsmob_input (s);
+ delete Input::unsmob (s);
return 0;
}
}
Input *
-unsmob_input (SCM s)
+Input::unsmob (SCM s)
{
if (SCM_IMP (s))
return 0;
" end of line, @code{0}@tie{}unbroken, and"
" @code{1}@tie{}beginning of line.")
{
- LY_ASSERT_TYPE (unsmob_item, it, 1);
- Item *me = unsmob_item (it);
+ LY_ASSERT_TYPE (Item::unsmob, it, 1);
+ Item *me = Item::unsmob (it);
return scm_from_int (me->break_status_dir ());
}
}
Item *
-unsmob_item (SCM s)
+Item::unsmob (SCM s)
{
return dynamic_cast<Item *> (Grob::unsmob (s));
}
* a single note head (attached as an articulation inside a chord) */
Stream_event *tie_ev = event_;
Grob *head = inf.grob ();
- Stream_event *note_ev = unsmob_stream_event (head->get_property ("cause"));
+ Stream_event *note_ev = Stream_event::unsmob (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 = unsmob_stream_event (scm_car (s));
+ Stream_event *ev = Stream_event::unsmob (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 (unsmob_stream_event (cause)->get_property ("direction")))
+ if (is_direction (Stream_event::unsmob (cause)->get_property ("direction")))
{
- Direction d = to_dir (unsmob_stream_event (cause)->get_property ("direction"));
+ Direction d = to_dir (Stream_event::unsmob (cause)->get_property ("direction"));
lv_tie->set_property ("direction", scm_from_int (d));
}
return -1;
/* produce requested token */
- yylloc = *unsmob_input (scm_caar (extra_tokens_));
+ yylloc = *Input::unsmob (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 = unsmob_music (sid))
+ if (Music *m = Music::unsmob (sid))
{
m->set_spot (override_input (here_input ()));
}
Lily_lexer::scan_shorthand (const string &str)
{
SCM sid = lookup_identifier (str);
- if (Music *m = unsmob_music (sid))
+ if (Music *m = Music::unsmob (sid))
{
m->set_spot (override_input (here_input ()));
}
p = scm_cdr (p))
{
SCM v = scm_car (p);
- if (Music *m = unsmob_music (v))
+ if (Music *m = Music::unsmob (v))
{
- if (!unsmob_input (m->get_property ("origin")))
+ if (!Input::unsmob (m->get_property ("origin")))
m->set_spot (override_input (here_input ()));
}
sval = SCM_UNSPECIFIED;
}
- if (Music *m = unsmob_music (sval))
+ if (Music *m = Music::unsmob (sval))
{
- if (!unsmob_input (m->get_property ("origin")))
+ if (!Input::unsmob (m->get_property ("origin")))
m->set_spot (override_input (here_input ()));
}
main_input_level_ = 0;
extra_tokens_ = SCM_EOL;
- if (unsmob_input (override_input))
- override_input_ = *unsmob_input (override_input);
+ if (Input::unsmob (override_input))
+ override_input_ = *Input::unsmob (override_input);
smobify_self ();
LY_ASSERT_TYPE (scm_is_string, msg, 2);
string s = ly_scm2string (msg);
- Input *i = unsmob_input (input);
+ Input *i = Input::unsmob (input);
if (i)
p->parser_error (*i, s);
else
SCM
Line_spanner::calc_bound_info (SCM smob, Direction dir)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Grob *commonx = me->get_bound (LEFT)->common_refpoint (me->get_bound (RIGHT), X_AXIS);
commonx = me->common_refpoint (commonx, X_AXIS);
SCM
Line_spanner::calc_cross_staff (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (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 = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
SCM text = me->get_property ("text");
if (Text_interface::is_markup (text)
void
Lyric_combine_music_iterator::set_busy (SCM se)
{
- Stream_event *e = unsmob_stream_event (se);
+ Stream_event *e = Stream_event::unsmob (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 = unsmob_music (get_music ()->get_property ("element"));
+ Music *m = Music::unsmob (get_music ()->get_property ("element"));
lyric_iter_ = Music_iterator::unsmob (get_iterator (m));
if (!lyric_iter_)
return;
SCM
Lyric_combine_music::length_callback (SCM m)
{
- Music *me = unsmob_music (m);
- Music *melody = unsmob_music (scm_car (me->get_property ("elements")));
+ Music *me = Music::unsmob (m);
+ Music *melody = Music::unsmob (scm_car (me->get_property ("elements")));
return melody->get_length ().smobbed_copy ();
}
SCM
Lyric_extender::print (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Item *left_edge = me->get_bound (LEFT);
- Item *right_text = unsmob_item (me->get_object ("next"));
+ Item *right_text = Item::unsmob (me->get_object ("next"));
Grob *common = left_edge;
SCM
Lyric_hyphen::print (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Drul_array<Item *> bounds (me->get_bound (LEFT),
me->get_bound (RIGHT));
void
Midi_control_function_performer::announce_function_value_change (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
SCM sym = ev->get_property ("symbol");
if (!scm_is_symbol (sym))
return;
"Get the length of music expression @var{mus} and return"
" it as a @code{Moment} object.")
{
- LY_ASSERT_TYPE (unsmob_music, mus, 1);
- Music *sc = unsmob_music (mus);
+ LY_ASSERT_TYPE (Music::unsmob, mus, 1);
+ Music *sc = Music::unsmob (mus);
return sc->get_length ().smobbed_copy ();
}
" @var{mus}. If no value is found, return @var{val} or"
" @code{'()} if @var{val} is not specified.")
{
- LY_ASSERT_TYPE (unsmob_music, mus, 1);
+ LY_ASSERT_TYPE (Music::unsmob, mus, 1);
return ly_prob_property (mus, sym, val);
}
"Set property @var{sym} in music expression @var{mus} to"
" @var{val}.")
{
- LY_ASSERT_TYPE (unsmob_music, mus, 1);
+ LY_ASSERT_TYPE (Music::unsmob, mus, 1);
return ly_prob_set_property_x (mus, sym, val);
}
1, 0, 0, (SCM obj),
"Is @var{obj} a music object?")
{
- return scm_from_bool (unsmob_music (obj));
+ return scm_from_bool (Music::unsmob (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 = unsmob_music (obj))
+ if (Music *m = Music::unsmob (obj))
{
return scm_from_bool (m->is_mus_type ("post-event"));
}
" The immutable properties are not available, since they are"
" constant and initialized by the @code{make-music} function.")
{
- LY_ASSERT_TYPE (unsmob_music, mus, 1);
- Music *m = unsmob_music (mus);
+ LY_ASSERT_TYPE (Music::unsmob, mus, 1);
+ Music *m = Music::unsmob (mus);
return m->get_property_alist (true);
}
while (scm_is_pair (lst))
{
- if (!unsmob_music (scm_car (lst)))
+ if (!Music::unsmob (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 (unsmob_music (m))
- return unsmob_music (m)->clone ()->unprotect ();
+ if (Music::unsmob (m))
+ return Music::unsmob (m)->clone ()->unprotect ();
if (scm_is_pair (m))
{
SCM copy = SCM_EOL;
"Transpose @var{m} such that central@tie{}C is mapped"
" to@tie{}@var{p}. Return@tie{}@var{m}.")
{
- LY_ASSERT_TYPE (unsmob_music, m, 1);
+ LY_ASSERT_TYPE (Music::unsmob, m, 1);
LY_ASSERT_SMOB (Pitch, p, 2);
- Music *sc = unsmob_music (m);
+ Music *sc = Music::unsmob (m);
Pitch *sp = Pitch::unsmob (p);
sc->transpose (*sp);
2, 0, 0, (SCM m, SCM factor),
"Compress music object@tie{}@var{m} by moment @var{factor}.")
{
- LY_ASSERT_TYPE (unsmob_music, m, 1);
+ LY_ASSERT_TYPE (Music::unsmob, m, 1);
LY_ASSERT_TYPE (Moment::unsmob, factor, 2);
- Music *sc = unsmob_music (m);
+ Music *sc = Music::unsmob (m);
sc->compress (*Moment::unsmob (factor));
return sc->self_scm ();
}
"Make @var{music} relative to @var{pitch},"
" return final pitch.")
{
- LY_ASSERT_TYPE (unsmob_music, music, 1);
+ LY_ASSERT_TYPE (Music::unsmob, music, 1);
LY_ASSERT_TYPE (Pitch::unsmob, pitch, 2);
Pitch start = *Pitch::unsmob (pitch);
- Music *m = unsmob_music (music);
+ Music *m = Music::unsmob (music);
Pitch last = m->to_relative_octave (start);
return last.smobbed_copy ();
"Extract the duration field from @var{mus} and return the"
" length.")
{
- LY_ASSERT_TYPE (unsmob_music, mus, 1);
- Music *m = unsmob_music (mus);
+ LY_ASSERT_TYPE (Music::unsmob, mus, 1);
+ Music *m = Music::unsmob (mus);
Duration *d = Duration::unsmob (m->get_property ("duration"));
Moment len;
"Compress @var{mus} by factor @var{fact}, which is a"
" @code{Moment}.")
{
- LY_ASSERT_TYPE (unsmob_music, mus, 1);
+ LY_ASSERT_TYPE (Music::unsmob, mus, 1);
LY_ASSERT_SMOB (Moment, fact, 2);
- Music *m = unsmob_music (mus);
+ Music *m = Music::unsmob (mus);
Moment *f = Moment::unsmob (fact);
Duration *d = Duration::unsmob (m->get_property ("duration"));
transpose_music_list (SCM lst, Pitch rq)
{
for (SCM s = lst; scm_is_pair (s); s = scm_cdr (s))
- unsmob_music (scm_car (s))->transpose (rq);
+ Music::unsmob (scm_car (s))->transpose (rq);
}
Moment
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
{
- Moment l = unsmob_music (scm_car (s))->get_length ();
+ Moment l = Music::unsmob (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 = unsmob_music (scm_car (s));
+ Music *m = Music::unsmob (scm_car (s));
if (!m)
programming_error ("Music sequence should have music elements");
else
SCM
Music_sequence::maximum_length_callback (SCM m)
{
- Music *me = unsmob_music (m);
+ Music *me = Music::unsmob (m);
return maximum_length (me->get_property ("elements")).smobbed_copy ();
}
SCM
Music_sequence::event_chord_length_callback (SCM m)
{
- Music *me = unsmob_music (m);
+ Music *me = Music::unsmob (m);
Duration *d = Duration::unsmob (me->get_property ("duration"));
// Preset duration is used in chord repetitions.
if (d)
SCM
Music_sequence::cumulative_length_callback (SCM m)
{
- Music *me = unsmob_music (m);
+ Music *me = Music::unsmob (m);
return cumulative_length (me->get_property ("elements")).smobbed_copy ();
}
SCM
Music_sequence::minimum_start_callback (SCM m)
{
- Music *me = unsmob_music (m);
+ Music *me = Music::unsmob (m);
return minimum_start (me->get_property ("elements")).smobbed_copy ();
}
SCM
Music_sequence::first_start_callback (SCM m)
{
- Music *me = unsmob_music (m);
+ Music *me = Music::unsmob (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 = unsmob_music (scm_car (s)))
+ if (Music *m = Music::unsmob (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))
- unsmob_music (scm_car (s))->compress (m);
+ Music::unsmob (scm_car (s))->compress (m);
}
Moment
Moment m;
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
- m = min (m, unsmob_music (scm_car (s))->start_mom ());
+ m = min (m, Music::unsmob (scm_car (s))->start_mom ());
return m;
}
for (SCM s = l; scm_is_pair (s); s = scm_cdr (s))
{
- Music *mus = unsmob_music (scm_car (s));
+ Music *mus = Music::unsmob (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 = unsmob_music (music);
+ Music *me = Music::unsmob (music);
Pitch p = *Pitch::unsmob (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 = unsmob_music (music);
+ Music *me = Music::unsmob (music);
Pitch p = *Pitch::unsmob (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 = unsmob_music (my_music->get_property ("element"));
+ Music *child = Music::unsmob (my_music->get_property ("element"));
child_iter_ = (child)
? Music_iterator::unsmob (get_iterator (child))
: 0;
SCM
Music_wrapper::start_callback (SCM m)
{
- Music *me = unsmob_music (m);
- Music *elt = unsmob_music (me->get_property ("element"));
+ Music *me = Music::unsmob (m);
+ Music *elt = Music::unsmob (me->get_property ("element"));
if (elt)
return elt->start_mom ().smobbed_copy ();
else
SCM
Music_wrapper::length_callback (SCM m)
{
- Music *me = unsmob_music (m);
- Music *elt = unsmob_music (me->get_property ("element"));
+ Music *me = Music::unsmob (m);
+ Music *elt = Music::unsmob (me->get_property ("element"));
if (elt)
return elt->get_length ().smobbed_copy ();
else
last = new_pit;
}
- if (Music *m = unsmob_music (elt))
+ if (Music *m = Music::unsmob (elt))
last = m->to_relative_octave (last);
(void) music_list_to_relative (get_property ("articulations"), last, true);
{
SCM elt = get_property ("element");
- if (Music *m = unsmob_music (elt))
+ if (Music *m = Music::unsmob (elt))
m->compress (factor);
compress_music_list (get_property ("elements"), factor);
}
else if (prop == ly_symbol2scm ("element"))
{
- if (Music *m = unsmob_music (val))
+ if (Music *m = Music::unsmob (val))
m->transpose (delta);
}
else if (prop == ly_symbol2scm ("elements")
Input *
Music::origin () const
{
- Input *ip = unsmob_input (get_property ("origin"));
+ Input *ip = Input::unsmob (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 = unsmob_music (scm_car (art_mus));
+ Music *m = Music::unsmob (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 = unsmob_music (rv);
+ Music *m = Music::unsmob (rv);
m->protect ();
return m;
}
SCM
Music::duration_length_callback (SCM m)
{
- Music *me = unsmob_music (m);
+ Music *me = Music::unsmob (m);
Duration *d = Duration::unsmob (me->get_property ("duration"));
Moment mom;
}
Music *
-unsmob_music (SCM m)
+Music::unsmob (SCM m)
{
return dynamic_cast<Music *> (Prob::unsmob (m));
}
for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *ev = unsmob_stream_event (scm_car (s));
+ Stream_event *ev = Stream_event::unsmob (scm_car (s));
if (!ev)
continue;
Note_column::get_stem (Grob *me)
{
SCM s = me->get_object ("stem");
- return unsmob_item (s);
+ return Item::unsmob (s);
}
Item *
if (stem)
{
SCM s = stem->get_object ("flag");
- return unsmob_item (s);
+ return Item::unsmob (s);
}
return 0;
}
int velocity = 0;
for (SCM s = articulations; scm_is_pair (s); s = scm_cdr (s))
{
- Stream_event *ev = unsmob_stream_event (scm_car (s));
+ Stream_event *ev = Stream_event::unsmob (scm_car (s));
if (!ev)
continue;
"Return vector of @code{paper_system} objects from"
" @var{paper-score}.")
{
- LY_ASSERT_TYPE (unsmob_paper_score, paper_score, 1);
+ LY_ASSERT_TYPE (Paper_score::unsmob, paper_score, 1);
Paper_score *pscore = dynamic_cast<Paper_score *> (Music_output::unsmob (paper_score));
return pscore->get_paper_systems ();
}
Paper_score *
-unsmob_paper_score (SCM x)
+Paper_score::unsmob (SCM x)
{
return dynamic_cast<Paper_score *> (Music_output::unsmob (x));
}
| post_event post_events
{
$$ = scm_reverse_x ($2, SCM_EOL);
- if (Music *m = unsmob_music ($1))
+ if (Music *m = Music::unsmob ($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 (unsmob_music ($2))
+ if (Music::unsmob ($2))
$3 = scm_cons ($2, $3);
- if (unsmob_music ($1))
+ if (Music::unsmob ($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 = unsmob_music ($1))
+ if (Music *m = Music::unsmob ($1))
{
if (m->is_mus_type ("post-event-wrapper"))
$$ = scm_append
$$ = Context_def::make_scm ();
td = Context_def::unsmob ($$);
}
- if (unsmob_music ($2)) {
+ if (Music::unsmob ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
$2 = scm_call_2 (proc, parser->self_scm (), $2);
}
$2 = SCM_UNSPECIFIED;
}
} else if (!Score::unsmob ($$)) {
- if (unsmob_music ($2)) {
+ if (Music::unsmob ($2)) {
SCM scorify = ly_lily_module_constant ("scorify-music");
$2 = scm_call_2 (scorify, $2, parser->self_scm ());
}
if (Context_def::unsmob ($2))
assign_context_def (Output_def::unsmob ($1), $2);
// Seems unlikely, but let's be complete:
- else if (unsmob_music ($2))
+ else if (Music::unsmob ($2))
{
SCM proc = parser->lexer_->lookup_identifier
("output-def-music-handler");
$$ = SCM_EOL;
}
| music_list music_embedded {
- if (unsmob_music ($2))
+ if (Music::unsmob ($2))
$$ = scm_cons ($2, $1);
}
| music_list error {
| pitch_or_music
{
$$ = make_music_from_simple (parser, @1, $1);
- if (!unsmob_music ($$))
+ if (!Music::unsmob ($$))
{
parser->parser_error (@1, _ ("music expected"));
$$ = MAKE_SYNTAX ("void-music", @$);
music_embedded:
music
{
- if (unsmob_music ($1)->is_mus_type ("post-event")) {
+ if (Music::unsmob ($1)->is_mus_type ("post-event")) {
parser->parser_error (@1, _ ("unexpected post-event"));
$$ = SCM_UNSPECIFIED;
}
{
if (scm_is_eq ($1, SCM_UNSPECIFIED))
$$ = $1;
- else if (Music *m = unsmob_music ($1)) {
+ else if (Music *m = Music::unsmob ($1)) {
if (m->is_mus_type ("post-event")) {
parser->parser_error
(@1, _ ("unexpected post-event"));
}
| WITH context_modification_arg
{
- if (unsmob_music ($2)) {
+ if (Music::unsmob ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
$2 = scm_call_2 (proc, parser->self_scm (), $2);
}
| context_mod_list context_mod_arg {
if (scm_is_eq ($2, SCM_UNSPECIFIED))
;
- else if (unsmob_music ($2)) {
+ else if (Music::unsmob ($2)) {
SCM proc = parser->lexer_->lookup_identifier ("context-mod-music-handler");
$2 = scm_call_2 (proc, parser->self_scm (), $2);
}
simple_element post_events {
// Let the rhythmic music iterator sort this mess out.
if (scm_is_pair ($2)) {
- unsmob_music ($$)->set_property ("articulations",
+ Music::unsmob ($$)->set_property ("articulations",
scm_reverse_x ($2, SCM_EOL));
}
} %prec ':'
note_chord_element:
chord_body optional_notemode_duration post_events
{
- Music *m = unsmob_music ($1);
+ Music *m = Music::unsmob ($1);
SCM dur = Duration::unsmob ($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))
- unsmob_music (scm_car (s))->set_property ("duration", dur);
+ Music::unsmob (scm_car (s))->set_property ("duration", dur);
es = ly_append2 (es, postevs);
m-> set_property ("elements", es);
}
| music_function_chord_body
{
- Music *m = unsmob_music ($1);
+ Music *m = Music::unsmob ($1);
while (m && m->is_mus_type ("music-wrapper-music")) {
$$ = m->get_property ("element");
- m = unsmob_music ($$);
+ m = Music::unsmob ($$);
}
if (!(m && m->is_mus_type ("rhythmic-event"))) {
}
| post_events post_event {
$$ = $1;
- if (Music *m = unsmob_music ($2))
+ if (Music *m = Music::unsmob ($2))
{
if (m->is_mus_type ("post-event-wrapper"))
{
}
| script_dir music_function_call {
$$ = $2;
- if (!unsmob_music ($2)->is_mus_type ("post-event")) {
+ if (!Music::unsmob ($2)->is_mus_type ("post-event")) {
parser->parser_error (@2, _ ("post-event expected"));
$$ = SCM_UNSPECIFIED;
} else if (!SCM_UNBNDP ($1))
{
- unsmob_music ($$)->set_property ("direction", $1);
+ Music::unsmob ($$)->set_property ("direction", $1);
}
}
| HYPHEN {
| script_dir direction_reqd_event {
if (!SCM_UNBNDP ($1))
{
- Music *m = unsmob_music ($2);
+ Music *m = Music::unsmob ($2);
m->set_property ("direction", $1);
}
$$ = $2;
| script_dir direction_less_event {
if (!SCM_UNBNDP ($1))
{
- Music *m = unsmob_music ($2);
+ Music *m = Music::unsmob ($2);
m->set_property ("direction", $1);
}
$$ = $2;
| '^' fingering
{
$$ = $2;
- unsmob_music ($$)->set_property ("direction", scm_from_int (UP));
+ Music::unsmob ($$)->set_property ("direction", scm_from_int (UP));
}
| '_' fingering
{
$$ = $2;
- unsmob_music ($$)->set_property ("direction", scm_from_int (DOWN));
+ Music::unsmob ($$)->set_property ("direction", scm_from_int (DOWN));
}
;
a->set_property ("articulation-type", s);
$$ = a->unprotect ();
} else {
- Music *original = unsmob_music (s);
+ Music *original = Music::unsmob (s);
if (original && original->is_mus_type ("post-event")) {
Music *a = original->clone ();
a->set_spot (parser->lexer_->override_input (@$));
}
| embedded_scm
{
- Music *m = unsmob_music ($1);
+ Music *m = Music::unsmob ($1);
if (m && m->is_mus_type ("post-event"))
$$ = $1;
else if (Text_interface::is_markup ($1)) {
}
| bass_figure ']' {
$$ = $1;
- unsmob_music ($1)->set_property ("bracket-stop", SCM_BOOL_T);
+ Music::unsmob ($1)->set_property ("bracket-stop", SCM_BOOL_T);
}
| bass_figure figured_bass_alteration {
- Music *m = unsmob_music ($1);
+ Music *m = Music::unsmob ($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 = unsmob_music ($1);
+ Music *m = Music::unsmob ($1);
m->set_property ($2, SCM_BOOL_T);
}
;
}
| '[' bass_figure {
$$ = $2;
- unsmob_music ($$)->set_property ("bracket-start", SCM_BOOL_T);
+ Music::unsmob ($$)->set_property ("bracket-start", SCM_BOOL_T);
}
;
lyric_element optional_notemode_duration post_events {
$$ = MAKE_SYNTAX ("lyric-event", @$, $1, $2);
if (scm_is_pair ($3))
- unsmob_music ($$)->set_property
+ Music::unsmob ($$)->set_property
("articulations", scm_reverse_x ($3, SCM_EOL));
} %prec ':'
;
} else if (Context_mod::unsmob (sid)) {
*destination = Context_mod::unsmob (sid)->smobbed_copy ();
return CONTEXT_MOD_IDENTIFIER;
- } else if (Music *mus = unsmob_music (sid)) {
+ } else if (Music *mus = Music::unsmob (sid)) {
mus = mus->clone ();
*destination = mus->self_scm ();
bool is_event = mus->is_mus_type ("post-event");
SCM loc_on_music (Input loc, SCM arg)
{
- if (Music *m = unsmob_music (arg))
+ if (Music *m = Music::unsmob (arg))
{
m = m->clone ();
m->set_spot (loc);
SCM
make_music_from_simple (Lily_parser *parser, Input loc, SCM simple)
{
- if (unsmob_music (simple))
+ if (Music::unsmob (simple))
return simple;
if (parser->lexer_->is_note_state ()) {
if (scm_is_symbol (simple)) {
SCM res = scm_call_3 (chord_ctor, pitch, dur, modification_list);
for (SCM s = res; scm_is_pair (s); s = scm_cdr (s))
{
- unsmob_music (scm_car (s))->set_spot (loc);
+ Music::unsmob (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 (unsmob_music (scm_car (lst))));
+ first_iter_ = Music_iterator::unsmob (get_iterator (Music::unsmob (scm_car (lst))));
Context *two = handles_[CONTEXT_TWO].get_context ();
set_context (two);
- second_iter_ = Music_iterator::unsmob (get_iterator (unsmob_music (scm_cadr (lst))));
+ second_iter_ = Music_iterator::unsmob (get_iterator (Music::unsmob (scm_cadr (lst))));
Context *shared = handles_[CONTEXT_SHARED].get_context ();
set_context (shared);
if (!notice_busy_)
return;
- Stream_event *e = unsmob_stream_event (se);
+ Stream_event *e = Stream_event::unsmob (se);
if (e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
busy_ = true;
Percent_repeat_item_interface::beat_slash (SCM grob)
{
Grob *me = Grob::unsmob (grob);
- Stream_event *cause = unsmob_stream_event (me->get_property ("cause"));
+ Stream_event *cause = Stream_event::unsmob (me->get_property ("cause"));
int count = robust_scm2int (cause->get_property ("slash-count"), 1);
Stencil m;
2, 0, 0, (SCM performance, SCM filename),
"Write @var{performance} to @var{filename}.")
{
- LY_ASSERT_TYPE (unsmob_performance, performance, 1);
+ LY_ASSERT_TYPE (Performance::unsmob, performance, 1);
LY_ASSERT_TYPE (scm_is_string, filename, 2);
- unsmob_performance (performance)->write_output (ly_scm2string (filename));
+ Performance::unsmob (performance)->write_output (ly_scm2string (filename));
return SCM_UNSPECIFIED;
}
}
Performance *
-unsmob_performance (SCM x)
+Performance::unsmob (SCM x)
{
return dynamic_cast<Performance *> (Music_output::unsmob (x));
}
}
Performer *
-unsmob_performer (SCM perf)
+Performer::unsmob (SCM perf)
{
return dynamic_cast<Performer *> (Translator::unsmob (perf));
}
if (pedal_info_[i].line_spanner_)
{
SCM cc = get_property ("currentCommandColumn");
- Item *c = unsmob_item (cc);
+ Item *c = Item::unsmob (cc);
pedal_info_[i].line_spanner_->set_bound (RIGHT, c);
pedal_info_[i].clear ();
if (p->bracket_)
{
SCM cc = get_property ("currentCommandColumn");
- Item *c = unsmob_item (cc);
+ Item *c = Item::unsmob (cc);
p->bracket_->set_bound (RIGHT, c);
p->finished_bracket_ = p->bracket_;
SCM aval = scm_cdar (aprop);
SCM bval = scm_cdar (bprop);
if (scm_caar (aprop) != scm_caar (bprop)
- || (!(unsmob_input (aval) && unsmob_input (bval))
+ || (!(Input::unsmob (aval) && Input::unsmob (bval))
&&
!to_boolean (scm_equal_p (aval, bval))))
return SCM_BOOL_F;
SCM
Property_iterator::once_finalization (SCM ctx, SCM music, SCM previous_value)
{
- Music *m = unsmob_music (music);
+ Music *m = Music::unsmob (music);
Context *c = Context::unsmob (ctx);
// Do not use UnsetProperty, which sets the default, but rather
SCM
Push_property_iterator::once_finalization (SCM ctx, SCM music)
{
- Music *mus = unsmob_music (music);
+ Music *mus = Music::unsmob (music);
Context *c = Context::unsmob (ctx);
SCM sym = mus->get_property ("symbol");
{
SCM ev_acc = scm_car (s);
- Stream_event *ev = unsmob_stream_event (scm_car (ev_acc));
+ Stream_event *ev = Stream_event::unsmob (scm_car (ev_acc));
if (!ev)
programming_error ("no music found in quote");
else if (accept_music_type (ev, is_cue))
Relative_octave_check::relative_callback (SCM music, SCM last_pitch)
{
Pitch p = *Pitch::unsmob (last_pitch);
- Music *m = unsmob_music (music);
+ Music *m = Music::unsmob (music);
Pitch *check_p = Pitch::unsmob (m->get_property ("pitch"));
int delta_oct = 0;
semi_tie->set_parent (semi_tie_column_, Y_AXIS);
semi_ties_.push_back (semi_tie);
- if (is_direction (unsmob_stream_event (cause)->get_property ("direction")))
+ if (is_direction (Stream_event::unsmob (cause)->get_property ("direction")))
{
- Direction d = to_dir (unsmob_stream_event (cause)->get_property ("direction"));
+ Direction d = to_dir (Stream_event::unsmob (cause)->get_property ("direction"));
semi_tie->set_property ("direction", scm_from_int (d));
}
Music *
Repeated_music::body (Music *me)
{
- return unsmob_music (me->get_property ("element"));
+ return Music::unsmob (me->get_property ("element"));
}
SCM
SCM p = alternative_list;
while (scm_is_pair (p) && done < count)
{
- m = m + unsmob_music (scm_car (p))->get_length ();
+ m = m + Music::unsmob (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 = unsmob_music (me->get_property ("element")))
+ if (Music *body = Music::unsmob (me->get_property ("element")))
m = body->get_length ();
return m;
}
SCM
Repeated_music::unfolded_music_length (SCM m)
{
- Music *me = unsmob_music (m);
+ Music *me = Music::unsmob (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 = unsmob_music (m);
+ Music *me = Music::unsmob (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 = unsmob_music (m);
+ Music *me = Music::unsmob (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 = unsmob_music (m);
- Music *body = unsmob_music (me->get_property ("element"));
+ Music *me = Music::unsmob (m);
+ Music *body = Music::unsmob (me->get_property ("element"));
if (body)
return body->start_mom ().smobbed_copy ();
SCM
Repeated_music::first_start (SCM m)
{
- Music *me = unsmob_music (m);
- Music *body = unsmob_music (me->get_property ("element"));
+ Music *me = Music::unsmob (m);
+ Music *body = Music::unsmob (me->get_property ("element"));
Moment rv = (body) ? body->start_mom ()
: Music_sequence::first_start (me->get_property ("elements"));
Rhythmic_head::get_dots (Grob *me)
{
SCM s = me->get_object ("dot");
- return unsmob_item (s);
+ return Item::unsmob (s);
}
Item *
Rhythmic_head::get_stem (Grob *me)
{
SCM s = me->get_object ("stem");
- return unsmob_item (s);
+ return Item::unsmob (s);
}
int
SCM art = scm_car (arts);
if (c->event_source ()->is_listened_class
- (unsmob_stream_event (art)->get_property ("class")))
+ (Stream_event::unsmob (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 (unsmob_stream_event (scm_car (arts)));
+ c->event_source ()->broadcast (Stream_event::unsmob (scm_car (arts)));
}
else
c->event_source ()->broadcast (ev);
void
Score_performer::prepare (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
SCM sm = ev->get_property ("moment");
Moment *m = Moment::unsmob (sm);
audio_column_ = new Audio_column (*m);
Input *
Score::origin () const
{
- return unsmob_input (input_location_);
+ return Input::unsmob (input_location_);
}
Score::Score ()
smobify_self ();
input_location_ = make_input (*s.origin ());
- Music *m = unsmob_music (s.music_);
+ Music *m = Music::unsmob (s.music_);
if (m)
{
Music *mclone = m->clone ();
void
Score::set_music (SCM music)
{
- if (unsmob_music (music_))
+ if (Music::unsmob (music_))
{
- unsmob_music (music)->origin ()->error (_ ("already have music in score"));
- unsmob_music (music_)->origin ()->error (_ ("this is the previous music"));
+ Music::unsmob (music)->origin ()->error (_ ("already have music in score"));
+ Music::unsmob (music_)->origin ()->error (_ ("this is the previous music"));
}
- Music *m = unsmob_music (music);
+ Music *m = Music::unsmob (music);
if (m && to_boolean (m->get_property ("error-found")))
{
m->origin ()->error (_ ("errors found, ignoring music expression"));
SCM
Separation_item::calc_skylines (SCM smob)
{
- Item *me = unsmob_item (smob);
+ Item *me = Item::unsmob (smob);
vector<Box> bs = boxes (me, 0);
Skyline_pair sp (bs, Y_AXIS);
/*
if (scm_is_pair (cursor_))
- iter_->music_ == unsmob_music (scm_car (cursor_))
+ iter_->music_ == Music::unsmob (scm_car (cursor_))
else
iter_ == 0;
for (; scm_is_pair (cursor); cursor = scm_cdr (cursor))
{
- Music *mus = unsmob_music (scm_car (cursor));
+ Music *mus = Music::unsmob (scm_car (cursor));
Moment s = mus->start_mom ();
Moment l = mus->get_length () - s;
iter_ = 0;
if (scm_is_pair (cursor_))
{
- Music *m = unsmob_music (scm_car (cursor_));
+ Music *m = Music::unsmob (scm_car (cursor_));
iter_ = Music_iterator::unsmob (get_iterator (m));
}
iter_->quit ();
if (scm_is_pair (cursor_))
- iter_ = Music_iterator::unsmob (get_iterator (unsmob_music (scm_car (cursor_))));
+ iter_ = Music_iterator::unsmob (get_iterator (Music::unsmob (scm_car (cursor_))));
else
iter_ = 0;
}
SCM *tail = &children_list_;
for (; scm_is_pair (i); i = scm_cdr (i), j++)
{
- Music *mus = unsmob_music (scm_car (i));
+ Music *mus = Music::unsmob (scm_car (i));
SCM scm_iter = get_static_get_iterator (mus);
Music_iterator *mi = Music_iterator::unsmob (scm_iter);
if (!updown)
return false;
- Stream_event *c = unsmob_stream_event (slur->get_property ("cause"));
+ Stream_event *c = Stream_event::unsmob (slur->get_property ("cause"));
if (!c)
{
SCM
Slur::calc_control_points (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Slur_score_state state;
state.fill (me);
*/
- Item *r_neighbor = unsmob_item (col->get_object ("right-neighbor"));
- Item *l_neighbor = unsmob_item (col->get_object ("left-neighbor"));
+ Item *r_neighbor = Item::unsmob (col->get_object ("right-neighbor"));
+ Item *l_neighbor = Item::unsmob (col->get_object ("left-neighbor"));
if (!l_neighbor || !r_neighbor)
return false;
SCM
Spacing_spanner::set_springs (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
/*
can't use get_system () ? --hwn.
SCM
Spacing_spanner::calc_common_shortest_duration (SCM grob)
{
- Spanner *me = unsmob_spanner (grob);
+ Spanner *me = Spanner::unsmob (grob);
vector<Grob *> cols (get_columns (me));
"Get one of the bounds of @var{spanner}. @var{dir} is @w{@code{-1}}"
" for left, and @code{1} for right.")
{
- LY_ASSERT_TYPE (unsmob_spanner, spanner, 1);
+ LY_ASSERT_TYPE (Spanner::unsmob, spanner, 1);
LY_ASSERT_TYPE (is_direction, dir, 2);
- Item *bound = unsmob_spanner (spanner)->get_bound (to_dir (dir));
+ Item *bound = Spanner::unsmob (spanner)->get_bound (to_dir (dir));
return bound ? bound->self_scm () : SCM_EOL;
}
"Set grob @var{item} as bound in direction @var{dir} for"
" @var{spanner}.")
{
- LY_ASSERT_TYPE (unsmob_spanner, spanner, 1);
+ LY_ASSERT_TYPE (Spanner::unsmob, spanner, 1);
LY_ASSERT_TYPE (is_direction, dir, 2);
- LY_ASSERT_TYPE (unsmob_item, item, 3);
+ LY_ASSERT_TYPE (Item::unsmob, item, 3);
- unsmob_spanner (spanner)->set_bound (to_dir (dir), unsmob_item (item));
+ Spanner::unsmob (spanner)->set_bound (to_dir (dir), Item::unsmob (item));
return SCM_UNSPECIFIED;
}
1, 0, 0, (SCM spanner),
"Return broken-into list for @var{spanner}.")
{
- LY_ASSERT_TYPE (unsmob_spanner, spanner, 1);
+ LY_ASSERT_TYPE (Spanner::unsmob, spanner, 1);
Spanner *me = dynamic_cast<Spanner *> (Grob::unsmob (spanner));
SCM s = SCM_EOL;
SCM
Spanner::calc_normalized_endpoints (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
SCM result = SCM_EOL;
Spanner *orig = dynamic_cast<Spanner *> (me->original ());
}
Spanner *
-unsmob_spanner (SCM s)
+Spanner::unsmob (SCM s)
{
return dynamic_cast<Spanner *> (Grob::unsmob (s));
}
SCM
Spanner::bounds_width (SCM grob)
{
- Spanner *me = unsmob_spanner (grob);
+ Spanner *me = Spanner::unsmob (grob);
Grob *common = me->get_bound (LEFT)->common_refpoint (me->get_bound (RIGHT), X_AXIS);
SCM
Spanner::kill_zero_spanned_time (SCM grob)
{
- Spanner *me = unsmob_spanner (grob);
+ Spanner *me = Spanner::unsmob (grob);
/*
Remove the line or hairpin at the start of the line. For
piano voice indicators, it makes no sense to have them at
SCM
Stem_tremolo::pure_height (SCM smob, SCM, SCM)
{
- Item *me = unsmob_item (smob);
+ Item *me = Item::unsmob (smob);
/*
Cannot use the real slope, since it looks at the Beam.
*/
Stencil s1 (untranslated_stencil (me, 0.35));
- Item *stem = unsmob_item (me->get_object ("stem"));
+ Item *stem = Item::unsmob (me->get_object ("stem"));
if (!stem)
return ly_interval2scm (s1.extent (Y_AXIS));
SCM
Stem_tremolo::calc_direction (SCM smob)
{
- Item *me = unsmob_item (smob);
+ Item *me = Item::unsmob (smob);
- Item *stem = unsmob_item (me->get_object ("stem"));
+ Item *stem = Item::unsmob (me->get_object ("stem"));
if (!stem)
return scm_from_int (CENTER);
Real
Stem_tremolo::y_offset (Grob *me, bool pure)
{
- Item *stem = unsmob_item (me->get_object ("stem"));
+ Item *stem = Item::unsmob (me->get_object ("stem"));
if (!stem)
return 0.0;
1, 0, 0, (SCM obj),
"Is @code{@var{obj}} a @code{Stream_event} object?")
{
- return scm_from_bool (unsmob_stream_event (obj));
+ return scm_from_bool (Stream_event::unsmob (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_TYPE (unsmob_stream_event, sev, 1)
+ LY_ASSERT_TYPE (Stream_event::unsmob, sev, 1)
return ly_prob_property (sev, sym, val);
}
3, 0, 0, (SCM ev, SCM sym, SCM val),
"Set property @var{sym} in event @var{ev} to @var{val}.")
{
- LY_ASSERT_TYPE (unsmob_stream_event, ev, 1);
+ LY_ASSERT_TYPE (Stream_event::unsmob, ev, 1);
LY_ASSERT_TYPE (ly_is_symbol, sym, 2);
return ly_prob_set_property_x (ev, sym, val);
"Copy @var{m} and all sub expressions of@tie{}@var{m}.")
{
SCM copy = m;
- if (Stream_event *ev = unsmob_stream_event (m))
+ if (Stream_event *ev = Stream_event::unsmob (m))
{
ev = ev->clone ();
copy = ev->unprotect ();
Input *
Stream_event::origin () const
{
- Input *i = unsmob_input (get_property ("origin"));
+ Input *i = Input::unsmob (get_property ("origin"));
return i ? i : &dummy_input_global;
}
SCM val = scm_cdr (entry);
if ((Pitch::unsmob (val)
- || (prop == ly_symbol2scm ("element") && unsmob_music (val))
+ || (prop == ly_symbol2scm ("element") && Music::unsmob (val))
|| (prop == ly_symbol2scm ("elements") && scm_is_pair (val))
|| (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 = unsmob_stream_event (self);
+ Stream_event *ev = Stream_event::unsmob (self);
// Reversed alists look prettier.
return scm_cons (scm_reverse (ev->immutable_property_alist_),
scm_reverse (ev->mutable_property_alist_));
}
Stream_event *
-unsmob_stream_event (SCM m)
+Stream_event::unsmob (SCM m)
{
return dynamic_cast<Stream_event *> (Prob::unsmob (m));
}
SCM
System_start_delimiter::print (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
extract_grob_set (me, "elements", elts);
Grob *common = common_refpoint_of_array (elts, me, Y_AXIS);
SCM
System::footnotes_after_line_breaking (SCM smob)
{
- Spanner *sys_span = unsmob_spanner (smob);
+ Spanner *sys_span = Spanner::unsmob (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]);
if (left_item)
{
SCM left_cause = left_item->get_property ("cause");
- Item *slur_cause = unsmob_item (left_cause);
+ Item *slur_cause = Item::unsmob (left_cause);
if (slur_cause == note_heads_[k])
{
note_heads_[k]->set_property ("span-start", SCM_BOOL_T);
for (vsize i = heads_to_tie_.size (); i--;)
{
Grob *th = heads_to_tie_[i].head_;
- Stream_event *right_ev = unsmob_stream_event (h->get_property ("cause"));
- Stream_event *left_ev = unsmob_stream_event (th->get_property ("cause"));
+ Stream_event *right_ev = Stream_event::unsmob (h->get_property ("cause"));
+ Stream_event *left_ev = Stream_event::unsmob (th->get_property ("cause"));
/*
maybe should check positions too.
{
Grob *head = now_heads_[i];
Stream_event *left_ev
- = unsmob_stream_event (head->get_property ("cause"));
+ = Stream_event::unsmob (head->get_property ("cause"));
if (!left_ev)
{
!tie_event && !tie_stream_event && scm_is_pair (s);
s = scm_cdr (s))
{
- Stream_event *ev = unsmob_stream_event (scm_car (s));
+ Stream_event *ev = Stream_event::unsmob (scm_car (s));
if (!ev)
continue;
for (vsize i = 0; i < semi_ties.size (); i++)
{
Tie_specification spec;
- Item *head = unsmob_item (semi_ties[i]->get_object ("note-head"));
+ Item *head = Item::unsmob (semi_ties[i]->get_object ("note-head"));
if (!head)
programming_error ("LV tie without head?!");
SCM *tail = ℓ
for (SCM p = ell; scm_is_pair (p); p = scm_cdr (p))
{
- if (unsmob_performer (scm_car (*tail)))
+ if (Performer::unsmob (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 (unsmob_engraver (scm_car (*tail)))
+ if (Engraver::unsmob (scm_car (*tail)))
*tail = scm_cdr (*tail);
else
tail = SCM_CDRLOC (*tail);
void
Translator_group::create_child_translator (SCM sev)
{
- Stream_event *ev = unsmob_stream_event (sev);
+ Stream_event *ev = Stream_event::unsmob (sev);
// get from AnnounceNewContext
SCM cs = ev->get_property ("context");
Context *new_context = Context::unsmob (cs);
SCM
Tuplet_bracket::calc_connect_to_neighbors (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (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 = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
extract_grob_set (me, "note-columns", columns);
Grob *commonx = get_common_x (me);
SCM
Tuplet_bracket::print (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Stencil mol;
extract_grob_set (me, "note-columns", columns);
SCM
Tuplet_bracket::calc_positions (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Real dy = 0.0;
Real offset = 0.0;
if (stopped_tuplets_[i].full_length_)
{
Item *col
- = unsmob_item (stopped_tuplets_[i].full_length_note_
+ = Item::unsmob (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 = unsmob_item (get_property ("currentCommandColumn"));
+ Item *col = Item::unsmob (get_property ("currentCommandColumn"));
last_tuplets_[i]->set_bound (RIGHT, col);
}
}
Music *mus = get_music ();
- Music *ev = unsmob_music (ev_scm);
+ Music *ev = Music::unsmob (ev_scm);
ev->set_spot (*mus->origin ());
if (d == START)
{
Tuplet_number::adjacent_note_columns (Grob *me_grob, Grob *ref_stem)
{
Spanner *me = dynamic_cast<Spanner *> (me_grob);
- Spanner *tuplet = unsmob_spanner (me->get_object ("bracket"));
+ Spanner *tuplet = Spanner::unsmob (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 = unsmob_spanner (me->get_object ("bracket"));
+ Spanner *tuplet = Spanner::unsmob (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 = unsmob_spanner (smob);
- Spanner *tuplet = unsmob_spanner (me->get_object ("bracket"));
+ Spanner *me = Spanner::unsmob (smob);
+ Spanner *tuplet = Spanner::unsmob (me->get_object ("bracket"));
if (!tuplet || !tuplet->is_live ())
{
SCM
Tuplet_number::calc_x_offset (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (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 = unsmob_spanner (me->get_object ("bracket"));
+ Spanner *tuplet = Spanner::unsmob (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 = unsmob_spanner (smob);
- Spanner *tuplet = unsmob_spanner (me->get_object ("bracket"));
+ Spanner *me = Spanner::unsmob (smob);
+ Spanner *tuplet = Spanner::unsmob (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);
for (int i = 0; i < rep_count; i++)
{
- if (unsmob_music (body))
+ if (Music::unsmob (body))
*tail = scm_cons (body, SCM_EOL);
tail = SCM_CDRLOC (*tail);
SCM
Volta_bracket_interface::print (SCM smob)
{
- Spanner *me = unsmob_spanner (smob);
+ Spanner *me = Spanner::unsmob (smob);
Spanner *orig_span = dynamic_cast<Spanner *> (me->original ());
bool broken_first_bracket = orig_span && (orig_span->broken_intos_[0]
== (Spanner *)me);
projects / lilypond.git / commitdiff