release: 0.0.68pre

[lilypond.git] / lily / score-elem.cc

diff --git a/lily/score-elem.cc b/lily/score-elem.cc
index 11ce7936aaaef79e7d6bc1591504237f2fd9acc8..868dc3e176340ffec850aa1e5782fc8ed20f0e5a 100644 (file)
--- a/lily/score-elem.cc
+++ b/lily/score-elem.cc
@@ -16,6 +16,8 @@
 #include "dimen.hh"
 #include "spanner.hh"
 #include "scoreline.hh"
+#include "item.hh"
+#include "p-col.hh"
 
 Score_elem*
 Score_elem::dependency(int i)const
@@ -46,6 +48,8 @@ String
 Score_elem::TeX_string() const
 {
     assert( status > POSTCALCED);
+    if (transparent_b_ )
+       return "";
     String s("\\placebox{%}{%}{%}");
     Array<String> a;
     a.push(print_dimen(offset_.y));
@@ -57,12 +61,15 @@ Score_elem::TeX_string() const
 
 Score_elem::Score_elem(Score_elem const&s)
 {
+    transparent_b_ = s.transparent_b_;
+    empty_b_ = s.empty_b_;
     /* called from derived ctor, so most info points to the same deps
       as (Directed_graph_node&)s. Nobody points to us, so don't copy
       dependents.      
      */
     copy_edges_out(s);
-    group_element_i_ = 0;
+    x_group_element_i_ = 0;
+    y_group_element_i_ = 0;    
     status = s.status;
     assert(!s.output);
     output = 0;
@@ -77,20 +84,36 @@ Score_elem::~Score_elem()
     delete output;
     status = DELETED;
     output = 0;
-    assert(!group_element_i_ );
+    assert(!x_group_element_i_ && !y_group_element_i_);
 }
 
+void
+Score_elem::translate_x(Real x)
+{
+    offset_.x += x;
+}
+
+
+
+void
+Score_elem::translate_y(Real y)
+{
+    offset_.y += y;
+}
+
+
 void
 Score_elem::translate(Offset O)
 {
-    offset_ += O;
+    translate_y(O.y);
+    translate_x(O.x);
 }
 
 Interval
 Score_elem::do_width() const 
 {
     Interval r;
-    
+
     if (!output){
        Molecule*m = brew_molecule_p();
        r = m->extent().x;
@@ -103,7 +126,7 @@ Score_elem::do_width() const
 Interval
 Score_elem::width() const
 {
-    Interval r=do_width();
+    Interval r=(empty_b_)?Interval(0,0):do_width();
 
     if (!r.empty_b()) // float exception on DEC Alpha
        r+=offset_.x;
@@ -127,7 +150,7 @@ Score_elem::do_height() const
 Interval
 Score_elem::height() const
 {
-    Interval r=do_height();
+    Interval r=(empty_b_)?Interval(0,0): do_height();
 
     if (!r.empty_b())
        r+=offset_.y;
@@ -141,7 +164,7 @@ Score_elem::print()const
 {
 #ifndef NPRINT
     mtor << name() << "{\n";
-    mtor << "deps: " << dependent_size() << "depts: \n" << 
+    mtor << "dets: " << dependent_size() << "dependencies: " << 
        dependency_size() << "\n";
     do_print();
     if (output)
@@ -155,7 +178,9 @@ Score_elem::print()const
 
 Score_elem::Score_elem()
 {
-    group_element_i_ = 0;
+    transparent_b_ = empty_b_ = false;
+    x_group_element_i_ = 0;
+    y_group_element_i_ =0;
     pscore_l_=0;
     offset_ = Offset(0,0);
     output = 0;
@@ -196,6 +221,23 @@ Score_elem::pre_processing()
     status = PRECALCED;
 }
 
+void
+Score_elem::breakable_col_processing()
+{
+    if (status >= PREBROKEN )
+       return;
+
+    assert(status != PREBREAKING); // cyclic dependency
+    status = PREBREAKING;
+
+    for (int i=0; i < dependency_size(); i++)
+       dependency(i)->breakable_col_processing();
+
+    
+    do_breakable_col_processing();
+    status = PREBROKEN;
+}
+
 void
 Score_elem::break_processing()
 {
@@ -245,6 +287,8 @@ Score_elem::molecule_processing()
     for (int i=0; i < dependency_size(); i++)
        dependency(i)->molecule_processing();
 
+    if (transparent_b_)
+       return ;
     output= brew_molecule_p();
 }
 
@@ -253,6 +297,12 @@ Score_elem::do_post_processing()
 {
 }
 
+void
+Score_elem::do_breakable_col_processing()
+{
+    handle_prebroken_dependencies();
+}
+
 void
 Score_elem::do_pre_processing()
 {
@@ -271,6 +321,7 @@ Score_elem::do_substitute_dependency(Score_elem*,Score_elem*)
 
 
 IMPLEMENT_STATIC_NAME(Score_elem);
+IMPLEMENT_IS_TYPE_B(Score_elem);
 
 Molecule*
 Score_elem::brew_molecule_p()const
@@ -307,11 +358,6 @@ Score_elem::add_dependency(Score_elem*e)
     Directed_graph_node::add(e);
 }
 
-bool
-Score_elem::is_type_b(char const *s)
-{
-    return s == static_name();
-}
 
 void
 Score_elem::handle_broken_dependencies()
@@ -329,7 +375,12 @@ Score_elem::handle_broken_dependencies()
                Spanner * broken = sp->find_broken_piece(line);
                do_substitute_dependency(sp, broken);
                add_dependency(broken);
-               remove_us_arr.push(sp);
+           } else if (elt->item() && elt->item()->pcol_l_->breakpoint_b()
+                      && elt->item()->break_status_i() == 0) {
+               Item * my_item = elt->item()->find_prebroken_piece(line);
+               do_substitute_dependency( elt, my_item);
+               if (my_item)
+                   add_dependency( my_item);
            }
            remove_us_arr.push(elt);
        } 
@@ -341,10 +392,61 @@ Score_elem::handle_broken_dependencies()
     for (int i=0;  i <remove_us_arr.size(); i++)
        remove_dependency(remove_us_arr[i]);
 
+    /* Reset this. If we are a (broken) copy of a spanner, then
+      break_processing() was not called on us (and we are not breaking).  */
     if (status < BROKEN)
        status = BROKEN;
 }
 
+/*
+  This sux.
+
+  unlike with spanners, the number of items can increase
+
+  span: item1
+
+  becomes
+
+  span: item1 item2 item3
+
+  How to let span (a derived class) know that this happened?
+ */
+void
+Score_elem::handle_prebroken_dependencies()
+{
+    Link_array<Score_elem> remove_us_arr;
+    for (int i=0; i < dependency_size(); i++) {
+       Score_elem * elt = dependency(i);
+       Item *it_l = elt->item();
+       if (it_l && it_l->pcol_l_->breakable_b())
+           if (item()) {
+               Score_elem *new_l = it_l->find_prebroken_piece(item()->pcol_l_);
+               if (new_l != elt ) {
+                   do_substitute_dependency( elt, new_l);
+                   remove_us_arr.push(elt);
+                   
+                   add_dependency(new_l);
+               } 
+           }else {
+               add_dependency(it_l->broken_to_a_[0]);
+               add_dependency(it_l->broken_to_a_[1]);          
+           }
+
+    }
+    
+    remove_us_arr.default_sort();
+    remove_us_arr.uniq();
+    for (int i=0;  i <remove_us_arr.size(); i++)
+       remove_dependency(remove_us_arr[i]);
+
+    /*
+      see comment at handle_broken_dependencies()
+     */
+    if (status < PREBROKEN)
+       status = PREBROKEN;
+}
+
+
 
 void
 Score_elem::unlink_all()
@@ -352,7 +454,8 @@ Score_elem::unlink_all()
     for (int i=0; i < dependency_size(); i++) 
        dependency(i)->unlink_all();
     junk_links();
-    group_element_i_ = 0;
+    y_group_element_i_ = 0;
+    x_group_element_i_ = 0;
 }
 
 void