class Grace_auto_beam_engraver : public Auto_beam_engraver
{
TRANSLATOR_DECLARATIONS (Grace_auto_beam_engraver);
+ TRANSLATOR_INHERIT (Auto_beam_engraver)
DECLARE_TRANSLATOR_LISTENER (beam_forbid);
private:
{
public:
TRANSLATOR_DECLARATIONS (Grace_beam_engraver);
-
+ TRANSLATOR_INHERIT (Beam_engraver);
DECLARE_TRANSLATOR_LISTENER (beam);
protected:
public:
// no TRANSLATOR_DECLARATIONS (Coherent_ligature_engraver) needed
// since this class is abstract
+ TRANSLATOR_INHERIT (Ligature_engraver)
+ DECLARE_TRANSLATOR_CALLBACKS (Coherent_ligature_engraver);
protected:
virtual void build_ligature (Spanner *ligature,
#ifndef ENGRAVER_HH
#define ENGRAVER_HH
+#include "callback.hh"
+#include "grob.hh"
#include "grob-info.hh"
#include "translator.hh"
Engraver_group *get_daddy_engraver () const;
public:
+ template <class T, void (T::*callback)(Grob_info)>
+ static SCM ack_trampoline (SCM target, SCM grob, SCM source_engraver)
+ {
+ T *t = LY_ASSERT_SMOB (T, target, 1);
+ Grob *g = LY_ASSERT_SMOB (Grob, grob, 2);
+ Engraver *e = LY_ASSERT_SMOB (Engraver, source_engraver, 3);
+
+ (t->*callback) (Grob_info (e, g));
+ return SCM_UNSPECIFIED;
+ }
+ template <class T, void (T::*callback)(Grob_info)>
+ static SCM ack_find_base ()
+ { return Callback2_wrapper::make_smob<ack_trampoline<T, callback> > (); }
+
/**
Announce element. Default: pass on to daddy. Utility
*/
override other ctor
*/
DECLARE_CLASSNAME (Engraver);
+ DECLARE_TRANSLATOR_CALLBACKS (Engraver);
Engraver ();
};
// no TRANSLATOR_DECLARATIONS (Gregorian_ligature_engraver) needed
// since this class is abstract
+ TRANSLATOR_INHERIT(Coherent_ligature_engraver)
+ DECLARE_TRANSLATOR_CALLBACKS (Gregorian_ligature_engraver);
protected:
Gregorian_ligature_engraver ();
public:
// no TRANSLATOR_DECLARATIONS (Ligature_engraver) needed since this
// class is abstract
+ DECLARE_TRANSLATOR_CALLBACKS (Ligature_engraver);
private:
Drul_array<Stream_event *> events_drul_;
};
#endif /* SCHEME_ENGRAVER_HH */
-
public:
// no TRANSLATOR_DECLARATIONS (Slur_proto_engraver) needed since this
// class is abstract
+ DECLARE_TRANSLATOR_CALLBACKS (Slur_proto_engraver);
};
#endif // SLUR_PROTO_ENGRAVER_HH
#define TRANSLATOR_DISPATCH_LIST_HH
#include "lily-proto.hh"
+#include "callback.hh"
#include "std-vector.hh"
#include "smobs.hh"
#include "translator.hh"
-struct Engraver_dispatch_entry
-{
- Engraver *engraver_;
- Translator::Grob_info_callback function_;
-};
-
class Engraver_dispatch_list : public Simple_smob<Engraver_dispatch_list>
{
- vector<Engraver_dispatch_entry> dispatch_entries_;
+ vector<Method_instance> dispatch_entries_;
public:
static const char * const type_p_name_; // = 0
void apply (Grob_info);
#include "global-ctor.hh"
#include "lily-proto.hh"
#include "virtual-methods.hh"
+#include "callback.hh"
#include "input.hh" // for error reporting
#include "smobs.hh"
#include "std-vector.hh"
VIRTUAL_COPY_CONSTRUCTOR (Translator, NAME); \
static Drul_array<vector<Acknowledge_information> > acknowledge_static_array_drul_; \
virtual void fetch_precomputable_methods (Callback methods[]); \
- static Grob_info_callback static_get_acknowledger (SCM sym); \
- static Grob_info_callback static_get_end_acknowledger(SCM); \
- virtual Grob_info_callback get_acknowledger (SCM sym) \
+ DECLARE_TRANSLATOR_CALLBACKS (NAME); \
+ TRANSLATOR_INHERIT (Translator) \
+ static SCM static_get_acknowledger (SCM sym); \
+ static SCM static_get_end_acknowledger(SCM); \
+ virtual SCM get_acknowledger (SCM sym) \
{ \
return static_get_acknowledger (sym); \
} \
- virtual Grob_info_callback get_end_acknowledger (SCM sym) \
+ virtual SCM get_end_acknowledger (SCM sym) \
{ \
return static_get_end_acknowledger (sym); \
} \
/* end #define */
+#define TRANSLATOR_INHERIT(BASE) \
+ using BASE::ack_finder;
+
+#define DECLARE_TRANSLATOR_CALLBACKS(NAME) \
+ template <void (NAME::*callback)(Grob_info)> \
+ static SCM ack_finder () { return ack_find_base<NAME, callback> (); } \
+ /* end #define */
+
/*
Each translator class has a static alist of event class symbols
mapping to callbacks that are called with a translator instance and
*/
#define TRANSLATOR_DECLARATIONS(NAME) \
- TRANSLATOR_FAMILY_DECLARATIONS(NAME) \
+ public: \
+ TRANSLATOR_FAMILY_DECLARATIONS (NAME); \
static SCM static_description_; \
static Protected_scm listener_list_; \
public: \
class Translator : public Smob<Translator>
{
public:
- // We don't make Grob_info_callback specific to Engraver since we
- // otherwise get into a circular mess with regard to the definitions
- // as the timing of Engraver is exercised from within Translator
- typedef void (Translator::*Grob_info_callback) (Grob_info);
typedef void (Translator::*Callback) (void);
int print_smob (SCM, scm_print_state *) const;
SCM mark_smob () const;
virtual void fetch_precomputable_methods (Callback methods[]) = 0;
virtual SCM get_listener_list () const = 0;
virtual SCM translator_description () const = 0;
- virtual Grob_info_callback get_acknowledger (SCM sym) = 0;
- virtual Grob_info_callback get_end_acknowledger (SCM sym) = 0;
+ virtual SCM get_acknowledger (SCM sym) = 0;
+ virtual SCM get_end_acknowledger (SCM sym) = 0;
protected: // should be private.
Context *daddy_context_;
return SCM_UNSPECIFIED;
}
+ // Overriden in Engraver.
+ template <class T, void (T::*callback)(Grob_info)>
+ static SCM
+ ack_find_base () { return SCM_UNDEFINED; }
+
+ template <void (Translator::*)(Grob_info)>
+ static SCM
+ ack_finder () { return SCM_UNDEFINED; }
+
virtual void derived_mark () const;
static SCM event_class_symbol (const char *ev_class);
SCM static_translator_description (const char *grobs,
struct Acknowledge_information
{
SCM symbol_;
- Translator::Grob_info_callback function_;
+ SCM function_;
Acknowledge_information ()
{
symbol_ = SCM_EOL;
- function_ = 0;
+ function_ = SCM_UNDEFINED;
}
};
#include "callback.hh"
#include "std-vector.hh"
-#include "translator.hh"
+#include "engraver.hh"
/*
TODO: derive "foo-bar-interface" from Foo_bar classname.
#define DEFINE_ACKNOWLEDGERS(classname) \
Drul_array< vector<Acknowledge_information> > classname::acknowledge_static_array_drul_; \
- Translator::Grob_info_callback \
+ SCM \
classname::static_get_acknowledger (SCM sym) \
{ \
return generic_get_acknowledger (sym, &acknowledge_static_array_drul_[START]); \
} \
- Translator::Grob_info_callback \
+ SCM \
classname::static_get_end_acknowledger (SCM sym) \
{ \
return generic_get_acknowledger (sym, &acknowledge_static_array_drul_[STOP]); \
: static_cast<Callback> (&T::process_acknowledged); \
}
-void add_acknowledger (Translator::Grob_info_callback ptr,
+void add_acknowledger (SCM ptr,
char const *func_name,
vector<Acknowledge_information> *ack_array);
-Translator::Grob_info_callback
+SCM
generic_get_acknowledger (SCM sym,
vector<Acknowledge_information> const *ack_array);
#define ADD_ACKNOWLEDGER(CLASS, NAME) \
void CLASS ## NAME ## _ack_adder () \
{ \
- add_acknowledger (static_cast<Translator::Grob_info_callback> (&CLASS::acknowledge_ ## NAME), #NAME, &CLASS::acknowledge_static_array_drul_[START]); \
+ add_acknowledger (CLASS::ack_finder<&CLASS::acknowledge_ ## NAME> (), \
+ #NAME, &CLASS::acknowledge_static_array_drul_[START]); \
} \
ADD_SCM_INIT_FUNC (CLASS ## NAME ## _ack_adder_initclass, CLASS ## NAME ## _ack_adder);
-#define ADD_END_ACKNOWLEDGER(CLASS, NAME) \
- void CLASS ## NAME ## _end_ack_adder () \
+#define ADD_END_ACKNOWLEDGER(CLASS, NAME) \
+ void CLASS ## NAME ## _end_ack_adder () \
{ \
- add_acknowledger (static_cast<Translator::Grob_info_callback> (&CLASS::acknowledge_end_ ## NAME), #NAME, &CLASS::acknowledge_static_array_drul_[STOP]); \
+ add_acknowledger (CLASS::ack_finder<&CLASS::acknowledge_end_ ## NAME> (), \
+ #NAME, &CLASS::acknowledge_static_array_drul_[STOP]); \
} \
ADD_SCM_INIT_FUNC (CLASS ## NAME ## _end_ack_adder_initclass, CLASS ## NAME ## _end_ack_adder);
public:
TRANSLATOR_DECLARATIONS (Kievan_ligature_engraver);
+ TRANSLATOR_INHERIT (Coherent_ligature_engraver)
private:
void fold_up_primitives (vector<Grob_info> const &primitives, Real padding, Real &min_length);
public:
TRANSLATOR_DECLARATIONS (Mensural_ligature_engraver);
+ TRANSLATOR_INHERIT (Coherent_ligature_engraver);
private:
void transform_heads (vector<Grob_info> const &primitives);
public:
SCM event_symbol ();
TRANSLATOR_DECLARATIONS (Phrasing_slur_engraver);
+ TRANSLATOR_INHERIT (Slur_proto_engraver);
};
Phrasing_slur_engraver::Phrasing_slur_engraver () :
public:
SCM event_symbol ();
TRANSLATOR_DECLARATIONS (Slur_engraver);
+ TRANSLATOR_INHERIT (Slur_proto_engraver);
};
Slur_engraver::Slur_engraver () :
void
Engraver_dispatch_list::apply (Grob_info gi)
{
- Translator *origin = gi.origin_translator ();
+ SCM origin = gi.origin_translator ()->self_scm ();
+ SCM grob = gi.grob ()->self_scm ();
for (vsize i = 0; i < dispatch_entries_.size (); i++)
{
- Engraver_dispatch_entry const &e (dispatch_entries_[i]);
- if (e.engraver_ == origin)
+ Method_instance const &e (dispatch_entries_[i]);
+ if (scm_is_eq (e.instance (), origin))
continue;
- (e.engraver_->*e.function_) (gi);
+ e (grob, origin);
}
}
SCM retval = Engraver_dispatch_list ().smobbed_copy ();
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
- = unsmob<Engraver> (scm_car (s));
+ Engraver *eng = unsmob<Engraver> (scm_car (s));
if (!eng)
continue;
- entry.engraver_ = eng;
for (SCM i = iface_list; scm_is_pair (i); i = scm_cdr (i))
{
- Translator::Grob_info_callback ptr
+ SCM ptr
= (start_end == START)
- ? eng->get_acknowledger (scm_car (i))
- : eng->get_end_acknowledger (scm_car (i));
+ ? eng->get_acknowledger (scm_car (i))
+ : eng->get_end_acknowledger (scm_car (i));
- if (ptr)
- {
- entry.function_ = ptr;
- list->dispatch_entries_.push_back (entry);
- found = true;
- }
+ if (!SCM_UNBNDP (ptr))
+ list->dispatch_entries_.push_back (Method_instance (ptr, eng));
}
}
- return found ? retval : SCM_EOL;
+ return list->dispatch_entries_.empty () ? SCM_EOL : retval;
}
}
void
-add_acknowledger (Translator::Grob_info_callback ptr,
+add_acknowledger (SCM ptr,
char const *func_name,
vector<Acknowledge_information> *ack_array)
{
ack_array->push_back (inf);
}
-Translator::Grob_info_callback
+SCM
generic_get_acknowledger (SCM sym, vector<Acknowledge_information> const *ack_array)
{
for (vsize i = 0; i < ack_array->size (); i++)
if (ack_array->at (i).symbol_ == sym)
return ack_array->at (i).function_;
}
- return 0;
+ return SCM_UNDEFINED;
}
Moment
public:
TRANSLATOR_DECLARATIONS (Vaticana_ligature_engraver);
-
+ TRANSLATOR_INHERIT (Gregorian_ligature_engraver)
protected:
virtual Spanner *create_ligature_spanner ();
virtual void transform_heads (Spanner *ligature,