lilypond-0.0.38

diff --git a/src/register.cc b/src/register.cc
index a1b45a96a5a090617e455c1bbe369c08e567bed2..126507cc6b9ecbfaea032b88060490986c934b7d 100644 (file)
--- a/src/register.cc
+++ b/src/register.cc
@@ -10,9 +10,11 @@
 #include "musicalrequest.hh"
 #include "register.hh"
 #include "notehead.hh"
-#include "complexwalker.hh"
-#include "localkeyitem.hh"
-#include "complexstaff.hh"
+#include "complex-walker.hh"
+#include "local-key-item.hh"
+#include "complex-staff.hh"
+#include "registergroup.hh"
+#include "debug.hh"
 
 
 bool
@@ -23,54 +25,33 @@ Request_register::try_request(Request*)
 
 Request_register::Request_register()
 {
-    walk_l_=0;
-}
-
-Request_register::Request_register(Complex_walker*w_l)
-{
-    walk_l_=w_l;    
-}
-
-void
-Request_register::pre_move_processing()
-{    
-    do_pre_move_process();
-    accepted_req_arr_.set_size(0);
-}
-void
-Request_register::post_move_processing()
-{    
-    do_post_move_process();
-}
-
-Request_register::Request_register(Request_register const&)
-{
-    assert(false);
+    daddy_reg_l_ = 0;
 }
 
 void
 Request_register::announce_element(Staff_elem_info i)
 {
-    walk_l_->announce_element(i);
+    i.origin_reg_l_arr_.push(this);
+    daddy_reg_l_->announce_element(i);
 }
 
 void
 Request_register::typeset_element(Staff_elem*p)
 {
-    walk_l_->typeset_element(p);
+    daddy_reg_l_->typeset_element(p);
 }
 
-Paperdef*
+Paper_def*
 Request_register::paper()const
 {
-    return walk_l_->staff()->paper();
+    return daddy_reg_l_->paper();
 }
 
 void
 Request_register::typeset_breakable_item(Item * pre_p , Item * nobreak_p,
                                         Item * post_p)
 {
-    walk_l_->typeset_breakable_item(pre_p,  nobreak_p,post_p);
+    daddy_reg_l_->typeset_breakable_item(pre_p,  nobreak_p, post_p);
 }
 
 bool
@@ -78,3 +59,30 @@ Request_register::acceptable_request_b(Request*)const
 {
     return false;
 }
+
+bool
+Request_register::contains_b(Request_register *reg_l)
+{
+    return this == reg_l;
+}
+
+Staff_info
+Request_register::get_staff_info() return inf;
+{
+    inf = daddy_reg_l_->get_staff_info();
+}
+
+void
+Request_register::print() const
+{
+#ifndef NPRINT
+    mtor << name() << " {";
+    do_print();
+    mtor << "}\n";
+#endif
+}
+
+void
+Request_register::do_print()const
+{
+}

