lily/multi-measure-rest-engraver.cc

   1 /*
   2   multi_measure_rest-engraver.cc -- implement Multi_measure_rest_engraver
   3
   4   (c) 1998--2003 Jan Nieuwenhuizen <janneke@gnu.org>
   5        Han-Wen Nienhuys <hanwen@cs.uu.nl>
   6 */
   7
   8 #include "event.hh"
   9 #include "multi-measure-rest.hh"
  10 #include "paper-column.hh"
  11 #include "engraver-group-engraver.hh"
  12 #include "side-position-interface.hh"
  13 #include "staff-symbol-referencer.hh"
  14 #include "engraver.hh"
  15 #include "moment.hh"
  16 #include "spanner.hh"
  17
  18 /**
  19    The name says it all: make multi measure rests
  20
  21 */
  22 class Multi_measure_rest_engraver : public Engraver
  23 {
  24 public:
  25   TRANSLATOR_DECLARATIONS(Multi_measure_rest_engraver);
  26
  27 protected:
  28   virtual bool try_music (Music*);
  29   virtual void process_music ();
  30   virtual void stop_translation_timestep ();
  31   virtual void start_translation_timestep ();
  32   virtual void finalize ();
  33
  34 private:
  35   Music * new_req_;
  36   Music * busy_span_req_;
  37   Music * stop_req_;
  38   Link_array<Music> text_events_;
  39   int start_measure_;
  40   Moment start_moment_;
  41   Rational last_main_moment_;
  42
  43   bool bar_seen_;
  44
  45   Spanner *mmrest_;
  46   Link_array<Spanner> numbers_;
  47
  48   Link_array<Spanner> last_numbers_;
  49   Spanner *last_rest_;
  50 };
  51
  52 Multi_measure_rest_engraver::Multi_measure_rest_engraver ()
  53 {
  54   bar_seen_ = false;
  55   start_measure_ = 0;
  56   mmrest_ = 0;
  57   last_rest_ =0;
  58   new_req_ = busy_span_req_ = stop_req_ =0;
  59 }
  60
  61 bool
  62 Multi_measure_rest_engraver::try_music (Music* req)
  63 {
  64   if (req->is_mus_type ("multi-measure-rest-event"))
  65     {
  66       Direction d = to_dir (req->get_mus_property ("span-direction"));
  67       if (d == STOP)
  68         {
  69           stop_req_ = req;
  70         }
  71       else if (d == START&& !new_req_)
  72         {
  73           new_req_ = req;
  74         }
  75       return true;
  76     }
  77   else if (req->is_mus_type ("multi-measure-text-event"))
  78     {
  79       text_events_.push (req);
  80       return true;
  81     }
  82   return false;
  83 }
  84
  85 void
  86 Multi_measure_rest_engraver::process_music ()
  87 {
  88
  89   if (new_req_ && stop_req_)
  90     stop_req_ = 0;
  91
  92   if (new_req_)
  93     start_moment_ = now_mom ();
  94
  95   if (stop_req_)
  96     {
  97       busy_span_req_ =0;
  98       stop_req_ = 0;
  99     }
 100
 101   if (new_req_)
 102     {
 103       busy_span_req_ = new_req_;
 104       new_req_ =0;
 105     }
 106
 107   if (busy_span_req_ && !mmrest_)
 108     {
 109       mmrest_ = new Spanner (get_property ("MultiMeasureRest"));
 110
 111       if (text_events_.size())
 112         {
 113           for (int i = 0; i < text_events_.size(); i++)
 114             {
 115               Spanner *sp
 116                 = new Spanner (get_property ("MultiMeasureRestText"));
 117
 118               Music* e = text_events_[i];
 119               SCM t = e->get_mus_property ("text");
 120               SCM dir = e->get_mus_property ("direction");
 121               sp->set_grob_property ("text",t);
 122               if (is_direction (dir))
 123                 sp->set_grob_property ("direction",dir);
 124
 125               numbers_.push (sp);
 126               announce_grob (sp, e->self_scm());
 127             }
 128
 129           /*
 130             Stack different scripts.
 131            */
 132           Direction d = DOWN;
 133           do {
 134             Grob *last =0;
 135             for (int i=0; i <numbers_.size(); i++)
 136               {
 137                 if (gh_int2scm (d) == numbers_[i]->get_grob_property ("direction"))
 138                   {
 139                     if (last)
 140                       Side_position_interface::add_support (numbers_[i], last);
 141                     last = numbers_[i];
 142                   }
 143               }
 144           } while (flip (&d) != DOWN);
 145         }
 146       else
 147         {
 148           Spanner *sp
 149             = new Spanner (get_property ("MultiMeasureRestNumber"));
 150           numbers_.push (sp);
 151           announce_grob (sp, busy_span_req_->self_scm());
 152         }
 153
 154       for (int i =0 ; i < numbers_.size(); i++)
 155         {
 156           Side_position_interface::add_support (numbers_[i], mmrest_);
 157           numbers_[i]->set_parent (mmrest_, Y_AXIS);
 158         }
 159
 160       announce_grob (mmrest_, busy_span_req_->self_scm());
 161       start_measure_
 162         = gh_scm2int (get_property ("currentBarNumber"));
 163     }
 164
 165   bar_seen_ = gh_string_p (get_property ("whichBar"));
 166 }
 167
 168 void
 169 Multi_measure_rest_engraver::stop_translation_timestep ()
 170 {
 171   /*
 172     We can not do this earlier, as breakableSeparationItem is not yet there.
 173   */
 174
 175   if (bar_seen_)
 176     {
 177       Grob *cmc = unsmob_grob (get_property("breakableSeparationItem"));
 178       if (!cmc)
 179         cmc = unsmob_grob (get_property ("currentCommandColumn"));
 180
 181       Item *it = dynamic_cast<Item*> (cmc);
 182
 183       if (mmrest_)
 184         {
 185           add_bound_item (mmrest_, it);
 186           for (int i = 0; i < numbers_.size(); i++)
 187             add_bound_item (numbers_[i], it);
 188         }
 189
 190       if (last_rest_)
 191         {
 192           add_bound_item (last_rest_,it);
 193           for (int i = 0; i < last_numbers_.size(); i++)
 194             add_bound_item (last_numbers_[i], it);
 195         }
 196     }
 197
 198
 199   SCM smp = get_property ("measurePosition");
 200   Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
 201
 202   if (mmrest_ && (now_mom () >= start_moment_)
 203       && !mp.to_bool ()
 204       && mmrest_->get_bound (LEFT) && mmrest_->get_bound (RIGHT))
 205     {
 206       typeset_grob (mmrest_);
 207       for (int i = 0 ; i < numbers_.size(); i++)
 208         {
 209           typeset_grob (numbers_[i]);
 210           Side_position_interface::add_staff_support (numbers_[i]);
 211         }
 212
 213       /*
 214         we must keep mmrest_ around to set measure-count, so
 215         no mmrest_ = 0 here.
 216        */
 217     }
 218
 219   if (last_rest_)
 220     {
 221       /* sanity check */
 222       if (last_rest_->get_bound (LEFT) && last_rest_->get_bound (RIGHT)
 223           && last_rest_->get_bound (LEFT) != last_rest_->get_bound (RIGHT))
 224         {
 225           typeset_grob (last_rest_);
 226
 227           for (int i = 0; i < last_numbers_.size ();i++)
 228             {
 229               typeset_grob (last_numbers_[i]);
 230               Side_position_interface::add_staff_support (last_numbers_[i]);
 231             }
 232         }
 233       last_rest_ = 0;
 234       last_numbers_.clear();
 235     }
 236
 237   if (new_req_)
 238     {
 239       busy_span_req_ = new_req_;
 240       new_req_ =0;
 241     }
 242
 243   text_events_.clear ();
 244 }
 245
 246 void
 247 Multi_measure_rest_engraver::start_translation_timestep ()
 248 {
 249   bar_seen_ = false;
 250
 251   SCM smp = get_property ("measurePosition");
 252   Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
 253
 254   Moment now =now_mom ();
 255   if (mmrest_
 256       && now.main_part_ != last_main_moment_
 257       && mp.main_part_ == Rational (0))
 258     {
 259       last_rest_ = mmrest_;
 260       last_numbers_ = numbers_;
 261
 262       int cur = gh_scm2int (get_property ("currentBarNumber"));
 263       int num = cur - start_measure_;
 264       last_rest_->set_grob_property ("measure-count", gh_int2scm (num));
 265
 266       SCM sml = get_property ("measureLength");
 267       Rational ml = (unsmob_moment (sml)) ? unsmob_moment (sml)->main_part_ : Rational (1);
 268       if (ml >= Rational (2))
 269         {
 270           last_rest_->set_grob_property ("use-breve-rest", SCM_BOOL_T);
 271         }
 272
 273       mmrest_ = 0;
 274       numbers_.clear ();
 275
 276       Grob * last = last_numbers_.size() ? last_numbers_[0] : 0;
 277       if (last && last->get_grob_property ("text") == SCM_EOL)
 278         {
 279           SCM thres = get_property ("restNumberThreshold");
 280           int t = 1;
 281           if (gh_number_p (thres))
 282             t = gh_scm2int (thres);
 283
 284           if (num <= t)
 285             last->suicide();
 286           else
 287             {
 288               SCM text
 289                 = scm_number_to_string (gh_int2scm (num), SCM_MAKINUM (10));
 290               last->set_grob_property ("text", text);
 291             }
 292         }
 293     }
 294
 295   last_main_moment_ = now.main_part_;
 296 }
 297
 298 void
 299 Multi_measure_rest_engraver::finalize ()
 300 {
 301   if (mmrest_)
 302     {
 303       typeset_grob (mmrest_);
 304     }
 305   if (last_rest_)
 306     {
 307       typeset_grob (last_rest_);
 308     }
 309
 310   for (int i = 0; i < last_numbers_.size ();i++)
 311     typeset_grob (last_numbers_[i]);
 312
 313   for (int i = 0; i < numbers_.size ();i++)
 314     typeset_grob (numbers_[i]);
 315
 316 }
 317
 318 ENTER_DESCRIPTION(Multi_measure_rest_engraver,
 319 /* descr */
 320                   "Engraves multi-measure rests that are produced with @code{R}.  Reads "
 321 "measurePosition and currentBarNumber to determine what number to print "
 322 "over the MultiMeasureRest.  Reads measureLength to determine if it "
 323 "should use a whole rest or a breve rest to represent 1 measure "
 324                   ,
 325 /* creats*/       "MultiMeasureRest MultiMeasureRestNumber MultiMeasureRestText",
 326 /* accepts */     "multi-measure-rest-event multi-measure-text-event",
 327 /* acks  */      "",
 328 /* reads */       "currentBarNumber restNumberThreshold breakableSeparationItem currentCommandColumn measurePosition measureLength",
 329 /* write */       "");