lily/lyric-combine-music-iterator.cc

   1 /*
   2   lyric-combine-music-iterator.cc --  implement Lyric_combine_music_iterator
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1999--2003 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7
   8  */
   9
  10 #include "translator-group.hh"
  11 #include "lyric-combine-music.hh"
  12 #include "event.hh"
  13 #include "note-head.hh"
  14 #include "grob.hh"
  15 #include "music-iterator.hh"
  16
  17 class Lyric_combine_music_iterator : public Music_iterator
  18 {
  19 public:
  20   VIRTUAL_COPY_CONS (Music_iterator);
  21   Lyric_combine_music_iterator ();
  22   Lyric_combine_music_iterator (Lyric_combine_music_iterator const&src);
  23   DECLARE_SCHEME_CALLBACK(constructor, ());
  24 protected:
  25   virtual void construct_children ();
  26   virtual Moment pending_moment () const;
  27   virtual void do_quit();
  28   virtual void process (Moment);
  29   virtual Music_iterator *try_music_in_children (Music *) const;
  30
  31   virtual bool ok () const;
  32   virtual void derived_mark () const;
  33 private:
  34   bool get_busy_status ()const ;
  35   bool  melisma_busy ();
  36
  37
  38   Music_iterator * music_iter_;
  39   Music_iterator * lyric_iter_;
  40 };
  41
  42
  43
  44 /*
  45   Ugh, why static?
  46  */
  47 Music *busy_req;
  48 Music *melisma_playing_req;
  49
  50 Lyric_combine_music_iterator::Lyric_combine_music_iterator ()
  51 {
  52   if (!busy_req)
  53     {
  54       busy_req
  55         = make_music_by_name (ly_symbol2scm ("BusyPlayingEvent"));
  56       melisma_playing_req
  57         = make_music_by_name (ly_symbol2scm ("MelismaPlayingEvent"));
  58     }
  59
  60   music_iter_ =0;
  61   lyric_iter_ =0;
  62 }
  63
  64 Moment
  65 Lyric_combine_music_iterator::pending_moment () const
  66 {
  67   Moment musnext = music_iter_->pending_moment ();
  68   return musnext;
  69 }
  70
  71 bool
  72 Lyric_combine_music_iterator::ok () const
  73 {
  74   return music_iter_->ok ();
  75 }
  76
  77 void
  78 Lyric_combine_music_iterator::derived_mark()const
  79 {
  80   if (music_iter_)
  81     scm_gc_mark (music_iter_->self_scm());
  82   if (lyric_iter_)
  83     scm_gc_mark (lyric_iter_->self_scm());
  84 }
  85
  86 void
  87 Lyric_combine_music_iterator::construct_children ()
  88 {
  89   Lyric_combine_music const * m = dynamic_cast<Lyric_combine_music const*> (get_music ());
  90
  91   music_iter_ = unsmob_iterator (get_iterator (m->get_music ()));
  92   lyric_iter_ = unsmob_iterator (get_iterator (m->get_lyrics ()));
  93 }
  94
  95 bool
  96 Lyric_combine_music_iterator::get_busy_status () const
  97 {
  98   /*
  99     We have to use both the event and the busyGrobs queue.  The
 100     busyGrobs queue doesn't contain any notes that have started this
 101     instant.  */
 102   if (try_music (busy_req))
 103     return true;
 104
 105   Translator_group * tr = music_iter_->report_to ();
 106
 107   SCM grobs = tr->get_property ("busyGrobs");
 108   Moment now = tr->now_mom();
 109   for (; gh_pair_p (grobs); grobs = gh_cdr (grobs))
 110     {
 111       SCM grob = gh_cdar (grobs);
 112       Moment end  =*unsmob_moment (gh_caar (grobs));
 113
 114
 115       /*
 116         This is slightly ugh: we are now confunding the frontend
 117         (iterators) and the backend (note heads) */
 118       if (end > now
 119           && Note_head::has_interface (unsmob_grob (grob)))
 120         return true;
 121     }
 122
 123   return false;
 124 }
 125
 126
 127 bool
 128 Lyric_combine_music_iterator::melisma_busy ()
 129 {
 130 #if 0
 131
 132   Translator_group * trg = music_iter_->report_to();
 133   bool melisma_busy= to_boolean (trg->get_property ("melismaBusy"));
 134
 135   melisma_busy = melisma_busy ||  to_boolean (trg->get_property ("slurMelismaBusy"));
 136   melisma_busy = melisma_busy ||  to_boolean (trg->get_property ("tieMelismaBusy"));
 137   melisma_busy = melisma_busy ||  to_boolean (trg->get_property ("beamMelismaBusy"));
 138   return melisma_busy;
 139
 140 #else
 141
 142   /*
 143     The above code is nicer since it doesn't rely on a special
 144     engraver to signal the melisma status. Unfortunately,
 145     music_iter_->report_to() might not be the context that sets the
 146     melisma properties, but rather a parent context.
 147    */
 148   return music_iter_->try_music (melisma_playing_req);
 149 #endif
 150
 151 }
 152
 153 void
 154 Lyric_combine_music_iterator::process (Moment m)
 155 {
 156   Moment my_next = music_iter_->pending_moment ();
 157   if (my_next > m)
 158     return;
 159
 160   music_iter_->process (m);
 161
 162   if (get_busy_status () && !melisma_busy () && lyric_iter_->ok ())
 163     {
 164       Moment m= lyric_iter_->pending_moment ();
 165       lyric_iter_->process (m);
 166     }
 167 }
 168
 169 void
 170 Lyric_combine_music_iterator::do_quit ()
 171 {
 172   if (music_iter_)
 173     music_iter_->quit();
 174   if (lyric_iter_)
 175     lyric_iter_->quit();
 176
 177 }
 178 Lyric_combine_music_iterator::Lyric_combine_music_iterator (Lyric_combine_music_iterator const & src)
 179     : Music_iterator (src)
 180 {
 181   lyric_iter_ = 0;
 182   music_iter_ = 0;
 183
 184   if (src.lyric_iter_)
 185     lyric_iter_ =  src.lyric_iter_->clone ();
 186   if (src.music_iter_)
 187     music_iter_ =  src.music_iter_->clone ();
 188
 189   if (lyric_iter_)
 190     scm_gc_unprotect_object (lyric_iter_->self_scm());
 191   if (music_iter_)
 192     scm_gc_unprotect_object (music_iter_->self_scm());
 193 }
 194
 195 Music_iterator*
 196 Lyric_combine_music_iterator::try_music_in_children (Music *m) const
 197 {
 198   Music_iterator * i =  music_iter_->try_music (m);
 199   if (i)
 200     return i;
 201   else
 202     return lyric_iter_->try_music (m);
 203 }
 204
 205
 206 IMPLEMENT_CTOR_CALLBACK (Lyric_combine_music_iterator);