lilypond-0.0.32

diff --git a/src/complexwalker.cc b/src/complexwalker.cc
index ba8253205b8b9c832c998061345c3bd83960476b..c6478fbb236f78b8231b13d523bfcdc522ad74f1 100644 (file)
--- a/src/complexwalker.cc
+++ b/src/complexwalker.cc
@@ -1,115 +1,28 @@
+/*
+  complexwalker.cc -- implement Complex_walker
+
+  source file of the LilyPond music typesetter
+
+  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+
 #include "associter.hh"
 #include "script.hh"
-#include "request.hh"
+#include "musicalrequest.hh"
 #include "voice.hh"
-#include "clef.hh"
 #include "pscore.hh"
 #include "complexstaff.hh"
 #include "debug.hh"
-#include "keyitem.hh"
-#include "clefitem.hh"
 #include "voicegroup.hh"
-#include "localkeyreg.hh"
 #include "complexwalker.hh"
 #include "misc.hh"
+#include "commandrequest.hh"
+#include "clefreg.hh"
+#include "localkeyreg.hh"
+#include "keyreg.hh"
+#include "meterreg.hh"
+#include "barreg.hh"
 
-Rhythmic_grouping
-parse_grouping(Array<Scalar> const &a)
-{
-    Array<int> r;
-    Array<Moment> grouplen_arr;
-    for (int i= 0 ; i < a.size()/2; ) {
-       r.push(a[i++]);
-       grouplen_arr.push(Moment(1,(int) a[i++]));
-    }
-    Moment here =0;
-
-    Array<Rhythmic_grouping*> children;
-    for (int i=0; i < r.size(); i++) {
-       
-       Moment last = here;
-       here += grouplen_arr[i] * Rational(r[i]);
-       children.push(
-           new Rhythmic_grouping(MInterval(last, here), r[i] ));
-    }
-    return Rhythmic_grouping(children);
-}
-
-void
-Complex_walker::do_INTERPRET_command(Command*com_l)
-{
-    Array<Scalar> args(com_l->args);
-    args.del(0);
-    String com = com_l->args[0];
-    
-    if (com == "GROUPING") {   
-       default_grouping = parse_grouping(args);
-    }else if (com == "NEWMEASURE") {
-       local_key_.reset(key_);
-
-    } else if (com == "KEY") {
-       
-       if (col()->when() > Moment(0)) {
-           assert(!oldkey_undo);
-           oldkey_undo = new Array<int>( key_.oldkey_undo(args));
-       }
-       
-       typesetkey = key_.read(args);
-       local_key_.reset(key_); 
-    } else if (com == "CLEF") {
-       clef_.set_type(args[0]);
-    } else {
-       WARN << " ignoring INTERPRET command: " << com<< "\n";
-    }
-}
-
-void
-Complex_walker::do_TYPESET_command(Command*com)
-{
-    /* ignore these commands if non-default versions have been
-      processed.  */
-    if (com->args[0] == "CURRENTKEY") 
-       if (processed_key) 
-           return;
-       else
-           com->args[0] = "KEY"; // urgh
-    
-    if (com->args[0] == "CURRENTCLEF") {
-       if (processed_clef) 
-           return;
-    }
-    if (com->args[0] == "BAR") {
-       
-       if (processed_bar_priority > com->priority)
-           return;
-       else
-           processed_bar_priority = com->priority;
-    }
-
-    Item* i = staff()->get_TYPESET_item(com);
-    if (!i)
-       return;
-
-    if (com->args[0] == "KEY") {
-       ((Keyitem*) i)->read(clef_);
-       if (oldkey_undo) {
-           ((Keyitem*) i)->read(*oldkey_undo);
-           delete oldkey_undo;
-           oldkey_undo = 0;
-       }
-       processed_key = true;
-       
-       ((Keyitem*) i)->read(typesetkey); // ugh        
-    }
-
-    if (com->args[0] == "CLEF"||com->args[0] == "CURRENTCLEF") {
-       processed_clef =true;
-       Clef_item*c=(Clef_item*)i;
-       c->read(clef_);
-       c->change = (break_status != BREAK_POST - BREAK_PRE);
-    }
-    col()->typeset_item_directional(i, 1, break_status);
-}
 
 void
 Complex_walker::announce_element(Staff_elem_info info)
@@ -121,15 +34,24 @@ Complex_walker::announce_element(Staff_elem_info info)
 void
 Complex_walker::do_announces()
 {
+    Request dummy_req;
     for (int i = 0; i < announce_info_arr_.size(); i++){
        Staff_elem_info info = announce_info_arr_[i];
+       if (!info.req_l_)
+           info.req_l_ = &dummy_req;
+       
        for (iter_top(voice_reg_list_,j); j.ok(); j++) {
            j->acknowledge_element(info);
        }
        for (iter_top ( group_reg_list_, j); j.ok(); j++) {
            j->acknowledge_element(info);
        }
-       local_key_reg_.acknowledge_element(info);
+       bar_reg_p_->acknowledge_element(info);
+       clef_reg_p_->acknowledge_element(info);
+       key_reg_p_->acknowledge_element(info);
+       meter_reg_p_->acknowledge_element(info);
+       
+       local_key_reg_p_->acknowledge_element(info);
     }
 }
 
@@ -204,15 +126,37 @@ Complex_walker::do_change_group(Voice * v, String group_id_str)
     voice_group_map_[v] = get_voice_group(group_id_str);
 }
 
