X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Flyric-combine-music-iterator.cc;h=336b167f2e98cdf2d4179b687330d1913b6d21b9;hb=5d84bfad4626892bcffd05adcced53c8a2329047;hp=aaccf2e2107bccd81438c580b05cc8efe612f136;hpb=a6a733a8e2f138a4c30d7abdff7b0372d9b9fb97;p=lilypond.git diff --git a/lily/lyric-combine-music-iterator.cc b/lily/lyric-combine-music-iterator.cc index aaccf2e210..336b167f2e 100644 --- a/lily/lyric-combine-music-iterator.cc +++ b/lily/lyric-combine-music-iterator.cc @@ -1,12 +1,22 @@ /* - new-lyric-combine-iterator.cc -- implement Lyric_combine_music_iterator + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 2004--2015 Han-Wen Nienhuys - (c) 2004--2006 Han-Wen Nienhuys + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ -#include "context.hh" #include "dispatcher.hh" #include "global-context.hh" #include "grob.hh" @@ -16,6 +26,20 @@ #include "music-iterator.hh" #include "music.hh" +/* + This iterator is hairy. It tracks both lyric and melody contexts, + and has a complicated communication route, reading/writing + properties in both. + + In the future, this should rather be done with + + \interpretAsMelodyFor { MUSIC } { LYRICS LYRICS LYRICS } + + This can run an interpret step on MUSIC, generating a stream. Then + the stream can be perused at leisure to apply durations to all of + the LYRICS. +*/ + class Lyric_combine_music_iterator : public Music_iterator { public: @@ -33,42 +57,53 @@ protected: virtual void derived_substitute (Context *, Context *); void set_music_context (Context *to); private: - bool start_new_syllable (); + bool start_new_syllable () const; Context *find_voice (); - DECLARE_LISTENER (set_busy); - DECLARE_LISTENER (check_new_context); + void set_busy (SCM); + void check_new_context (SCM); - bool pending_grace_lyric_; bool music_found_; + bool lyrics_found_; Context *lyrics_context_; Context *music_context_; SCM lyricsto_voice_name_; + SCM lyricsto_voice_type_; + + Moment busy_moment_; + Moment pending_grace_moment_; - bool busy_; Music_iterator *lyric_iter_; }; Lyric_combine_music_iterator::Lyric_combine_music_iterator () { music_found_ = false; - pending_grace_lyric_ = false; + lyrics_found_ = false; + pending_grace_moment_.set_infinite (1); lyric_iter_ = 0; music_context_ = 0; lyrics_context_ = 0; - busy_ = false; + busy_moment_.set_infinite (-1); + lyricsto_voice_name_ = SCM_UNDEFINED; + lyricsto_voice_type_ = SCM_UNDEFINED; } -IMPLEMENT_LISTENER (Lyric_combine_music_iterator, set_busy) +/* + It's dubious whether we can ever make this fully work. Due to + associatedVoice switching, this routine may be triggered for + the wrong music_context_ + */ void 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); + Stream_event *e = unsmob (se); + + if ((e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event")) + && music_context_) + + busy_moment_ = max (music_context_->now_mom (), + busy_moment_); - if (m->is_mus_type ("note-event") || m->is_mus_type ("cluster-note-event")) - busy_ = true; } void @@ -76,25 +111,24 @@ Lyric_combine_music_iterator::set_music_context (Context *to) { if (music_context_) { - music_context_->event_source()->remove_listener (GET_LISTENER (set_busy), ly_symbol2scm ("OldMusicEvent")); - lyrics_context_->unset_property (ly_symbol2scm ("associatedVoiceContext")); + music_context_->events_below ()-> + remove_listener (GET_LISTENER (Lyric_combine_music_iterator, set_busy), ly_symbol2scm ("rhythmic-event")); } + music_context_ = to; if (to) { - to->event_source()->add_listener (GET_LISTENER (set_busy), ly_symbol2scm ("OldMusicEvent")); - lyrics_context_->set_property ("associatedVoiceContext", to->self_scm ()); + to->events_below ()->add_listener (GET_LISTENER (Lyric_combine_music_iterator, set_busy), + ly_symbol2scm ("rhythmic-event")); } } bool -Lyric_combine_music_iterator::start_new_syllable () +Lyric_combine_music_iterator::start_new_syllable () const { - if (!busy_) + if (busy_moment_ < music_context_->now_mom ()) return false; - busy_ = false; - if (!lyrics_context_) return false; @@ -102,7 +136,7 @@ Lyric_combine_music_iterator::start_new_syllable () { bool m = melisma_busy (music_context_); if (m) - return false; + return false; } return true; @@ -127,7 +161,8 @@ Lyric_combine_music_iterator::run_always () const bool Lyric_combine_music_iterator::ok () const { - return lyric_iter_ && lyric_iter_->ok (); + return lyric_iter_ && lyric_iter_->ok () + && !(music_context_ && music_context_->is_removable ()); } void @@ -139,6 +174,8 @@ Lyric_combine_music_iterator::derived_mark ()const scm_gc_mark (lyrics_context_->self_scm ()); if (music_context_) scm_gc_mark (music_context_->self_scm ()); + scm_gc_mark (lyricsto_voice_name_); + scm_gc_mark (lyricsto_voice_type_); } void @@ -155,27 +192,33 @@ Lyric_combine_music_iterator::derived_substitute (Context *f, Context *t) void Lyric_combine_music_iterator::construct_children () { - Music *m = unsmob_music (get_music ()->get_property ("element")); - lyric_iter_ = unsmob_iterator (get_iterator (m)); + Music *m = unsmob (get_music ()->get_property ("element")); + lyric_iter_ = unsmob (get_iterator (m)); if (!lyric_iter_) return; lyrics_context_ = find_context_below (lyric_iter_->get_outlet (), - ly_symbol2scm ("Lyrics"), ""); + ly_symbol2scm ("Lyrics"), ""); + + if (!lyrics_context_) + { + m->origin ()->warning (_ ("argument of \\lyricsto should contain Lyrics context")); + } lyricsto_voice_name_ = get_music ()->get_property ("associated-context"); + lyricsto_voice_type_ = get_music ()->get_property ("associated-context-type"); + if (!scm_is_symbol (lyricsto_voice_type_)) + lyricsto_voice_type_ = ly_symbol2scm ("Voice"); Context *voice = find_voice (); if (voice) set_music_context (voice); - else - { - /* - Wait for a Create_context event. If this isn't done, lyrics can be - delayed when voices are created implicitly. - */ - Global_context *g = lyrics_context_->get_global_context (); - g->events_below ()->add_listener (GET_LISTENER (check_new_context), ly_symbol2scm ("CreateContext")); - } + + /* + Wait for a Create_context event. If this isn't done, lyrics can be + delayed when voices are created implicitly. + */ + Global_context *g = get_outlet ()->get_global_context (); + g->events_below ()->add_listener (GET_LISTENER (Lyric_combine_music_iterator, check_new_context), ly_symbol2scm ("CreateContext")); /* We do not create a Lyrics context, because the user might @@ -184,20 +227,18 @@ Lyric_combine_music_iterator::construct_children () */ } -IMPLEMENT_LISTENER (Lyric_combine_music_iterator, check_new_context) void -Lyric_combine_music_iterator::check_new_context (SCM sev) +Lyric_combine_music_iterator::check_new_context (SCM /*sev*/) { - // TODO: Check first if type=Voice and if id matches - (void)sev; + if (!ok ()) + return; + // Search for a possible candidate voice to attach the lyrics to. If none + // is found, we'll try next time again. Context *voice = find_voice (); if (voice) { set_music_context (voice); - - Global_context *g = voice->get_global_context (); - g->events_below ()->remove_listener (GET_LISTENER (check_new_context), ly_symbol2scm ("CreateContext")); } } @@ -213,66 +254,77 @@ Lyric_combine_music_iterator::find_voice () { SCM voice_name = lyricsto_voice_name_; SCM running = lyrics_context_ - ? lyrics_context_->get_property ("associatedVoice") - : SCM_EOL; - - if (scm_is_string (running)) + ? lyrics_context_->get_property ("associatedVoice") + : SCM_EOL; + SCM voice_type = lyricsto_voice_type_; + if (scm_is_string (running)) { voice_name = running; + voice_type = lyrics_context_->get_property ("associatedVoiceType"); + } if (scm_is_string (voice_name) - && (!music_context_ || ly_scm2string (voice_name) != music_context_->id_string ())) + && (!music_context_ || ly_scm2string (voice_name) != music_context_->id_string ()) + && scm_is_symbol (voice_type)) { - Context *t = get_outlet (); - while (t && t->get_parent_context ()) - t = t->get_parent_context (); - - string name = ly_scm2string (voice_name); - return find_context_below (t, ly_symbol2scm ("Voice"), name); + return find_context_below (find_top_context (get_outlet ()), + voice_type, ly_scm2string (voice_name)); } return 0; } void -Lyric_combine_music_iterator::process (Moment) +Lyric_combine_music_iterator::process (Moment /* when */) { /* see if associatedVoice has been changed */ Context *new_voice = find_voice (); if (new_voice) set_music_context (new_voice); + lyrics_found_ = true; if (!music_context_) return; if (!music_context_->get_parent_context ()) { /* - The melody has died. - We die too. + The melody has died. + We die too. */ if (lyrics_context_) - lyrics_context_->unset_property (ly_symbol2scm ("associatedVoiceContext")); + lyrics_context_->unset_property (ly_symbol2scm ("associatedVoiceContext")); lyric_iter_ = 0; set_music_context (0); } if (music_context_ - && (start_new_syllable () || pending_grace_lyric_) + && (start_new_syllable () + || (busy_moment_ >= pending_grace_moment_)) && lyric_iter_->ok ()) { - if (music_context_->now_mom ().grace_part_) - { - pending_grace_lyric_ = true; - return; - } + Moment now = music_context_->now_mom (); + if (now.grace_part_ && !to_boolean (lyrics_context_->get_property ("includeGraceNotes"))) + { + pending_grace_moment_ = now; + pending_grace_moment_.grace_part_ = Rational (0); + return; + } else - pending_grace_lyric_ = false; - + { + pending_grace_moment_.set_infinite (1); + } + Moment m = lyric_iter_->pending_moment (); + lyrics_context_->set_property (ly_symbol2scm ("associatedVoiceContext"), + music_context_->self_scm ()); lyric_iter_->process (m); music_found_ = true; } + + new_voice = find_voice (); + if (new_voice) + set_music_context (new_voice); } void @@ -281,13 +333,16 @@ Lyric_combine_music_iterator::do_quit () if (!music_found_) { SCM voice_name = get_music ()->get_property ("associated-context"); - - string name; + SCM voice_type = get_music ()->get_property ("associated-context-type"); + string name, type; if (scm_is_string (voice_name)) - name = ly_scm2string (voice_name); - - get_music ()->origin ()->warning (_f ("cannot find Voice `%s'", - name.c_str ()) + "\n"); + name = ly_scm2string (voice_name); + type = robust_symbol2string (voice_type, "Voice"); + /* Don't print a warning for empty lyrics (in which case we don't try + to find the proper voice, so it will not be found) */ + if (lyrics_found_) + get_music ()->origin ()->warning (_f ("cannot find %s `%s'", + type.c_str (), name.c_str ()) + "\n"); } if (lyric_iter_)