#include "translator-group.hh"
#include "global-context.hh"
#include "moment.hh"
+#include "lily-imports.hh"
void
Timing_translator::stop_translation_timestep ()
void
Timing_translator::initialize ()
{
- Context *timing = Context::unsmob (scm_call_2 (ly_lily_module_constant ("ly:context-find"),
- context ()->self_scm (),
- ly_symbol2scm ("Timing")));
+ Context *timing = unsmob<Context>
+ (Lily::ly_context_find (context ()->self_scm (), ly_symbol2scm ("Timing")));
if (timing != context ())
{
context ()->add_alias (ly_symbol2scm ("Timing"));
SCM measureLength = timing->get_property ("measureLength");
- if (!Moment::is_smob (measureLength))
+ if (!unsmob<Moment> (measureLength))
{
measureLength =
Moment (ly_scm2rational
if (!scm_is_pair (timeSignatureSettings))
{
programming_error ("missing timeSignatureSettings");
- // A memoized constant is not the prettiest thing as a fallback
- // since it does not track changes of the variable. However,
- // this is still better than nothing, and we already complained
- // via a programming_error
- timeSignatureSettings = ly_lily_module_constant ("default-time-signature-settings");
+ timeSignatureSettings = Lily::default_time_signature_settings;
}
context ()->set_property ("timeSignatureSettings", timeSignatureSettings);
SCM beamExceptions = timing->get_property ("beamExceptions");
if (!scm_is_pair (beamExceptions))
{
- beamExceptions =
- scm_call_2 (ly_lily_module_constant ("beam-exceptions"),
- timeSignatureFraction,
- timeSignatureSettings);
+ beamExceptions = Lily::beam_exceptions (timeSignatureFraction,
+ timeSignatureSettings);
}
context ()->set_property ("beamExceptions", beamExceptions);
SCM baseMoment = timing->get_property ("baseMoment");
- if (!Moment::is_smob (baseMoment))
+ if (!unsmob<Moment> (baseMoment))
{
baseMoment =
Moment (ly_scm2rational
- (scm_call_2 (ly_lily_module_constant ("base-length"),
- timeSignatureFraction,
- timeSignatureSettings))).smobbed_copy ();
+ (Lily::base_length (timeSignatureFraction,
+ timeSignatureSettings))).smobbed_copy ();
}
context ()->set_property ("baseMoment", baseMoment);
if (!scm_is_pair (beatStructure))
{
beatStructure =
- scm_call_3 (ly_lily_module_constant ("beat-structure"),
- ly_rational2scm (Moment::unsmob (baseMoment)->main_part_),
- timeSignatureFraction,
- timeSignatureSettings);
+ Lily::beat_structure (ly_rational2scm (unsmob<Moment> (baseMoment)->main_part_),
+ timeSignatureFraction,
+ timeSignatureSettings);
}
context ()->set_property ("beatStructure", beatStructure);
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);
}
-Timing_translator::Timing_translator ()
+Timing_translator::Timing_translator (Context *c)
+ : Translator (c)
{
}
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;
#include "translator.icc"
+void
+Timing_translator::boot ()
+{
+
+}
+
ADD_TRANSLATOR (Timing_translator,
/* doc */
"This engraver adds the alias @code{Timing} to its containing"