release: 1.3.55

[lilypond.git] / lily / spanner.cc

diff --git a/lily/spanner.cc b/lily/spanner.cc
index 222a39149674456a2206d50d42e0da2ab62ae59a..01ae90892ce657273cf1a7b27f4932a6ec114c78 100644 (file)
--- a/lily/spanner.cc
+++ b/lily/spanner.cc
@@ -18,21 +18,45 @@
 #include "line-of-score.hh"
 #include "break-align-item.hh"
 
+
 void
-Spanner::do_break_processing()
+Spanner::do_break_processing ()
 {
   //break_into_pieces
-  
-  if (line_l () || broken_b ())
-    return;
-  
   Item * left = spanned_drul_[LEFT];
   Item * right = spanned_drul_[RIGHT];
 
+  if (!left || !right)
+    return;
+  
   if  (left == right)
     {
-      warning (_ ("Left spanpoint is right spanpoint"));
+      warning (_f ("Spanner `%s' has equal left and right spanpoints",
+                  classname (this)));
+    }
+
+  /*
+    Check if our parent in X-direction spans equally wide
+    or wider than we do.
+   */
+  for (int a = X_AXIS; a < NO_AXES; a ++)
+    {
+      if (Spanner* parent = dynamic_cast<Spanner*> (parent_l ((Axis)a)))
+       {
+         if (!parent->spanned_rank_iv ().contains_b (this->spanned_rank_iv ()))
+           {
+             programming_error (to_str ("Spanner `%s' is not fully contained in parent spanner `%s'.",
+                                        classname (this),
+                                        classname (parent)));
+           }
+       }
+    }
+  
+  if (line_l () || broken_b ())
+    return;
 
+  if  (left == right)
+    {
       /*
        FIXME: this is broken.
        */
@@ -42,20 +66,23 @@ Spanner::do_break_processing()
       Direction d = LEFT;
       do
        {
-         Item* bound = left->find_broken_piece (d);
-         Spanner * span_p = dynamic_cast<Spanner*>( clone ());
-         span_p->set_bound (LEFT, bound);
-         span_p->set_bound (RIGHT, bound);
+         Item* bound = left->find_prebroken_piece (d);
+         if (bound->line_l ())
+           {
+             Spanner * span_p = dynamic_cast<Spanner*>( clone ());
+             span_p->set_bound (LEFT, bound);
+             span_p->set_bound (RIGHT, bound);
 
-         assert (span_p->line_l ()); 
-         pscore_l_->typeset_element (span_p);
-         broken_into_l_arr_.push (span_p);
+             assert (span_p->line_l ()); 
+             span_p->line_l ()->typeset_element (span_p);
+             broken_into_l_arr_.push (span_p);
+           }
        }
       while ((flip(&d))!= LEFT);
     }
   else
     {
-      Link_array<Item> break_points = pscore_l_->broken_col_range (left,right);
+      Link_array<Item> break_points = pscore_l_->line_l_->broken_col_range (left,right);
 
       break_points.insert (left,0);
       break_points.push (right);
@@ -68,19 +95,26 @@ Spanner::do_break_processing()
          Direction d = LEFT;
          do
            {
-             Item *&pc_l = bounds[d] ;
-             if (!pc_l->line_l())
-               pc_l =  pc_l->find_broken_piece(- d);
-         
-             assert (pc_l);
+             if (!bounds[d]->line_l())
+               bounds[d] = bounds[d]->find_prebroken_piece(- d);
            }
          while ((flip(&d))!= LEFT);
 
+         if (!bounds[LEFT] ||  ! bounds[RIGHT])
+           {
+             programming_error ("bounds of this piece aren't breakable. ");
+             continue; 
+           }
+
          Spanner *span_p = dynamic_cast<Spanner*>(clone ());
          span_p->set_bound(LEFT,bounds[LEFT]);
          span_p->set_bound(RIGHT,bounds[RIGHT]);
-      
-         pscore_l_->typeset_element (span_p);
+
+
+         assert (bounds[LEFT]->line_l () ==
+                 bounds[RIGHT]->line_l ());
+
+         bounds[LEFT]->line_l ()->typeset_element (span_p);
          broken_into_l_arr_.push (span_p);
        }
     }
@@ -94,11 +128,26 @@ Spanner::set_my_columns()
   do 
     {
       if (!spanned_drul_[i]->line_l())
-       set_bound(i,spanned_drul_[i]->find_broken_piece((Direction) -i));
+       set_bound(i,spanned_drul_[i]->find_prebroken_piece((Direction) -i));
     } 
   while (flip(&i) != LEFT);
 }       
 
+Interval_t<int>
+Spanner::spanned_rank_iv ()
+{
+  Interval_t<int> iv (0, 0);
+
+  if (spanned_drul_[LEFT])
+    {
+      iv[LEFT] = spanned_drul_[LEFT]->column_l ()->rank_i ();
+    }
+  if ( spanned_drul_[RIGHT])
+    {
+      iv[RIGHT] = spanned_drul_[RIGHT]->column_l ()->rank_i ();
+    }
+  return iv;
+}
 
 Item*
 Spanner::get_bound (Direction d) const
@@ -110,14 +159,10 @@ void
 Spanner::set_bound(Direction d, Item*i)
 {
   spanned_drul_[d] =i;
-  if (i)
-    {
-      i->used_b_ = true;
-    }
 
   /**
-     Prevent the column -> line_of_score -> column -> line_of_score -> etc situation
-  */
+     We check for Line_of_score to prevent the column -> line_of_score
+     -> column -> line_of_score -> etc situation */
   if (d== LEFT && !dynamic_cast<Line_of_score*> (this))
     {
       set_parent (i, X_AXIS);
@@ -125,11 +170,13 @@ Spanner::set_bound(Direction d, Item*i)
   
   if (spanned_drul_[Direction(-d)] == spanned_drul_[d]
        && i)
-    warning (_f ("Spanner `%s' has equal left and right spanpoints", classname (this)));
+    warning (_f ("Spanner `%s' has equal left and right spanpoints",
+                classname (this)));
 }
 
 
-Spanner::Spanner ()
+Spanner::Spanner (SCM s)
+  : Score_element (s)
 {
   spanned_drul_[LEFT]=0;
   spanned_drul_[RIGHT]=0;