2005-07-23 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ * lily/engraver*cc: use throughout.
+
+ * lily/include/translator.icc (ADD_ACKNOWLEDGER): new macro.
+
+ * lily/translator.cc (add_acknowledger): new file. Directly jump
+ into an Engraver::acknowledge_xxx () method based on a grobs
+ interface-list.
+
+ * lily/include/translator-dispatch-list.hh (class
+ Engraver_dispatch_list): new struct., new file.
+
* scm/define-context-properties.scm
(all-internal-translation-properties): remove acceptHashTable,
acknowledgeHashTable
protected:
TRANSLATOR_DECLARATIONS (Accidental_engraver);
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+
+ void acknowledge_tie (Grob_info);
+ void acknowledge_arpeggio (Grob_info);
+ void acknowledge_rhythmic_head (Grob_info);
+ void acknowledge_finger (Grob_info);
+
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void initialize ();
PRECOMPUTED_VIRTUAL void process_acknowledged ();
}
void
-Accidental_engraver::acknowledge_grob (Grob_info info)
+Accidental_engraver::acknowledge_rhythmic_head (Grob_info info)
{
Music *note = info.music_cause ();
-
if (note
- && note->is_mus_type ("note-event")
- && Rhythmic_head::has_interface (info.grob ()))
+ && note->is_mus_type ("note-event"))
{
/*
String harmonics usually don't have accidentals.
accidentals_.push (entry);
}
}
- else if (Tie::has_interface (info.grob ()))
- ties_.push (dynamic_cast<Spanner *> (info.grob ()));
- else if (Arpeggio::has_interface (info.grob ()))
- left_objects_.push (info.grob ());
- else if (info.grob ()
- ->internal_has_interface (ly_symbol2scm ("finger-interface")))
- left_objects_.push (info.grob ());
+}
+
+void
+Accidental_engraver::acknowledge_tie (Grob_info info)
+{
+ ties_.push (dynamic_cast<Spanner *> (info.grob ()));
+}
+
+void
+Accidental_engraver::acknowledge_arpeggio (Grob_info info)
+{
+ left_objects_.push (info.grob ());
+}
+
+void
+Accidental_engraver::acknowledge_finger (Grob_info info)
+{
+ left_objects_.push (info.grob ());
}
void
update_local_key_signature ();
}
+
+ADD_ACKNOWLEDGER(Accidental_engraver, arpeggio);
+ADD_ACKNOWLEDGER(Accidental_engraver, finger);
+ADD_ACKNOWLEDGER(Accidental_engraver, rhythmic_head);
+ADD_ACKNOWLEDGER(Accidental_engraver, tie);
+
ADD_TRANSLATOR (Accidental_engraver,
"Make accidentals. "
"Catch note heads, ties and notices key-change events. "
"",
/* acks */
- "arpeggio-interface "
- "finger-interface "
- "rhythmic-head-interface "
- "tie-interface ",
+ "",
"autoAccidentals "
"autoCautionaries "
public:
TRANSLATOR_DECLARATIONS (Ambitus_engraver);
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+ void acknowledge_note_head (Grob_info);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void finalize ();
virtual void derived_mark () const;
}
void
-Ambitus_engraver::acknowledge_grob (Grob_info info)
+Ambitus_engraver::acknowledge_note_head (Grob_info info)
{
- Item *item = dynamic_cast<Item *> (info.grob ());
- if (item)
+ Music *nr = info.music_cause ();
+ if (nr && nr->is_mus_type ("note-event"))
{
- if (Note_head::has_interface (info.grob ()))
- {
- Music *nr = info.music_cause ();
- if (nr && nr->is_mus_type ("note-event"))
- {
- Pitch pitch = *unsmob_pitch (nr->get_property ("pitch"));
- pitch_interval_.add_point (pitch);
- }
- }
+ Pitch pitch = *unsmob_pitch (nr->get_property ("pitch"));
+ pitch_interval_.add_point (pitch);
}
}
}
}
-#include "translator.icc"
+ADD_ACKNOWLEDGER(Ambitus_engraver, note_head);
ADD_TRANSLATOR (Ambitus_engraver,
/* descr */ "",
/* creats*/ "Ambitus AmbitusLine AmbitusNoteHead AmbitusAccidental",
/* accepts */ "",
- /* acks */ "note-head-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
public:
TRANSLATOR_DECLARATIONS (Arpeggio_engraver);
+ void acknowledge_stem (Grob_info);
+ void acknowledge_rhythmic_head (Grob_info);
+ void acknowledge_note_column (Grob_info);
protected:
- virtual void acknowledge_grob (Grob_info);
PRECOMPUTED_VIRTUAL void process_music ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual bool try_music (Music *);
}
void
-Arpeggio_engraver::acknowledge_grob (Grob_info info)
+Arpeggio_engraver::acknowledge_stem (Grob_info info)
{
if (arpeggio_)
{
- if (Stem::has_interface (info.grob ()))
- {
- if (!arpeggio_->get_parent (Y_AXIS))
- arpeggio_->set_parent (info.grob (), Y_AXIS);
-
- Pointer_group_interface::add_grob (arpeggio_,
- ly_symbol2scm ("stems"),
- info.grob ());
- }
-
- /*
- We can't catch local key items (accidentals) from Voice context,
- see Local_key_engraver
- */
- else if (Rhythmic_head::has_interface (info.grob ()))
- {
- Side_position_interface::add_support (arpeggio_, info.grob ());
- }
- else if (Note_column::has_interface (info.grob ()))
- {
- info.grob ()->set_object ("arpeggio", arpeggio_->self_scm ());
- }
+ if (!arpeggio_->get_parent (Y_AXIS))
+ arpeggio_->set_parent (info.grob (), Y_AXIS);
+
+ Pointer_group_interface::add_grob (arpeggio_,
+ ly_symbol2scm ("stems"),
+ info.grob ());
+ }
+}
+void
+Arpeggio_engraver::acknowledge_rhythmic_head (Grob_info info)
+{
+ if (arpeggio_)
+
+ /*
+ We can't catch local key items (accidentals) from Voice context,
+ see Local_key_engraver
+ */
+ {
+ Side_position_interface::add_support (arpeggio_, info.grob ());
+ }
+}
+
+void
+Arpeggio_engraver::acknowledge_note_column (Grob_info info)
+{
+ if (arpeggio_)
+ {
+ info.grob ()->set_object ("arpeggio", arpeggio_->self_scm ());
}
}
arpeggio_event_ = 0;
}
+ADD_ACKNOWLEDGER(Arpeggio_engraver, stem)
+ADD_ACKNOWLEDGER(Arpeggio_engraver, rhythmic_head)
+ADD_ACKNOWLEDGER(Arpeggio_engraver, note_column)
+
ADD_TRANSLATOR (Arpeggio_engraver,
/* descr */ "Generate an Arpeggio symbol",
/* creats*/ "Arpeggio",
/* accepts */ "arpeggio-event",
- /* acks */ "stem-interface rhythmic-head-interface note-column-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
PRECOMPUTED_VIRTUAL void process_music ();
virtual bool try_music (Music *);
virtual void finalize ();
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(rest);
+ DECLARE_ACKNOWLEDGER(beam);
+ DECLARE_ACKNOWLEDGER(bar_line);
+ DECLARE_ACKNOWLEDGER(stem);
+
PRECOMPUTED_VIRTUAL void process_acknowledged ();
private:
SCM beam_settings_; // ugh. should protect ?
Beaming_info_list *finished_grouping_;
+
+ void check_bar_property ();
};
+
+void
+Auto_beam_engraver::check_bar_property ()
+{
+ /* Duplicated from process_music (), since
+ Repeat_acknowledge_engraver::process_music () may also set whichBar. */
+
+ Moment now = now_mom ();
+ if (scm_is_string (get_property ("whichBar"))
+ && beam_start_moment_ < now)
+ {
+ consider_end (shortest_mom_);
+ junk_beam ();
+ }
+}
+
void
Auto_beam_engraver::process_music ()
{
junk_beam ();
}
+
+
+
void
-Auto_beam_engraver::acknowledge_grob (Grob_info info)
+Auto_beam_engraver::acknowledge_beam (Grob_info info)
{
- /* Duplicated from process_music (), since
- Repeat_acknowledge_engraver::process_music () may also set whichBar. */
-
- Moment now = now_mom ();
- if (scm_is_string (get_property ("whichBar"))
- && beam_start_moment_ < now)
+ check_bar_property ();
+ if (stems_)
{
- consider_end (shortest_mom_);
- junk_beam ();
+ end_beam ();
}
+}
+
+void
+Auto_beam_engraver::acknowledge_bar_line (Grob_info info)
+{
+ check_bar_property ();
+ if (stems_)
+ end_beam ();
+}
+void
+Auto_beam_engraver::acknowledge_rest (Grob_info info)
+{
+ check_bar_property ();
if (stems_)
+ end_beam ();
+}
+
+void
+Auto_beam_engraver::acknowledge_stem (Grob_info info)
+{
+ check_bar_property ();
+ Item *stem = dynamic_cast<Item *> (info.grob ());
+ Music *m = info.music_cause ();
+ if (!m->is_mus_type ("rhythmic-event"))
{
- if (Beam::has_interface (info.grob ()))
- {
- end_beam ();
- }
- else if (Bar_line::has_interface (info.grob ()))
- {
- end_beam ();
- }
- else if (Rest::has_interface (info.grob ()))
- {
- end_beam ();
- }
+ programming_error ("stem must have rhythmic structure");
+ return;
}
- if (Stem::has_interface (info.grob ()))
+ /*
+ Don't (start) auto-beam over empty stems; skips or rests
+ */
+ if (!Stem::head_count (stem))
{
- Item *stem = dynamic_cast<Item *> (info.grob ());
- Music *m = info.music_cause ();
- if (!m->is_mus_type ("rhythmic-event"))
- {
- programming_error ("stem must have rhythmic structure");
- return;
- }
-
- /*
- Don't (start) auto-beam over empty stems; skips or rests
- */
- if (!Stem::head_count (stem))
- {
- if (stems_)
- end_beam ();
- return;
- }
+ if (stems_)
+ end_beam ();
+ return;
+ }
- if (Stem::get_beam (stem))
- {
- if (stems_)
- junk_beam ();
- return;
- }
+ if (Stem::get_beam (stem))
+ {
+ if (stems_)
+ junk_beam ();
+ return;
+ }
- int durlog = unsmob_duration (m->get_property ("duration"))->duration_log ();
+ int durlog = unsmob_duration (m->get_property ("duration"))->duration_log ();
- if (durlog <= 2)
- {
- if (stems_)
- end_beam ();
- return;
- }
+ if (durlog <= 2)
+ {
+ if (stems_)
+ end_beam ();
+ return;
+ }
- /*
- ignore grace notes.
- */
- if (bool (beam_start_location_.grace_part_) != bool (now.grace_part_))
- return;
+ /*
+ ignore grace notes.
+ */
+ Moment now = now_mom ();
+ if (bool (beam_start_location_.grace_part_) != bool (now.grace_part_))
+ return;
- Moment dur = unsmob_duration (m->get_property ("duration"))->get_length ();
+ Moment dur = unsmob_duration (m->get_property ("duration"))->get_length ();
- consider_end (dur);
- consider_begin (dur);
+ consider_end (dur);
+ consider_begin (dur);
- if (dur < shortest_mom_)
- shortest_mom_ = dur;
+ if (dur < shortest_mom_)
+ shortest_mom_ = dur;
- if (!stems_)
- return;
+ if (!stems_)
+ return;
- grouping_->add_stem (now - beam_start_moment_ + beam_start_location_,
- durlog - 2);
- stems_->push (stem);
- last_add_mom_ = now;
- extend_mom_ = max (extend_mom_, now) + m->get_length ();
- }
+ grouping_->add_stem (now - beam_start_moment_ + beam_start_location_,
+ durlog - 2);
+ stems_->push (stem);
+ last_add_mom_ = now;
+ extend_mom_ = max (extend_mom_, now) + m->get_length ();
}
void
process_acknowledged_count_++;
}
+ADD_ACKNOWLEDGER(Auto_beam_engraver,stem);
+ADD_ACKNOWLEDGER(Auto_beam_engraver,bar_line);
+ADD_ACKNOWLEDGER(Auto_beam_engraver,beam);
+ADD_ACKNOWLEDGER(Auto_beam_engraver,rest);
ADD_TRANSLATOR (Auto_beam_engraver,
/* descr */ "Generate beams based on measure characteristics and observed "
"Stems. Uses beatLength, measureLength and measurePosition to decide "
"@code{stemRightBeamCount}. ",
/* creats*/ "Beam",
/* accepts */ "beam-forbid-event",
- /* acks */ "stem-interface rest-interface beam-interface bar-line-interface",
+ /* acks */ "",
/* reads */ "autoBeaming autoBeamSettings beatLength subdivideBeams",
/* write */ "");
Axis_group_interface::add_element (staffline_, e);
}
+ADD_ACKNOWLEDGER(Axis_group_engraver, grob);
+
ADD_TRANSLATOR (Axis_group_engraver,
/* descr */ "Group all objects created in this context in a VerticalAxisGroup spanner.",
/* creats*/ "VerticalAxisGroup",
/* accepts */ "",
- /* acks */ "grob-interface",
+ /* acks */ "",
/* reads */ "verticalExtent minimumVerticalExtent extraVerticalExtent",
/* write */ "");
Item *text_;
protected:
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(break_aligned);
PRECOMPUTED_VIRTUAL void process_music ();
void create_items ();
TRANSLATOR_DECLARATIONS (Bar_number_engraver);
}
void
-Bar_number_engraver::acknowledge_grob (Grob_info inf)
+Bar_number_engraver::acknowledge_break_aligned (Grob_info inf)
{
Grob *s = inf.grob ();
if (text_
/* creats*/ "BarNumber",
/* accepts */ "",
- /* acks */ "break-aligned-interface",
+ /* acks */ "",
/* reads */ "currentBarNumber stavesFound barNumberVisibility",
/* write */ "");
class Beam_engraver : public Engraver
{
+public:
+ DECLARE_ACKNOWLEDGER(stem);
+ DECLARE_ACKNOWLEDGER(rest);
protected:
Music *start_ev_;
PRECOMPUTED_VIRTUAL void start_translation_timestep ();
virtual void finalize ();
- virtual void acknowledge_grob (Grob_info);
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Beam_engraver::acknowledge_grob (Grob_info info)
+Beam_engraver::acknowledge_rest (Grob_info info)
+{
+ if (beam_)
+ info.grob ()->add_offset_callback (Beam::rest_collision_callback_proc, Y_AXIS);
+}
+
+void
+Beam_engraver::acknowledge_stem (Grob_info info)
{
if (beam_)
{
- if (Rest::has_interface (info.grob ()))
+ Moment now = now_mom ();
+
+ if (!valid_start_point ())
+ return;
+
+ Item *stem = dynamic_cast<Item *> (info.grob ());
+ if (Stem::get_beam (stem))
+ return;
+
+ Music *m = info.music_cause ();
+ if (!m->is_mus_type ("rhythmic-event"))
{
- info.grob ()->add_offset_callback (Beam::rest_collision_callback_proc, Y_AXIS);
+ String s = _ ("stem must have Rhythmic structure");
+ if (info.music_cause ())
+ info.music_cause ()->origin ()->warning (s);
+ else
+ ::warning (s);
+
+ return;
}
- else if (Stem::has_interface (info.grob ()))
+
+ last_stem_added_at_ = now;
+ int durlog = unsmob_duration (m->get_property ("duration"))->duration_log ();
+ if (durlog <= 2)
{
- Moment now = now_mom ();
-
- if (!valid_start_point ())
- return;
-
- Item *stem = dynamic_cast<Item *> (info.grob ());
- if (Stem::get_beam (stem))
- return;
-
- Music *m = info.music_cause ();
- if (!m->is_mus_type ("rhythmic-event"))
- {
- String s = _ ("stem must have Rhythmic structure");
- if (info.music_cause ())
- info.music_cause ()->origin ()->warning (s);
- else
- ::warning (s);
-
- return;
- }
-
- last_stem_added_at_ = now;
- int durlog = unsmob_duration (m->get_property ("duration"))->duration_log ();
- if (durlog <= 2)
- {
- m->origin ()->warning (_ ("stem doesn't fit in beam"));
- prev_start_ev_->origin ()->warning (_ ("beam was started here"));
- /*
- don't return, since
-
- [r4 c8] can just as well be modern notation.
- */
- }
-
- stem->set_property ("duration-log",
- scm_int2num (durlog));
- Moment stem_location = now - beam_start_mom_ + beam_start_location_;
- beam_info_->add_stem (stem_location,
- max (durlog- 2, 0));
- Beam::add_stem (beam_, stem);
+ m->origin ()->warning (_ ("stem doesn't fit in beam"));
+ prev_start_ev_->origin ()->warning (_ ("beam was started here"));
+ /*
+ don't return, since
+
+ [r4 c8] can just as well be modern notation.
+ */
}
+
+ stem->set_property ("duration-log",
+ scm_int2num (durlog));
+ Moment stem_location = now - beam_start_mom_ + beam_start_location_;
+ beam_info_->add_stem (stem_location,
+ max (durlog- 2, 0));
+ Beam::add_stem (beam_, stem);
}
}
+ADD_ACKNOWLEDGER(Beam_engraver, stem);
+ADD_ACKNOWLEDGER(Beam_engraver, rest);
+
ADD_TRANSLATOR (Beam_engraver,
/* descr */ "Handles Beam events by engraving Beams. If omitted, then notes will be "
"printed with flags instead of beams.",
/* creats*/ "Beam",
/* accepts */ "beam-event",
- /* acks */ "stem-interface rest-interface",
+ /* acks */ "",
/* reads */ "beamMelismaBusy beatLength subdivideBeams",
/* write */ "");
return beam_ && valid_start_point ();
}
+ADD_ACKNOWLEDGER(Grace_beam_engraver, stem);
+ADD_ACKNOWLEDGER(Grace_beam_engraver, rest);
ADD_TRANSLATOR (Grace_beam_engraver,
/* descr */ "Handles Beam events by engraving Beams. If omitted, then notes will "
"be printed with flags instead of beams. Only engraves beams when we "
void add_to_group (SCM, Item *);
protected:
- virtual void acknowledge_grob (Grob_info i);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void derived_mark () const;
public:
TRANSLATOR_DECLARATIONS (Break_align_engraver);
+ DECLARE_ACKNOWLEDGER(break_aligned);
+
};
void
}
void
-Break_align_engraver::acknowledge_grob (Grob_info inf)
+Break_align_engraver::acknowledge_break_aligned (Grob_info inf)
{
if (Item *item = dynamic_cast<Item *> (inf.grob ()))
{
}
Axis_group_interface::add_element (group, item);
}
-
+ADD_ACKNOWLEDGER(Break_align_engraver, break_aligned);
ADD_TRANSLATOR (Break_align_engraver,
"Align grobs with corresponding @code{break-align-symbols} into "
"groups, and order the groups according to @code{breakAlignOrder}. "
"The left edge of the alignment gets a separate group, with a symbol @code{left-edge}. ",
/* creats*/ "BreakAlignment BreakAlignGroup LeftEdge",
/* accepts */ "",
- /* acks */ "break-aligned-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
#include "stem-tremolo.hh"
#include "math.h" // ceil
+#include "translator.icc"
+
/**
This acknowledges repeated music with "tremolo" style. It typesets
protected:
virtual void finalize ();
virtual bool try_music (Music *);
- virtual void acknowledge_grob (Grob_info);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void start_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
+ DECLARE_ACKNOWLEDGER(stem);
};
Chord_tremolo_engraver::Chord_tremolo_engraver ()
}
void
-Chord_tremolo_engraver::acknowledge_grob (Grob_info info)
+Chord_tremolo_engraver::acknowledge_stem (Grob_info info)
{
- if (beam_ && Stem::has_interface (info.grob ()))
+ if (beam_)
{
Grob *s = info.grob ();
}
else if (repeat_
&& flags_
- && !body_is_sequential_
- && Stem::has_interface (info.grob ()))
+ && !body_is_sequential_)
{
stem_tremolo_ = make_item ("StemTremolo", repeat_->self_scm ());
stem_tremolo_->set_property ("flag-count",
typeset_beam ();
}
-#include "translator.icc"
+ADD_ACKNOWLEDGER(Chord_tremolo_engraver,stem);
ADD_TRANSLATOR (Chord_tremolo_engraver,
/* descr */ "Generates beams for tremolo repeats.",
/* creats*/ "Beam",
/* accepts */ "repeated-music",
- /* acks */ "stem-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
#include "direction.hh"
#include "side-position-interface.hh"
+#include "translator.icc"
+
class Clef_engraver : public Engraver
{
public:
protected:
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(bar_line);
private:
Item *clef_;
Item *octavate_;
ie. a breakpoint)
*/
void
-Clef_engraver::acknowledge_grob (Grob_info info)
+Clef_engraver::acknowledge_bar_line (Grob_info info)
{
Item *item = dynamic_cast<Item *> (info.grob ());
- if (item)
+ if (item && scm_is_string (get_property ("clefGlyph")))
{
- if (Bar_line::has_interface (info.grob ())
- && scm_is_string (get_property ("clefGlyph")))
- create_clef ();
+ create_clef ();
}
}
}
}
-#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Clef_engraver, bar_line);
ADD_TRANSLATOR (Clef_engraver,
/* descr */ "Determine and set reference point for pitches",
/* creats*/ "Clef OctavateEight",
/* accepts */ "",
- /* acks */ "bar-line-interface",
+ /* acks */ "",
/* reads */ "clefPosition clefGlyph middleCPosition clefOctavation explicitClefVisibility forceClef",
/* write */ "");
TRANSLATOR_DECLARATIONS (Cluster_spanner_engraver);
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_column);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void finalize ();
private:
}
void
-Cluster_spanner_engraver::acknowledge_grob (Grob_info info)
+Cluster_spanner_engraver::acknowledge_note_column (Grob_info info)
{
if (!beacon_ && Note_column::has_interface (info.grob ()))
{
#include "translator.icc"
+ADD_ACKNOWLEDGER(Cluster_spanner_engraver, note_column);
ADD_TRANSLATOR (Cluster_spanner_engraver,
/* descr */ "Engraves a cluster using Spanner notation ",
/* creats*/ "ClusterSpanner ClusterSpannerBeacon",
/* accepts */ "cluster-note-event busy-playing-event",
- /* acks */ "note-column-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
Link_array<Grob> note_columns_;
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_column);
PRECOMPUTED_VIRTUAL void process_acknowledged ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
public:
}
void
-Collision_engraver::acknowledge_grob (Grob_info i)
+Collision_engraver::acknowledge_note_column (Grob_info i)
{
if (Note_column::has_interface (i.grob ()))
{
#include "translator.icc"
+ADD_ACKNOWLEDGER(Collision_engraver, note_column);
+
ADD_TRANSLATOR (Collision_engraver,
/* descr */ "Collect NoteColumns, and as soon as there are two or more, put them in a NoteCollision object.",
/* creats*/ "NoteCollision",
/* accepts */ "",
- /* acks */ "note-column-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
#include "warn.hh"
#include "pitch.hh"
+#include "translator.icc"
+
/*
* This class implements an engraver for custos symbols.
public:
TRANSLATOR_DECLARATIONS (Custos_engraver);
PRECOMPUTED_VIRTUAL void start_translation_timestep ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(bar);
+ DECLARE_ACKNOWLEDGER(note_head);
PRECOMPUTED_VIRTUAL void process_acknowledged ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void finalize ();
private:
Item *create_custos ();
- bool custos_permitted;
+ bool custos_permitted_;
Link_array<Grob> custodes_;
Array<Pitch> pitches_;
};
Custos_engraver::Custos_engraver ()
{
- custos_permitted = false;
+ custos_permitted_ = false;
}
void
*/
pitches_.clear ();
- custos_permitted = false;
+ custos_permitted_ = false;
}
void
}
void
-Custos_engraver::acknowledge_grob (Grob_info info)
+Custos_engraver::acknowledge_bar (Grob_info info)
+{
+ custos_permitted_ = true;
+}
+
+void
+Custos_engraver::acknowledge_note_head (Grob_info info)
{
- Item *item = dynamic_cast<Item *> (info.grob ());
- if (item)
+ Music *m = info.music_cause ();
+ if (m && m->is_mus_type ("note-event"))
{
- Music *m = info.music_cause ();
- if (Bar_line::has_interface (info.grob ()))
- custos_permitted = true;
- else if (Note_head::has_interface (info.grob ())
- && m
- && m->is_mus_type ("note-event"))
- {
- /*
- ideally, we'd do custos->set_parent (Y_AXIS, notehead),
- but since the note head lives on the other system, we can't
+ /*
+ ideally, we'd do custos->set_parent (Y_AXIS, notehead),
+ but since the note head lives on the other system, we can't
- So we copy the position from the note head pitch. We
- don't look at the staff-position, since we can't be sure
- whether Clef_engraver already applied a vertical shift.
- */
- pitches_.push (*unsmob_pitch (m->get_property ("pitch")));
- }
+ So we copy the position from the note head pitch. We
+ don't look at the staff-position, since we can't be sure
+ whether Clef_engraver already applied a vertical shift.
+ */
+ pitches_.push (*unsmob_pitch (m->get_property ("pitch")));
}
}
Custos_engraver::process_acknowledged ()
{
if (scm_is_string (get_property ("whichBar")))
- custos_permitted = true;
+ custos_permitted_ = true;
- if (custos_permitted)
+ if (custos_permitted_)
{
for (int i = pitches_.size (); i--;)
{
custodes_.clear ();
}
-#include "translator.icc"
+
+ADD_ACKNOWLEDGER(Custos_engraver,bar);
+ADD_ACKNOWLEDGER(Custos_engraver,note_head);
ADD_TRANSLATOR (Custos_engraver,
/* descr */ "",
/* creats*/ "Custos",
/* accepts */ "",
- /* acks */ "bar-line-interface note-head-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
#include "side-position-interface.hh"
#include "engraver.hh"
#include "stem.hh"
+#include "translator.icc"
class Dot_column_engraver : public Engraver
{
TRANSLATOR_DECLARATIONS (Dot_column_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(stem);
+ DECLARE_ACKNOWLEDGER(rhythmic_head);
+
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
};
}
void
-Dot_column_engraver::acknowledge_grob (Grob_info info)
+Dot_column_engraver::acknowledge_rhythmic_head (Grob_info info)
{
Grob *d = unsmob_grob (info.grob ()->get_object ("dot"));
if (d)
Dot_column::add_head (dotcol_, info.grob ());
}
- else if (Stem::has_interface (info.grob ()))
- {
- stem_ = info.grob ();
- }
}
-#include "translator.icc"
+void
+Dot_column_engraver::acknowledge_stem (Grob_info info)
+{
+ stem_ = info.grob ();
+}
+
+ADD_ACKNOWLEDGER(Dot_column_engraver, stem);
+ADD_ACKNOWLEDGER(Dot_column_engraver, rhythmic_head);
ADD_TRANSLATOR (Dot_column_engraver,
/* descr */ "Engraves dots on dotted notes shifted to the right of the note.\n"
"If omitted, then dots appear on top of the notes.",
/* creats*/ "DotColumn",
/* accepts */ "",
- /* acks */ "rhythmic-head-interface dot-column-interface stem-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
protected:
virtual bool try_music (Music *ev);
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(stem);
+ DECLARE_ACKNOWLEDGER(note_column);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
};
}
void
-Drum_notes_engraver::acknowledge_grob (Grob_info inf)
+Drum_notes_engraver::acknowledge_stem (Grob_info inf)
{
- if (Stem::has_interface (inf.grob ()))
+ for (int i = 0; i < scripts_.size (); i++)
{
- for (int i = 0; i < scripts_.size (); i++)
- {
- Grob *e = scripts_[i];
+ Grob *e = scripts_[i];
- if (to_dir (e->get_property ("side-relative-direction")))
- e->set_object ("direction-source", inf.grob ()->self_scm ());
+ if (to_dir (e->get_property ("side-relative-direction")))
+ e->set_object ("direction-source", inf.grob ()->self_scm ());
- /*
- add dep ?
- */
- e->add_dependency (inf.grob ());
- Side_position_interface::add_support (e, inf.grob ());
- }
+ /*
+ add dep ?
+ */
+ e->add_dependency (inf.grob ());
+ Side_position_interface::add_support (e, inf.grob ());
}
- else if (Note_column::has_interface (inf.grob ()))
+}
+void
+Drum_notes_engraver::acknowledge_note_column (Grob_info inf)
+{
+ for (int i = 0; i < scripts_.size (); i++)
{
- for (int i = 0; i < scripts_.size (); i++)
- {
- Grob *e = scripts_[i];
+ Grob *e = scripts_[i];
- if (!e->get_parent (X_AXIS)
- && Side_position_interface::get_axis (e) == Y_AXIS)
- {
- e->set_parent (inf.grob (), X_AXIS);
- }
+ if (!e->get_parent (X_AXIS)
+ && Side_position_interface::get_axis (e) == Y_AXIS)
+ {
+ e->set_parent (inf.grob (), X_AXIS);
}
}
}
#include "translator.icc"
+ADD_ACKNOWLEDGER(Drum_notes_engraver, stem);
+ADD_ACKNOWLEDGER(Drum_notes_engraver,note_column);
ADD_TRANSLATOR (Drum_notes_engraver,
/* descr */ "Generate noteheads.",
/* creats*/ "NoteHead Dots Script",
/* accepts */ "note-event busy-playing-event",
- /* acks */ "stem-interface note-column-interface",
+ /* acks */ "",
/* reads */ "drumStyleTable",
/* write */ "");
#include "self-alignment-interface.hh"
#include "pointer-group-interface.hh"
+#include "translator.icc"
+
/*
TODO:
void typeset_all ();
TRANSLATOR_DECLARATIONS (Dynamic_engraver);
+ DECLARE_ACKNOWLEDGER(script);
+ DECLARE_ACKNOWLEDGER(note_column);
+
protected:
virtual void finalize ();
- virtual void acknowledge_grob (Grob_info);
virtual bool try_music (Music *event);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Dynamic_engraver::acknowledge_grob (Grob_info info)
+Dynamic_engraver::acknowledge_note_column (Grob_info info)
{
if (!line_spanner_)
return;
- if (Note_column::has_interface (info.grob ()))
+ if (line_spanner_
+ /* Don't refill killed spanner */
+ && line_spanner_->is_live ())
{
- if (line_spanner_
- /* Don't refill killed spanner */
- && line_spanner_->is_live ())
- {
- Side_position_interface::add_support (line_spanner_, info.grob ());
- add_bound_item (line_spanner_, dynamic_cast<Item *> (info.grob ()));
- }
+ Side_position_interface::add_support (line_spanner_, info.grob ());
+ add_bound_item (line_spanner_, dynamic_cast<Item *> (info.grob ()));
+ }
- if (script_ && !script_->get_parent (X_AXIS))
+ if (script_ && !script_->get_parent (X_AXIS))
+ {
+ extract_grob_set (info.grob (), "note-heads", heads);
+ if (heads.size())
{
- extract_grob_set (info.grob (), "note-heads", heads);
- if (heads.size())
- {
- Grob *head = heads[0];
- script_->set_parent (head, X_AXIS);
- script_->add_offset_callback (Self_alignment_interface::centered_on_parent_proc,
- X_AXIS);
+ Grob *head = heads[0];
+ script_->set_parent (head, X_AXIS);
+ script_->add_offset_callback (Self_alignment_interface::centered_on_parent_proc,
+ X_AXIS);
- }
- }
-
- if (cresc_)
- {
- if (!cresc_->get_bound (LEFT))
- {
- cresc_->set_bound (LEFT, info.grob ());
- add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
- }
}
+ }
- if (finished_cresc_ && !finished_cresc_->get_bound (RIGHT))
+ if (cresc_)
+ {
+ if (!cresc_->get_bound (LEFT))
{
- finished_cresc_->set_bound (RIGHT, info.grob ());
+ cresc_->set_bound (LEFT, info.grob ());
+ add_bound_item (line_spanner_, cresc_->get_bound (LEFT));
}
}
-
- else if (Script_interface::has_interface (info.grob ()) && script_)
+
+ if (finished_cresc_ && !finished_cresc_->get_bound (RIGHT))
{
- SCM p = info.grob ()->get_property ("script-priority");
+ finished_cresc_->set_bound (RIGHT, info.grob ());
+ }
+}
- /*
- UGH.
+void
+Dynamic_engraver::acknowledge_script (Grob_info info)
+{
+ if (!line_spanner_ || !script_)
+ return;
- DynamicText doesn't really have a script-priority field.
- */
- if (scm_is_number (p)
- && scm_to_int (p)
- < scm_to_int (script_->get_property ("script-priority")))
- Side_position_interface::add_support (line_spanner_, info.grob ());
- }
+ SCM p = info.grob ()->get_property ("script-priority");
+
+ /*
+ UGH.
+
+ DynamicText doesn't really have a script-priority field.
+ */
+ if (scm_is_number (p)
+ && scm_to_int (p)
+ < scm_to_int (script_->get_property ("script-priority")))
+ Side_position_interface::add_support (line_spanner_, info.grob ());
}
-#include "translator.icc"
+
+ADD_ACKNOWLEDGER(Dynamic_engraver,script);
+ADD_ACKNOWLEDGER(Dynamic_engraver,note_column);
ADD_TRANSLATOR (Dynamic_engraver,
/* descr */
#include "engraver-group-engraver.hh"
-#include "flower-proto.hh"
#include "warn.hh"
#include "paper-score.hh"
#include "grob.hh"
#include "context.hh"
+#include "translator-dispatch-list.hh"
void
Engraver_group_engraver::announce_grob (Grob_info info)
}
SCM acklist = scm_hashq_ref (acknowledge_hash_table_, nm, SCM_UNDEFINED);
+ Engraver_dispatch_list *dispatch
+ = Engraver_dispatch_list::unsmob (acklist);
+
if (acklist == SCM_BOOL_F)
{
- acklist = find_acknowledge_engravers (get_simple_trans_list (), meta);
- scm_hashq_set_x (acknowledge_hash_table_, nm, acklist);
+ SCM ifaces
+ = scm_cdr (scm_assoc (ly_symbol2scm ("interfaces"), meta));
+ acklist = Engraver_dispatch_list::create (get_simple_trans_list (),
+ ifaces);
+
+ dispatch
+ = Engraver_dispatch_list::unsmob (acklist);
+
+ if (dispatch)
+ scm_hashq_set_x (acknowledge_hash_table_, nm, acklist);
}
- for (SCM p = acklist; scm_is_pair (p); p = scm_cdr (p))
+
+ if (dispatch)
{
- Translator *t = unsmob_translator (scm_car (p));
- Engraver *eng = dynamic_cast<Engraver *> (t);
- if (eng && eng != info.origin_translator ())
- eng->acknowledge_grob (info);
+ dispatch->apply (info);
+ }
+ else
+ {
+ if (acklist == SCM_BOOL_F)
+ {
+ acklist = find_acknowledge_engravers (get_simple_trans_list (),
+ meta);
+ scm_hashq_set_x (acknowledge_hash_table_, nm, acklist);
+ }
+
+ for (SCM p = acklist; scm_is_pair (p); p = scm_cdr (p))
+ {
+ Translator *t = unsmob_translator (scm_car (p));
+ Engraver *eng = dynamic_cast<Engraver *> (t);
+ if (eng && eng != info.origin_translator ())
+ eng->acknowledge_grob (info);
+ }
}
}
}
-
/*
Ugh. This is slightly expensive. We could/should cache the value of
the group count?
bool
engraver_valid (Translator *tr, SCM ifaces)
{
- SCM ack_ifs = scm_assoc (ly_symbol2scm ("interfaces-acked"), tr->translator_description ());
+ SCM ack_ifs = scm_assoc (ly_symbol2scm ("interfaces-acked"),
+ tr->translator_description ());
ack_ifs = scm_cdr (ack_ifs);
for (SCM s = ifaces; scm_is_pair (s); s = scm_cdr (s))
if (scm_c_memq (scm_car (s), ack_ifs) != SCM_BOOL_F)
}
SCM
-find_acknowledge_engravers (SCM gravlist, SCM meta_alist)
+find_acknowledge_engravers (SCM gravlist, SCM ifaces)
{
- SCM ifaces = scm_cdr (scm_assoc (ly_symbol2scm ("interfaces"), meta_alist));
-
SCM l = SCM_EOL;
for (SCM s = gravlist; scm_is_pair (s); s = scm_cdr (s))
{
TRANSLATOR_DECLARATIONS (Extender_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(lyric_syllable);
virtual void finalize ();
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
}
void
-Extender_engraver::acknowledge_grob (Grob_info i)
+Extender_engraver::acknowledge_lyric_syllable (Grob_info i)
{
- Item *item = dynamic_cast<Item *> (i.grob ());
+ Item *item = i.item ();
+ if (extender_)
+ extender_->set_bound (LEFT, item);
- if (item
- && item->internal_has_interface (ly_symbol2scm ("lyric-syllable-interface")))
+ if (pending_extender_)
{
- if (extender_)
- extender_->set_bound (LEFT, item);
-
- if (pending_extender_)
- {
- pending_extender_->set_object ("next", item->self_scm ());
- completize_extender (pending_extender_);
- pending_extender_ = 0;
- }
+ pending_extender_->set_object ("next", item->self_scm ());
+ completize_extender (pending_extender_);
+ pending_extender_ = 0;
}
}
#include "translator.icc"
+ADD_ACKNOWLEDGER(Extender_engraver,lyric_syllable);
ADD_TRANSLATOR (Extender_engraver,
/* descr */ "Create lyric extenders",
/* creats*/ "LyricExtender",
/* accepts */ "extender-event",
- /* acks */ "lyric-syllable-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
virtual bool try_music (Music *m);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(rhythmic_head);
+ DECLARE_ACKNOWLEDGER(stem);
private:
void make_script (Direction, Music *, int);
}
void
-Fingering_engraver::acknowledge_grob (Grob_info inf)
+Fingering_engraver::acknowledge_stem (Grob_info inf)
{
- if (Stem::has_interface (inf.grob ()))
+ for (int i = 0; i < fingerings_.size (); i++)
{
- for (int i = 0; i < fingerings_.size (); i++)
- {
- Side_position_interface::add_support (fingerings_[i], inf.grob ());
- }
+ Side_position_interface::add_support (fingerings_[i], inf.grob ());
}
- else if (Rhythmic_head::has_interface (inf.grob ()))
+}
+
+void
+Fingering_engraver::acknowledge_rhythmic_head (Grob_info inf)
+{
+ for (int i = 0; i < fingerings_.size (); i++)
{
- for (int i = 0; i < fingerings_.size (); i++)
- {
- Grob *t = fingerings_[i];
- Side_position_interface::add_support (t, inf.grob ());
- if (!t->get_parent (X_AXIS))
- t->set_parent (inf.grob (), X_AXIS);
- }
+ Grob *t = fingerings_[i];
+ Side_position_interface::add_support (t, inf.grob ());
+ if (!t->get_parent (X_AXIS))
+ t->set_parent (inf.grob (), X_AXIS);
}
}
#include "translator.icc"
+ADD_ACKNOWLEDGER(Fingering_engraver,rhythmic_head);
+ADD_ACKNOWLEDGER(Fingering_engraver,stem);
ADD_TRANSLATOR (Fingering_engraver,
/* descr */ "Create fingering-scripts",
/* creats*/ "Fingering",
TRANSLATOR_DECLARATIONS (Font_size_engraver);
protected:
- virtual void acknowledge_grob (Grob_info gi);
+ DECLARE_ACKNOWLEDGER(font);
private:
};
}
void
-Font_size_engraver::acknowledge_grob (Grob_info gi)
+Font_size_engraver::acknowledge_font (Grob_info gi)
{
SCM sz = get_property ("fontSize");
#include "translator.icc"
+ADD_ACKNOWLEDGER(Font_size_engraver,font);
ADD_TRANSLATOR (Font_size_engraver,
/* descr */ "Puts fontSize into font-relative-size grob property.",
/* creats*/ "",
/* accepts */ "",
- /* acks */ "font-interface",
+ /* acks */ "",
/* reads */ "fontSize",
/* write */ "");
TRANSLATOR_DECLARATIONS (Glissando_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(rhythmic_head);
virtual void finalize ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual bool try_music (Music *);
}
void
-Glissando_engraver::acknowledge_grob (Grob_info info)
+Glissando_engraver::acknowledge_rhythmic_head (Grob_info info)
{
- if (Rhythmic_head::has_interface (info.grob ()))
- {
- Grob *g = info.grob ();
- if (line_)
- line_->set_bound (LEFT, g);
+ Grob *g = info.grob ();
+ if (line_)
+ line_->set_bound (LEFT, g);
- if (last_line_)
- last_line_->set_bound (RIGHT, g);
- }
+ if (last_line_)
+ last_line_->set_bound (RIGHT, g);
}
void
#include "translator.icc"
+ADD_ACKNOWLEDGER(Glissando_engraver,rhythmic_head);
ADD_TRANSLATOR (Glissando_engraver,
/* descr */ "Engrave a glissandi",
/* creats*/ "Glissando",
/* accepts */ "glissando-event",
- /* acks */ "rhythmic-head-interface",
+ /* acks */ "",
/* reads */ "followVoice",
/* write */ "");
public:
TRANSLATOR_DECLARATIONS (Grid_line_span_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(grid_point);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
};
}
void
-Grid_line_span_engraver::acknowledge_grob (Grob_info i)
+Grid_line_span_engraver::acknowledge_grid_point (Grob_info i)
{
int depth = i.origin_contexts (this).size ();
- if (depth && i.grob ()->internal_has_interface (ly_symbol2scm ("grid-point-interface")))
+ if (depth)
{
Item *it = dynamic_cast<Item *> (i.grob ());
lines_.push (it);
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Grid_line_span_engraver, grid_point);
ADD_TRANSLATOR (Grid_line_span_engraver,
/* descr */ "This engraver makes cross-staff linelines: It catches all normal "
"line lines, and draws a single span-line across them.",
/* creats*/ "GridLine",
/* accepts */ "",
- /* acks */ "grid-point-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
#include "music.hh"
#include "translator-group.hh"
#include "context.hh"
+#include "spanner.hh"
+#include "item.hh"
Grob_info::Grob_info (Translator *t, Grob *g)
return origin_trans_->context ();
}
+Spanner*
+Grob_info::spanner () const
+{
+ return dynamic_cast<Spanner*> (grob_);
+}
+
+Item*
+Grob_info::item () const
+{
+ return dynamic_cast<Item*> (grob_);
+}
TRANSLATOR_DECLARATIONS (Grob_pq_engraver);
protected:
virtual void initialize ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(grob);
PRECOMPUTED_VIRTUAL void start_translation_timestep ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Grob_pq_engraver, grob);
ADD_TRANSLATOR (Grob_pq_engraver,
/* descr */ "Administrate when certain grobs (eg. note heads) stop playing",
/* creats*/ "",
/* accepts */ "",
- /* acks */ "grob-interface",
+ /* acks */ "",
/* reads */ "busyGrobs",
/* write */ "busyGrobs");
{
protected:
virtual Spanner *get_spanner ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(grob);
virtual void add_element (Grob *e);
PRECOMPUTED_VIRTUAL void start_translation_timestep ();
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Hara_kiri_engraver, grob);
ADD_TRANSLATOR (Hara_kiri_engraver,
/* descr */ "Like Axis_group_engraver, but make a hara-kiri spanner, and add "
"interesting items (ie. note heads, lyric syllables and normal rests) ",
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_column);
};
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Horizontal_bracket_engraver,note_column);
ADD_TRANSLATOR (Horizontal_bracket_engraver,
"Create horizontal brackets over notes for musical analysis purposes.",
"HorizontalBracket",
"note-grouping-event",
- "note-column-interface",
+ "",
"",
"");
}
void
-Horizontal_bracket_engraver::acknowledge_grob (Grob_info gi)
+Horizontal_bracket_engraver::acknowledge_note_column (Grob_info gi)
{
- if (Note_column::has_interface (gi.grob ()))
+ for (int i = 0; i < bracket_stack_.size (); i++)
{
- for (int i = 0; i < bracket_stack_.size (); i++)
- {
- Side_position_interface::add_support (bracket_stack_[i], gi.grob ());
- Pointer_group_interface::add_grob (bracket_stack_[i],
- ly_symbol2scm ("columns"), gi.grob ());
- add_bound_item (bracket_stack_[i],
- gi.grob ());
- }
+ Side_position_interface::add_support (bracket_stack_[i], gi.grob ());
+ Pointer_group_interface::add_grob (bracket_stack_[i],
+ ly_symbol2scm ("columns"), gi.grob ());
+ add_bound_item (bracket_stack_[i],
+ gi.grob ());
}
}
TRANSLATOR_DECLARATIONS (Hyphen_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(lyric_syllable);
virtual void finalize ();
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
}
void
-Hyphen_engraver::acknowledge_grob (Grob_info i)
+Hyphen_engraver::acknowledge_lyric_syllable (Grob_info i)
{
- Item *item = dynamic_cast<Item *> (i.grob ());
- // -> Text_item
- if (item && item->internal_has_interface (ly_symbol2scm ("lyric-syllable-interface")))
- {
- if (hyphen_)
- hyphen_->set_bound (LEFT, item);
+ Item *item = i.item();
+ if (hyphen_)
+ hyphen_->set_bound (LEFT, item);
- if (finished_hyphen_)
- finished_hyphen_->set_bound (RIGHT, item);
- }
+ if (finished_hyphen_)
+ finished_hyphen_->set_bound (RIGHT, item);
}
bool
#include "translator.icc"
+ADD_ACKNOWLEDGER(Hyphen_engraver,lyric_syllable);
ADD_TRANSLATOR (Hyphen_engraver,
/* descr */ "Create lyric hyphens",
/* creats*/ "LyricHyphen",
/* accepts */ "hyphen-event",
- /* acks */ "lyric-syllable-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
Link_array<Grob> elts_;
PRECOMPUTED_VIRTUAL void process_music ();
virtual void finalize ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(grob);
PRECOMPUTED_VIRTUAL void process_acknowledged ();
virtual Spanner *get_spanner ();
virtual void add_element (Grob *);
class Grob_info
{
Translator *origin_trans_;
- friend class Engraver;
Grob *grob_;
+ friend class Engraver;
public:
Grob *grob () const { return grob_; }
Translator *origin_translator () const { return origin_trans_; }
Link_array<Context> origin_contexts (Translator *) const;
Grob_info (Translator *, Grob *);
Grob_info ();
+
+ Item *item () const;
+ Spanner *spanner () const;
};
#endif // STAFFELEMINFO_HH
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void finalize ();
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(rest);
+ DECLARE_ACKNOWLEDGER(note_head);
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void process_music ();
virtual Spanner *create_ligature_spanner (); /* abstract method */
class Grace_music;
class Grob;
class Grob_array;
+class Grob_info;
class Hara_kiri_engraver;
class Hara_kiri_line_group_engraver;
class Includable_lexer;
class Type_swallow_translator;
class yyFlexLexer;
+
+typedef void (*Engraver_void_function_engraver_grob_info)(Engraver*, Grob_info);
+typedef void (*Translator_void_method_ptr)(Translator*);
+
+
+
+
#endif /* LILY_PROTO_HH */
virtual void initialize ();
virtual void finalize ();
virtual bool try_music (Music*);
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(item);
+ DECLARE_ACKNOWLEDGER(note_spacing);
+ DECLARE_ACKNOWLEDGER(staff_spacing);
System *system_;
Music *break_event_;
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual bool try_music (Music *);
virtual ~Staff_symbol_engraver ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(grob);
virtual void finalize ();
PRECOMPUTED_VIRTUAL void process_music ();
};
--- /dev/null
+/*
+ translator-dispatch-list.hh -- declare Translator_dispatch_list
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 2005 Han-Wen Nienhuys <hanwen@xs4all.nl>
+
+*/
+
+#ifndef TRANSLATOR_DISPATCH_LIST_HH
+#define TRANSLATOR_DISPATCH_LIST_HH
+
+#include "lily-proto.hh"
+#include "lily-guile.hh"
+#include "array.hh"
+#include "smobs.hh"
+
+struct Engraver_dispatch_entry
+{
+ Engraver *engraver_;
+ Engraver_void_function_engraver_grob_info function_;
+};
+
+class Engraver_dispatch_list
+{
+ Array<Engraver_dispatch_entry> dispatch_entries_;
+public:
+ void apply (Grob_info);
+ SCM static create (SCM trans_list,
+ SCM iface_list);
+
+ DECLARE_SIMPLE_SMOBS(Engraver_dispatch_list,);
+};
+
+#endif /* TRANSLATOR_DISPATCH_LIST_HH */
#include "input.hh"
#include "smobs.hh"
-
-
-typedef void (*Translator_void_method_ptr)(Translator*);
-
-
struct Acknowledge_information
{
SCM symbol_;
- Translator_void_method_ptr function_;
+ Engraver_void_function_engraver_grob_info function_;
};
-
#define TRANSLATOR_DECLARATIONS(NAME) \
public: \
NAME (); \
virtual void fetch_precomputable_methods (Translator_void_method_ptr methods[]);\
virtual SCM static_translator_description () const; \
virtual SCM translator_description () const; \
- virtual Translator_void_method_ptr get_acknowledger (SCM sym) { \
+ virtual Engraver_void_function_engraver_grob_info get_acknowledger (SCM sym) { \
return static_get_acknowledger (sym);\
}\
- static Translator_void_method_ptr static_get_acknowledger (SCM sym);
+ static Engraver_void_function_engraver_grob_info static_get_acknowledger (SCM sym);
+
+#define DECLARE_ACKNOWLEDGER(x) public: void acknowledge_ ## x (Grob_info); protected:
enum Translator_precompute_index {
START_TRANSLATION_TIMESTEP,
Array<Acknowledge_information> classname::acknowledge_static_array_;\
IMPLEMENT_FETCH_PRECOMPUTABLE_METHODS(classname); \
ADD_THIS_TRANSLATOR (classname); \
- Translator_void_method_ptr\
+ Engraver_void_function_engraver_grob_info\
classname::static_get_acknowledger (SCM sym) \
{\
return generic_get_acknowledger (sym, &acknowledge_static_array_);\
: (Translator_void_method_ptr) &T::process_acknowledged; \
}
-void add_acknowledger (Translator_void_method_ptr ptr, const char *func_name, Array<Acknowledge_information> *ack_array);
-Translator_void_method_ptr
-generic_get_acknowledger (SCM sym, Array<Acknowledge_information> const *ack_array);
+void add_acknowledger (Engraver_void_function_engraver_grob_info ptr,
+ const char *func_name,
+ Array<Acknowledge_information> *ack_array);
+
+Engraver_void_function_engraver_grob_info
+generic_get_acknowledger (SCM sym,
+ Array<Acknowledge_information> const *ack_array);
#define ADD_ACKNOWLEDGER(CLASS,NAME) \
void CLASS ## NAME ## _ack_adder () \
{\
- add_acknowledger ((Translator_void_method_ptr) &CLASS::NAME, #NAME, &CLASS::acknowledge_static_array_);\
+ add_acknowledger ((Engraver_void_function_engraver_grob_info) &CLASS::acknowledge_ ## NAME, #NAME, &CLASS::acknowledge_static_array_);\
}\
-ADD_SCM_INIT_FUNC(CLASS ## NAME ## _ack_adder);\
+ ADD_SCM_INIT_FUNC(CLASS ## NAME ## _ack_adder_initclass, CLASS ## NAME ## _ack_adder); \
+
#include "text-interface.hh"
#include "grob-array.hh"
+#include "translator.icc"
+
class Instrument_name_engraver : public Engraver
{
bool first_;
virtual void create_text ();
virtual void initialize ();
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(bar_line);
+ DECLARE_ACKNOWLEDGER(axis_group);
+
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Instrument_name_engraver::acknowledge_grob (Grob_info i)
+Instrument_name_engraver::acknowledge_bar_line (Grob_info i)
{
- if (Bar_line::has_interface (i.grob ()))
- {
- create_text ();
- }
+ (void)i;
+ create_text ();
+}
+
+void
+Instrument_name_engraver::acknowledge_axis_group (Grob_info i)
+{
/*
Ugh - typechecking for pedal and dynamic sucks.
*/
#include "translator.icc"
+
+ADD_ACKNOWLEDGER(Instrument_name_engraver, bar_line);
+ADD_ACKNOWLEDGER(Instrument_name_engraver, axis_group);
ADD_TRANSLATOR (Instrument_name_engraver,
/* descr */ " Prints the name of the instrument (specified by "
" @code{Staff.instrument} and @code{Staff.instr}) "
text_->set_property ("text", txt);
}
-#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Vocal_name_engraver, bar_line);
+ADD_ACKNOWLEDGER(Vocal_name_engraver, axis_group);
ADD_TRANSLATOR (Vocal_name_engraver,
/* descr */ " Prints the name of the a lyric voice (specified by "
" @code{Staff.vocalName} and @code{Staff.vocNam}) "
"at the left of the staff. ",
/* creats*/ "VocalName",
/* accepts */ "",
- /* acks */ "bar-line-interface axis-group-interface",
+ /* acks */ "",
/* reads */ "vocNam vocalName",
/* write */ "");
virtual bool try_music (Music *ev);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(clef);
+ DECLARE_ACKNOWLEDGER(bar_line);
+
};
void
}
void
-Key_engraver::acknowledge_grob (Grob_info info)
+Key_engraver::acknowledge_clef (Grob_info info)
{
- if (Clef::has_interface (info.grob ()))
+ SCM c = get_property ("createKeyOnClefChange");
+ if (to_boolean (c))
{
- SCM c = get_property ("createKeyOnClefChange");
- if (to_boolean (c))
- {
- create_key (false);
- }
+ create_key (false);
}
- else if (Bar_line::has_interface (info.grob ())
- && scm_is_pair (get_property ("keySignature")))
+}
+
+void
+Key_engraver::acknowledge_bar_line (Grob_info info)
+{
+ if (scm_is_pair (get_property ("keySignature")))
{
create_key (true);
}
#include "translator.icc"
+ADD_ACKNOWLEDGER(Key_engraver,clef);
+ADD_ACKNOWLEDGER(Key_engraver,bar_line);
ADD_TRANSLATOR (Key_engraver,
/* descr */ "",
/* creats*/ "KeySignature",
/* accepts */ "key-change-event",
- /* acks */ "bar-line-interface clef-interface",
+ /* acks */ "",
/* reads */ "keySignature printKeyCancellation lastKeySignature explicitKeySignatureVisibility createKeyOnClefChange keyAccidentalOrder keySignature",
/* write */ "lastKeySignature tonic keySignature");
protected:
virtual void finalize ();
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(ledgered);
+ DECLARE_ACKNOWLEDGER(staff_symbol);
void start_spanner ();
void stop_spanner ();
}
void
-Ledger_line_engraver::acknowledge_grob (Grob_info s)
+Ledger_line_engraver::acknowledge_staff_symbol (Grob_info s)
{
- if (Staff_symbol::has_interface (s.grob ()))
+ Spanner *sym = dynamic_cast<Spanner*> (s.grob ());
+
+ if (!span_
+ || span_->get_bound (LEFT) != sym->get_bound (LEFT))
{
- Spanner *sym = dynamic_cast<Spanner*> (s.grob ());
-
- if (!span_
- || span_->get_bound (LEFT) != sym->get_bound (LEFT))
- {
- stop_spanner ();
- start_spanner ();
- }
+ stop_spanner ();
+ start_spanner ();
}
- else if (span_)
+}
+
+void
+Ledger_line_engraver::acknowledge_ledgered (Grob_info s)
+{
+ if (span_)
{
if (!to_boolean (s.grob ()->get_property ("no-ledgers")))
Pointer_group_interface::add_grob (span_, ly_symbol2scm ("note-heads"),
#include "translator.icc"
+ADD_ACKNOWLEDGER(Ledger_line_engraver,ledgered);
+ADD_ACKNOWLEDGER(Ledger_line_engraver,staff_symbol);
ADD_TRANSLATOR (Ledger_line_engraver,
"Creates the spanner to draw ledger lines, and notices objects that need ledger lines",
/* creats*/ "LedgerLineSpanner",
/* accepts */ "",
- /* acks */ "staff-symbol-interface ledgered-interface", // ledgered-interface?
+ /* acks */ "", // ledgered-interface?
/* reads */ "",
/* write */ "")
{
protected:
virtual Spanner *create_ligature_spanner ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(rest);
+ DECLARE_ACKNOWLEDGER(note_column);
public:
TRANSLATOR_DECLARATIONS (Ligature_bracket_engraver);
};
}
void
-Ligature_bracket_engraver::acknowledge_grob (Grob_info info)
+Ligature_bracket_engraver::acknowledge_note_column (Grob_info info)
{
if (current_ligature ())
{
- if (Note_column::has_interface (info.grob ()))
- {
- Tuplet_bracket::add_column (current_ligature (),
- dynamic_cast<Item *> (info.grob ()));
- }
- else Ligature_engraver::acknowledge_grob (info);
+ Tuplet_bracket::add_column (current_ligature (),
+ dynamic_cast<Item *> (info.grob ()));
}
}
+void
+Ligature_bracket_engraver::acknowledge_rest (Grob_info info)
+{
+ if (current_ligature ())
+ Ligature_engraver::acknowledge_rest (info);
+}
+
#include "translator.icc"
+ADD_ACKNOWLEDGER(Ligature_bracket_engraver, rest);
+ADD_ACKNOWLEDGER(Ligature_bracket_engraver, note_column);
ADD_TRANSLATOR (Ligature_bracket_engraver,
/* descr */ "Handles Ligature_events by engraving Ligature brackets.",
/* creats*/ "TupletBracket",
/* accepts */ "ligature-event",
- /* acks */ "rest-interface note-column-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
}
void
-Ligature_engraver::acknowledge_grob (Grob_info info)
+Ligature_engraver::acknowledge_note_head (Grob_info info)
{
if (ligature_)
{
- if (Note_head::has_interface (info.grob ()))
- {
- primitives_.push (info);
- info.grob ()->set_property ("print-function",
- brew_ligature_primitive_proc);
- }
- if (Rest::has_interface (info.grob ()))
- {
- info.music_cause ()->origin ()->warning (_ ("ignoring rest: ligature may not contain rest"));
- prev_start_event_->origin ()->warning (_ ("ligature was started here"));
- // TODO: maybe better should stop ligature here rather than
- // ignoring the rest?
- }
+ primitives_.push (info);
+ info.grob ()->set_property ("print-function",
+ brew_ligature_primitive_proc);
}
}
+void
+Ligature_engraver::acknowledge_rest (Grob_info info)
+{
+ info.music_cause ()->origin ()->warning (_ ("ignoring rest: ligature may not contain rest"));
+ prev_start_event_->origin ()->warning (_ ("ligature was started here"));
+ // TODO: maybe better should stop ligature here rather than
+ // ignoring the rest?
+}
+
+
#include "translator.icc"
+ADD_ACKNOWLEDGER(Ligature_engraver, rest);
+ADD_ACKNOWLEDGER(Ligature_engraver, note_head);
ADD_TRANSLATOR (Ligature_engraver,
/* descr */ "Abstract class; a concrete subclass handles Ligature_events by engraving Ligatures in a concrete style.",
/* creats */ "",
/* accepts */ "ligature-event",
- /* acks */ "note-head-interface rest-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
Item *text_;
protected:
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(bar_line);
void create_items (Music *);
virtual bool try_music (Music *ev);
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Mark_engraver::acknowledge_grob (Grob_info inf)
+Mark_engraver::acknowledge_bar_line (Grob_info inf)
{
Grob *s = inf.grob ();
- if (text_ && Bar_line::has_interface (s))
+ if (text_)
{
/*
TODO: make this configurable. RehearsalMark cannot be
#include "translator.icc"
+ADD_ACKNOWLEDGER(Mark_engraver,bar_line);
ADD_TRANSLATOR (Mark_engraver,
/* descr */ "This engraver will create RehearsalMark objects. "
"It puts them on top of all staves (which is taken from "
"end up on the same Y-location",
/* creats*/ "RehearsalMark",
/* accepts */ "mark-event",
- /* acks */ "bar-line-interface",
+ /* acks */ "",
/* reads */ "rehearsalMark markFormatter stavesFound",
/* write */ "");
#include "global-context.hh"
#include "engraver.hh"
+#include "translator.icc"
+
class Measure_grouping_engraver : public Engraver
{
public:
PRECOMPUTED_VIRTUAL void process_music ();
virtual void finalize ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_column);
};
void
}
void
-Measure_grouping_engraver::acknowledge_grob (Grob_info gi)
+Measure_grouping_engraver::acknowledge_note_column (Grob_info gi)
{
if (grouping_)
{
grouping_ = 0;
}
-#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Measure_grouping_engraver, note_column);
ADD_TRANSLATOR (Measure_grouping_engraver,
/* descr */ "Creates MeasureGrouping to indicate beat subdivision.",
/* creats*/ "MeasureGrouping",
/* accepts */ "",
- /* acks */ "note-column-interface",
+ /* acks */ "",
/* reads */ "beatGrouping beatLength measurePosition currentMusicalColumn",
/* write */ "");
}
#include "ly-smobs.icc"
+
IMPLEMENT_SIMPLE_SMOBS (Moment);
IMPLEMENT_TYPE_P (Moment, "ly:moment?");
#include "script-interface.hh"
#include "stem.hh"
+#include "translator.icc"
+
struct Finger_tuple
{
Grob *head_;
TRANSLATOR_DECLARATIONS (New_fingering_engraver);
protected:
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(rhythmic_head);
+ DECLARE_ACKNOWLEDGER(stem);
void add_fingering (Grob *, Music *, Music *);
void add_script (Grob *, Music *, Music *);
void add_string (Grob *, Music *, Music *);
};
void
-New_fingering_engraver::acknowledge_grob (Grob_info inf)
+New_fingering_engraver::acknowledge_rhythmic_head (Grob_info inf)
{
- if (Rhythmic_head::has_interface (inf.grob ()))
+ Music *note_ev = inf.music_cause ();
+ if (!note_ev)
+ return;
+
+ SCM arts = note_ev->get_property ("articulations");
+
+ for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
{
- Music *note_ev = inf.music_cause ();
- if (!note_ev)
- return;
+ Music *m = unsmob_music (scm_car (s));
- SCM arts = note_ev->get_property ("articulations");
+ if (!m)
+ continue;
- for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
+ if (m->is_mus_type ("fingering-event"))
{
- Music *m = unsmob_music (scm_car (s));
-
- if (!m)
- continue;
-
- if (m->is_mus_type ("fingering-event"))
- {
- add_fingering (inf.grob (), m, note_ev);
- }
- else if (m->is_mus_type ("text-script-event"))
- {
- m->origin ()->warning (_ ("can't add text scripts to individual note heads"));
- }
- else if (m->is_mus_type ("script-event"))
- {
- add_script (inf.grob (), m, note_ev);
- }
- else if (m->is_mus_type ("string-number-event"))
- {
- add_string (inf.grob (), m, note_ev);
- }
- else if (m->is_mus_type ("harmonic-event"))
- {
- inf.grob ()->set_property ("style", ly_symbol2scm ("harmonic"));
- Grob *d = unsmob_grob (inf.grob ()->get_object ("dot"));
- if (d)
- d->suicide ();
- }
+ add_fingering (inf.grob (), m, note_ev);
+ }
+ else if (m->is_mus_type ("text-script-event"))
+ {
+ m->origin ()->warning (_ ("can't add text scripts to individual note heads"));
+ }
+ else if (m->is_mus_type ("script-event"))
+ {
+ add_script (inf.grob (), m, note_ev);
+ }
+ else if (m->is_mus_type ("string-number-event"))
+ {
+ add_string (inf.grob (), m, note_ev);
+ }
+ else if (m->is_mus_type ("harmonic-event"))
+ {
+ inf.grob ()->set_property ("style", ly_symbol2scm ("harmonic"));
+ Grob *d = unsmob_grob (inf.grob ()->get_object ("dot"));
+ if (d)
+ d->suicide ();
}
-
- heads_.push (inf.grob ());
- }
- else if (Stem::has_interface (inf.grob ()))
- {
- stem_ = inf.grob ();
}
+
+ heads_.push (inf.grob ());
+}
+
+void
+New_fingering_engraver::acknowledge_stem (Grob_info inf)
+{
+ stem_ = inf.grob ();
}
void
{
stem_ = 0;
}
-
-#include "translator.icc"
+ADD_ACKNOWLEDGER(New_fingering_engraver, rhythmic_head);
+ADD_ACKNOWLEDGER(New_fingering_engraver, stem);
ADD_TRANSLATOR (New_fingering_engraver,
/* descr */ "Create fingering-scripts for notes in a new chord. "
TRANSLATOR_DECLARATIONS (Note_head_line_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(rhythmic_head);
PRECOMPUTED_VIRTUAL void process_acknowledged ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
}
void
-Note_head_line_engraver::acknowledge_grob (Grob_info info)
+Note_head_line_engraver::acknowledge_rhythmic_head (Grob_info info)
{
- if (Rhythmic_head::has_interface (info.grob ()))
+ head_ = info.grob ();
+ if (to_boolean (get_property ("followVoice")))
{
- head_ = info.grob ();
- if (to_boolean (get_property ("followVoice")))
+ Context *tr = context ();
+ while (tr && !tr->is_alias (ly_symbol2scm ("Staff")))
+ tr = tr->get_parent_context ();
+
+ if (tr
+ && tr->is_alias (ly_symbol2scm ("Staff")) && tr != last_staff_)
{
- Context *tr = context ();
- while (tr && !tr->is_alias (ly_symbol2scm ("Staff")))
- tr = tr->get_parent_context ();
-
- if (tr
- && tr->is_alias (ly_symbol2scm ("Staff")) && tr != last_staff_)
- {
- if (last_head_)
- follow_ = true;
- last_staff_ = tr;
- }
+ if (last_head_)
+ follow_ = true;
+ last_staff_ = tr;
}
}
}
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Note_head_line_engraver, rhythmic_head);
ADD_TRANSLATOR (Note_head_line_engraver,
/* descr */ "Engrave a line between two note heads, for example a glissando. If "
" followVoice is set, staff switches also generate a line.",
/* creats*/ "Glissando VoiceFollower",
/* accepts */ "glissando-event",
- /* acks */ "rhythmic-head-interface",
+ /* acks */ "",
/* reads */ "followVoice",
/* write */ "");
TRANSLATOR_DECLARATIONS (Ottava_spanner_engraver);
protected:
virtual void finalize ();
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(note_column);
+
PRECOMPUTED_VIRTUAL void process_music ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void derived_mark () const;
}
void
-Ottava_spanner_engraver::acknowledge_grob (Grob_info info)
+Ottava_spanner_engraver::acknowledge_note_column (Grob_info info)
{
- Item *it = dynamic_cast<Item *> (info.grob ());
- if (span_ && it && Note_column::has_interface (info.grob ()))
+ Item *it = info.item();
+ if (span_ && it)
{
Side_position_interface::add_support (span_, it);
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Ottava_spanner_engraver, note_column);
ADD_TRANSLATOR (Ottava_spanner_engraver,
/* descr */ "Create a text spanner when the ottavation property changes..",
/* creats*/ "OttavaBracket",
/* accepts */ "",
- /* acks */ "note-column-interface",
+ /* acks */ "",
/* reads */ "ottavation",
/* write */ "");
class Output_property_engraver : public Engraver
{
-TRANSLATOR_DECLARATIONS (Output_property_engraver);
+ TRANSLATOR_DECLARATIONS (Output_property_engraver);
protected:
Link_array<Music> props_;
+ DECLARE_ACKNOWLEDGER(grob)
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
- virtual void acknowledge_grob (Grob_info);
virtual bool try_music (Music*);
};
Music * o = props_[i];
SCM pred = o->get_property ("predicate");
-
-
if (ly_is_procedure (pred))
{
/*
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Output_property_engraver,grob)
ADD_TRANSLATOR (Output_property_engraver,
/* descr */ "Interpret Music of Output_property type, and apply a function "
" to any Graphic objects that satisfies the predicate.",
/* creats*/ "",
/* accepts */ "layout-instruction",
-/* acks */ "grob-interface",
+/* acks */ "",
/* reads */ "",
/* write */ "");
}
void
-Paper_column_engraver::acknowledge_grob (Grob_info gi)
+Paper_column_engraver::acknowledge_item (Grob_info gi)
{
- Item *item = dynamic_cast<Item *> (gi.grob ());
- if (!item)
- {
- programming_error ("Spanner found in Paper_column_engraver::acknowledge_grob()");
- return;
- }
-
- items_.push (item);
-
- if (Staff_spacing::has_interface (item))
- {
- Pointer_group_interface::add_grob (command_column_,
- ly_symbol2scm ("spacing-wishes"),
- gi.grob ());
- }
- if (Note_spacing::has_interface (item))
- {
- Pointer_group_interface::add_grob (musical_column_,
- ly_symbol2scm ("spacing-wishes"),
- gi.grob ());
- }
+ items_.push (gi.item ());
+}
+
+void
+Paper_column_engraver::acknowledge_staff_spacing (Grob_info gi)
+{
+ Pointer_group_interface::add_grob (command_column_,
+ ly_symbol2scm ("spacing-wishes"),
+ gi.grob ());
+}
+void
+Paper_column_engraver::acknowledge_note_spacing (Grob_info gi)
+{
+ Pointer_group_interface::add_grob (musical_column_,
+ ly_symbol2scm ("spacing-wishes"),
+ gi.grob ());
}
void
make_columns ();
}
-
+ADD_ACKNOWLEDGER(Paper_column_engraver,item);
+ADD_ACKNOWLEDGER(Paper_column_engraver,note_spacing);
+ADD_ACKNOWLEDGER(Paper_column_engraver,staff_spacing);
ADD_TRANSLATOR (Paper_column_engraver,
"that there are no beams or notes that prevent a breakpoint.) ",
/* creats*/ "PaperColumn NonMusicalPaperColumn",
/* accepts */ "break-event",
- /* acks */ "item-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "currentCommandColumn currentMusicalColumn");
TRANSLATOR_DECLARATIONS (Part_combine_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_head);
+ DECLARE_ACKNOWLEDGER(stem);
+
PRECOMPUTED_VIRTUAL void process_music ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual bool try_music (Music *);
}
void
-Part_combine_engraver::acknowledge_grob (Grob_info i)
+Part_combine_engraver::acknowledge_note_head (Grob_info i)
{
if (text_)
{
- if (Note_head::has_interface (i.grob ()))
- {
- Grob *t = text_;
- Side_position_interface::add_support (t, i.grob ());
- if (Side_position_interface::get_axis (t) == X_AXIS
- && !t->get_parent (Y_AXIS))
- t->set_parent (i.grob (), Y_AXIS);
- }
- if (Stem::has_interface (i.grob ()))
- {
- Side_position_interface::add_support (text_, i.grob ());
- }
+ Grob *t = text_;
+ Side_position_interface::add_support (t, i.grob ());
+ if (Side_position_interface::get_axis (t) == X_AXIS
+ && !t->get_parent (Y_AXIS))
+ t->set_parent (i.grob (), Y_AXIS);
}
}
+void
+Part_combine_engraver::acknowledge_stem (Grob_info i)
+{
+ if (text_)
+ Side_position_interface::add_support (text_, i.grob ());
+}
+
void
Part_combine_engraver::stop_translation_timestep ()
{
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Part_combine_engraver, note_head);
+ADD_ACKNOWLEDGER(Part_combine_engraver, stem);
ADD_TRANSLATOR (Part_combine_engraver,
/* descr */ "Part combine engraver for orchestral scores: "
"Print markings a2, Solo, Solo II, and unisono ",
/* creats*/ "CombineTextScript",
/* accepts */ "part-combine-event",
- /* acks */ "multi-measure-rest-interface "
- "slur-interface stem-interface note-head-interface",
+ /* acks */ "",
/* reads */ "printPartCombineTexts soloText soloIIText "
"aDueText",
/* write */ "");
protected:
virtual bool try_music (Music *);
- virtual void acknowledge_grob (Grob_info);
+
+ void acknowledge_extra_object (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_column);
+ DECLARE_ACKNOWLEDGER(accidental);
+ DECLARE_ACKNOWLEDGER(fingering);
+ DECLARE_ACKNOWLEDGER(script);
+ DECLARE_ACKNOWLEDGER(tie);
+ DECLARE_ACKNOWLEDGER(text_script);
+ DECLARE_ACKNOWLEDGER(slur);
+
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void finalize ();
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Phrasing_slur_engraver::acknowledge_grob (Grob_info info)
+Phrasing_slur_engraver::acknowledge_note_column (Grob_info info)
{
Grob *e = info.grob ();
- if (Note_column::has_interface (info.grob ()))
+ for (int i = slurs_.size (); i--;)
+ Slur::add_column (slurs_[i], e);
+ for (int i = end_slurs_.size (); i--;)
+ Slur::add_column (end_slurs_[i], e);
+}
+
+void
+Phrasing_slur_engraver::acknowledge_extra_object (Grob_info info)
+{
+ Grob*e = info.grob ();
+ SCM inside = e->get_property ("inside-slur");
+ if (Tie::has_interface (e)
+ || to_boolean (inside))
{
for (int i = slurs_.size (); i--;)
- Slur::add_column (slurs_[i], e);
+ Slur::add_extra_encompass (slurs_[i], e);
for (int i = end_slurs_.size (); i--;)
- Slur::add_column (end_slurs_[i], e);
+ Slur::add_extra_encompass (end_slurs_[i], e);
}
- else
+ else if (inside == SCM_BOOL_F)
{
- /*
- ugh. cut & paste from slur-engraver.cc
- */
- SCM inside = e->get_property ("inside-slur");
- if (Tie::has_interface (e)
- || Slur::has_interface (e)
- || to_boolean (inside))
- {
- for (int i = slurs_.size (); i--;)
- Slur::add_extra_encompass (slurs_[i], e);
- for (int i = end_slurs_.size (); i--;)
- Slur::add_extra_encompass (end_slurs_[i], e);
- }
- else if (inside == SCM_BOOL_F)
+ Grob *slur = slurs_.size () ? slurs_[0] : 0;
+ slur = (end_slurs_.size () && !slur)
+ ? end_slurs_[0] : slur;
+
+ if (slur)
{
- Grob *slur = slurs_.size () ? slurs_[0] : 0;
- slur = (end_slurs_.size () && !slur)
- ? end_slurs_[0] : slur;
-
- if (slur)
- {
- e->add_offset_callback (Slur::outside_slur_callback_proc, Y_AXIS);
- e->set_object ("slur", slur->self_scm ());
- }
+ e->add_offset_callback (Slur::outside_slur_callback_proc, Y_AXIS);
+ e->set_object ("slur", slur->self_scm ());
}
}
}
+void
+Phrasing_slur_engraver::acknowledge_accidental (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+
+void
+Phrasing_slur_engraver::acknowledge_fingering (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+void
+Phrasing_slur_engraver::acknowledge_script (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+void
+Phrasing_slur_engraver::acknowledge_text_script (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+void
+Phrasing_slur_engraver::acknowledge_tie (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+
+void
+Phrasing_slur_engraver::acknowledge_slur (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
void
Phrasing_slur_engraver::finalize ()
{
#include "translator.icc"
+
+ADD_ACKNOWLEDGER(Phrasing_slur_engraver,note_column);
+ADD_ACKNOWLEDGER(Phrasing_slur_engraver,accidental);
+ADD_ACKNOWLEDGER(Phrasing_slur_engraver,fingering)
+ADD_ACKNOWLEDGER(Phrasing_slur_engraver,script);
+ADD_ACKNOWLEDGER(Phrasing_slur_engraver,tie);
+ADD_ACKNOWLEDGER(Phrasing_slur_engraver,text_script);
+ADD_ACKNOWLEDGER(Phrasing_slur_engraver,slur);
+
ADD_TRANSLATOR (Phrasing_slur_engraver,
/* descr */ "Print phrasing slurs. Similar to @ref{Slur_engraver}",
/* creats*/ "PhrasingSlur",
/* accepts */ "phrasing-slur-event",
- /* acks */ "note-column-interface tie-interface fingering-interface script-interface slur-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
virtual void finalize ();
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_column);
PRECOMPUTED_VIRTUAL void process_music ();
private:
I'm a script
*/
void
-Piano_pedal_engraver::acknowledge_grob (Grob_info info)
+Piano_pedal_engraver::acknowledge_note_column (Grob_info info)
{
for (Pedal_info *p = info_list_; p && p->name_; p++)
{
- if (Note_column::has_interface (info.grob ()))
+ if (p->line_spanner_)
{
- if (p->line_spanner_)
- {
- Side_position_interface::add_support (p->line_spanner_, info.grob ());
- add_bound_item (p->line_spanner_, info.grob ());
- }
- if (p->bracket_)
- add_bound_item (p->bracket_, info.grob ());
- if (p->finished_bracket_)
- add_bound_item (p->finished_bracket_, info.grob ());
+ Side_position_interface::add_support (p->line_spanner_, info.grob ());
+ add_bound_item (p->line_spanner_, info.grob ());
}
+ if (p->bracket_)
+ add_bound_item (p->bracket_, info.grob ());
+ if (p->finished_bracket_)
+ add_bound_item (p->finished_bracket_, info.grob ());
}
}
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Piano_pedal_engraver,note_column);
ADD_TRANSLATOR (Piano_pedal_engraver,
/* descr */ "Engrave piano pedal symbols and brackets.",
/* creats*/ "SostenutoPedal SustainPedal UnaCordaPedal SostenutoPedalLineSpanner SustainPedalLineSpanner UnaCordaPedalLineSpanner",
/* accepts */ "pedal-event",
- /* acks */ "note-column-interface",
+ /* acks */ "",
/* reads */ "currentCommandColumn "
"pedalSostenutoStrings pedalSustainStrings "
"pedalUnaCordaStrings pedalSostenutoStyle "
TRANSLATOR_DECLARATIONS(Pitched_trill_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER( note_head);
+ DECLARE_ACKNOWLEDGER( dots);
+ DECLARE_ACKNOWLEDGER( text_spanner);
PRECOMPUTED_VIRTUAL void process_music ();
virtual bool try_music (Music*);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
}
void
-Pitched_trill_engraver::acknowledge_grob (Grob_info info)
+Pitched_trill_engraver::acknowledge_dots (Grob_info info)
+{
+ heads_.push (info.grob ());
+}
+void
+Pitched_trill_engraver::acknowledge_note_head (Grob_info info)
+{
+ heads_.push (info.grob ());
+}
+
+void
+Pitched_trill_engraver::acknowledge_text_spanner (Grob_info info)
{
Music *mus = info.music_cause ();
-
- if (Note_head::has_interface (info.grob ())
- || Dots::has_interface (info.grob ()))
- {
- heads_.push (info.grob ());
- }
- else if (mus
- && mus->is_mus_type ("trill-span-event")
- && to_dir (mus->get_property ("span-direction")) == START
- && unsmob_pitch (mus->get_property ("trill-pitch")))
+ if (mus
+ && mus->is_mus_type ("trill-span-event")
+ && to_dir (mus->get_property ("span-direction")) == START
+ && unsmob_pitch (mus->get_property ("trill-pitch")))
{
make_trill (mus);
}
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Pitched_trill_engraver, note_head);
+ADD_ACKNOWLEDGER(Pitched_trill_engraver, dots);
+ADD_ACKNOWLEDGER(Pitched_trill_engraver, text_spanner);
ADD_TRANSLATOR (Pitched_trill_engraver,
/* descr */ "Print the bracketed notehead after a notehead with trill.",
/* creats*/ "TrillPitchHead TrillPitchAccidental TrillPitchGroup",
/* accepts */ "",
- /* acks */ "script-interface text-spanner-interface dots-interface note-head-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
#include "dot-column.hh"
#include "pointer-group-interface.hh"
+#include "translator.icc"
+
/*
this engraver glues together stems, rests and note heads into a NoteColumn
grob.
TRANSLATOR_DECLARATIONS (Rhythmic_column_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+DECLARE_ACKNOWLEDGER(dot_column);
+DECLARE_ACKNOWLEDGER(stem);
+DECLARE_ACKNOWLEDGER(rhythmic_head);
PRECOMPUTED_VIRTUAL void process_acknowledged ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
};
}
void
-Rhythmic_column_engraver::acknowledge_grob (Grob_info i)
+Rhythmic_column_engraver::acknowledge_stem (Grob_info i)
{
- Item *item = dynamic_cast<Item *> (i.grob ());
- if (!item || item->get_parent (X_AXIS))
- return;
- if (Stem::has_interface (item))
- {
- stem_ = item;
- }
- else if (Rhythmic_head::has_interface (item))
- {
- rheads_.push (item);
- }
- else if (Dot_column::has_interface (item))
- {
- dotcol_ = item;
- }
+ stem_ = i.grob();
+}
+
+void
+Rhythmic_column_engraver::acknowledge_rhythmic_head (Grob_info i)
+{
+ rheads_.push (i.grob ());
+}
+
+void
+Rhythmic_column_engraver::acknowledge_dot_column (Grob_info i)
+{
+ dotcol_ = i.grob ();
}
void
stem_ = 0;
}
-#include "translator.icc"
+
+ADD_ACKNOWLEDGER(Rhythmic_column_engraver,dot_column);
+ADD_ACKNOWLEDGER(Rhythmic_column_engraver,stem);
+ADD_ACKNOWLEDGER(Rhythmic_column_engraver,rhythmic_head);
ADD_TRANSLATOR (Rhythmic_column_engraver,
/* descr */ "Generates NoteColumn, an objects that groups stems, noteheads and rests.",
/* creats*/ "NoteColumn NoteSpacing",
/* accepts */ "",
- /* acks */ "stem-interface rhythmic-head-interface dot-column-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
public:
TRANSLATOR_DECLARATIONS (Script_column_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(side_position);
PRECOMPUTED_VIRTUAL void process_acknowledged ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
};
}
void
-Script_column_engraver::acknowledge_grob (Grob_info inf)
+Script_column_engraver::acknowledge_side_position (Grob_info inf)
{
Item *thing = dynamic_cast<Item *> (inf.grob ());
- if (thing && Side_position_interface::has_interface (inf.grob ())) // ugh FIXME
+ if (thing)
{
if (!Item::is_breakable (thing)
&& Side_position_interface::get_axis (inf.grob ()) == Y_AXIS)
scripts_.clear ();
}
}
-
+ADD_ACKNOWLEDGER(Script_column_engraver, side_position);
ADD_TRANSLATOR (Script_column_engraver,
/* descr */ "",
/* creats*/ "ScriptColumn",
/* accepts */ "",
- /* acks */ "side-position-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER( slur);
+ DECLARE_ACKNOWLEDGER( rhythmic_head);
+ DECLARE_ACKNOWLEDGER( stem);
+ DECLARE_ACKNOWLEDGER( note_column);
public:
TRANSLATOR_DECLARATIONS (Script_engraver);
int script_count = scripts_.size ();
for (int i = 0; i < script_count; i++)
if (ly_is_equal (scripts_[i].event_
- ->get_property ("articulation-type"),
- m->get_property ("articulation-type")))
+ ->get_property ("articulation-type"),
+ m->get_property ("articulation-type")))
return true;
Script_tuple t;
void
Script_engraver::process_music ()
{
- int script_count = scripts_.size ();
- for (int i = 0; i < script_count; i++)
- {
+ for (int i = 0; i < scripts_.size(); i++)
+ {
Music *m = scripts_[i].event_;
Grob *p = make_item ("Script", m->self_scm ());
}
}
+
void
-Script_engraver::acknowledge_grob (Grob_info info)
+Script_engraver::acknowledge_stem (Grob_info info)
{
int script_count = scripts_.size ();
- if (Stem::has_interface (info.grob ()))
+ for (int i = 0; i < script_count; i++)
{
- for (int i = 0; i < script_count; i++)
- {
- Grob *e = scripts_[i].script_;
+ Grob *e = scripts_[i].script_;
- if (to_dir (e->get_property ("side-relative-direction")))
- e->set_object ("direction-source", info.grob ()->self_scm ());
+ if (to_dir (e->get_property ("side-relative-direction")))
+ e->set_object ("direction-source", info.grob ()->self_scm ());
- /* FIXME: add dependency */
- e->add_dependency (info.grob ());
- Side_position_interface::add_support (e, info.grob ());
- }
+ /* FIXME: add dependency */
+ e->add_dependency (info.grob ());
+ Side_position_interface::add_support (e, info.grob ());
}
- else if (Rhythmic_head::has_interface (info.grob ())
- && info.music_cause ())
+}
+
+void
+Script_engraver::acknowledge_rhythmic_head (Grob_info info)
+{
+ if(info.music_cause ())
{
- for (int i = 0; i < script_count; i++)
- {
+ for (int i = 0; i < scripts_.size(); i++)
+ {
Grob *e = scripts_[i].script_;
if (Side_position_interface::get_axis (e) == X_AXIS
Side_position_interface::add_support (e, info.grob ());
}
}
- else if (Note_column::has_interface (info.grob ()))
- {
- /* Make note column the parent of the script. That is not
- correct, but due to seconds in a chord, noteheads may be
- swapped around horizontally.
+}
- As the note head to put it on is not known now, postpone this
- decision to Script_interface::before_line_breaking (). */
- for (int i = 0; i < script_count; i++)
- {
- Grob *e = scripts_[i].script_;
+void
+Script_engraver::acknowledge_note_column (Grob_info info)
+{
+ /* Make note column the parent of the script. That is not
+ correct, but due to seconds in a chord, noteheads may be
+ swapped around horizontally.
+
+ As the note head to put it on is not known now, postpone this
+ decision to Script_interface::before_line_breaking (). */
+
+ for (int i = 0; i < scripts_.size(); i++)
+ {
+ Grob *e = scripts_[i].script_;
- if (!e->get_parent (X_AXIS)
- && Side_position_interface::get_axis (e) == Y_AXIS)
- e->set_parent (info.grob (), X_AXIS);
- }
+ if (!e->get_parent (X_AXIS)
+ && Side_position_interface::get_axis (e) == Y_AXIS)
+ e->set_parent (info.grob (), X_AXIS);
}
- else if (Slur::has_interface (info.grob ()))
- slur_ = dynamic_cast<Spanner *> (info.grob ());
+}
+
+void
+Script_engraver::acknowledge_slur (Grob_info info)
+{
+ slur_ = info.spanner ();
}
void
#include "translator.icc"
+ADD_ACKNOWLEDGER(Script_engraver, slur);
+ADD_ACKNOWLEDGER(Script_engraver, rhythmic_head);
+ADD_ACKNOWLEDGER(Script_engraver, stem);
+ADD_ACKNOWLEDGER(Script_engraver, note_column);
+
ADD_TRANSLATOR (Script_engraver,
/* descr */ "Handles note scripted articulations.",
/* creats*/ "Script",
/* accepts */ "script-event articulation-event",
- /* acks */ "stem-interface rhythmic-head-interface "
- "slur-interface note-column-interface",
+ /* acks */ "",
/* reads */ "scriptDefinitions",
/* write */ "");
#include "grob-array.hh"
#include "pointer-group-interface.hh"
+#include "translator.icc"
+
struct Spacings
{
Item *staff_spacing_;
Spanner *sep_span_;
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(item);
PRECOMPUTED_VIRTUAL void process_music ();
virtual void finalize ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
}
void
-Separating_line_group_engraver::acknowledge_grob (Grob_info i)
+Separating_line_group_engraver::acknowledge_item (Grob_info i)
{
Item *it = dynamic_cast<Item *> (i.grob ());
if (!it)
musical_item_ = 0;
}
-#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Separating_line_group_engraver, item);
ADD_TRANSLATOR (Separating_line_group_engraver,
/* descr */ "Generates objects for computing spacing parameters.",
/* creats*/ "SeparationItem SeparatingGroupSpanner StaffSpacing",
/* accepts */ "",
- /* acks */ "item-interface",
+ /* acks */ "",
/* reads */ "createSpacing",
/* write */ "breakableSeparationItem");
protected:
virtual bool try_music (Music *);
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(note_column);
+ DECLARE_ACKNOWLEDGER(accidental);
+ DECLARE_ACKNOWLEDGER(fingering);
+ DECLARE_ACKNOWLEDGER(script);
+ DECLARE_ACKNOWLEDGER(tie);
+ DECLARE_ACKNOWLEDGER(text_script);
+ void acknowledge_extra_object (Grob_info);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void finalize ();
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Slur_engraver::acknowledge_grob (Grob_info info)
+Slur_engraver::acknowledge_note_column (Grob_info info)
{
Grob *e = info.grob ();
- if (Note_column::has_interface (info.grob ()))
+ for (int i = slurs_.size (); i--;)
+ Slur::add_column (slurs_[i], e);
+ for (int i = end_slurs_.size (); i--;)
+ Slur::add_column (end_slurs_[i], e);
+}
+
+void
+Slur_engraver::acknowledge_extra_object (Grob_info info)
+{
+ Grob*e = info.grob ();
+ SCM inside = e->get_property ("inside-slur");
+ if (Tie::has_interface (e)
+ || to_boolean (inside))
{
for (int i = slurs_.size (); i--;)
- Slur::add_column (slurs_[i], e);
+ Slur::add_extra_encompass (slurs_[i], e);
for (int i = end_slurs_.size (); i--;)
- Slur::add_column (end_slurs_[i], e);
+ Slur::add_extra_encompass (end_slurs_[i], e);
}
- else
+ else if (inside == SCM_BOOL_F)
{
- SCM inside = e->get_property ("inside-slur");
- if (Tie::has_interface (e)
- || to_boolean (inside))
- {
- for (int i = slurs_.size (); i--;)
- Slur::add_extra_encompass (slurs_[i], e);
- for (int i = end_slurs_.size (); i--;)
- Slur::add_extra_encompass (end_slurs_[i], e);
- }
- else if (inside == SCM_BOOL_F)
+ Grob *slur = slurs_.size () ? slurs_[0] : 0;
+ slur = (end_slurs_.size () && !slur)
+ ? end_slurs_[0] : slur;
+
+ if (slur)
{
- Grob *slur = slurs_.size () ? slurs_[0] : 0;
- slur = (end_slurs_.size () && !slur)
- ? end_slurs_[0] : slur;
-
- if (slur)
- {
- e->add_offset_callback (Slur::outside_slur_callback_proc, Y_AXIS);
- e->set_object ("slur", slur->self_scm ());
- }
+ e->add_offset_callback (Slur::outside_slur_callback_proc, Y_AXIS);
+ e->set_object ("slur", slur->self_scm ());
}
}
}
+void
+Slur_engraver::acknowledge_accidental (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+
+void
+Slur_engraver::acknowledge_fingering (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+void
+Slur_engraver::acknowledge_script (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+void
+Slur_engraver::acknowledge_text_script (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+void
+Slur_engraver::acknowledge_tie (Grob_info info)
+{
+ acknowledge_extra_object (info);
+}
+
+
+
+
void
Slur_engraver::finalize ()
{
#include "translator.icc"
+ADD_ACKNOWLEDGER(Slur_engraver,note_column);
+ADD_ACKNOWLEDGER(Slur_engraver,accidental);
+ADD_ACKNOWLEDGER(Slur_engraver,fingering)
+ADD_ACKNOWLEDGER(Slur_engraver,script);
+ADD_ACKNOWLEDGER(Slur_engraver,tie);
+ADD_ACKNOWLEDGER(Slur_engraver,text_script);
ADD_TRANSLATOR (Slur_engraver,
/* descr */ "Build slurs grobs from slur events",
/* creats*/ "Slur",
/* accepts */ "slur-event",
- /* acks */ "note-column-interface accidental-interface fingering-interface script-interface tie-interface text-script-interface",
+ /* acks */ "",
/* reads */ "slurMelismaBusy doubleSlurs",
/* write */ "");
TRANSLATOR_DECLARATIONS (Spacing_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(staff_spacing);
+ DECLARE_ACKNOWLEDGER(note_spacing);
+ DECLARE_ACKNOWLEDGER(rhythmic_head);
PRECOMPUTED_VIRTUAL void start_translation_timestep ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Spacing_engraver::acknowledge_grob (Grob_info i)
+Spacing_engraver::acknowledge_note_spacing (Grob_info i)
{
- if (Note_spacing::has_interface (i.grob ()) || Staff_spacing::has_interface (i.grob ()))
- {
- Pointer_group_interface::add_grob (spacing_, ly_symbol2scm ("wishes"), i.grob ());
- }
+ Pointer_group_interface::add_grob (spacing_, ly_symbol2scm ("wishes"), i.grob ());
+}
+void
+Spacing_engraver::acknowledge_staff_spacing (Grob_info i)
+{
+ Pointer_group_interface::add_grob (spacing_, ly_symbol2scm ("wishes"), i.grob ());
+}
+
+void
+Spacing_engraver::acknowledge_rhythmic_head (Grob_info i)
+{
if (i.grob ()->internal_has_interface (ly_symbol2scm ("lyric-syllable-interface"))
- || i.grob ()->internal_has_interface (ly_symbol2scm ("multi-measure-event")))
+ || i.grob ()->internal_has_interface (ly_symbol2scm ("multi-measure-interface")))
return;
/*
#include "translator.icc"
+ADD_ACKNOWLEDGER(Spacing_engraver,staff_spacing);
+ADD_ACKNOWLEDGER(Spacing_engraver,note_spacing);
+ADD_ACKNOWLEDGER(Spacing_engraver,rhythmic_head);
+
ADD_TRANSLATOR (Spacing_engraver,
/* descr */ "make a SpacingSpanner and do bookkeeping of shortest starting and playing notes ",
/* creats*/ "SpacingSpanner",
/* accepts */ "",
- /* acks */ "grob-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
{
public:
TRANSLATOR_DECLARATIONS (Span_arpeggio_engraver);
+ DECLARE_ACKNOWLEDGER(arpeggio);
protected:
- virtual void acknowledge_grob (Grob_info);
PRECOMPUTED_VIRTUAL void process_acknowledged ();
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
}
void
-Span_arpeggio_engraver::acknowledge_grob (Grob_info info)
+Span_arpeggio_engraver::acknowledge_arpeggio (Grob_info info)
{
- if (Arpeggio::has_interface (info.grob ())
- && info.origin_contexts (this).size ()) // huh? what's this test for?
+ if (info.origin_contexts (this).size ()) // huh? what's this test for?
{
arpeggios_.push (info.grob ());
}
#include "translator.icc"
+ADD_ACKNOWLEDGER(Span_arpeggio_engraver,arpeggio);
ADD_TRANSLATOR (Span_arpeggio_engraver,
/* descr */ "",
/* creats*/ "Arpeggio",
/* accepts */ "",
- /* acks */ "arpeggio-interface",
+ /* acks */ "",
/* reads */ "connectArpeggios",
/* write */ "");
public:
TRANSLATOR_DECLARATIONS (Span_bar_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(bar_line);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
};
}
void
-Span_bar_engraver::acknowledge_grob (Grob_info i)
+Span_bar_engraver::acknowledge_bar_line (Grob_info i)
{
int depth = i.origin_contexts (this).size ();
if (depth && Bar_line::has_interface (i.grob ()))
#include "translator.icc"
+ADD_ACKNOWLEDGER(Span_bar_engraver, bar_line);
ADD_TRANSLATOR (Span_bar_engraver,
/* descr */ "This engraver makes cross-staff barlines: It catches all normal "
"bar lines, and draws a single span-bar across them.",
/* creats*/ "SpanBar",
/* accepts */ "",
- /* acks */ "bar-line-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
{
public:
TRANSLATOR_DECLARATIONS (Staff_collecting_engraver);
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(staff_symbol);
};
Staff_collecting_engraver::Staff_collecting_engraver ()
}
void
-Staff_collecting_engraver::acknowledge_grob (Grob_info gi)
+Staff_collecting_engraver::acknowledge_staff_symbol (Grob_info gi)
{
- if (Staff_symbol::has_interface (gi.grob ()))
- {
- SCM staffs = get_property ("stavesFound");
- staffs = scm_cons (gi.grob ()->self_scm (), staffs);
+ SCM staffs = get_property ("stavesFound");
+ staffs = scm_cons (gi.grob ()->self_scm (), staffs);
- context ()->set_property ("stavesFound", staffs);
- }
+ context ()->set_property ("stavesFound", staffs);
}
#include "translator.icc"
+ADD_ACKNOWLEDGER(Staff_collecting_engraver,staff_symbol);
ADD_TRANSLATOR (Staff_collecting_engraver,
/* descr */ "Maintain the stavesFound variable",
/* creats*/ "",
/* accepts */ "",
- /* acks */ "staff-symbol-interface",
+ /* acks */ "",
/* reads */ "stavesFound",
/* write */ "stavesFound");
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Staff_symbol_engraver,grob);
ADD_TRANSLATOR (Staff_symbol_engraver,
/* descr */ "Create the constellation of five (default) "
"staff lines.",
/* creats*/ "StaffSymbol",
/* accepts */ "staff-span-event",
- /* acks */ "grob-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
protected:
void make_stem (Grob_info);
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(rhythmic_head);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual bool try_music (Music *);
};
}
void
-Stem_engraver::acknowledge_grob (Grob_info gi)
+Stem_engraver::acknowledge_rhythmic_head (Grob_info gi)
{
- if (Rhythmic_head::has_interface (gi.grob ()))
- {
- if (Rhythmic_head::get_stem (gi.grob ()))
- return;
-
- Music *cause = gi.music_cause ();
- if (!cause)
- return;
- Duration *d = unsmob_duration (cause->get_property ("duration"));
- if (!d)
- return ;
+ if (Rhythmic_head::get_stem (gi.grob ()))
+ return;
+
+ Music *cause = gi.music_cause ();
+ if (!cause)
+ return;
+ Duration *d = unsmob_duration (cause->get_property ("duration"));
+ if (!d)
+ return ;
- if (!stem_)
- make_stem (gi);
+ if (!stem_)
+ make_stem (gi);
- if (Stem::duration_log (stem_) != d->duration_log ())
- {
- // FIXME:
- gi.music_cause ()->origin ()->warning (_f ("adding note head to incompatible stem (type = %d)",
- 1 << Stem::duration_log (stem_)));
- gi.music_cause ()->origin ()->warning (_f ("maybe input should specify polyphonic voices"));
- }
-
- Stem::add_head (stem_, gi.grob ());
+ if (Stem::duration_log (stem_) != d->duration_log ())
+ {
+ // FIXME:
+ gi.music_cause ()->origin ()->warning (_f ("adding note head to incompatible stem (type = %d)",
+ 1 << Stem::duration_log (stem_)));
+ gi.music_cause ()->origin ()->warning (_f ("maybe input should specify polyphonic voices"));
}
+
+ Stem::add_head (stem_, gi.grob ());
}
void
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Stem_engraver,rhythmic_head);
ADD_TRANSLATOR (Stem_engraver,
/* descr */ "Create stems and single-stem tremolos. It also works together with "
"the beam engraver for overriding beaming.",
/* creats*/ "Stem StemTremolo",
/* accepts */ "tremolo-event",
- /* acks */ "rhythmic-head-interface",
+ /* acks */ "",
/* reads */ "tremoloFlags stemLeftBeamCount stemRightBeamCount",
/* write */ "");
protected:
Spanner *delim_;
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(system_start_delimiter);
+ DECLARE_ACKNOWLEDGER(staff_symbol);
+
PRECOMPUTED_VIRTUAL void process_music ();
virtual void finalize ();
};
void
-System_start_delimiter_engraver::acknowledge_grob (Grob_info inf)
+System_start_delimiter_engraver::acknowledge_staff_symbol (Grob_info inf)
{
- if (Staff_symbol::has_interface (inf.grob ()))
- {
- /*
- don't add as Axis_group_interface::add_element (delim_, ),
- because that would set the parent as well */
+ /*
+ don't add as Axis_group_interface::add_element (delim_, ),
+ because that would set the parent as well */
- Pointer_group_interface::add_grob (delim_, ly_symbol2scm ("elements"), inf.grob ());
- }
- else if (System_start_delimiter::has_interface (inf.grob ()))
- {
- SCM gl = inf.grob ()->get_property ("glyph");
- SCM my_gl = delim_->get_property ("glyph");
+ Pointer_group_interface::add_grob (delim_, ly_symbol2scm ("elements"), inf.grob ());
+}
+void
+System_start_delimiter_engraver::acknowledge_system_start_delimiter (Grob_info inf)
+{
+ SCM gl = inf.grob ()->get_property ("glyph");
+ SCM my_gl = delim_->get_property ("glyph");
- /*
- UGH UGH
- */
- if (scm_is_string (gl) && ly_is_equal (gl, scm_makfrom0str ("brace"))
- && scm_is_string (my_gl) && ly_is_equal (my_gl, scm_makfrom0str ("bracket")))
- inf.grob ()->translate_axis (-0.8, X_AXIS); // ugh
- else if (scm_is_string (gl) && ly_is_equal (gl, scm_makfrom0str ("bracket"))
- && scm_is_string (my_gl) && ly_is_equal (my_gl, scm_makfrom0str ("bracket")))
- {
- inf.grob ()->translate_axis (-0.8, X_AXIS); // ugh
- }
+ /*
+ UGH UGH
+ */
+ if (scm_is_string (gl) && ly_is_equal (gl, scm_makfrom0str ("brace"))
+ && scm_is_string (my_gl) && ly_is_equal (my_gl, scm_makfrom0str ("bracket")))
+ inf.grob ()->translate_axis (-0.8, X_AXIS); // ugh
+ else if (scm_is_string (gl) && ly_is_equal (gl, scm_makfrom0str ("bracket"))
+ && scm_is_string (my_gl) && ly_is_equal (my_gl, scm_makfrom0str ("bracket")))
+ {
+ inf.grob ()->translate_axis (-0.8, X_AXIS); // ugh
}
}
#include "translator.icc"
+ADD_ACKNOWLEDGER(System_start_delimiter_engraver, system_start_delimiter);
+ADD_ACKNOWLEDGER(System_start_delimiter_engraver, staff_symbol);
+
ADD_TRANSLATOR (System_start_delimiter_engraver,
/* descr */ "Creates a system start delimiter (ie. SystemStart@{Bar, Brace, Bracket@} spanner",
/* creats*/ "SystemStartBar SystemStartBrace SystemStartBracket",
/* accepts */ "",
- /* acks */ "system-start-delimiter-interface staff-symbol-interface",
+ /* acks */ "",
/* reads */ "systemStartDelimiter",
/* write */ "");
#include "translator.icc"
+ADD_ACKNOWLEDGER(Tab_staff_symbol_engraver,grob);
ADD_TRANSLATOR (Tab_staff_symbol_engraver,
/* descr */ "Create a staff-symbol, but look at stringTunings for the number of lines."
"staff lines.",
/* creats*/ "StaffSymbol",
/* accepts */ "staff-span-event",
- /* acks */ "grob-interface",
+ /* acks */ "",
/* reads */ "stringTunings",
/* write */ "");
virtual bool try_music (Music *m);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_acknowledged ();
- virtual void acknowledge_grob (Grob_info);
+
+ DECLARE_ACKNOWLEDGER(stem);
+ DECLARE_ACKNOWLEDGER(rhythmic_head);
};
bool
}
void
-Text_engraver::acknowledge_grob (Grob_info inf)
+Text_engraver::acknowledge_rhythmic_head (Grob_info inf)
{
- if (Rhythmic_head::has_interface (inf.grob ()))
+ for (int i = 0; i < texts_.size (); i++)
{
- for (int i = 0; i < texts_.size (); i++)
- {
- Grob *t = texts_[i];
- Side_position_interface::add_support (t, inf.grob ());
-
- /*
- ugh.
- */
- if (Side_position_interface::get_axis (t) == X_AXIS
- && !t->get_parent (Y_AXIS))
- t->set_parent (inf.grob (), Y_AXIS);
- else if (Side_position_interface::get_axis (t) == Y_AXIS
- && !t->get_parent (X_AXIS))
- t->set_parent (inf.grob (), X_AXIS);
- }
+ Grob *t = texts_[i];
+ Side_position_interface::add_support (t, inf.grob ());
+
+ /*
+ ugh.
+ */
+ if (Side_position_interface::get_axis (t) == X_AXIS
+ && !t->get_parent (Y_AXIS))
+ t->set_parent (inf.grob (), Y_AXIS);
+ else if (Side_position_interface::get_axis (t) == Y_AXIS
+ && !t->get_parent (X_AXIS))
+ t->set_parent (inf.grob (), X_AXIS);
}
+}
- if (Stem::has_interface (inf.grob ()))
+void
+Text_engraver::acknowledge_stem (Grob_info inf)
+{
+ for (int i = 0; i < texts_.size (); i++)
{
- for (int i = 0; i < texts_.size (); i++)
- {
- Side_position_interface::add_support (texts_[i], inf.grob ());
- }
+ Side_position_interface::add_support (texts_[i], inf.grob ());
}
}
#include "translator.icc"
+ADD_ACKNOWLEDGER(Text_engraver, stem);
+ADD_ACKNOWLEDGER(Text_engraver, rhythmic_head);
ADD_TRANSLATOR (Text_engraver,
/* descr */ "Create text-scripts",
/* creats*/ "TextScript",
/* accepts */ "text-script-event",
- /* acks */ "rhythmic-head-interface stem-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
TRANSLATOR_DECLARATIONS (Text_spanner_engraver);
protected:
virtual void finalize ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_column);
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Text_spanner_engraver::acknowledge_grob (Grob_info info)
+Text_spanner_engraver::acknowledge_note_column (Grob_info info)
{
Spanner *spans[2] ={span_, finished_};
for (int i = 0; i < 2; i++)
{
- if (spans[i] && Note_column::has_interface (info.grob ()))
+ if (spans[i])
{
Side_position_interface::add_support (spans[i], info.grob ());
add_bound_item (spans[i], dynamic_cast<Item *> (info.grob ()));
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Text_spanner_engraver,note_column);
ADD_TRANSLATOR (Text_spanner_engraver,
/* descr */ "Create text spanner from a Music.",
/* creats*/ "TextSpanner",
/* accepts */ "text-span-event",
- /* acks */ "note-column-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
virtual void derived_mark () const;
PRECOMPUTED_VIRTUAL void start_translation_timestep ();
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(note_head);
virtual bool try_music (Music *);
PRECOMPUTED_VIRTUAL void process_music ();
void typeset_tie (Grob *);
}
void
-Tie_engraver::acknowledge_grob (Grob_info i)
+Tie_engraver::acknowledge_note_head (Grob_info i)
{
- if (Note_head::has_interface (i.grob ()))
+ Grob *h = i.grob ();
+ now_heads_.push (h);
+ for (int i = heads_to_tie_.size (); i--;)
{
- Grob *h = i.grob ();
- now_heads_.push (h);
- for (int i = heads_to_tie_.size (); i--;)
+ Grob *th = heads_to_tie_[i].head_;
+ Music *right_mus = unsmob_music (h->get_property ("cause"));
+ Music *left_mus = unsmob_music (th->get_property ("cause"));
+
+ /*
+ maybe should check positions too.
+ */
+ if (right_mus && left_mus
+ && ly_is_equal (right_mus->get_property ("pitch"),
+ left_mus->get_property ("pitch")))
{
- Grob *th = heads_to_tie_[i].head_;
- Music *right_mus = unsmob_music (h->get_property ("cause"));
- Music *left_mus = unsmob_music (th->get_property ("cause"));
-
- /*
- maybe should check positions too.
- */
- if (right_mus && left_mus
- && ly_is_equal (right_mus->get_property ("pitch"),
- left_mus->get_property ("pitch")))
- {
- Grob *p = new Spanner (heads_to_tie_[i].tie_definition_,
- context ()->get_grob_key ("Tie"));
- announce_grob (p, heads_to_tie_[i].event_->self_scm ());
- Tie::set_interface (p); // cannot remove yet!
-
- Tie::set_head (p, LEFT, th);
- Tie::set_head (p, RIGHT, h);
-
- ties_.push (p);
- heads_to_tie_.del (i);
- }
- }
+ Grob *p = new Spanner (heads_to_tie_[i].tie_definition_,
+ context ()->get_grob_key ("Tie"));
+ announce_grob (p, heads_to_tie_[i].event_->self_scm ());
+ Tie::set_interface (p); // cannot remove yet!
- if (ties_.size () && ! tie_column_)
- {
- tie_column_ = make_spanner ("TieColumn", ties_[0]->self_scm ());
+ Tie::set_head (p, LEFT, th);
+ Tie::set_head (p, RIGHT, h);
+
+ ties_.push (p);
+ heads_to_tie_.del (i);
}
+ }
- if (tie_column_)
- for (int i = ties_.size (); i--;)
- Tie_column::add_tie (tie_column_, ties_[i]);
+ if (ties_.size () && ! tie_column_)
+ {
+ tie_column_ = make_spanner ("TieColumn", ties_[0]->self_scm ());
}
+
+ if (tie_column_)
+ for (int i = ties_.size (); i--;)
+ Tie_column::add_tie (tie_column_, ties_[i]);
}
void
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Tie_engraver, note_head);
ADD_TRANSLATOR (Tie_engraver,
/* descr */ "Generate ties between noteheads of equal pitch.",
/* creats*/ "Tie TieColumn",
/* accepts */ "tie-event",
- /* acks */ "rhythmic-head-interface",
+ /* acks */ "",
/* reads */ "tieMelismaBusy",
/* write */ "");
--- /dev/null
+/*
+ translator-dispatch-list.cc -- implement Translator_dispatch_list
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 2005 Han-Wen Nienhuys <hanwen@xs4all.nl>
+
+*/
+
+#include "translator-dispatch-list.hh"
+
+#include "grob-info.hh"
+#include "engraver.hh"
+
+#include "ly-smobs.icc"
+
+void
+Engraver_dispatch_list::apply (Grob_info gi)
+{
+ for (int i = 0; i < dispatch_entries_.size (); i++)
+ {
+ Engraver_dispatch_entry const &e (dispatch_entries_[i]);
+ if (e.engraver_ == gi.origin_translator ())
+ continue;
+
+ (*e.function_) (e.engraver_, gi);
+ }
+}
+
+SCM
+Engraver_dispatch_list::create (SCM trans_list,
+ SCM iface_list)
+{
+ SCM retval = Engraver_dispatch_list().smobbed_copy ();
+ Engraver_dispatch_list * list = Engraver_dispatch_list::unsmob (retval);
+
+ Engraver_dispatch_entry entry;
+ bool found = false;
+ for (SCM s = trans_list; scm_is_pair (s); s = scm_cdr (s))
+ {
+ Engraver * eng
+ = dynamic_cast<Engraver*> (unsmob_translator (scm_car (s)));
+
+ if (!eng)
+ continue;
+
+ entry.engraver_ = eng;
+ for (SCM i = iface_list; scm_is_pair (i); i = scm_cdr (i))
+ {
+ Engraver_void_function_engraver_grob_info ptr
+ = eng->get_acknowledger (scm_car (i));
+ if (ptr)
+ {
+ entry.function_ = ptr;
+ list->dispatch_entries_.push (entry);
+ found = true;
+ }
+
+ }
+ }
+
+
+ return found ? retval : SCM_BOOL_F;
+}
+
+SCM
+Engraver_dispatch_list::mark_smob (SCM x)
+{
+ (void)x;
+ return SCM_BOOL_F;
+}
+
+
+int
+Engraver_dispatch_list::print_smob (SCM x, SCM p, scm_print_state *)
+{
+ (void)x;
+ scm_puts ("#<Engraver_dispatch_list>", p);
+ return 1;
+}
+
+IMPLEMENT_SIMPLE_SMOBS(Engraver_dispatch_list);
+IMPLEMENT_DEFAULT_EQUAL_P(Engraver_dispatch_list);
}
void
-add_acknowledger (Translator_void_method_ptr ptr,
+add_acknowledger (Engraver_void_function_engraver_grob_info ptr,
const char *func_name,
Array<Acknowledge_information> *ack_array)
{
String interface_name(func_name);
- interface_name = interface_name.substitute ("acknowledge_", "");
interface_name = interface_name.substitute ('_', '-');
interface_name += "-interface";
ack_array->push (inf);
}
-Translator_void_method_ptr
+Engraver_void_function_engraver_grob_info
generic_get_acknowledger (SCM sym, Array<Acknowledge_information> const *ack_array)
{
for (int i = 0; i < ack_array->size(); i++)
public:
TRANSLATOR_DECLARATIONS (Vertical_align_engraver);
+ DECLARE_ACKNOWLEDGER(axis_group);
protected:
virtual void derived_mark () const;
- virtual void acknowledge_grob (Grob_info);
PRECOMPUTED_VIRTUAL void process_music ();
virtual void finalize ();
virtual void initialize ();
};
-
+ADD_ACKNOWLEDGER(Vertical_align_engraver, axis_group);
ADD_TRANSLATOR (Vertical_align_engraver,
"Catch groups (staffs, lyrics lines, etc.) and stack "
"them vertically.",
/* creats*/ "VerticalAlignment",
/* accepts */ "",
- /* acks */ "axis-group-interface",
+ /* acks */ "",
/* reads */ "",
/* write */ "");
}
void
-Vertical_align_engraver::acknowledge_grob (Grob_info i)
+Vertical_align_engraver::acknowledge_axis_group (Grob_info i)
{
if (qualifies (i))
{
{
TRANSLATOR_DECLARATIONS(Vertically_spaced_contexts_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
virtual void initialize ();
+ DECLARE_ACKNOWLEDGER(vertically_spaceable);
private:
- Grob * system_;
+ Grob *system_;
};
}
void
-Vertically_spaced_contexts_engraver::acknowledge_grob (Grob_info gi)
+Vertically_spaced_contexts_engraver::acknowledge_vertically_spaceable (Grob_info gi)
{
- if (Axis_group_interface::has_interface (gi.grob ())
- && gi.grob ()->internal_has_interface (ly_symbol2scm ("vertically-spaceable-interface")))
+ if (Axis_group_interface::has_interface (gi.grob ()))
{
SCM spaceable = get_property ("verticallySpacedContexts");
Context *orig = gi.origin_contexts (this)[0];
}
#include "translator.icc"
-
+ADD_ACKNOWLEDGER(Vertically_spaced_contexts_engraver, vertically_spaceable);
ADD_TRANSLATOR (Vertically_spaced_contexts_engraver,
/* descr */ "",
/* creats*/ "",
/* accepts */ "",
- /* acks */ "axis-group-interface",
+ /* acks */ "",
/* reads */ "verticallySpacedContexts",
/* write */ "verticallySpacedContexts");
TRANSLATOR_DECLARATIONS (Volta_engraver);
protected:
- virtual void acknowledge_grob (Grob_info);
+ DECLARE_ACKNOWLEDGER(staff_symbol);
+ DECLARE_ACKNOWLEDGER(note_column);
+ DECLARE_ACKNOWLEDGER(bar_line);
+
virtual void finalize ();
+
PRECOMPUTED_VIRTUAL void stop_translation_timestep ();
PRECOMPUTED_VIRTUAL void process_music ();
}
void
-Volta_engraver::acknowledge_grob (Grob_info i)
+Volta_engraver::acknowledge_note_column (Grob_info i)
{
- if (Item *item = dynamic_cast<Item *> (i.grob ()))
- {
- if (Note_column::has_interface (item))
- {
- if (volta_span_)
- Volta_bracket_interface::add_column (volta_span_, item);
- }
- if (Bar_line::has_interface (item))
- {
- if (volta_span_)
- Volta_bracket_interface::add_bar (volta_span_, item);
- if (end_volta_span_)
- Volta_bracket_interface::add_bar (end_volta_span_, item);
- }
- }
- else if (Staff_symbol::has_interface (i.grob ()))
- {
- /*
- We only want to know about a single staff: then we add to the
- support. */
- if (staff_ != SCM_EOL)
- staff_ = SCM_UNDEFINED;
+ if (volta_span_)
+ Volta_bracket_interface::add_column (volta_span_, i.grob());
+}
- if (staff_ != SCM_UNDEFINED)
- staff_ = i.grob ()->self_scm ();
- }
+void
+Volta_engraver::acknowledge_bar_line (Grob_info i)
+{
+ if (volta_span_)
+ Volta_bracket_interface::add_bar (volta_span_, i.item ());
+ if (end_volta_span_)
+ Volta_bracket_interface::add_bar (end_volta_span_, i.item ());
+}
+
+void
+Volta_engraver::acknowledge_staff_symbol (Grob_info i)
+{
+ /*
+ We only want to know about a single staff: then we add to the
+ support. */
+ if (staff_ != SCM_EOL)
+ staff_ = SCM_UNDEFINED;
+
+ if (staff_ != SCM_UNDEFINED)
+ staff_ = i.grob ()->self_scm ();
}
void
/*
TODO: should attach volta to paper-column if no bar is found.
*/
-
+ADD_ACKNOWLEDGER(Volta_engraver, staff_symbol);
+ADD_ACKNOWLEDGER(Volta_engraver, note_column);
+ADD_ACKNOWLEDGER(Volta_engraver, bar_line);
ADD_TRANSLATOR (Volta_engraver,
/* descr */ "Make volta brackets.",
/* creats*/ "VoltaBracket",
/* accepts */ "",
- /* acks */ "bar-line-interface staff-symbol-interface note-column-interface",
+ /* acks */ "",
/* reads */ "repeatCommands voltaSpannerDuration stavesFound",
/* write */ "");
projects / lilypond.git / commitdiff