+bool
+Complex_walker::try_command_request(Nonmusical_req *req_l)
+{
+    bool b=false;
+    Voice *voice_l = (Voice*)req_l->elt_l_->voice_l_; // ugh
+    if (req_l->groupchange()){
+       do_change_group(voice_l, req_l->groupchange()->newgroup_str_);
+       b|= true;
+    } else if(req_l->groupfeature()) {
+       Voice_group_registers* reg_l = get_voice_group(voice_l);
+       b |= reg_l->try_request(req_l);
+    } else {
+       if (!b)
+           b |= bar_reg_p_->try_request(req_l);
+       b |= clef_reg_p_->try_request(req_l);
+       if (!b) 
+           b |= key_reg_p_->try_request(req_l);
+       if (!b)
+           b |= meter_reg_p_->try_request(req_l);
+    }
+    return b;
+}
+
 void
 Complex_walker::try_request(Request*req)
 {
     bool b=false;
-    Voice *voice_l = req->elt_l_->voice_l_;
+    Voice *voice_l = (Voice*)req->elt_l_->voice_l_; // ahh. This sux
 
-    if (req->groupchange()) {
-       do_change_group(voice_l, req->groupchange()->newgroup_str_);
-       b = true;
+    if (req->nonmus()) {
+       b = try_command_request(req->nonmus());
     } else if (Voice_registers::acceptable_request(req)) {
        Voice_registers *vregs_l = get_voice_reg(voice_l);
        b = vregs_l->try_request(req);
@@ -222,7 +166,8 @@ Complex_walker::try_request(Request*req)
     } 
 
     if (!b)
-       warning("junking request: "  + String(req->name()), req->defined_ch_c_l_m);
+       warning("junking request: "  + String(req->name()),
+               req->defined_ch_c_l_);
 }
 
 void
@@ -251,7 +196,12 @@ Complex_walker::regs_process_requests()
     for (iter_top(group_reg_list_, j); j.ok(); j++) 
        j->process_requests();
     
-    local_key_reg_.process_request();
+    
+    bar_reg_p_->process_request();
+    clef_reg_p_->process_request();
+    key_reg_p_->process_request();
+    meter_reg_p_->process_request();
+    local_key_reg_p_->process_request();
 }
 
 void
@@ -262,17 +212,43 @@ Complex_walker::typeset_element(Staff_elem *elem_p)
     if (elem_p->spanner())
        pscore_l_->typeset_spanner(elem_p->spanner(), staff()->pstaff_l_);
     else
-       col()->typeset_item(elem_p->item()); 
+       col()->typeset_musical_item(elem_p->item()); 
 }
 
 Complex_walker::Complex_walker(Complex_staff*s)
-    : Staff_walker(s, s->pstaff_l_->pscore_l_),
-      local_key_reg_(this)      
+    : Staff_walker(s, s->pstaff_l_->pscore_l_)
 {
-    oldkey_undo = 0;
+    local_key_reg_p_= new Local_key_register(this);
+    clef_reg_p_= new Clef_register(this);
+    key_reg_p_ = new Key_register(this);
+    bar_reg_p_ = new Bar_register(this);
+    meter_reg_p_ = new Meter_register(this);
+    
     do_post_move();
 }
 
+
+Complex_walker::~Complex_walker()
+{
+    delete local_key_reg_p_;
+    delete clef_reg_p_;
+    delete meter_reg_p_;
+    delete bar_reg_p_;
+    delete key_reg_p_;
+}
+
+int
+Complex_walker::c0_position_i()const
+{
+    return c0_position_i_;
+}
+
+void
+Complex_walker::set_c0_position(int p)
+{
+    c0_position_i_ =p;
+}
+
 Complex_staff*
 Complex_walker::staff()
 {
@@ -293,31 +269,54 @@ Complex_walker::do_pre_move()
     }
     for (iter_top (group_reg_list_, j); j.ok(); j++) 
        j->pre_move_processing();
-    local_key_reg_.pre_move_processing();
+    local_key_reg_p_->pre_move_processing();
+    bar_reg_p_->pre_move_processing();
+    clef_reg_p_->pre_move_processing();
+    key_reg_p_->pre_move_processing();
+    meter_reg_p_->pre_move_processing();
+
+    col()->typeset_breakable_items(prebreak_item_p_arr_,
+                                  nobreak_item_p_arr_,
+                                  postbreak_item_p_arr_);
 }
 
 void
 Complex_walker::do_post_move()
 {
-    processed_clef = false;    
-    processed_key = false;
-    processed_bar_priority = 0;
-    
     for (iter_top(voice_reg_list_,i); i.ok(); i++) {
        i->post_move_processing();   
     }
     announce_info_arr_.set_size(0);
     for (iter_top (group_reg_list_, j); j.ok(); j++) 
        j->post_move_processing();
-    local_key_reg_.post_move_processing();
+    
+    local_key_reg_p_->post_move_processing();
+    bar_reg_p_->post_move_processing();
+    clef_reg_p_->post_move_processing();
+    key_reg_p_->post_move_processing();
+    meter_reg_p_->post_move_processing();
+
 }
 
 Array<Voice_registers*>
 Complex_walker::get_voice_regs(Voice_group_registers* group_regs_l) const
     return l_arr;
 {
-    for (Assoc_iter<Voice*,Voice_group_registers*> i(voice_group_map_); i.ok(); i++) {
+    for (Assoc_iter<Voice*,Voice_group_registers*> i(voice_group_map_);
+        i.ok(); i++) {
        if (i.val() == group_regs_l)
            l_arr.push(find_voice_reg(i.key()));
     }
 }
+
+void
+Complex_walker::typeset_breakable_item(Item * pre_p , Item * nobreak_p,
+                                      Item * post_p)
+{
+    if (pre_p)
+       prebreak_item_p_arr_.push(pre_p);
+    if (nobreak_p)
+       nobreak_item_p_arr_.push(nobreak_p);
+    if (post_p)
+       postbreak_item_p_arr_.push(post_p);
+}