diff --git a/src/registergroup.cc b/src/registergroup.cc
index c1bb809be877b5c8abea12a185b1a93663a95f46..87652e5e5472429a96a5ac4422035ce512c4dadb 100644 (file)
--- a/src/registergroup.cc
+++ b/src/registergroup.cc
@@ -1,5 +1,5 @@
 /*
-  registergroup.cc -- implement Register_group
+  registergroup.cc -- implement Register_group_register
 
   source file of the LilyPond music typesetter
 
@@ -10,7 +10,7 @@
 #include "register.hh"
 
 bool
-Register_group::acceptable_request_b(Request* r)
+Register_group_register::acceptable_request_b(Request* r)
 {
     for (iter_top(reg_list_, i); i.ok(); i++) {
        if (i->acceptable_request_b(r))
@@ -20,54 +20,61 @@ Register_group::acceptable_request_b(Request* r)
 }
 
 void
-Register_group::set_dir(int d)
+Register_group_register::set_feature(Features d)
 {
     for (iter_top(reg_list_, i); i.ok(); i++) {
-       i->set_dir(d);
+       i->set_feature(d);
     }
 }
 
 void
-Register_group::pre_move_processing()
+Register_group_register::pre_move_processing()
 {
     for (iter_top(reg_list_, i); i.ok(); i++) 
        i->pre_move_processing();
 }
 
 void
-Register_group::process_requests()
+Register_group_register::process_requests()
 {
     for (iter_top(reg_list_, i); i.ok(); i++) 
-       i->process_request();
+       i->process_requests();
 }
 
 void
-Register_group::post_move_processing()
+Register_group_register::post_move_processing()
 {
     for (iter_top(reg_list_, i); i.ok(); i++) 
        i->post_move_processing();
 }
 
 void
-Register_group::acknowledge_element(Staff_elem_info info)
+Register_group_register::acknowledge_element(Staff_elem_info info)
 {
+    if (!contains_b(info.origin_reg_l_arr_[0]))
+       return;
+    
     for (iter_top(reg_list_, i); i.ok(); i++) 
        i->acknowledge_element(info);
 }
 
-
 bool
-Register_group::contains_b(Request_register* reg_l)
+Register_group_register::contains_b(Request_register* reg_l)
 {
-     for (iter_top(reg_list_, i); i.ok(); i++) 
-       if (i.ptr() == reg_l)
+    bool parent_b = Request_register::contains_b(reg_l);
+    
+    if (parent_b)
+       return true;
+    for (iter_top(reg_list_, j); j.ok(); j++)
+       if (j->contains_b(reg_l))
            return true;
-     return false;
+    return false;
 }
+       
 
 
 bool
-Register_group::try_request(Request*req_l)
+Register_group_register::try_request(Request*req_l)
 {
     for (iter_top(reg_list_, i); i.ok(); i++) 
        if (i->try_request(req_l))
@@ -75,14 +82,38 @@ Register_group::try_request(Request*req_l)
     return false;
 }
 
-
-                           
 void
-Register_group::add(Request_register *reg_p)
+Register_group_register::add(Request_register *reg_p)
 {
     reg_list_.bottom().add(reg_p);
+    reg_p->daddy_reg_l_ = this;
+}
+
+
+Register_group_register::~Register_group_register()
+{
+    
+}
+
+Request_register *
+Register_group_register::get_register_p(Request_register*reg_l)
+{
+    iterator(reg_list_) reg_cur= reg_list_.find(reg_l);
+    assert(reg_cur.ok());
+    return reg_cur.get_p();
+}
+
+void
+Register_group_register::terminate_register(Request_register*r_l)
+{
+    delete get_register_p(r_l);
 }
 
-Register_group::~Register_group()
+void
+Register_group_register::do_print()const
 {
+#ifndef NPRINT
+    for (iter_top(reg_list_, i); i.ok(); i++) 
+       i->print();
+#endif
 }

diff --git a/src/voice-regs.cc b/src/voice-regs.cc
new file mode 100644 (file)
index 0000000..1f61617
--- /dev/null
+++ b/src/voice-regs.cc
@@ -0,0 +1,65 @@
+/*
+  voice-regs.cc -- implement Voice_registers
+
+  source file of the LilyPond music typesetter
+
+  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+*/
+#include "commandrequest.hh"
+#include "musicalrequest.hh"
+#include "voice-regs.hh"
+#include "register.hh"
+#include "slur-reg.hh"
+#include "headreg.hh"
+#include "walkregs.hh"
+#include "debug.hh"
+
+Voice_registers::Voice_registers(Voice *v_p)
+{
+    voice_l_ = v_p;
+    add(new Notehead_register);
+    add(new Slur_register);
+}
+
+void
+Voice_registers::acknowledge_element(Staff_elem_info i)
+{
+    if (i.voice_l_ != voice_l_)
+       return;
+    Register_group_register::acknowledge_element(i);
+}
+
+bool
+Voice_registers::try_request(Request*r_l)
+{
+    if (r_l->voice_l() !=voice_l_)
+       return false;
+    
+    Command_req *c=r_l->command();
+    if (c&&c->terminate()) {
+       daddy_reg_l_->terminate_register(this);
+       return true;            // scary. We're deleted now.. 
+    } else if (c&&c->groupchange()) {
+
+       ((Walker_registers*)daddy_reg_l_->daddy_reg_l_)->       // scary.
+           change_group(c->groupchange(), this,
+                        (Voice_group_registers*)daddy_reg_l_); // UGR!
+       return true;
+    }
+    
+    return Register_group_register::try_request(r_l);
+}
+
+bool
+Voice_registers::acceptable_request_b(Request*r)
+{
+//    return (r->rest() || r->note() || r->slur() || r->groupchange());
+    return  r->groupchange()
+       || Register_group_register::acceptable_request_b(r);
+}
+void
+Voice_registers::do_print() const
+{
+    mtor << "Voice= " << voice_l_<<'\n';
+    Register_group_register::do_print();
+}