lily/slur-engraver.cc

   1 /*
   2   slur-engraver.cc -- implement Slur_engraver
   3
   4   (c)  1997--2001 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   5 */
   6
   7 #include "musical-request.hh"
   8 #include "slur.hh"
   9 #include "debug.hh"
  10 #include "note-column.hh"
  11 #include "translator-group.hh"
  12 #include "engraver.hh"
  13 #include "spanner.hh"
  14
  15 class Slur_engraver : public Engraver
  16 {
  17   Link_array<Span_req> requests_arr_;
  18   Link_array<Span_req> new_slur_req_l_arr_;
  19   Link_array<Grob> slur_l_stack_;
  20   Link_array<Grob> end_slur_l_arr_;
  21   Moment last_start_;
  22
  23   void set_melisma (bool);
  24
  25 protected:
  26   virtual bool try_music (Music*);
  27   virtual void acknowledge_grob (Grob_info);
  28   virtual void stop_translation_timestep ();
  29   virtual void start_translation_timestep ();
  30   virtual void finalize ();
  31   virtual void create_grobs ();
  32
  33 public:
  34   VIRTUAL_COPY_CONS (Translator);
  35   Slur_engraver ();
  36 };
  37
  38 Slur_engraver::Slur_engraver ()
  39 {
  40   last_start_ = Moment (-1);
  41 }
  42
  43 bool
  44 Slur_engraver::try_music (Music *req_l)
  45 {
  46   if (Span_req *sl = dynamic_cast <Span_req *> (req_l))
  47     {
  48       String t =  ly_scm2string (sl->get_mus_property ("span-type"));
  49       if (t == "abort")
  50         {
  51           for (int i = 0; i < slur_l_stack_.size (); i++)
  52             {
  53               slur_l_stack_[i]->suicide ();
  54             }
  55           slur_l_stack_.clear ();
  56           for (int i = 0; i < end_slur_l_arr_.size (); i++)
  57             {
  58               end_slur_l_arr_[i]->suicide ();
  59             }
  60           end_slur_l_arr_.clear ();
  61           requests_arr_.clear ();
  62           new_slur_req_l_arr_.clear ();
  63         }
  64       else if (t == "slur")
  65         {
  66           /*
  67             Let's not start more than one slur per moment.
  68            */
  69           if (sl->get_span_dir () == START)
  70             {
  71               if (now_mom () > last_start_)
  72                 {
  73                   new_slur_req_l_arr_.push (sl);
  74                   last_start_ = now_mom ();
  75                   return true;
  76                 }
  77             }
  78           else
  79             {
  80               new_slur_req_l_arr_.push (sl);
  81               return true;
  82             }
  83         }
  84     }
  85   return false;
  86 }
  87
  88 void
  89 Slur_engraver::set_melisma (bool m)
  90 {
  91   daddy_trans_l_->set_property ("slurMelismaBusy", m ? SCM_BOOL_T :SCM_BOOL_F);
  92 }
  93
  94 void
  95 Slur_engraver::acknowledge_grob (Grob_info info)
  96 {
  97   if (Note_column::has_interface (info.elem_l_))
  98     {
  99       Grob *e =info.elem_l_;
 100       for (int i = 0; i < slur_l_stack_.size (); i++)
 101         Slur::add_column (slur_l_stack_[i], e);
 102       for (int i = 0; i < end_slur_l_arr_.size (); i++)
 103         Slur::add_column (end_slur_l_arr_[i], e);
 104     }
 105 }
 106
 107 void
 108 Slur_engraver::finalize ()
 109 {
 110   for (int i = 0; i < slur_l_stack_.size (); i++)
 111     {
 112 #if 0
 113       typeset_grob (slur_l_stack_[i]);
 114 #else
 115       /*
 116         Let's not typeset unterminated stuff
 117        */
 118       slur_l_stack_[i]->suicide ();
 119 #endif
 120     }
 121   slur_l_stack_.clear ();
 122   SCM wg = get_property ("weAreGraceContext");
 123   bool wgb = to_boolean (wg);
 124   if (!wgb)
 125     for (int i=0; i < requests_arr_.size (); i++)
 126       {
 127         requests_arr_[i]->origin ()->warning (_ ("unterminated slur"));
 128       }
 129 }
 130
 131 void
 132 Slur_engraver::create_grobs ()
 133 {
 134   Link_array<Grob> start_slur_l_arr;
 135   for (int i=0; i< new_slur_req_l_arr_.size (); i++)
 136     {
 137       Span_req* slur_req_l = new_slur_req_l_arr_[i];
 138       // end slur: move the slur to other array
 139       if (slur_req_l->get_span_dir () == STOP)
 140         {
 141           if (slur_l_stack_.empty ())
 142             /* How to shut up this warning, when Voice_devnull_engraver has
 143                eaten start request? */
 144             slur_req_l->origin ()->warning (_f ("can't find start of slur"));
 145           else
 146             {
 147               Grob* slur = slur_l_stack_.pop ();
 148               SCM s = get_property ("slurEndAttachment");
 149               if (gh_symbol_p (s))
 150                 {
 151                   index_set_cell (slur->get_grob_property ("attachment"), STOP, s);
 152                 }
 153               end_slur_l_arr_.push (slur);
 154               requests_arr_.pop ();
 155             }
 156         }
 157       else  if (slur_req_l->get_span_dir () == START)
 158         {
 159           // push a new slur onto stack.
 160           // (use temp. array to wait for all slur STOPs)
 161           Grob* slur = new Spanner (get_property ("Slur"));
 162           Slur::set_interface (slur);
 163           SCM s = get_property ("slurBeginAttachment");
 164           if (gh_symbol_p (s))
 165             {
 166               index_set_cell (slur->get_grob_property ("attachment"), START, s);
 167             }
 168           start_slur_l_arr.push (slur);
 169           requests_arr_.push (slur_req_l);
 170           announce_grob (slur, slur_req_l);
 171         }
 172     }
 173   for (int i=0; i < start_slur_l_arr.size (); i++)
 174     slur_l_stack_.push (start_slur_l_arr[i]);
 175   new_slur_req_l_arr_.clear ();
 176 }
 177
 178 void
 179 Slur_engraver::stop_translation_timestep ()
 180 {
 181   for (int i = 0; i < end_slur_l_arr_.size (); i++)
 182     {
 183       typeset_grob (end_slur_l_arr_[i]);
 184     }
 185   end_slur_l_arr_.clear ();
 186 }
 187
 188 void
 189 Slur_engraver::start_translation_timestep ()
 190 {
 191   new_slur_req_l_arr_.clear ();
 192   SCM m = get_property ("automaticMelismata");
 193   if (to_boolean (m))
 194     {
 195       set_melisma (slur_l_stack_.size ());
 196     }
 197 }
 198
 199
 200 ADD_THIS_TRANSLATOR (Slur_engraver);