src/voiceregs.cc

   1 #include "rest.hh"
   2 #include "notehead.hh"
   3 #include "paper.hh"
   4 #include "debug.hh"
   5 #include "slur.hh"
   6 #include "request.hh"
   7 #include "complexwalker.hh"
   8 #include "complexstaff.hh"
   9 #include "voicegroup.hh"
  10 #include "register.hh"
  11
  12 Voice_registers::Voice_registers(Complex_walker*c_l, Voice *v_p)
  13     : head_reg_(c_l), slur_reg_(c_l)
  14 {
  15     voice_l_ = v_p;
  16 }
  17
  18 bool
  19 Voice_registers::try_request(Request * r_l)
  20 {
  21     bool b = head_reg_.try_request(r_l);
  22     if (!b)
  23         b = slur_reg_.try_request(r_l);
  24     return b;
  25 }
  26
  27 void
  28 Voice_registers::announce_element(Staff_elem_info i)
  29 {
  30     if (i.voice_l_ != voice_l_)
  31         return;
  32     if (i.origin_reg_l_ != &slur_reg_)
  33         slur_reg_.acknowledge_element(i);
  34 }
  35
  36 void
  37 Voice_registers::pre_move_processing()
  38 {
  39     head_reg_.pre_move_processing();
  40     slur_reg_.pre_move_processing();
  41 }
  42 void
  43 Voice_registers::post_move_processing()
  44 {
  45     head_reg_.post_move_processing();
  46     slur_reg_.post_move_processing();
  47 }
  48
  49 void
  50 Voice_registers::process_requests()
  51 {
  52     head_reg_.process_request();
  53     slur_reg_.process_request();
  54 }
  55
  56 /****************/
  57
  58 Notehead_register::Notehead_register(Complex_walker*w_l)
  59     :Request_register(w_l)
  60 {
  61     note_l_ = 0;
  62 }
  63
  64 bool
  65 Notehead_register::try_request(Request *req_l)
  66 {
  67     if (req_l->note() || req_l->rest())
  68         accepted_req_arr_.push(req_l);
  69     else
  70         return false;
  71
  72     return true;
  73 }
  74
  75 void
  76 Notehead_register::process_request()
  77 {
  78     Request* req_l = accepted_req_arr_.last();
  79     if (req_l->note()) {
  80         Notehead*n_p = new Notehead(8); // ugh
  81         note_l_ = n_p;
  82         n_p->set_rhythmic(req_l->rhythmic());
  83         n_p->position = req_l->note()->height() + -2;
  84     } else {
  85         note_l_ = new Rest ( req_l->rhythmic()->balltype,
  86                              req_l->rhythmic()->dots);
  87         if (req_l->rhythmic()->balltype <= 2)
  88             note_l_->translate(
  89                 Offset(0,
  90                        5 * walk_l_->staff()->paper()->internote()));
  91     }
  92     Staff_elem_info itinf(note_l_,req_l,this);
  93     walk_l_->announce_element(itinf);
  94 }
  95
  96 void
  97 Notehead_register::do_pre_move_process()
  98 {
  99     if (note_l_) {
 100         walk_l_->typeset_element(note_l_);
 101         note_l_ = 0;
 102     }
 103 }
 104
 105 /****************/
 106 /****************/
 107
 108 Slur_register::Slur_register(Complex_walker* w)
 109     : Request_register(w)
 110 {
 111 }
 112
 113 bool
 114 Slur_register::try_request(Request *req_l)
 115 {
 116     if(!req_l->slur())
 117         return false;
 118
 119     accepted_req_arr_.push(req_l);
 120     return true;
 121 }
 122
 123 void
 124 Slur_register::acknowledge_element(Staff_elem_info info)
 125 {
 126     if (info.elem_p_->name() == String("Notehead")) {
 127         Notehead *head_p =(Notehead*) info.elem_p_ ;// ugh
 128         for (int i = 0; i < slur_l_stack_.size(); i++)
 129             slur_l_stack_[i]->add(head_p );
 130         for (int i = 0; i < end_slur_l_arr_.size(); i++)
 131             end_slur_l_arr_[i]->add(head_p);
 132     }
 133 }
 134
 135 void
 136 Slur_register::process_request()
 137 {
 138     Array<Slur*> start_slur_l_arr_;
 139     for (int i=0; i< accepted_req_arr_.size(); i++) {
 140         Slur_req* slur_req_l = accepted_req_arr_[i]->slur();
 141         if (slur_req_l->spantype == Span_req::STOP) {
 142             if (slur_l_stack_.empty())
 143                 error_t("can't find slur to end; ",
 144                         *walk_l_->col()->tdescription_);
 145             end_slur_l_arr_.push(slur_l_stack_.pop());
 146
 147         } else  if (slur_req_l->spantype == Span_req::START) {
 148             Slur * s_p =new Slur;
 149             start_slur_l_arr_.push(s_p);
 150             walk_l_->announce_element(Staff_elem_info(s_p, slur_req_l, this));
 151         }
 152     }
 153     for (int i=0; i < start_slur_l_arr_.size(); i++)
 154         slur_l_stack_.push(start_slur_l_arr_[i]);
 155 }
 156
 157 void
 158 Slur_register::do_pre_move_process()
 159 {
 160     for (int i = 0; i < end_slur_l_arr_.size(); i++)
 161         walk_l_->typeset_element(end_slur_l_arr_[i]);
 162     end_slur_l_arr_.set_size(0);
 163 }
 164
 165 Slur_register::~Slur_register()
 166 {
 167     if (slur_l_stack_.size())
 168         error("unterminated slur");
 169 }