lily/part-combine-iterator.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2004--2014 Han-Wen Nienhuys
   5
   6   LilyPond is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   LilyPond is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "context.hh"
  21 #include "dispatcher.hh"
  22 #include "lily-guile.hh"
  23 #include "music.hh"
  24 #include "music-iterator.hh"
  25 #include "music-sequence.hh"
  26 #include "warn.hh"
  27
  28 enum Outlet_type
  29 {
  30   CONTEXT_ONE, CONTEXT_TWO,
  31   CONTEXT_SHARED, CONTEXT_SOLO,
  32   CONTEXT_NULL, NUM_OUTLETS
  33 };
  34
  35 static const char *outlet_names_[NUM_OUTLETS]
  36   = {"one", "two", "shared", "solo", "null"};
  37
  38 class Part_combine_iterator : public Music_iterator
  39 {
  40 public:
  41   Part_combine_iterator ();
  42
  43   DECLARE_SCHEME_CALLBACK (constructor, ());
  44 protected:
  45   virtual void derived_substitute (Context *f, Context *t);
  46   virtual void derived_mark () const;
  47
  48   virtual void construct_children ();
  49   virtual Moment pending_moment () const;
  50   virtual void do_quit ();
  51   virtual void process (Moment);
  52
  53   virtual bool ok () const;
  54
  55 private:
  56   /* used by try_process */
  57   DECLARE_LISTENER (set_busy);
  58   bool busy_;
  59   bool notice_busy_;
  60
  61   bool try_process (Music_iterator *i, Moment m);
  62
  63   Music_iterator *first_iter_;
  64   Music_iterator *second_iter_;
  65   Moment start_moment_;
  66
  67   SCM split_list_;
  68   SCM direction_;
  69   SCM directionOne_;
  70   SCM directionTwo_;
  71   SCM horizontalShiftOne_;
  72   SCM horizontalShiftTwo_;
  73
  74   Stream_event *unisono_event_;
  75   Stream_event *solo_one_event_;
  76   Stream_event *solo_two_event_;
  77   Stream_event *mmrest_event_;
  78
  79   enum Status
  80   {
  81     APART,
  82     TOGETHER,
  83     SOLO1,
  84     SOLO2,
  85     UNISONO,
  86     UNISILENCE,
  87   };
  88   Status state_;
  89   Status playing_state_;
  90
  91   /*
  92     Should be SOLO1 or SOLO2
  93   */
  94   Status last_playing_;
  95
  96   /*
  97     TODO: this is getting off hand...
  98   */
  99   Context_handle handles_[NUM_OUTLETS];
 100
 101   void substitute_both (Outlet_type to1,
 102                         Outlet_type to2);
 103
 104   /* parameter is really Outlet_type */
 105   void kill_mmrest (int in);
 106   void chords_together ();
 107   void solo1 ();
 108   void solo2 ();
 109   void apart (bool silent);
 110   void unisono (bool silent);
 111 };
 112
 113 void
 114 Part_combine_iterator::do_quit ()
 115 {
 116   if (first_iter_)
 117     first_iter_->quit ();
 118   if (second_iter_)
 119     second_iter_->quit ();
 120
 121   // Add listeners to all contexts except Devnull.
 122   for (int i = 0; i < NUM_OUTLETS; i++)
 123     {
 124       Context *c = handles_[i].get_context ();
 125       if (c->is_alias (ly_symbol2scm ("Voice")))
 126         c->event_source ()->remove_listener (GET_LISTENER (set_busy), ly_symbol2scm ("music-event"));
 127       handles_[i].set_context (0);
 128     }
 129 }
 130
 131 Part_combine_iterator::Part_combine_iterator ()
 132 {
 133   mmrest_event_ = 0;
 134   unisono_event_ = 0;
 135   solo_two_event_ = 0;
 136   solo_one_event_ = 0;
 137
 138   first_iter_ = 0;
 139   second_iter_ = 0;
 140   split_list_ = SCM_EOL;
 141   direction_ = SCM_BOOL_F;
 142   directionOne_ = scm_from_int (1);
 143   directionTwo_ = scm_from_int (-1);
 144   horizontalShiftOne_ = scm_from_int (0);
 145   horizontalShiftTwo_ = scm_from_int (1);
 146   state_ = APART;
 147   playing_state_ = APART;
 148   last_playing_ = APART;
 149
 150   busy_ = false;
 151   notice_busy_ = false;
 152 }
 153
 154 void
 155 Part_combine_iterator::derived_mark () const
 156 {
 157   if (first_iter_)
 158     scm_gc_mark (first_iter_->self_scm ());
 159   if (second_iter_)
 160     scm_gc_mark (second_iter_->self_scm ());
 161   if (unisono_event_)
 162     scm_gc_mark (unisono_event_->self_scm ());
 163   if (mmrest_event_)
 164     scm_gc_mark (mmrest_event_->self_scm ());
 165   if (solo_one_event_)
 166     scm_gc_mark (solo_one_event_->self_scm ());
 167   if (solo_two_event_)
 168     scm_gc_mark (solo_two_event_->self_scm ());
 169 }
 170
 171 void
 172 Part_combine_iterator::derived_substitute (Context *f,
 173                                            Context *t)
 174 {
 175   if (first_iter_)
 176     first_iter_->substitute_outlet (f, t);
 177 }
 178
 179 Moment
 180 Part_combine_iterator::pending_moment () const
 181 {
 182   Moment p;
 183   p.set_infinite (1);
 184   if (first_iter_->ok ())
 185     p = min (p, first_iter_->pending_moment ());
 186
 187   if (second_iter_->ok ())
 188     p = min (p, second_iter_->pending_moment ());
 189   return p;
 190 }
 191
 192 bool
 193 Part_combine_iterator::ok () const
 194 {
 195   return first_iter_->ok () || second_iter_->ok ();
 196 }
 197
 198 void
 199 Part_combine_iterator::substitute_both (Outlet_type to1,
 200                                         Outlet_type to2)
 201 {
 202   Outlet_type tos[] = {to1, to2};
 203
 204   Music_iterator *mis[] = {first_iter_, second_iter_};
 205
 206   for (int i = 0; i < 2; i++)
 207     {
 208       for (int j = 0; j < NUM_OUTLETS; j++)
 209         if (j != tos[i])
 210           mis[i]->substitute_outlet (handles_[j].get_context (), handles_[tos[i]].get_context ());
 211     }
 212
 213   for (int j = 0; j < NUM_OUTLETS; j++)
 214     {
 215       if (j != to1 && j != to2)
 216         kill_mmrest (j);
 217     }
 218 }
 219
 220 void
 221 Part_combine_iterator::kill_mmrest (int in)
 222 {
 223
 224   if (!mmrest_event_)
 225     {
 226       mmrest_event_ = new Stream_event
 227         (scm_call_1 (ly_lily_module_constant ("ly:make-event-class"),
 228                      ly_symbol2scm ("multi-measure-rest-event")));
 229       mmrest_event_->set_property ("duration", SCM_EOL);
 230       mmrest_event_->unprotect ();
 231     }
 232
 233   handles_[in].get_context ()->event_source ()->broadcast (mmrest_event_);
 234 }
 235
 236 void
 237 Part_combine_iterator::unisono (bool silent)
 238 {
 239   Status newstate = (silent) ? UNISILENCE : UNISONO;
 240
 241   if (newstate == state_)
 242     return;
 243   else
 244     {
 245       /*
 246         If we're coming from SOLO2 state, we might have kill mmrests
 247         in the 1st voice, so in that case, we use the second voice
 248         as a basis for events.
 249       */
 250       Outlet_type c1 = (last_playing_ == SOLO2) ? CONTEXT_NULL : CONTEXT_SHARED;
 251       Outlet_type c2 = (last_playing_ == SOLO2) ? CONTEXT_SHARED : CONTEXT_NULL;
 252       substitute_both (c1, c2);
 253       kill_mmrest ((last_playing_ == SOLO2) ? CONTEXT_ONE : CONTEXT_TWO);
 254       kill_mmrest (CONTEXT_SHARED);
 255
 256       if (playing_state_ != UNISONO
 257           && newstate == UNISONO)
 258         {
 259           if (!unisono_event_)
 260             {
 261               unisono_event_ = new Stream_event
 262                 (scm_call_1 (ly_lily_module_constant ("ly:make-event-class"),
 263                              ly_symbol2scm ("unisono-event")));
 264               unisono_event_->unprotect ();
 265             }
 266
 267           Context *out = (last_playing_ == SOLO2 ? second_iter_ : first_iter_)
 268                          ->get_outlet ();
 269           out->event_source ()->broadcast (unisono_event_);
 270           playing_state_ = UNISONO;
 271         }
 272       state_ = newstate;
 273     }
 274 }
 275
 276 void
 277 Part_combine_iterator::solo1 ()
 278 {
 279   if (state_ == SOLO1)
 280     return;
 281   else
 282     {
 283       state_ = SOLO1;
 284       substitute_both (CONTEXT_SOLO, CONTEXT_NULL);
 285
 286       kill_mmrest (CONTEXT_TWO);
 287       kill_mmrest (CONTEXT_SHARED);
 288
 289       if (playing_state_ != SOLO1)
 290         {
 291           if (!solo_one_event_)
 292             {
 293               solo_one_event_ = new Stream_event
 294                 (scm_call_1 (ly_lily_module_constant ("ly:make-event-class"),
 295                              ly_symbol2scm ("solo-one-event")));
 296               solo_one_event_->unprotect ();
 297             }
 298
 299           first_iter_->get_outlet ()->event_source ()->broadcast (solo_one_event_);
 300         }
 301       playing_state_ = SOLO1;
 302     }
 303 }
 304
 305 void
 306 Part_combine_iterator::solo2 ()
 307 {
 308   if (state_ == SOLO2)
 309     return;
 310   else
 311     {
 312       state_ = SOLO2;
 313
 314       substitute_both (CONTEXT_NULL, CONTEXT_SOLO);
 315
 316       if (playing_state_ != SOLO2)
 317         {
 318           if (!solo_two_event_)
 319             {
 320               solo_two_event_ = new Stream_event
 321                 (scm_call_1 (ly_lily_module_constant ("ly:make-event-class"),
 322                              ly_symbol2scm ("solo-two-event")));
 323               solo_two_event_->unprotect ();
 324             }
 325
 326           second_iter_->get_outlet ()->event_source ()->broadcast (solo_two_event_);
 327           playing_state_ = SOLO2;
 328         }
 329     }
 330 }
 331
 332 void
 333 Part_combine_iterator::chords_together ()
 334 {
 335   if (state_ == TOGETHER)
 336     return;
 337   else
 338     {
 339       playing_state_ = TOGETHER;
 340       state_ = TOGETHER;
 341
 342       substitute_both (CONTEXT_SHARED, CONTEXT_SHARED);
 343     }
 344 }
 345
 346 void
 347 Part_combine_iterator::apart (bool silent)
 348 {
 349   if (!silent)
 350     playing_state_ = APART;
 351
 352   if (state_ == APART)
 353     return;
 354   else
 355     {
 356       state_ = APART;
 357       substitute_both (CONTEXT_ONE, CONTEXT_TWO);
 358     }
 359 }
 360
 361 void
 362 Part_combine_iterator::construct_children ()
 363 {
 364   start_moment_ = get_outlet ()->now_mom ();
 365   split_list_ = get_music ()->get_property ("split-list");
 366   direction_ = get_music ()->get_property ("direction");
 367   if (is_direction (direction_))
 368     {
 369       directionOne_ = direction_;
 370       directionTwo_ = direction_;
 371       if (scm_is_true (scm_negative_p (direction_)))
 372         {
 373           horizontalShiftOne_ = scm_from_int (1);
 374           horizontalShiftTwo_ = scm_from_int (0);
 375         }
 376     }
 377
 378   Context *c = get_outlet ();
 379
 380   for (int i = 0; i < NUM_OUTLETS; i++)
 381     {
 382       SCM type = (i == CONTEXT_NULL) ? ly_symbol2scm ("Devnull") : ly_symbol2scm ("Voice");
 383       /* find context below c: otherwise we may create new staff for each voice */
 384       c = c->find_create_context (type, outlet_names_[i], SCM_EOL);
 385       handles_[i].set_context (c);
 386       if (c->is_alias (ly_symbol2scm ("Voice")))
 387         c->event_source ()->add_listener (GET_LISTENER (set_busy), ly_symbol2scm ("music-event"));
 388     }
 389
 390   SCM lst = get_music ()->get_property ("elements");
 391   Context *one = handles_[CONTEXT_ONE].get_context ();
 392   set_context (one);
 393   first_iter_ = unsmob_iterator (get_iterator (unsmob_music (scm_car (lst))));
 394   Context *two = handles_[CONTEXT_TWO].get_context ();
 395   set_context (two);
 396   second_iter_ = unsmob_iterator (get_iterator (unsmob_music (scm_cadr (lst))));
 397   Context *shared = handles_[CONTEXT_SHARED].get_context ();
 398   set_context (shared);
 399
 400   /* Mimic all settings of voiceOne/voiceTwo for the two separate voices...*/
 401   /* FIXME: Is there any way to use the definition of \voiceOne/\voiceTwo
 402             directly??? */
 403   char const *syms[]
 404   =
 405   {
 406     "Stem",
 407     "DynamicLineSpanner",
 408     "Tie",
 409     "Dots",
 410     "MultiMeasureRest",
 411     "Rest",
 412     "Slur",
 413     "TextScript",
 414     "Script",
 415     0
 416   };
 417
 418   for (char const **p = syms; *p; p++)
 419     {
 420       SCM sym = ly_symbol2scm (*p);
 421       execute_pushpop_property (one, sym,
 422                                 ly_symbol2scm ("direction"), directionOne_);
 423
 424       execute_pushpop_property (two, sym,
 425                                 ly_symbol2scm ("direction"), directionTwo_);
 426
 427       if (scm_is_number (direction_))
 428         execute_pushpop_property (shared, sym,
 429                                   ly_symbol2scm ("direction"), direction_);
 430     }
 431   /* Handle horizontal shifts for crossing notes */
 432   execute_pushpop_property (one, ly_symbol2scm ("NoteColumn"),
 433                             ly_symbol2scm ("horizontal-shift"), horizontalShiftOne_);
 434   execute_pushpop_property (two, ly_symbol2scm ("NoteColumn"),
 435                             ly_symbol2scm ("horizontal-shift"), horizontalShiftTwo_);
 436
 437 }
 438
 439 IMPLEMENT_LISTENER (Part_combine_iterator, set_busy);
 440 void
 441 Part_combine_iterator::set_busy (SCM se)
 442 {
 443   if (!notice_busy_)
 444     return;
 445
 446   Stream_event *e = unsmob_stream_event (se);
 447
 448   if (e->in_event_class ("note-event") || e->in_event_class ("cluster-note-event"))
 449     busy_ = true;
 450 }
 451
 452 /*
 453   Processes a moment in an iterator, and returns whether any new music
 454   was reported.
 455 */
 456 bool
 457 Part_combine_iterator::try_process (Music_iterator *i, Moment m)
 458 {
 459   busy_ = false;
 460   notice_busy_ = true;
 461
 462   i->process (m);
 463
 464   notice_busy_ = false;
 465   return busy_;
 466 }
 467
 468 void
 469 Part_combine_iterator::process (Moment m)
 470 {
 471   Moment now = get_outlet ()->now_mom ();
 472   Moment *splitm = 0;
 473
 474   /* This is needed if construct_children was called before iteration
 475      started */
 476   if (start_moment_.main_part_.is_infinity () && start_moment_ < 0)
 477     start_moment_ = now;
 478
 479   for (; scm_is_pair (split_list_); split_list_ = scm_cdr (split_list_))
 480     {
 481       splitm = unsmob_moment (scm_caar (split_list_));
 482       if (splitm && *splitm + start_moment_ > now)
 483         break;
 484
 485       SCM tag = scm_cdar (split_list_);
 486
 487       if (tag == ly_symbol2scm ("chords"))
 488         chords_together ();
 489       else if (tag == ly_symbol2scm ("apart")
 490                || tag == ly_symbol2scm ("apart-silence")
 491                || tag == ly_symbol2scm ("apart-spanner"))
 492         apart (tag == ly_symbol2scm ("apart-silence"));
 493       else if (tag == ly_symbol2scm ("unisono"))
 494         unisono (false);
 495       else if (tag == ly_symbol2scm ("unisilence"))
 496         unisono (true);
 497       else if (tag == ly_symbol2scm ("solo1"))
 498         solo1 ();
 499       else if (tag == ly_symbol2scm ("solo2"))
 500         solo2 ();
 501       else if (scm_is_symbol (tag))
 502         {
 503           string s = "Unknown split directive: "
 504                      + (scm_is_symbol (tag) ? ly_symbol2string (tag) : string ("not a symbol"));
 505           programming_error (s);
 506         }
 507     }
 508
 509   if (first_iter_->ok ())
 510     {
 511       if (try_process (first_iter_, m))
 512         last_playing_ = SOLO1;
 513     }
 514
 515   if (second_iter_->ok ())
 516     {
 517       if (try_process (second_iter_, m))
 518         last_playing_ = SOLO2;
 519     }
 520 }
 521
 522 IMPLEMENT_CTOR_CALLBACK (Part_combine_iterator);