lily/tie-engraver.cc

   1 /*
   2   ctie-engraver.cc --  implement Tie_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1998--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7
   8  */
   9
  10 #include "tie-engraver.hh"
  11 #include "command-request.hh"
  12 #include "note-head.hh"
  13 #include "musical-request.hh"
  14 #include "tie.hh"
  15 #include "translator-group.hh"
  16
  17 Tie_engraver::Tie_engraver()
  18 {
  19   req_l_ = 0;
  20 }
  21
  22
  23 bool
  24 Tie_engraver::do_try_music (Music *m)
  25 {
  26   if (Tie_req * c = dynamic_cast<Tie_req*> (m))
  27     {
  28       req_l_ = c;
  29       if (get_property ("automaticMelismata",0).to_bool ())
  30         {
  31           set_melisma (true);
  32         }
  33       return true;
  34     }
  35   return false;
  36 }
  37
  38 void
  39 Tie_engraver::set_melisma (bool m)
  40 {
  41   Translator_group *where = daddy_trans_l_;
  42   get_property ("tieMelismaBusy", &where);
  43   if (!where)
  44     where = daddy_trans_l_;
  45
  46   daddy_trans_l_->set_property ("tieMelismaBusy", m ? "1" :"0");
  47 }
  48
  49 void
  50 Tie_engraver::acknowledge_element (Score_element_info i)
  51 {
  52   if (Note_head *nh = dynamic_cast<Note_head *> (i.elem_l_))
  53     {
  54       Note_req * m = dynamic_cast<Note_req* > (i.req_l_);
  55       if (!m)
  56         return;
  57       now_heads_.push (CHead_melodic_tuple (nh, m, now_mom()+ m->length_mom ()));
  58     }
  59 }
  60
  61 void
  62 Tie_engraver::do_process_requests ()
  63 {
  64   if (req_l_)
  65     {
  66       Moment now = now_mom ();
  67       Link_array<Note_head> nharr;
  68
  69       stopped_heads_.clear ();
  70       while (past_notes_pq_.size ()
  71              && past_notes_pq_.front ().end_ == now)
  72         stopped_heads_.push (past_notes_pq_.get ());
  73     }
  74 }
  75
  76 void
  77 Tie_engraver::process_acknowledged ()
  78 {
  79   bool old_behavior = get_property ("oldTieBehavior", 0).to_bool ();
  80
  81   if (req_l_)
  82     {
  83
  84       /*
  85         JUNKME!
  86        */
  87       if (old_behavior)
  88         {
  89           if (now_heads_.size () != stopped_heads_.size ())
  90             {
  91               req_l_->warning (_ ("unequal number of note heads for tie"));
  92             }
  93           int sz = now_heads_.size () <? stopped_heads_.size ();
  94
  95           /* hmm. Should do something more sensible.
  96        because, we assume no more noteheads come along after the 1st pass.
  97           */
  98           if (sz <= tie_p_arr_.size ())
  99             return;
 100
 101           now_heads_.sort (CHead_melodic_tuple::pitch_compare);
 102           stopped_heads_.sort(CHead_melodic_tuple::pitch_compare);
 103
 104           for (int i=0; i < sz; i++)
 105             {
 106               Tie * p = new Tie;
 107               p->set_head (LEFT, stopped_heads_[i].head_l_);
 108               p->set_head (RIGHT, now_heads_[i].head_l_);
 109               tie_p_arr_.push (p);
 110               announce_element (Score_element_info (p, req_l_));
 111             }
 112         }
 113       else
 114         {
 115           now_heads_.sort (CHead_melodic_tuple::pitch_compare);
 116           stopped_heads_.sort(CHead_melodic_tuple::pitch_compare);
 117           int i=0;
 118           int j=0;
 119           int tie_count=0;
 120           while  ( i < now_heads_.size () && j < stopped_heads_.size ())
 121             {
 122               int comp
 123                 = Musical_pitch::compare (now_heads_[i].req_l_->pitch_ ,
 124                                           stopped_heads_[j].req_l_->pitch_);
 125
 126               if (comp)
 127                 {
 128                   (comp < 0) ? i ++ : j++;
 129                   continue;
 130                 }
 131               else
 132                 {
 133                   tie_count ++;
 134
 135                   /* don't go around recreating ties that were already
 136                   made. Not infallible. Due to reordering in sort (),
 137                   we will make the wrong ties when noteheads are
 138                   added.  */
 139                   if (tie_count > tie_p_arr_.size ())
 140                     {
 141                       Tie * p = new Tie;
 142                       p->set_head (LEFT, stopped_heads_[j].head_l_);
 143                       p->set_head (RIGHT, now_heads_[i].head_l_);
 144                       tie_p_arr_.push (p);
 145                       announce_element (Score_element_info (p, req_l_));
 146                     }
 147                   i++;
 148                   j++;
 149
 150                 }
 151             }
 152
 153           if (!tie_p_arr_.size ())
 154             {
 155               req_l_->warning (_ ("No ties were created!"));
 156             }
 157
 158         }
 159     }
 160 }
 161
 162 void
 163 Tie_engraver::do_pre_move_processing ()
 164 {
 165   for (int i=0; i < now_heads_.size (); i++)
 166     {
 167       past_notes_pq_.insert (now_heads_[i]);
 168     }
 169   now_heads_.clear ();
 170
 171   Scalar dir (get_property ("tieVerticalDirection", 0));
 172   Scalar dir2 (get_property ("verticalDirection", 0));
 173
 174   Direction tie_dir = CENTER;
 175   if (dir.length_i () && dir.isnum_b ())
 176     tie_dir = (Direction) sign (int(dir));
 177   else if (dir2.length_i () && dir2.isnum_b ())
 178     tie_dir = (Direction) sign (int (dir2));
 179
 180   for (int i=0; i<  tie_p_arr_.size (); i++)
 181    {
 182       tie_p_arr_[i]->dir_ = tie_dir;
 183       typeset_element (tie_p_arr_[i]);
 184     }
 185   tie_p_arr_.clear ();
 186 }
 187
 188 void
 189 Tie_engraver::do_post_move_processing ()
 190 {
 191   if (get_property ("automaticMelismata",0).to_bool ())
 192     {
 193       set_melisma (false);
 194     }
 195   req_l_ = 0;
 196   Moment now = now_mom ();
 197   while (past_notes_pq_.size () && past_notes_pq_.front ().end_ < now)
 198     past_notes_pq_.delmin ();
 199 }
 200
 201 ADD_THIS_TRANSLATOR(Tie_engraver);
 202
 203
 204 CHead_melodic_tuple::CHead_melodic_tuple ()
 205 {
 206   head_l_ =0;
 207   req_l_ =0;
 208   end_ = 0;
 209 }
 210
 211 CHead_melodic_tuple::CHead_melodic_tuple (Note_head *h, Melodic_req*m, Moment mom)
 212 {
 213   head_l_ = h;
 214   req_l_ = m;
 215   end_ = mom;
 216 }
 217
 218 int
 219 CHead_melodic_tuple::pitch_compare (CHead_melodic_tuple const&h1,
 220                              CHead_melodic_tuple const &h2)
 221 {
 222   return Melodic_req::compare (*h1.req_l_, *h2.req_l_);
 223 }
 224
 225 int
 226 CHead_melodic_tuple::time_compare (CHead_melodic_tuple const&h1,
 227                              CHead_melodic_tuple const &h2)
 228 {
 229   return (h1.end_ - h2.end_ ).sign ();
 230 }