lily/timing-translator.cc

   1 /*
   2   timing-translator.cc -- implement Timing_translator
   3
   4
   5   source file of the GNU LilyPond music typesetter
   6
   7   (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   8 */
   9
  10 #include "debug.hh"
  11 #include "timing-translator.hh"
  12 #include "command-request.hh"
  13 #include "translator-group.hh"
  14 #include "global-translator.hh"
  15 #include "multi-measure-rest.hh"
  16
  17 bool
  18 Timing_translator::do_try_music (Music*r)
  19 {
  20   if (Timing_req *t =  dynamic_cast <Timing_req *> (r))
  21     {
  22       for (int i=0; i < timing_req_l_arr_.size (); i++)
  23         {
  24           if (timing_req_l_arr_[i]->equal_b(t))
  25             return true;
  26           if (String (classname (timing_req_l_arr_[i])) == classname (r))
  27             {
  28               r->warning (_ ("conflicting timing request"));
  29               return false;
  30             }
  31         }
  32
  33       timing_req_l_arr_.push(t);
  34       return true;
  35     }
  36   return false;
  37 }
  38
  39 /*ugh.
  40  */
  41 Time_signature_change_req*
  42 Timing_translator::time_signature_req_l() const
  43 {
  44   Time_signature_change_req *m_l=0;
  45   for (int i=0; !m_l && i < timing_req_l_arr_.size (); i++)
  46     {
  47       m_l=dynamic_cast<Time_signature_change_req*> (timing_req_l_arr_[i]);
  48     }
  49   return m_l;
  50 }
  51
  52 void
  53 Timing_translator::do_process_requests()
  54 {
  55   for (int i=0; i < timing_req_l_arr_.size (); i++)
  56     {
  57       Timing_req * tr_l = timing_req_l_arr_[i];
  58
  59       if (Time_signature_change_req *m_l = dynamic_cast <Time_signature_change_req *> (tr_l))
  60         {
  61           int b_i= m_l->beats_i_;
  62           int o_i = m_l->one_beat_i_;
  63           set_time_signature (b_i, o_i);
  64         }
  65       else if (dynamic_cast <Barcheck_req *> (tr_l))
  66         {
  67           if (measure_position ())
  68             {
  69               tr_l ->warning (_f ("barcheck failed at: %s",
  70                                   measure_position ().str ()));
  71               // resync
  72               daddy_trans_l_->set_property("measurePosition",
  73                                            (new Moment)->smobify_self ());
  74
  75
  76             }
  77         }
  78     }
  79
  80
  81 }
  82
  83
  84 void
  85 Timing_translator::do_pre_move_processing()
  86 {
  87   timing_req_l_arr_.set_size (0);
  88   Translator *t = this;
  89   Global_translator *global_l =0;
  90   do
  91     {
  92       t = t->daddy_trans_l_ ;
  93       global_l = dynamic_cast<Global_translator*> (t);
  94     }
  95   while (!global_l);
  96
  97   /* allbars == ! skipbars */
  98   SCM sb = get_property ("skipBars", 0);
  99   bool allbars = !(gh_boolean_p (sb)&&gh_scm2bool (sb));
 100
 101   // urg: multi bar rests: should always process whole of first bar?
 102   SCM tim = get_property ("timing", 0);
 103   bool timb = gh_boolean_p (tim) && gh_scm2bool ( tim);
 104
 105
 106   if (timb && allbars)
 107     {
 108       Moment barleft = (measure_length () - measure_position ());
 109
 110       if (barleft < Moment (0))
 111         barleft = 0;
 112
 113       global_l->add_moment_to_process (now_mom () + barleft);
 114     }
 115 }
 116
 117
 118 ADD_THIS_TRANSLATOR(Timing_translator);
 119
 120 void
 121 Timing_translator::do_creation_processing()
 122 {
 123   daddy_trans_l_->set_property ("timing" , SCM_BOOL_T);
 124   daddy_trans_l_->set_property ("currentBarNumber" , gh_int2scm (1));
 125   daddy_trans_l_->set_property("measurePosition",
 126                                (new Moment)->smobify_self());
 127   daddy_trans_l_->set_property("measureLength",
 128                                (new Moment (1))->smobify_self());
 129
 130 }
 131
 132 Moment
 133 Timing_translator::measure_length () const
 134 {
 135   SCM l = get_property("measureLength",0);
 136   if (SMOB_IS_TYPE_B(Moment, l))
 137     return *SMOB_TO_TYPE (Moment, l);
 138   else
 139     return Moment (1);
 140 }
 141
 142
 143 void
 144 Timing_translator::get_time_signature (int *n, int *d) const
 145 {
 146   *n = measure_length () / one_beat_;
 147   *d = one_beat_.den_i ();
 148 }
 149
 150
 151 void
 152 Timing_translator::set_time_signature (int l, int o)
 153 {
 154   one_beat_ = Moment (1)/Moment (o);
 155   Moment len = Moment (l) * one_beat_;
 156   daddy_trans_l_->set_property ("measureLength",
 157                                 (new Moment (len))->smobify_self ());
 158 }
 159
 160 Timing_translator::Timing_translator()
 161 {
 162   one_beat_ = Moment( 1,4);
 163 }
 164
 165
 166 Moment
 167 Timing_translator::measure_position () const
 168 {
 169   SCM sm = get_property ("measurePosition",0);
 170
 171   Moment m   =0;
 172   if (SMOB_IS_TYPE_B (Moment, sm))
 173     {
 174       m = *SMOB_TO_TYPE (Moment, sm);
 175       while (m < Moment (0))
 176         m += measure_length ();
 177     }
 178
 179   return m;
 180 }
 181
 182 void
 183 Timing_translator::do_post_move_processing()
 184 {
 185   Translator *t = this;
 186   Global_translator *global_l =0;
 187   do
 188     {
 189       t = t->daddy_trans_l_ ;
 190       global_l = dynamic_cast<Global_translator*> (t);
 191     }
 192   while (!global_l);
 193
 194   Moment dt = global_l->now_mom_  - global_l -> prev_mom_;
 195   if (dt < Moment (0))
 196     {
 197       programming_error ("Moving backwards in time");
 198       dt = 0;
 199     }
 200
 201   if (!dt)
 202     return;
 203
 204   Moment * measposp =0;
 205
 206   SCM s = get_property ("measurePosition", 0);
 207   if (SMOB_IS_TYPE_B (Moment, s))
 208     {
 209       measposp = SMOB_TO_TYPE (Moment,s);
 210     }
 211   else
 212     {
 213       measposp = new Moment;
 214       daddy_trans_l_->set_property ("measurePosition", measposp->smobify_self ());
 215     }
 216
 217   *measposp += dt;
 218   // don't need to set_property
 219
 220   Translator_group * tr =daddy_trans_l_;
 221   SCM barn = get_property ("currentBarNumber", &tr);
 222   int b = 0;
 223   if (gh_number_p(barn))
 224     {
 225       b = gh_scm2int (barn);
 226     }
 227
 228   SCM cad = get_property ("timing", 0);
 229   bool c= gh_boolean_p (cad ) && gh_scm2bool (cad);
 230
 231   Moment len = measure_length ();
 232   while (c && *measposp >= len)
 233       {
 234         *measposp -= len;
 235         b ++;
 236       }
 237
 238   tr->set_property ("currentBarNumber", gh_int2scm (b));
 239 }
 240
 241
 242
 243 int
 244 Timing_translator::bars_i () const
 245 {
 246   return gh_scm2int (get_property ("currentBarNumber", 0));
 247 }