lily/repeat-engraver.cc

   1 /*
   2   repeat-engraver.cc -- implement Repeat_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1998--1999 Jan Nieuwenhuizen <janneke@gnu.org>
   7 */
   8
   9 #include "repeat-engraver.hh"
  10 #include "bar.hh"
  11 #include "bar-engraver.hh"
  12 #include "musical-request.hh"
  13 #include "multi-measure-rest.hh"
  14 #include "command-request.hh"
  15 #include "time-description.hh"
  16 #include "engraver-group-engraver.hh"
  17 #include "repeated-music.hh"
  18 #include "time-description.hh"
  19 #include "volta-spanner.hh"
  20 #include "note-column.hh"
  21 #include "paper-def.hh"
  22 #include "music-list.hh"
  23
  24 ADD_THIS_TRANSLATOR (Repeat_engraver);
  25
  26 bool
  27 Repeat_engraver::do_try_music (Music* m)
  28 {
  29   if (Repeated_music* r = dynamic_cast<Repeated_music *> (m))
  30     {
  31       if (repeated_music_l_)
  32         return false;
  33
  34       if (r->volta_fold_b_)
  35         {
  36           repeated_music_l_ = r;
  37         }
  38
  39       /*
  40         We acknowledge other types of unfolded music as well, to
  41         get auto context selection right.
  42        */
  43       return true;
  44
  45     }
  46   return false;
  47 }
  48
  49 /**
  50  Walk through repeat music, and generate events for appropriate times.
  51 */
  52 void
  53 Repeat_engraver::queue_events ()
  54 {
  55   Music_sequence* alt = repeated_music_l_->alternatives_p_;
  56   Moment walk_mom = now_mom () + repeated_music_l_->repeat_body_p_->length_mom ();
  57
  58   bool create_volta = ! get_property ("noVoltaBraces",0).to_bool ();
  59
  60   Cons_list<Bar_create_event> becel;
  61   becel.append (new Bar_create_event (now_mom (), "|:"));
  62
  63   if (!alt)
  64     {
  65       becel.append  (new Bar_create_event (walk_mom, ":|"));
  66       becel.append  (new Bar_create_event (walk_mom, "stop"));
  67    }
  68   else
  69     {
  70       int last_number = 0;
  71       int volta_number = repeated_music_l_->repeats_i_ - alt->length_i () + 1;
  72
  73       /*
  74         all repeat alternatives, and generate events with
  75         appropriate timestamps. The volta spanner event (a number string)
  76         happens at the begin of the alt. The :| bar event at the ending.
  77       */
  78       for (Cons<Music> *i = alt->music_p_list_p_->head_; i; i = i->next_)
  79         {
  80
  81           /*
  82             some idiot might typeset a repeat not starting on a
  83             barline.  Make sure there is one.
  84
  85             (todo: should try to avoid line breaks?)
  86           */
  87           if (last_number == 0)
  88             {
  89               becel.append (new Bar_create_event (walk_mom, ""));
  90             }
  91
  92
  93           if (create_volta)
  94             {
  95               Bar_create_event * c = new Bar_create_event (walk_mom, last_number+ 1,
  96                                                            volta_number);
  97
  98               if (!i->next_)
  99                 c->last_b_ = true;
 100
 101               becel.append (c);
 102               last_number = volta_number;
 103               volta_number ++;
 104             }
 105           // should think about voltaSpannerDuration
 106           walk_mom += i->car_->length_mom();
 107
 108           if (i->next_)
 109             becel.append (new Bar_create_event (walk_mom, ":|"));
 110           else
 111             becel.append (new Bar_create_event (walk_mom, "stop"));
 112         }
 113     }
 114
 115   Cons<Bar_create_event> *&tail = create_barmoments_queue_
 116     ? last_cons (create_barmoments_queue_)->next_
 117     : create_barmoments_queue_;
 118
 119   tail = becel.head_ ;
 120   becel.head_ = 0;
 121 }
 122
 123 void
 124 Repeat_engraver::do_process_requests ()
 125 {
 126   if (repeated_music_l_ && !done_this_one_b_)
 127     {
 128       queue_events ();
 129       done_this_one_b_ = true;
 130     }
 131
 132
 133   Cons<Bar_create_event> * head =   create_barmoments_queue_;
 134   if (!head)
 135     return;
 136
 137   Bar_engraver* bar_engraver_l = dynamic_cast <Bar_engraver*>
 138     (daddy_grav_l ()->get_simple_translator ("Bar_engraver"));
 139
 140   /*
 141     Do all the events that need to be done now.
 142   */
 143   while (head && now_mom () == head->car_->when_)
 144     {
 145       create_barmoments_queue_ = create_barmoments_queue_->next_;
 146       head->next_ =0;
 147       if (bar_engraver_l)
 148         {
 149           String t = head->car_->type_;
 150           if (head->car_->bar_b_)
 151             {
 152               if (t == "stop" || t == ":|")
 153                 {
 154                   end_volta_span_p_ = volta_span_p_;
 155                   volta_span_p_ =0;
 156                 }
 157
 158               if (t != "stop")
 159                 bar_engraver_l->request_bar (t);
 160               else
 161                 bar_engraver_l->request_bar ("");
 162             }
 163           else
 164             {
 165               assert (!volta_span_p_);
 166               volta_span_p_ = new Volta_spanner;
 167               announce_element (Score_element_info (volta_span_p_,0));
 168               volta_span_p_->number_str_ = t;
 169               volta_span_p_->last_b_ = head->car_->last_b_;
 170               // voltaSpannerDuration stuff here.
 171               // other property stuff here.
 172             }
 173
 174         }
 175       else
 176         {
 177           warning (_ ("No bar engraver found.  Ignoring repeats."));
 178         }
 179
 180       delete head->car_;
 181       delete head;
 182
 183       head = create_barmoments_queue_;
 184     }
 185
 186   assert (!head || head->car_->when_ > now_mom ());
 187 }
 188
 189
 190 void
 191 Repeat_engraver::acknowledge_element (Score_element_info i)
 192 {
 193   if (Note_column *c = dynamic_cast<Note_column *> (i.elem_l_))
 194     {
 195       if (volta_span_p_)
 196         volta_span_p_->add_column (c);
 197       if (end_volta_span_p_)
 198         end_volta_span_p_->add_column (c);
 199     }
 200   if (Bar *c = dynamic_cast<Bar*> (i.elem_l_))
 201     {
 202       if (volta_span_p_)
 203         volta_span_p_->add_bar (c);
 204       if (end_volta_span_p_)
 205         end_volta_span_p_ ->add_bar(c);
 206     }
 207 }
 208
 209
 210 void
 211 Repeat_engraver::do_removal_processing ()
 212 {
 213   if (volta_span_p_)
 214     {
 215       typeset_element(volta_span_p_);
 216     }
 217   if (end_volta_span_p_)
 218     {
 219       typeset_element (end_volta_span_p_);
 220     }
 221   // todo: the paranoid may also delete create_barmoments_queue_
 222 }
 223
 224 void
 225 Repeat_engraver::do_post_move_processing ()
 226 {
 227   for (Cons<Bar_create_event> *p = create_barmoments_queue_;
 228        p && p->car_->when_ == now_mom (); p = p->next_)
 229     if (p->car_->type_ == "stop")
 230       {
 231         repeated_music_l_ = 0;
 232         done_this_one_b_ = false;
 233       }
 234 }
 235
 236 void
 237 Repeat_engraver::do_pre_move_processing ()
 238 {
 239   if (end_volta_span_p_)
 240     {
 241       typeset_element (end_volta_span_p_ );
 242       end_volta_span_p_ =0;
 243     }
 244
 245 }
 246
 247
 248 Repeat_engraver::Repeat_engraver()
 249 {
 250   repeated_music_l_ =0;
 251   end_volta_span_p_ =0;
 252   volta_span_p_ =0;
 253   done_this_one_b_ = false;
 254   create_barmoments_queue_ =0;
 255 }
 256
 257 /* ************** */
 258 Bar_create_event::Bar_create_event()
 259 {
 260   last_b_ =false;
 261   bar_b_ = true;
 262 }
 263
 264 Bar_create_event::Bar_create_event (Moment w, String s)
 265 {
 266   last_b_ =false;
 267   when_ = w;
 268   type_ = s;
 269   bar_b_ = true;
 270 }
 271
 272 Bar_create_event::Bar_create_event (Moment w, int i, int j)
 273 {
 274   last_b_ =false;
 275   when_ = w ;
 276   bar_b_ = false;
 277
 278   if (i!=j)
 279     type_ = to_str (i) + ".-" ;
 280
 281   type_ += to_str(j) + ".";
 282 }