release: 1.3.49

[lilypond.git] / lily / spanner.cc

diff --git a/lily/spanner.cc b/lily/spanner.cc
index 7d0ca15fdd2635b27c47641b2c2231f1c5c6ddf6..9a8ed71038379a4cc4de36abed5e67c7144d7153 100644 (file)
--- a/lily/spanner.cc
+++ b/lily/spanner.cc
@@ -3,7 +3,7 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c) 1996, 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+  (c) 1996--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
 */
 #include <math.h>
 
@@ -18,52 +18,100 @@
 #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)
     {
-      warning (_ ("Left spanpoint is right spanpoint"));
-      return;
+      warning (_f ("Spanner `%s' has equal left and right spanpoints",
+                  classname (this)));
     }
-  
-  Link_array<Item> break_points = pscore_l_->broken_col_range (left,right);
 
-  break_points.insert (left,0);
-  break_points.push (right);
+  /*
+    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;
 
-  for (int i=1; i < break_points.size(); i++) 
+  if  (left == right)
     {
-      Drul_array<Item*> bounds;
-      bounds[LEFT] = break_points[i-1];
-      bounds[RIGHT] = break_points[i];
+      /*
+       FIXME: this is broken.
+       */
+      /*
+       If we have a spanner spanning one column, we must break it
+       anyway because it might provide a parent for another item.  */
       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);
+         Item* bound = left->find_broken_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 ()); 
+             span_p->line_l ()->typeset_element (span_p);
+             broken_into_l_arr_.push (span_p);
+           }
        }
       while ((flip(&d))!= LEFT);
-
-      Spanner *span_p = dynamic_cast<Spanner*>(clone ());
-      span_p->set_bounds(LEFT,bounds[LEFT]);
-      span_p->set_bounds(RIGHT,bounds[RIGHT]);
-      
-      pscore_l_->typeset_element (span_p);
-      broken_into_l_arr_.push (span_p);
     }
+  else
+    {
+      Link_array<Item> break_points = pscore_l_->line_l_->broken_col_range (left,right);
+
+      break_points.insert (left,0);
+      break_points.push (right);
+
+      for (int i=1; i < break_points.size(); i++) 
+       {
+         Drul_array<Item*> bounds;
+         bounds[LEFT] = break_points[i-1];
+         bounds[RIGHT] = break_points[i];
+         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);
+           }
+         while ((flip(&d))!= LEFT);
+
+         Spanner *span_p = dynamic_cast<Spanner*>(clone ());
+         span_p->set_bound(LEFT,bounds[LEFT]);
+         span_p->set_bound(RIGHT,bounds[RIGHT]);
 
+
+         assert (bounds[LEFT]->line_l () ==
+                 bounds[RIGHT]->line_l ());
+
+         bounds[LEFT]->line_l ()->typeset_element (span_p);
+         broken_into_l_arr_.push (span_p);
+       }
+    }
   broken_into_l_arr_.sort (Spanner::compare);
 }
 
@@ -74,13 +122,35 @@ Spanner::set_my_columns()
   do 
     {
       if (!spanned_drul_[i]->line_l())
-       set_bounds(i,spanned_drul_[i]->find_broken_piece((Direction) -i));
+       set_bound(i,spanned_drul_[i]->find_broken_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
+{
+  return spanned_drul_ [d];
+}
+
 void
-Spanner::set_bounds(Direction d, Item*i)
+Spanner::set_bound(Direction d, Item*i)
 {
   spanned_drul_[d] =i;
   if (i)
@@ -98,7 +168,8 @@ Spanner::set_bounds(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)));
 }