hidden_state. Works around a problem when parser fetches
MUSIC_FUNCTION token but not the following EXPECT_* token.
+ * lily/translator.cc, lily/context.cc:, lily/translator-group.cc:
+ remove try_music
+
+ * lily/*-engraver.cc, lily/*-performer.cc: Remove all remaining
+ references to Music; use ASSIGN_EVENT_ONCE everywhere
+
+ * lily/grob-info.cc: junk *music_cause
+
+ * lily/music.cc: copy eventified articulations to stream event
+
+ * lily/part-combine-iterator.cc: Cleanup using enums
+
+ * lily/translator-group.cc: Junk OldMusicEvent, and associated
+ methods
+
+ * lily/include/engraver.hh: Junk music.hh include
+
+ * lily/stream-event.cc: Changed constructors
+
2006-09-21 Graham Percival <gpermus@gmail.com>
* Documentation/user/tweaks.itely (Fitting music onto fewer
string _f (char const *format, ...)
__attribute__ ((format (printf, 1, 2)));
string _f (char const *format, string s, string s2 = "", string s3 = "");
+/**
+ va_list version of _f
+ */
+string v_f (char const *format, va_list args);
#endif // INTERNATIONAL_HH
{
va_list args;
va_start (args, format);
- string str = String_convert::vform_string (gettext (format), args);
+ string str = v_f (format, args);
va_end (args);
return str;
}
+string
+v_f (char const *format, va_list args)
+{
+ return String_convert::vform_string (gettext (format), args);
+}
+
string
_f (char const *format, string s, string s2, string s3)
{
#include "context.hh"
#include "engraver.hh"
#include "international.hh"
-#include "music.hh"
#include "pitch.hh"
#include "protected-scm.hh"
#include "rhythmic-head.hh"
#include "side-position-interface.hh"
+#include "stream-event.hh"
#include "tie.hh"
#include "warn.hh"
{
public:
bool done_;
- Music *melodic_;
+ Stream_event *melodic_;
Grob *accidental_;
Context *origin_;
Engraver *origin_engraver_;
int get_bar_number ();
void update_local_key_signature ();
void create_accidental (Accidental_entry *entry, bool, bool);
- Grob *make_standard_accidental (Music *note, Grob *note_head, Engraver *trans);
- Grob *make_suggested_accidental (Music *note, Grob *note_head, Engraver *trans);
+ Grob *make_standard_accidental (Stream_event *note, Grob *note_head, Engraver *trans);
+ Grob *make_suggested_accidental (Stream_event *note, Grob *note_head, Engraver *trans);
protected:
TRANSLATOR_DECLARATIONS (Accidental_engraver);
continue;
accidentals_[i].done_ = true;
- Music *note = accidentals_[i].melodic_;
+ Stream_event *note = accidentals_[i].melodic_;
Context *origin = accidentals_[i].origin_;
Pitch *pitch = unsmob_pitch (note->get_property ("pitch"));
/* Cannot look for ties: it's not guaranteed that they reach
us before the notes. */
if (num
- && !note->is_mus_type ("trill-span-event"))
+ && !note->in_event_class ("trill-span-event"))
create_accidental (&accidentals_[i], num > 1, cautionary);
}
}
bool restore_natural,
bool cautionary)
{
- Music *note = entry->melodic_;
+ Stream_event *note = entry->melodic_;
Grob *support = entry->head_;
Pitch *pitch = unsmob_pitch (note->get_property ("pitch"));
}
Grob *
-Accidental_engraver::make_standard_accidental (Music *note,
+Accidental_engraver::make_standard_accidental (Stream_event *note,
Grob *note_head,
Engraver *trans)
{
}
Grob *
-Accidental_engraver::make_suggested_accidental (Music *note,
+Accidental_engraver::make_suggested_accidental (Stream_event *note,
Grob *note_head,
Engraver *trans)
{
{
int barnum = get_bar_number ();
- Music *note = accidentals_[i].melodic_;
+ Stream_event *note = accidentals_[i].melodic_;
Context *origin = accidentals_[i].origin_;
Pitch *pitch = unsmob_pitch (note->get_property ("pitch"));
void
Accidental_engraver::acknowledge_rhythmic_head (Grob_info info)
{
- Music *note = info.music_cause ();
+ Stream_event *note = info.event_cause ();
if (note
- && (note->is_mus_type ("note-event")
- || note->is_mus_type ("trill-span-event")))
+ && (note->in_event_class ("note-event")
+ || note->in_event_class ("trill-span-event")))
{
/*
string harmonics usually don't have accidentals.
#include "protected-scm.hh"
#include "side-position-interface.hh"
#include "staff-symbol-referencer.hh"
+#include "stream-event.hh"
#include "translator.icc"
void
Ambitus_engraver::acknowledge_note_head (Grob_info info)
{
- Music *nr = info.music_cause ();
- if (nr && nr->is_mus_type ("note-event"))
+ Stream_event *nr = info.event_cause ();
+ if (nr && nr->in_event_class ("note-event"))
{
Pitch pitch = *unsmob_pitch (nr->get_property ("pitch"));
pitch_interval_.add_point (pitch);
IMPLEMENT_TRANSLATOR_LISTENER (Arpeggio_engraver, arpeggio);
void Arpeggio_engraver::listen_arpeggio (Stream_event *ev)
{
- arpeggio_event_ = ev;
+ ASSIGN_EVENT_ONCE (arpeggio_event_, ev);
}
void
void
Auto_beam_engraver::listen_beam_forbid (Stream_event *ev)
{
- forbid_ = ev;
+ ASSIGN_EVENT_ONCE (forbid_, ev);
}
bool
Direction d = to_dir (ev->get_property ("span-direction"));
if (d == START && valid_start_point ())
- start_ev_ = ev;
+ ASSIGN_EVENT_ONCE (start_ev_, ev);
else if (d == STOP && valid_end_point ())
- now_stop_ev_ = ev;
+ ASSIGN_EVENT_ONCE (now_stop_ev_, ev);
}
void
#include "global-context.hh"
#include "stream-event.hh"
#include "warn.hh"
-#include "music.hh"
#include "translator.icc"
IMPLEMENT_TRANSLATOR_LISTENER (Breathing_sign_engraver, breathing);
void
-Breathing_sign_engraver::listen_breathing (Stream_event *r)
+Breathing_sign_engraver::listen_breathing (Stream_event *ev)
{
- breathing_sign_event_ = r;
+ ASSIGN_EVENT_ONCE (breathing_sign_event_, ev);
}
void
Direction span_dir = to_dir (ev->get_property ("span-direction"));
if (span_dir == START)
{
- repeat_ = ev;
- int type = scm_to_int (ev->get_property ("tremolo-type"));
- /* e.g. 1 for type 8, 2 for type 16 */
- flags_ = intlog2 (type) - 2;
- expected_beam_count_ = scm_to_int (ev->get_property ("expected-beam-count"));
- beam_dir_ = RIGHT;
+ if (ASSIGN_EVENT_ONCE (repeat_, ev))
+ {
+ int type = scm_to_int (ev->get_property ("tremolo-type"));
+ /* e.g. 1 for type 8, 2 for type 16 */
+ flags_ = intlog2 (type) - 2;
+ expected_beam_count_ = scm_to_int (ev->get_property ("expected-beam-count"));
+ beam_dir_ = RIGHT;
+ }
}
else if (span_dir == STOP)
{
+ if (!repeat_)
+ ev->origin ()->warning (_ ("No tremolo to end"));
repeat_ = 0;
beam_ = 0;
expected_beam_count_ = 0;
if (beam_dir_ == RIGHT)
beam_dir_ = LEFT;
- if (info.ultimate_music_cause ()->is_mus_type ("rhythmic-event"))
+ if (info.ultimate_event_cause ()->in_event_class ("rhythmic-event"))
Beam::add_stem (beam_, s);
else
{
string s = _ ("stem must have Rhythmic structure");
- if (info.music_cause ())
- info.music_cause ()->origin ()->warning (s);
+ if (info.event_cause ())
+ info.event_cause ()->origin ()->warning (s);
else
::warning (s);
}
#include "coherent-ligature-engraver.hh"
#include "warn.hh"
-#include "staff-symbol-referencer.hh"
-#include "spanner.hh"
#include "paper-column.hh"
#include "pitch.hh"
#include "pointer-group-interface.hh"
+#include "spanner.hh"
+#include "staff-symbol-referencer.hh"
+#include "stream-event.hh"
/*
* This abstract class serves as common superclass for all ligature
for (vsize i = 0; i < primitives.size (); i++)
{
primitive = dynamic_cast<Item *> (primitives[i].grob ());
- Music *music_cause = primitives[i].music_cause ();
+ Stream_event *cause = primitives[i].event_cause ();
int pitch
- = unsmob_pitch (music_cause->get_property ("pitch"))->steps ();
+ = unsmob_pitch (cause->get_property ("pitch"))->steps ();
if (prev_primitive)
{
delta_pitch = pitch - prev_pitch;
#include "duration.hh"
#include "global-context.hh"
#include "item.hh"
-#include "music.hh"
#include "output-def.hh"
#include "pitch.hh"
#include "rhythmic-head.hh"
{
if (brk != end_brk)
{
- warning ( _("couldn't find line breaking that satisfies constraints" ));
+ warning (_ ("couldn't find line breaking that satisfies constraints" ));
ret.push_back (space_line (brk, end_brk));
}
/* build up the good solution */
}
}
/* if we get to here, just put everything on one line */
- warning ( _("couldn't find line breaking that satisfies constraints" ));
+ warning (_ ("couldn't find line breaking that satisfies constraints" ));
ret.push_back (space_line (0, end_brk));
return ret;
}
outlet_ = 0;
}
-bool
-Context_handle::try_music (Music *m)
-{
- return outlet_->try_music (m);
-}
-
void
Context_handle::operator = (Context_handle const &s)
{
IMPLEMENT_DEFAULT_EQUAL_P (Context);
IMPLEMENT_TYPE_P (Context, "ly:context?");
-bool
-Context::try_music (Music *m)
-{
- Translator_group *t = implementation ();
- if (!t)
- return false;
-
- bool b = t->try_music (m);
- if (!b && daddy_context_)
- b = daddy_context_->try_music (m);
-
- return b;
-}
-
Global_context *
Context::get_global_context () const
{
#include "bar-line.hh"
#include "item.hh"
#include "note-head.hh"
+#include "pitch.hh"
#include "staff-symbol-referencer.hh"
+#include "stream-event.hh"
#include "warn.hh"
-#include "pitch.hh"
#include "translator.icc"
void
Custos_engraver::acknowledge_note_head (Grob_info info)
{
- Music *m = info.music_cause ();
- if (m && m->is_mus_type ("note-event"))
+ Stream_event *ev = info.event_cause ();
+ if (ev && ev->in_event_class ("note-event"))
{
/*
don't look at the staff-position, since we can't be sure
whether Clef_engraver already applied a vertical shift.
*/
- pitches_.push_back (*unsmob_pitch (m->get_property ("pitch")));
+ pitches_.push_back (*unsmob_pitch (ev->get_property ("pitch")));
}
}
#include "audio-item.hh"
#include "audio-column.hh"
#include "global-context.hh"
-#include "music.hh"
#include "pitch.hh"
#include "stream-event.hh"
#include "translator.icc"
if (Pitch *pit = unsmob_pitch (defn))
{
SCM articulations = n->get_property ("articulations");
- Music *tie_event = 0;
+ Stream_event *tie_event = 0;
for (SCM s = articulations;
!tie_event && scm_is_pair (s);
s = scm_cdr (s))
{
- Music *m = unsmob_music (scm_car (s));
- if (!m)
+ Stream_event *ev = unsmob_stream_event (scm_car (s));
+ if (!ev)
continue;
- if (m->is_mus_type ("tie-event"))
- tie_event = m;
+ if (ev->in_event_class ("tie-event"))
+ tie_event = ev;
}
Audio_note *p = new Audio_note (*pit, get_event_length (n),
/*
TODO: probably broken.
*/
- script_ev_ = ev;
+ ASSIGN_EVENT_ONCE (script_ev_, ev);
}
IMPLEMENT_TRANSLATOR_LISTENER (Dynamic_engraver, span_dynamic);
{
Direction d = to_dir (ev->get_property ("span-direction"));
- accepted_spanevents_drul_[d] = ev;
- if (current_cresc_ev_ && d == START)
- accepted_spanevents_drul_[STOP] = ev;
+ if (d == START)
+ ASSIGN_EVENT_ONCE (accepted_spanevents_drul_[START], ev);
+
+ /* Cancel any ongoing crescendo, either explicitly by \! or
+ implicitly by a new crescendo. Also avoid warning if cresc is
+ cancelled both implicitly and explicitly. */
+ if ((d == STOP || current_cresc_ev_) && !accepted_spanevents_drul_[STOP])
+ ASSIGN_EVENT_ONCE (accepted_spanevents_drul_[STOP], ev);
}
void
#include "event-chord-iterator.hh"
#include "context.hh"
+#include "dispatcher.hh"
#include "duration.hh"
#include "input.hh"
#include "international.hh"
#include "music.hh"
#include "pitch.hh"
+#include "stream-event.hh"
#include "warn.hh"
Event_chord_iterator::Event_chord_iterator ()
Music *mus = unsmob_music (scm_car (s));
report_event (mus);
}
+ for (SCM s = get_music ()->get_property ("events");
+ scm_is_pair (s); s = scm_cdr (s))
+ {
+ Stream_event *ev = unsmob_stream_event (scm_car (s));
+ get_outlet ()->event_source ()->broadcast (ev);
+ }
}
Simple_music_iterator::process (m);
}
#include "engraver.hh"
#include "item.hh"
+#include "moment.hh"
#include "spanner.hh"
#include "stream-event.hh"
void
Bend_after_engraver::listen_bend_after (Stream_event *ev)
{
- fall_event_ = ev;
+ ASSIGN_EVENT_ONCE (fall_event_, ev);
}
void
Figured_bass_engraver::listen_rest (Stream_event *ev)
{
new_event_found_ = true;
- rest_event_ = ev;
+ ASSIGN_EVENT_ONCE (rest_event_, ev);
}
IMPLEMENT_TRANSLATOR_LISTENER (Figured_bass_engraver, bass_figure);
Figured_bass_engraver::listen_bass_figure (Stream_event *ev)
{
new_event_found_ = true;
- stop_moment_ = now_mom () + get_event_length (ev);
-
+ Moment stop = now_mom () + get_event_length (ev);
+ stop_moment_ = max (stop_moment_, stop);
+
SCM fig = ev->get_property ("figure");
for (vsize i = 0; i < groups_.size (); i++)
{
#include "engraver.hh"
#include "context.hh"
-#include "music.hh"
#include "spanner.hh"
#include "side-position-interface.hh"
#include "translator.icc"
*/
#include "engraver.hh"
-#include "spanner.hh"
+#include "moment.hh"
#include "pointer-group-interface.hh"
+#include "spanner.hh"
#include "translator.icc"
#include "stream-event.hh"
#include "warn.hh"
+/* ASSIGN_EVENT_ONCE */
+#include "translator.icc"
+
/*
* This abstract class is the common superclass for all ligature
* engravers for Gregorian chant notation. It cares for the musical
void
Gregorian_ligature_engraver::listen_pes_or_flexa (Stream_event *ev)
{
- pes_or_flexa_req_ = ev;
+ ASSIGN_EVENT_ONCE (pes_or_flexa_req_, ev);
}
void fix_prefix (char *name, int mask,
origin_trans_ = 0;
}
-/* ES TODO: Junk this when no more engravers use try_music */
-Music *
-Grob_info::music_cause () const
-{
- SCM cause = grob_->get_property ("cause");
-
- Music *ret = unsmob_music (cause);
- if (ret)
- return ret;
- else
- {
- Stream_event *ev = unsmob_stream_event (cause);
- if (!ev)
- return 0;
- return unsmob_music (ev->get_property ("music-cause"));
- }
-}
-
Stream_event *
Grob_info::event_cause () const
{
}
return unsmob_stream_event (cause);
}
-
-/*
-ES TODO: Junk this when no more engraver uses try_music
-*/
-Music *
-Grob_info::ultimate_music_cause () const
-{
- SCM cause = grob_->self_scm ();
- while (unsmob_grob (cause))
- {
- cause = unsmob_grob (cause)->get_property ("cause");
- }
-
- Music *ret = unsmob_music (cause);
- if (ret)
- return ret;
- else
- {
- Stream_event *ev = unsmob_stream_event (cause);
- return unsmob_music (ev->get_property ("music-cause"));
- }
-}
void
Grob_pq_engraver::acknowledge_grob (Grob_info gi)
{
- Music *m = gi.music_cause ();
+ Stream_event *ev = gi.event_cause ();
- if (m
+ if (ev
&& !gi.grob ()->internal_has_interface (ly_symbol2scm ("multi-measure-interface")))
{
Moment n = now_mom ();
- Moment l = m->get_length ();
+ Moment l = get_event_length (ev);
if (!l.to_bool ())
return;
Context_handle ();
void set_context (Context *);
- bool try_music (Music *);
void operator = (Context_handle const &);
Context_handle (Context_handle const &);
Context *get_outlet () const;
void add_context (Context *trans);
bool is_bottom_context () const;
bool is_removable () const;
- bool try_music (Music *);
Context *find_create_context (SCM context_name,
string id, SCM ops);
#ifndef ENGRAVER_HH
#define ENGRAVER_HH
-#include "music.hh"
#include "grob-info.hh"
#include "translator.hh"
Context *context () const;
Stream_event *event_cause () const;
- Music *music_cause () const;
Stream_event *ultimate_event_cause () const;
- Music *ultimate_music_cause () const;
vector<Context*> origin_contexts (Translator *) const;
Grob_info (Translator *, Grob *);
Grob_info ();
#include "engraver.hh"
#include "listener.hh"
+#include "moment.hh"
#include "stream-event.hh"
class Paper_column_engraver : public Engraver
Stream_event ();
VIRTUAL_COPY_CONSTRUCTOR (Stream_event, Stream_event);
// todo: remove unneeded constructors
- Stream_event (SCM event_class, SCM mutable_props);
- Stream_event (SCM property_alist);
+ Stream_event (SCM event_class, SCM mutable_props=SCM_EOL);
Stream_event (SCM class_name, Input *);
Stream_event (Stream_event *ev);
SCM protected_events_;
DECLARE_LISTENER (create_child_translator);
- DECLARE_LISTENER (eat_event);
public:
VIRTUAL_COPY_CONSTRUCTOR (Translator_group, Translator_group);
virtual void disconnect_from_context ();
virtual Translator_group *get_daddy_translator ()const;
virtual SCM get_simple_trans_list ();
- virtual bool try_music (Music *req);
virtual void initialize ();
virtual void finalize ();
Context *context () const { return context_; }
protected:
SCM simple_trans_list_;
- SCM accept_hash_table_;
Context *context_;
friend class Context_def;
virtual Translator_group *get_daddy_translator ()const;
virtual Moment now_mom () const;
- virtual bool try_music (Music *req);
virtual void initialize ();
virtual void finalize ();
Ligature_engraver::listen_ligature (Stream_event *ev)
{
Direction d = to_dir (ev->get_property ("span-direction"));
- events_drul_[d] = ev;
+ ASSIGN_EVENT_ONCE (events_drul_[d], ev);
}
void
exit (2);
}
- if ((file_name != "-") && global_path.find (file_name).empty ())
+ if ((file_name != "-") && file_name.empty ())
{
- warning (_f ("can't find file: `%s'", file_name));
+ warning (_f ("can't find file: `%s'", file));
scm_throw (ly_symbol2scm ("ly-file-failed"),
scm_list_1 (scm_makfrom0str (file_name.c_str ())));
}
Lyric_combine_music_iterator::set_busy (SCM se)
{
Stream_event *e = unsmob_stream_event (se);
- SCM mus = e->get_property ("music");
- Music *m = unsmob_music (mus);
- assert (m);
- if (m->is_mus_type ("note-event") || m->is_mus_type ("cluster-note-event"))
+ if (e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
busy_ = true;
}
{
if (music_context_)
{
- music_context_->event_source()->remove_listener (GET_LISTENER (set_busy), ly_symbol2scm ("OldMusicEvent"));
+ music_context_->event_source()->remove_listener (GET_LISTENER (set_busy), ly_symbol2scm ("music-event"));
lyrics_context_->unset_property (ly_symbol2scm ("associatedVoiceContext"));
}
music_context_ = to;
if (to)
{
- to->event_source()->add_listener (GET_LISTENER (set_busy), ly_symbol2scm ("OldMusicEvent"));
+ to->event_source()->add_listener (GET_LISTENER (set_busy), ly_symbol2scm ("music-event"));
lyrics_context_->set_property ("associatedVoiceContext", to->self_scm ());
}
}
void
Mark_engraver::listen_mark (Stream_event *ev)
{
- mark_ev_ = ev;
+ ASSIGN_EVENT_ONCE (mark_ev_, ev);
}
/*
#include "engraver.hh"
#include "grob.hh"
#include "context.hh"
+#include "music.hh"
#include "translator.icc"
/* Remove this translator. */
#include "font-interface.hh"
#include "international.hh"
#include "mensural-ligature.hh"
-#include "music.hh"
#include "note-column.hh"
#include "note-head.hh"
#include "output-def.hh"
#include "paper-column.hh"
+#include "pitch.hh"
#include "rhythmic-head.hh"
#include "spanner.hh"
#include "staff-symbol-referencer.hh"
Item *primitive = dynamic_cast<Item *> (info.grob ());
int duration_log = Note_head::get_balltype (primitive);
- Music *nr = info.music_cause ();
+ Stream_event *nr = info.event_cause ();
/*
ugh. why not simply check for pitch?
*/
- if (!nr->is_mus_type ("note-event"))
+ if (!nr->in_event_class ("note-event"))
{
nr->origin ()->warning
(_f ("cannot determine pitch of ligature primitive -> skipping"));
}
// b. descendens longa or brevis
else if (i < s - 1
- && (unsmob_pitch (primitives[i + 1].music_cause ()
+ && (unsmob_pitch (primitives[i + 1].event_cause ()
->get_property ("pitch"))->steps () < pitch)
&& duration_log > -3)
{
#include "engraver.hh"
-#include "item.hh"
#include "context.hh"
-#include "grob-array.hh"
#include "duration.hh"
+#include "grob-array.hh"
+#include "item.hh"
+#include "stream-event.hh"
+
+#include "translator.icc"
/**
put stuff over or next to bars. Examples: bar numbers, marginal notes,
last_count_ = count;
}
-#include "translator.icc"
-
ADD_TRANSLATOR (Metronome_mark_engraver,
/* doc */ "Engrave metro nome marking. This delegates the formatting work "
"to the function in the metronomeMarkFormatter property. "
void
Multi_measure_rest_engraver::listen_multi_measure_rest (Stream_event *ev)
{
+ /* FIXME: Should use ASSIGN_EVENT_ONCE. Can't do that yet because of
+ the kill-mm-rests hack in part-combine-iterator. */
rest_ev_ = ev;
stop_moment_ = now_mom () + get_event_length (rest_ev_);
+ /*
+ if (ASSIGN_EVENT_ONCE (rest_ev_, ev))
+ stop_moment_ = now_mom () + get_event_length (rest_ev_);
+ */
}
IMPLEMENT_TRANSLATOR_LISTENER (Multi_measure_rest_engraver, multi_measure_text);
FIXME: then don't do it.
*/
if (!m->is_mus_type ("event"))
- m->origin ()->programming_error (_f ("Sending non-event to context"));
+ m->origin ()->programming_error (_ ("Sending non-event to context"));
m->send_to_context (get_outlet ());
}
out[outpos] = 0;
SCM class_name = ly_symbol2scm (out);
- // catch mistakes.
+ // catch programming mistakes.
if (!internal_is_music_type (class_name))
{
programming_error ("Not a music type");
if (length.to_bool ())
e->set_property ("length", length.smobbed_copy ());
+ // articulations as events.
+ SCM art_mus = e->get_property ("articulations");
+ if (scm_is_pair (art_mus))
+ {
+ SCM art_ev = SCM_EOL;
+ for (; scm_is_pair (art_mus); art_mus = scm_cdr (art_mus))
+ {
+ Music *m = unsmob_music (scm_car (art_mus));
+ SCM ev = m ? m->to_event ()->unprotect () : scm_car (art_mus);
+ art_ev = scm_cons (ev, art_ev);
+ }
+ e->set_property ("articulations", scm_reverse_x (art_ev, SCM_EOL));
+ }
+
/*
ES TODO: This is a temporary fix. Stream_events should not be
aware of music.
*/
e->set_property ("music-cause", self_scm ());
+
return e;
}
void
Music::send_to_context (Context *c)
{
- /*
- TODO: This is a work-in-progress solution. Send the event so it
- can be read both by old-style translators and the new ones.
- */
- send_stream_event (c, "OldMusicEvent", origin (),
- ly_symbol2scm("music"), self_scm (), 0);
-
Stream_event *ev = to_event ();
c->event_source ()->broadcast (ev);
ev->unprotect ();
#include "self-alignment-interface.hh"
#include "side-position-interface.hh"
#include "stem.hh"
-#include "stem.hh"
+#include "stream-event.hh"
#include "warn.hh"
#include "translator.icc"
{
Grob *head_;
Grob *script_;
- Music *note_event_;
- Music *finger_event_;
+ Stream_event *note_event_;
+ Stream_event *finger_event_;
bool follow_into_staff_;
int position_;
void stop_translation_timestep ();
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 add_fingering (Grob *, Stream_event *, Stream_event *);
+ void add_script (Grob *, Stream_event *, Stream_event *);
+ void add_string (Grob *, Stream_event *, Stream_event *);
void position_scripts (SCM orientations, vector<Finger_tuple> *);
};
void
New_fingering_engraver::acknowledge_rhythmic_head (Grob_info inf)
{
- Music *note_ev = inf.music_cause ();
+ Stream_event *note_ev = inf.event_cause ();
if (!note_ev)
return;
for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
{
- Music *m = unsmob_music (scm_car (s));
+ Stream_event *ev = unsmob_stream_event (scm_car (s));
- if (!m)
+ if (!ev)
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"))
+ if (ev->in_event_class ("fingering-event"))
+ add_fingering (inf.grob (), ev, note_ev);
+ else if (ev->in_event_class ("text-script-event"))
+ ev->origin ()->warning (_ ("can't add text scripts to individual note heads"));
+ else if (ev->in_event_class ("script-event"))
+ add_script (inf.grob (), ev, note_ev);
+ else if (ev->in_event_class ("string-number-event"))
+ add_string (inf.grob (), ev, note_ev);
+ else if (ev->in_event_class ("harmonic-event"))
{
inf.grob ()->set_property ("style", ly_symbol2scm ("harmonic"));
Grob *d = unsmob_grob (inf.grob ()->get_object ("dot"));
void
New_fingering_engraver::add_script (Grob *head,
- Music *event,
- Music *note)
+ Stream_event *event,
+ Stream_event *note)
{
(void) note;
void
New_fingering_engraver::add_fingering (Grob *head,
- Music *event,
- Music *hevent)
+ Stream_event *event,
+ Stream_event *hevent)
{
Finger_tuple ft;
void
New_fingering_engraver::add_string (Grob *head,
- Music *event,
- Music *hevent)
+ Stream_event *event,
+ Stream_event *hevent)
{
Finger_tuple ft;
#include "duration.hh"
#include "item.hh"
#include "output-def.hh"
+#include "pitch.hh"
#include "rhythmic-head.hh"
#include "staff-symbol-referencer.hh"
#include "stream-event.hh"
#include "engraver.hh"
#include "item.hh"
+#include "pitch.hh"
#include "stream-event.hh"
#include "translator.icc"
#include "audio-item.hh"
#include "audio-column.hh"
#include "global-context.hh"
-#include "music.hh"
#include "stream-event.hh"
#include "warn.hh"
if (Pitch *pitp = unsmob_pitch (pit))
{
SCM articulations = n->get_property ("articulations");
- Music *tie_event = 0;
+ Stream_event *tie_event = 0;
for (SCM s = articulations;
!tie_event && scm_is_pair (s);
s = scm_cdr (s))
{
- Music *m = unsmob_music (scm_car (s));
- if (!m)
+ Stream_event *ev = unsmob_stream_event (scm_car (s));
+ if (!ev)
continue;
- if (m->is_mus_type ("tie-event"))
- tie_event = m;
+ if (ev->in_event_class ("tie-event"))
+ tie_event = ev;
}
Audio_note *p = new Audio_note (*pitp, get_event_length (n),
#include "engraver.hh"
-#include "warn.hh"
-#include "simple-closure.hh"
-#include "music.hh"
#include "grob.hh"
#include "item.hh"
#include "pointer-group-interface.hh"
+#include "simple-closure.hh"
+#include "stream-event.hh"
+#include "warn.hh"
#include "translator.icc"
void
Parenthesis_engraver::acknowledge_grob (Grob_info info)
{
- if (Music *music = info.music_cause ())
+ if (Stream_event *ev = info.event_cause ())
{
- if (to_boolean (music->get_property ("parenthesize")))
+ if (to_boolean (ev->get_property ("parenthesize")))
{
if (Item *victim = dynamic_cast<Item*> (info.grob ()))
{
void
Part_combine_engraver::listen_part_combine (Stream_event *ev)
{
- event_ = ev;
+ ASSIGN_EVENT_ONCE (event_, ev);
}
Part_combine_engraver::Part_combine_engraver ()
#include "music-sequence.hh"
#include "warn.hh"
+typedef enum Outlet_type
+ {
+ CONTEXT_ONE, CONTEXT_TWO, CONTEXT_SHARED, CONTEXT_SOLO, CONTEXT_NULL, NUM_OUTLETS
+ };
+
+static const char *outlet_names_[NUM_OUTLETS] =
+ {"one", "two", "shared", "solo", "null"};
+
class Part_combine_iterator : public Music_iterator
{
public:
/*
TODO: this is getting of hand...
*/
- Context_handle one_;
- Context_handle two_;
- Context_handle null_;
- Context_handle shared_;
- Context_handle solo_;
+ Context_handle handles_[NUM_OUTLETS];
- void substitute_both (Context *to1,
- Context *to2);
+ void substitute_both (Outlet_type to1,
+ Outlet_type to2);
- void kill_mmrest (Context *);
+ /* parameter is really Outlet_type */
+ void kill_mmrest (int in);
void chords_together ();
void solo1 ();
void solo2 ();
if (second_iter_)
second_iter_->quit ();
- null_.set_context (0);
- one_.set_context (0);
- two_.set_context (0);
- shared_.set_context (0);
- solo_.set_context (0);
+ // Add listeners to all contexts except Devnull.
+ for (int i = 0; i < NUM_OUTLETS; i++)
+ {
+ Context *c = handles_[i].get_outlet ();
+ if (c->is_alias (ly_symbol2scm ("Voice")))
+ c->event_source ()->remove_listener (GET_LISTENER (set_busy), ly_symbol2scm ("music-event"));
+ handles_[i].set_context (0);
+ }
}
Part_combine_iterator::Part_combine_iterator ()
playing_state_ = TOGETHER;
state_ = TOGETHER;
- substitute_both (shared_.get_outlet (), shared_.get_outlet ());
+ substitute_both (CONTEXT_SHARED, CONTEXT_SHARED);
}
}
void
-Part_combine_iterator::kill_mmrest (Context *tg)
+Part_combine_iterator::kill_mmrest (int in)
{
- static Music *mmrest;
+ static Stream_event *mmrest;
if (!mmrest)
{
- mmrest = make_music_by_name (ly_symbol2scm ("MultiMeasureRestEvent"));
+ mmrest = new Stream_event (ly_symbol2scm ("multi-measure-rest-event"));
mmrest->set_property ("duration", SCM_EOL);
}
- mmrest->send_to_context (tg);
+ handles_[in].get_outlet ()->event_source ()->broadcast (mmrest);
}
void
else
{
state_ = SOLO1;
- substitute_both (solo_.get_outlet (),
- null_.get_outlet ());
+ substitute_both (CONTEXT_SOLO, CONTEXT_NULL);
- kill_mmrest (two_.get_outlet ());
- kill_mmrest (shared_.get_outlet ());
+ kill_mmrest (CONTEXT_TWO);
+ kill_mmrest (CONTEXT_SHARED);
if (playing_state_ != SOLO1)
{
- static Music *event;
+ static Stream_event *event;
if (!event)
- event = make_music_by_name (ly_symbol2scm ("SoloOneEvent"));
+ event = new Stream_event (ly_symbol2scm ("solo1-event"));
- event->send_to_context (first_iter_->get_outlet ());
+ first_iter_->get_outlet ()->event_source ()->broadcast (event);
}
playing_state_ = SOLO1;
}
}
void
-Part_combine_iterator::substitute_both (Context *to1,
- Context *to2)
+Part_combine_iterator::substitute_both (Outlet_type to1,
+ Outlet_type to2)
{
- Context *tos[] = {to1, to2};
+ Outlet_type tos[] = {to1, to2};
+
Music_iterator *mis[] = {first_iter_, second_iter_};
- Context_handle *hs[]
- = {
- &null_,
- &one_, &two_,
- &shared_, &solo_,
- 0
- };
for (int i = 0; i < 2; i++)
{
- for (int j = 0; hs[j]; j++)
- if (hs[j]->get_outlet () != tos[i])
- mis[i]->substitute_outlet (hs[j]->get_outlet (), tos[i]);
+ for (int j = 0; j < NUM_OUTLETS; j++)
+ if (j != tos[i])
+ mis[i]->substitute_outlet (handles_[j].get_outlet (), handles_[tos[i]].get_outlet ());
}
- for (int j = 0; hs[j]; j++)
+ for (int j = 0; j < NUM_OUTLETS; j++)
{
- Context *t = hs[j]->get_outlet ();
- if (t != to1 && t != to2)
- kill_mmrest (t);
+ if (j != to1 && j != to2)
+ kill_mmrest (j);
}
}
in the 1st voice, so in that case, we use the second voice
as a basis for events.
*/
- Context *c1 = (last_playing_ == SOLO2) ? null_.get_outlet () : shared_.get_outlet ();
- Context *c2 = (last_playing_ == SOLO2) ? shared_.get_outlet () : null_.get_outlet ();
+ Outlet_type c1 = (last_playing_ == SOLO2) ? CONTEXT_NULL : CONTEXT_SHARED;
+ Outlet_type c2 = (last_playing_ == SOLO2) ? CONTEXT_SHARED : CONTEXT_NULL;
substitute_both (c1, c2);
kill_mmrest ((last_playing_ == SOLO2)
- ? one_.get_outlet () : two_.get_outlet ());
- kill_mmrest (shared_.get_outlet ());
+ ? CONTEXT_ONE : CONTEXT_TWO);
+ kill_mmrest (CONTEXT_SHARED);
if (playing_state_ != UNISONO
&& newstate == UNISONO)
{
- static Music *event;
+ static Stream_event *event;
if (!event)
- event = make_music_by_name (ly_symbol2scm ("UnisonoEvent"));
+ event = new Stream_event (ly_symbol2scm ("unisono-event"));
+
Context *out = (last_playing_ == SOLO2 ? second_iter_ : first_iter_)
->get_outlet ();
- event->send_to_context (out);
+ out->event_source ()->broadcast (event);
playing_state_ = UNISONO;
}
state_ = newstate;
{
state_ = SOLO2;
- substitute_both (null_.get_outlet (), solo_.get_outlet ());
+ substitute_both (CONTEXT_NULL, CONTEXT_SOLO);
if (playing_state_ != SOLO2)
{
- static Music *event;
+ static Stream_event *event;
if (!event)
- event = make_music_by_name (ly_symbol2scm ("SoloTwoEvent"));
+ event = new Stream_event (ly_symbol2scm ("solo2-event"));
- event->send_to_context (second_iter_->get_outlet ());
+ second_iter_->get_outlet ()->event_source ()->broadcast (event);
playing_state_ = SOLO2;
}
}
else
{
state_ = APART;
- substitute_both (one_.get_outlet (), two_.get_outlet ());
+ substitute_both (CONTEXT_ONE, CONTEXT_TWO);
}
}
{
start_moment_ = get_outlet ()->now_mom ();
split_list_ = get_music ()->get_property ("split-list");
- SCM lst = get_music ()->get_property ("elements");
-
- SCM props = scm_list_n (/*
- used to have tweaks here.
- */
- SCM_UNDEFINED);
+ Context *c = get_outlet ();
- Context *tr
- = get_outlet ()->find_create_context (ly_symbol2scm ("Voice"),
- "shared", props);
-
- shared_.set_context (tr);
-
- /*
- If we don't, we get a new staff for every Voice.
- */
- set_context (tr);
-
- Context *solo_tr
- = get_outlet ()->find_create_context (ly_symbol2scm ("Voice"),
- "solo", props);
-
- solo_.set_context (solo_tr);
-
- Context *null
- = get_outlet ()->find_create_context (ly_symbol2scm ("Devnull"),
- "", SCM_EOL);
-
- if (!null)
- programming_error ("no Devnull found");
-
- null_.set_context (null);
-
- Context *one = tr->find_create_context (ly_symbol2scm ("Voice"),
- "one", props);
-
- one_.set_context (one);
+ for (int i = 0; i < NUM_OUTLETS; i++)
+ {
+ SCM type = (i == CONTEXT_NULL) ? ly_symbol2scm ("Devnull") : ly_symbol2scm ("Voice");
+ /* find context below c: otherwise we may create new staff for each voice */
+ c = c->find_create_context (type, outlet_names_[i], SCM_EOL);
+ handles_[i].set_context (c);
+ if (c->is_alias (ly_symbol2scm ("Voice")))
+ c->event_source ()->add_listener (GET_LISTENER (set_busy), ly_symbol2scm ("music-event"));
+ }
+ SCM lst = get_music ()->get_property ("elements");
+ Context *one = handles_[CONTEXT_ONE].get_outlet ();
set_context (one);
first_iter_ = unsmob_iterator (get_iterator (unsmob_music (scm_car (lst))));
-
- Context *two = tr->find_create_context (ly_symbol2scm ("Voice"),
- "two", props);
- two_.set_context (two);
+ Context *two = handles_[CONTEXT_TWO].get_outlet ();
set_context (two);
second_iter_ = unsmob_iterator (get_iterator (unsmob_music (scm_cadr (lst))));
- set_context (tr);
-
char const *syms[]
= {
"Stem",
0
};
- // Add listeners to all contexts except Devnull.
- Context *contexts[] = {one, two, solo_tr, tr, 0};
- for (int i = 0; contexts[i]; i++)
- {
- contexts[i]->event_source ()->add_listener (GET_LISTENER (set_busy), ly_symbol2scm ("OldMusicEvent"));
- }
-
for (char const **p = syms; *p; p++)
{
SCM sym = ly_symbol2scm (*p);
return;
Stream_event *e = unsmob_stream_event (se);
- SCM mus = e->get_property ("music");
- Music *m = unsmob_music (mus);
- assert (m);
- if (m->is_mus_type ("note-event") || m->is_mus_type ("cluster-note-event"))
+ if (e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
busy_ = true;
}
Moment body_length = get_event_length (ev);
Moment meas_len (robust_scm2moment (get_property ("measureLength"),
Moment (1)));
-
if (meas_len == body_length)
- {
- repeat_sign_type_ = MEASURE;
- start_mom_ = now_mom ();
- stop_mom_ = now_mom () + body_length;
- get_global_context ()->add_moment_to_process (stop_mom_);
- }
+ {
+ repeat_sign_type_ = MEASURE;
+ start_mom_ = now_mom ();
+ stop_mom_ = now_mom () + body_length;
+ get_global_context ()->add_moment_to_process (stop_mom_);
+ }
else if (Moment (2) * meas_len == body_length)
- {
- repeat_sign_type_ = DOUBLE_MEASURE;
- start_mom_ = now_mom () + meas_len;
- stop_mom_ = now_mom () + body_length; /* never used */
- get_global_context ()->add_moment_to_process (start_mom_);
- }
+ {
+ repeat_sign_type_ = DOUBLE_MEASURE;
+ start_mom_ = now_mom () + meas_len;
+ stop_mom_ = now_mom () + body_length; /* never used */
+ get_global_context ()->add_moment_to_process (start_mom_);
+ }
else
- return;
-
+ {
+ ev->origin ()->warning (_ ("Junking percent repeat event: Duration must be exactly one or two measures"));
+ return;
+ }
percent_event_ = ev;
}
+ else
+ /* print a warning: no assignment happens because
+ percent_event_ != 0 */
+ ASSIGN_EVENT_ONCE (percent_event_, ev);
}
void
*/
Direction d = to_dir (ev->get_property ("span-direction"));
if (d == START)
- events_[START] = ev;
+ ASSIGN_EVENT_ONCE (events_[START], ev);
else if (d == STOP && !slurs_.empty ())
- events_[STOP] = ev;
+ ASSIGN_EVENT_ONCE (events_[STOP], ev);
}
void
IMPLEMENT_TRANSLATOR_LISTENER (Piano_pedal_engraver, sostenuto);
void
-Piano_pedal_engraver::listen_sostenuto (Stream_event *r)
+Piano_pedal_engraver::listen_sostenuto (Stream_event *ev)
{
- Direction d = to_dir (r->get_property ("span-direction"));
- info_list_[SOSTENUTO].event_drul_[d] = r;
+ Direction d = to_dir (ev->get_property ("span-direction"));
+ ASSIGN_EVENT_ONCE (info_list_[SOSTENUTO].event_drul_[d], ev);
}
IMPLEMENT_TRANSLATOR_LISTENER (Piano_pedal_engraver, sustain);
void
-Piano_pedal_engraver::listen_sustain (Stream_event *r)
+Piano_pedal_engraver::listen_sustain (Stream_event *ev)
{
- Direction d = to_dir (r->get_property ("span-direction"));
- info_list_[SUSTAIN].event_drul_[d] = r;
+ Direction d = to_dir (ev->get_property ("span-direction"));
+ ASSIGN_EVENT_ONCE (info_list_[SUSTAIN].event_drul_[d], ev);
}
IMPLEMENT_TRANSLATOR_LISTENER (Piano_pedal_engraver, una_corda);
void
-Piano_pedal_engraver::listen_una_corda (Stream_event *r)
+Piano_pedal_engraver::listen_una_corda (Stream_event *ev)
{
- Direction d = to_dir (r->get_property ("span-direction"));
- info_list_[UNA_CORDA].event_drul_[d] = r;
+ Direction d = to_dir (ev->get_property ("span-direction"));
+ ASSIGN_EVENT_ONCE (info_list_[UNA_CORDA].event_drul_[d], ev);
}
void
#include "engraver.hh"
-#include "dots.hh"
-#include "pointer-group-interface.hh"
#include "axis-group-interface.hh"
#include "context.hh"
-#include "note-head.hh"
+#include "dots.hh"
#include "item.hh"
-#include "side-position-interface.hh"
+#include "note-head.hh"
#include "pitch.hh"
+#include "pointer-group-interface.hh"
+#include "side-position-interface.hh"
+#include "stream-event.hh"
#include "warn.hh"
class Pitched_trill_engraver : public Engraver
vector<Grob*> heads_;
- void make_trill (Music *);
+ void make_trill (Stream_event *);
};
Pitched_trill_engraver::Pitched_trill_engraver ()
void
Pitched_trill_engraver::acknowledge_text_spanner (Grob_info info)
{
- Music *mus = info.music_cause ();
- if (mus
- && mus->is_mus_type ("trill-span-event")
- && to_dir (mus->get_property ("span-direction")) == START
- && unsmob_pitch (mus->get_property ("pitch")))
- make_trill (mus);
+ Stream_event *ev = info.event_cause ();
+ if (ev
+ && ev->in_event_class ("trill-span-event")
+ && to_dir (ev->get_property ("span-direction")) == START
+ && unsmob_pitch (ev->get_property ("pitch")))
+ make_trill (ev);
}
void
-Pitched_trill_engraver::make_trill (Music *mus)
+Pitched_trill_engraver::make_trill (Stream_event *ev)
{
- SCM scm_pitch = mus->get_property ("pitch");
+ SCM scm_pitch = ev->get_property ("pitch");
Pitch *p = unsmob_pitch (scm_pitch);
SCM keysig = get_property ("localKeySignature");
trill_head_ = 0;
}
- trill_head_ = make_item ("TrillPitchHead", mus->self_scm ());
+ trill_head_ = make_item ("TrillPitchHead", ev->self_scm ());
SCM c0scm = get_property ("middleCPosition");
int c0 = scm_is_number (c0scm) ? scm_to_int (c0scm) : 0;
scm_from_int (unsmob_pitch (scm_pitch)->steps ()
+ c0));
- trill_group_ = make_item ("TrillPitchGroup", mus->self_scm ());
+ trill_group_ = make_item ("TrillPitchGroup", ev->self_scm ());
trill_group_->set_parent (trill_head_, Y_AXIS);
Axis_group_interface::add_element (trill_group_, trill_head_);
if (print_acc)
{
- trill_accidental_ = make_item ("TrillPitchAccidental", mus->self_scm ());
+ trill_accidental_ = make_item ("TrillPitchAccidental", ev->self_scm ());
// fixme: naming -> alterations
trill_accidental_->set_property ("accidentals", scm_list_1 (scm_from_int (p->get_alteration ())));
source file of the GNU LilyPond music typesetter
(c) 2003--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
+
+TODO: junk this file
*/
#include "recording-group-engraver.hh"
#include "context.hh"
+#include "music.hh"
/*
TODO: Junk this class, extract events directly instead.
bool
Recording_group_engraver::try_music (Music *m)
{
- bool retval = Translator_group::try_music (m);
+ bool retval = true;//Translator_group::try_music (m);
add_music (m->self_scm (), ly_bool2scm (retval));
return retval;
else if (command == "prependdir")
prepend_env_path (variable.c_str (), value);
else
- error ( _f("Unknown relocation command %s", command));
+ error (_f ("Unknown relocation command %s", command));
}
fclose (f);
void
Repeat_tie_engraver::listen_repeat_tie (Stream_event *ev)
{
- event_ = ev;
+ ASSIGN_EVENT_ONCE (event_, ev);
}
void
#include "dots.hh"
#include "duration.hh"
#include "item.hh"
+#include "pitch.hh"
#include "rhythmic-head.hh"
#include "staff-symbol-referencer.hh"
#include "stream-event.hh"
#include "bar-line.hh"
#include "global-context.hh"
+#include "international.hh"
#include "item.hh"
#include "misc.hh"
#include "percent-repeat-iterator.hh"
= robust_scm2moment (get_property ("measureLength"), Moment (0));
if (get_event_length (ev) < meas_length)
- slash_ = ev;
+ ASSIGN_EVENT_ONCE (slash_, ev);
+ else
+ ev->origin ()->warning (_ ("Slash repeat doesn't fit in one measure, junking"));
}
void
{
Direction d = to_dir (ev->get_property ("span-direction"));
if (d == START)
- events_[START] = ev;
+ ASSIGN_EVENT_ONCE (events_[START], ev);
else if (d == STOP)
- events_[STOP] = ev;
+ ASSIGN_EVENT_ONCE (events_[STOP], ev);
+ else ev->origin ()->warning (_ ("Invalid direction of slur-event"));
}
void
*/
#include "engraver.hh"
+#include "moment.hh"
#include "note-spacing.hh"
#include "paper-column.hh"
#include "pointer-group-interface.hh"
void
Spacing_engraver::listen_spacing_section (Stream_event *ev)
{
- start_section_ = ev;
+ ASSIGN_EVENT_ONCE (start_section_, ev);
}
void
{
Direction d = to_dir (ev->get_property ("span-direction"));
if (d)
- span_events_[d] = ev;
+ ASSIGN_EVENT_ONCE (span_events_[d], ev);
else
programming_error (_ ("staff-span event has no direction"));
}
void
Stem_engraver::listen_tremolo (Stream_event *ev)
{
- tremolo_ev_ = ev;
+ ASSIGN_EVENT_ONCE (tremolo_ev_, ev);
}
ADD_ACKNOWLEDGER (Stem_engraver, rhythmic_head);
#include "stream-event.hh"
LY_DEFINE (ly_make_stream_event, "ly:make-stream-event",
- 1, 0, 0, (SCM proplist),
- "Creates a stream event, with the given property list.\n" )
+ 1, 1, 0, (SCM cl, SCM proplist),
+ "Creates a stream event of class @var{cl} with the given mutable property list.\n" )
{
- SCM_ASSERT_TYPE (scm_list_p (proplist), proplist, SCM_ARG1, __FUNCTION__, "association list");
- Stream_event *e = new Stream_event (proplist);
+ SCM_ASSERT_TYPE (scm_is_symbol (cl), cl, SCM_ARG1, __FUNCTION__, "symbol");
+ if (proplist != SCM_UNDEFINED)
+ {
+ SCM_ASSERT_TYPE (scm_list_p (proplist), proplist, SCM_ARG2, __FUNCTION__, "association list");
+ }
+ else
+ proplist = SCM_EOL;
+ Stream_event *e = new Stream_event (cl, proplist);
return e->unprotect ();
}
return e->internal_get_property (sym);
}
+
+LY_DEFINE (ly_event_set_property, "ly:event-set-property!",
+ 3, 0, 0, (SCM ev, SCM sym, SCM val),
+ "Set property @var{sym} in event @var{ev} to @var{val}."){
+ Stream_event *sc = unsmob_stream_event (ev);
+ SCM_ASSERT_TYPE (sc, ev, SCM_ARG1, __FUNCTION__, "event");
+ return ly_prob_set_property_x (ev, sym, val);
+}
mutable_property_alist_ = mutable_props;
}
-Stream_event::Stream_event (SCM property_alist)
- : Prob (ly_symbol2scm ("Stream_event"), SCM_EOL)
-{
- mutable_property_alist_ = property_alist;
-}
-
Stream_event::Stream_event (SCM class_name, Input *origin)
: Prob (ly_symbol2scm ("Stream_event"),
scm_list_1 (scm_cons (ly_symbol2scm ("class"), class_name)))
#include "dots.hh"
#include "duration.hh"
#include "item.hh"
-#include "music.hh"
#include "output-def.hh"
+#include "pitch.hh"
#include "rhythmic-head.hh"
#include "score-engraver.hh"
#include "staff-symbol-referencer.hh"
for (SCM s = event->get_property ("articulations");
!tabstring_event && scm_is_pair (s); s = scm_cdr (s))
{
- Music *art = unsmob_music (scm_car (s));
+ Stream_event *art = unsmob_stream_event (scm_car (s));
- if (art->is_mus_type ("string-number-event"))
- tabstring_event = art->to_event ();
+ if (art->in_event_class ("string-number-event"))
+ tabstring_event = art;
}
if (!tabstring_event && j < tabstring_events_.size ())
}
ADD_TRANSLATOR (Tab_note_heads_engraver,
- /* doc */ "Generate one or more tablature noteheads from Music of type NoteEvent.",
+ /* doc */ "Generate one or more tablature noteheads from event of type NoteEvent.",
/* create */ "TabNoteHead Dots",
/* accept */ "note-event string-number-event",
/* read */ "middleCPosition stringTunings minimumFret tablatureFormat highStringOne stringOneTopmost",
Text_spanner_engraver::listen_text_span (Stream_event *ev)
{
Direction d = to_dir (ev->get_property ("span-direction"));
- event_drul_[d] = ev;
+ ASSIGN_EVENT_ONCE (event_drul_[d], ev);
}
void
ADD_ACKNOWLEDGER (Text_spanner_engraver, note_column);
ADD_TRANSLATOR (Text_spanner_engraver,
- /* doc */ "Create text spanner from a Music.",
+ /* doc */ "Create text spanner from an event.",
/* create */ "TextSpanner",
/* accept */ "text-span-event",
/* read */ "",
Moment end_moment_;
SCM tie_definition_;
Stream_event *tie_stream_event_;
- Music *tie_event_;
+ Stream_event *tie_event_;
Head_event_tuple ()
{
void
Tie_engraver::listen_tie (Stream_event *ev)
{
- event_ = ev;
+ ASSIGN_EVENT_ONCE (event_, ev);
}
void
SCM left_articulations = left_ev->get_property ("articulations");
- Music *tie_event = 0;
+ Stream_event *tie_event = 0;
Stream_event *tie_stream_event = event_;
for (SCM s = left_articulations;
!tie_event && !tie_stream_event && scm_is_pair (s);
s = scm_cdr (s))
{
- Music *m = unsmob_music (scm_car (s));
- if (!m)
+ Stream_event *ev = unsmob_stream_event (scm_car (s));
+ if (!ev)
continue;
- if (m->is_mus_type ("tie-event"))
- tie_event = m;
+ if (ev->in_event_class ("tie-event"))
+ tie_event = ev;
}
if (left_ev && (tie_event || tie_stream_event))
}
context_ = c;
- c->event_source ()->add_listener (GET_LISTENER (eat_event),
- ly_symbol2scm ("OldMusicEvent"));
c->event_source ()->add_listener (GET_LISTENER (create_child_translator),
ly_symbol2scm ("AnnounceNewContext"));
for (SCM tr_list = simple_trans_list_; scm_is_pair (tr_list); tr_list = scm_cdr (tr_list))
Translator *tr = unsmob_translator (scm_car (tr_list));
tr->disconnect_from_context (context_);
}
- context_->event_source ()->remove_listener (GET_LISTENER (eat_event),
- ly_symbol2scm ("OldMusicEvent"));
context_->event_source ()->remove_listener (GET_LISTENER (create_child_translator),
ly_symbol2scm ("AnnounceNewContext"));
context_ = 0;
{
}
-bool
-translator_accepts_any_of (Translator *tr, SCM ifaces)
-{
- SCM ack_ifs = scm_assoc (ly_symbol2scm ("events-accepted"),
- 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)
- return true;
- return false;
-}
-
-SCM
-find_accept_translators (SCM gravlist, SCM ifaces)
-{
- SCM l = SCM_EOL;
- for (SCM s = gravlist; scm_is_pair (s); s = scm_cdr (s))
- {
- Translator *tr = unsmob_translator (scm_car (s));
- if (translator_accepts_any_of (tr, ifaces))
- l = scm_cons (tr->self_scm (), l);
- }
- l = scm_reverse_x (l, SCM_EOL);
-
- return l;
-}
-
SCM
filter_performers (SCM ell)
{
DOWN);
}
-IMPLEMENT_LISTENER (Translator_group, eat_event);
-void
-Translator_group::eat_event (SCM sev)
-{
- Stream_event *ev = unsmob_stream_event (sev);
- SCM sm = ev->get_property ("music");
- Music *m = unsmob_music (sm);
- try_music (m);
-}
-
-bool
-Translator_group::try_music (Music *m)
-{
- SCM name = scm_sloppy_assq (ly_symbol2scm ("name"),
- m->get_property_alist (false));
-
- if (!scm_is_pair (name))
- return false;
-
- name = scm_cdr (name);
- SCM accept_list = scm_hashq_ref (accept_hash_table_, name, SCM_UNDEFINED);
- if (accept_list == SCM_BOOL_F)
- {
- accept_list = find_accept_translators (get_simple_trans_list (),
- m->get_property ("types"));
- scm_hashq_set_x (accept_hash_table_, name, accept_list);
- }
-
- for (SCM p = accept_list; scm_is_pair (p); p = scm_cdr (p))
- {
- Translator *t = unsmob_translator (scm_car (p));
- if (t && t->try_music (m))
- return true;
- }
-
- // We couldn't swallow the event in this context. Try parent.
- Context *p = context ()->get_parent_context ();
- // Global context's translator group is a dummy, so don't try it.
- if (p->get_parent_context())
- // ES todo: Make Translators listeners directly instead.
- return p->implementation ()->try_music (m);
- // 'junking event' warning is temporarily disabled during translator cleanup
- /*
- else
- // We have tried all possible contexts. Give up.
- m->origin ()->warning (_f ("junking event: `%s'", m->name ()));
- */
- return false;
-}
-
SCM
Translator_group::get_simple_trans_list ()
{
Translator_group::Translator_group ()
{
simple_trans_list_ = SCM_EOL;
- accept_hash_table_ = SCM_EOL;
protected_events_ = SCM_EOL;
context_ = 0;
smobify_self ();
-
- accept_hash_table_ = scm_c_make_hash_table (19);
}
void
Translator_group *me = (Translator_group *)SCM_CELL_WORD_1 (smob);
me->derived_mark ();
- scm_gc_mark (me->accept_hash_table_);
scm_gc_mark (me->protected_events_);
return me->simple_trans_list_;
}
must_be_last_ = src.must_be_last_;
}
-bool
-Translator::try_music (Music *)
-{
- return false;
-}
-
Moment
Translator::now_mom () const
{
}
/*
- this function has 2 properties
-
- - It is called before try_music ()
-
- - It is called before any user information enters the translators.
- (i.e. any \property or event is not processed yet.)
+ this function is called once each moment, before any user
+ information enters the translators. (i.e. no \property or event has
+ been processed yet.)
*/
void
Translator::start_translation_timestep ()
{
/* extract event class from function name */
const char *prefix = "listen_";
- assert (!strncmp (function, "listen_", strlen (prefix)));
- function += strlen (prefix);
- char ev_class[strlen (function) + 1];
- strcpy (ev_class, function);
- for (char *c = ev_class; *c; c++)
- if (*c == '_')
- *c = '-';
-
- new_ev->origin ()->warning (_f ("Two simultaneous %s events, junking this one", ev_class));
- (*old_ev)->origin ()->warning (_f ("Previous %s event here", ev_class));
+ string ev_class = function;
+ /* This assertion fails if EVENT_ASSIGNMENT was called outside a
+ translator listener. Don't do that. */
+ assert (0 == ev_class.find (prefix));
+
+ /* "listen_foo_bar" -> "foo-bar" */
+ ev_class.erase (0, strlen(prefix));
+ replace_all (ev_class, '_', '-');
+
+ new_ev->origin ()->warning (_f ("Two simultaneous %s events, junking this one", ev_class.c_str ()));
+ (*old_ev)->origin ()->warning (_f ("Previous %s event here", ev_class.c_str ()));
return false;
}
else
Trill_spanner_engraver::listen_trill_span (Stream_event *ev)
{
Direction d = to_dir (ev->get_property ("span-direction"));
- event_drul_[d] = ev;
+ ASSIGN_EVENT_ONCE (event_drul_[d], ev);
}
void
ADD_ACKNOWLEDGER (Trill_spanner_engraver, note_column);
ADD_TRANSLATOR (Trill_spanner_engraver,
- /* doc */ "Create trill spanner from a Music.",
+ /* doc */ "Create trill spanner from an event.",
/* create */ "TrillSpanner",
/* accept */ "trill-span-event",
/* read */ "",
(c) 1998--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
*/
-#include "tuplet-bracket.hh"
-#include "note-column.hh"
#include "beam.hh"
#include "engraver.hh"
+#include "international.hh"
+#include "note-column.hh"
#include "spanner.hh"
#include "stream-event.hh"
+#include "tuplet-bracket.hh"
+#include "warn.hh"
#include "translator.icc"
d.event_ = ev;
tuplets_.push_back (d);
}
- if (dir == STOP && tuplets_.size ())
+ else if (dir == STOP && tuplets_.size ())
{
stopped_tuplets_.push_back (tuplets_.back ());
tuplets_.pop_back ();
}
+ else
+ programming_error (_ ("invalid direction of tuplet-span-event"));
}
void
#include "engraver.hh"
-#include "music.hh"
#include "grob.hh"
+#include "stream-event.hh"
#include "translator.icc"
class Tweak_engraver : public Engraver
void
Tweak_engraver::acknowledge_grob (Grob_info info)
{
- if (Music *music = info.music_cause ())
+ if (Stream_event *ev = info.event_cause ())
{
- for (SCM s = music->get_property ("tweaks");
+ for (SCM s = ev->get_property ("tweaks");
scm_is_pair (s); s = scm_cdr (s))
{
info.grob ()->internal_set_property (scm_caar (s), scm_cdar (s));
ADD_ACKNOWLEDGER (Tweak_engraver, grob);
ADD_TRANSLATOR (Tweak_engraver,
- /* doc */ "Read the @code{tweaks} property from the originating Music event, and set properties." ,
+ /* doc */ "Read the @code{tweaks} property from the originating event, and set properties." ,
/* create */ "",
/* accept */ "",
(define-public (ly:make-event-class leaf)
(hashq-ref ancestor-lookup leaf))
+(define-public (ly:in-event-class? ev cl)
+ "Does event @var{ev} belong to event class @var{cl}?"
+ (memq cl (ly:make-event-class (ly:event-property ev 'class))))
+
;; does this exist in guile already?
(define (map-tree f t)
(cond
((pair? e) (cons (simplify (car e))
(simplify (cdr e))))
((ly:stream-event? e)
- (list 'unquote `(make-stream-event ,(simplify (Stream_event::dump e)))))
+ (list 'unquote (list 'make-stream-event (simplify (Stream_event::dump e)))))
((ly:music? e)
(list 'unquote (music->make-music e)))
((ly:moment? e)
;; TODO: should link back into user manual.
(define (mm-rest-child-list music)
- "Check if we have R1*4-\\markup { .. }, and if applicable convert to
-a property set for MultiMeasureRestNumber."
+ "Generate events for multimeasure rests, to be used by the sequential-iterator"
(let ((location (ly:music-property music 'origin))
(duration (ly:music-property music 'duration)))
(list (make-music 'BarCheck
;; Bass figures.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-public (format-bass-figure figure stream-event context)
- (let* ((event (ly:event-property stream-event 'music-cause ))
- (fig (ly:music-property event 'figure))
+(define-public (format-bass-figure figure event context)
+ (let* ((fig (ly:event-property event 'figure))
(fig-markup (if (number? figure)
;; this is not very elegant, but center-aligning all digits
(lambda (y) (make-translate-scaled-markup (cons -0.7 0) y))
identity)
- (if (eq? #t (ly:music-property event 'diminished))
+ (if (eq? #t (ly:event-property event 'diminished))
(markup #:slashed-digit figure)
(markup #:number (number->string figure 10))))
#f
))
- (alt (ly:music-property event 'alteration))
+ (alt (ly:event-property event 'alteration))
(alt-markup
(if (number? alt)
(markup
(alteration->text-accidental-markup alt))
#f))
- (plus-markup (if (eq? #t (ly:music-property event 'augmented))
+ (plus-markup (if (eq? #t (ly:event-property event 'augmented))
(markup #:number "+")
#f))
projects / lilypond.git / commitdiff