release: 0.1.11

[lilypond.git] / lily / spanner.cc

diff --git a/lily/spanner.cc b/lily/spanner.cc
index eac107ba8dc113e7c4d51a2c529cc9feb2edd5c4..397cfdb6c5fbf37c9bd8fd20a4f3c2230460d6ea 100644 (file)
--- a/lily/spanner.cc
+++ b/lily/spanner.cc
@@ -15,37 +15,26 @@
 IMPLEMENT_IS_TYPE_B1(Spanner,Score_elem);
 
 void
-Spanner::do_print()const
+Spanner::do_print() const
 {
 #ifndef NPRINT
   DOUT << "Between col ";
-  if ( left_col_l_)
-       DOUT << left_col_l_->rank_i();
-  else 
-       DOUT << "nop";
-  DOUT << ", ";
-  if ( right_col_l_)
-       DOUT << right_col_l_->rank_i();
-  else 
-       DOUT << "nop";
   if (broken_into_l_arr_.size())
-       DOUT << "with broken pieces\n";
+    DOUT << "with broken pieces\n";
 #endif
 }
 
 void
-Spanner::break_into_pieces (bool copy_deps_b)
+Spanner::break_into_pieces ()
 {
-  if (  broken_into_l_arr_.size())
-       return; 
+  if (broken_into_l_arr_.size())
+    return; 
         
-  PCol * left = left_col_l_;
-  PCol * right = right_col_l_;
-  if (left->daddy_l_) left = left->daddy_l_;
-  if (right->daddy_l_) right = right->daddy_l_;
+  Item * left = spanned_drul_[LEFT];
+  Item * right = spanned_drul_[RIGHT];
   
   
-  Link_array<PCol> break_cols = pscore_l_->broken_col_range (left,right);
+  Link_array<Item> break_cols = pscore_l_->broken_col_range (left,right);
   Link_array<Spanner> broken_into_l_arr;
 
   break_cols.insert (left,0);
@@ -53,23 +42,21 @@ Spanner::break_into_pieces (bool copy_deps_b)
 
   for (int i=1; i < break_cols.size(); i++) 
     {
-       Spanner* span_p = clone()->spanner ();
-       if (copy_deps_b)
-           span_p->copy_dependencies (*this);
-       left = break_cols[i-1];
-       right = break_cols[i];
-       if (!right->line_l_)
-           right = right->prebreak_p_;
-       if (!left->line_l_)
-           left = left->postbreak_p_;
-
-       assert (left&&right && left->line_l_ == right->line_l_);
-
-       span_p->left_col_l_  = left;
-       span_p->right_col_l_ = right;
+      Spanner* span_p = clone()->spanner ();
+      left = break_cols[i-1];
+      right = break_cols[i];
+      if (!right->line_l())
+       right = right->find_prebroken_piece(-1);
+      if (!left->line_l())
+       left = left->find_prebroken_piece(1);
+
+            assert (left&&right && left->line_l() == right->line_l());
+
+      span_p->set_bounds(LEFT,left);
+      span_p->set_bounds(RIGHT,right);
        
-       pscore_l_->typeset_broken_spanner (span_p);
-       broken_into_l_arr.push (span_p);
+      pscore_l_->typeset_broken_spanner (span_p);
+      broken_into_l_arr.push (span_p);
     }
    
   broken_into_l_arr_ = broken_into_l_arr;
@@ -78,68 +65,110 @@ Spanner::break_into_pieces (bool copy_deps_b)
 void
 Spanner::set_my_columns()
 {
-  if (!left_col_l_->line_l_)
-       left_col_l_ = left_col_l_->postbreak_p_;
-  if (!right_col_l_->line_l_)
-       right_col_l_ = right_col_l_->prebreak_p_;
+  Direction i = (Direction)1;
+  do 
+    {
+      if (!spanned_drul_[i]->line_l())
+       set_bounds(i,spanned_drul_[i]->find_prebroken_piece(-i));
+    } 
+  while ((i*=-1) != 1);
 }       
 
+
 void
-Spanner::do_break_processing()
+Spanner::set_bounds(Direction d, Item*i)
 {
-  set_my_columns();
+  if (spanned_drul_[d])
+    spanned_drul_[d]->attached_span_l_arr_.substitute(this,0);
   
-  if (!line_l()) 
+  spanned_drul_[d] =i;
+  if (i)
+    i->attached_span_l_arr_.push(this);
+}
+
+void
+Spanner::do_break_processing()
+{
+  if (!line_l())
     {
-       break_into_pieces (true);
-       for (int i=0; i < broken_into_l_arr_.size(); i++)
-           broken_into_l_arr_[i]->handle_broken_dependencies();
+      break_into_pieces ();
+      for (int i=0; i < broken_into_l_arr_.size(); i++)
+       broken_into_l_arr_[i]->handle_broken_dependencies();
     }
   else 
     {
-       handle_broken_dependencies();
+      handle_broken_dependencies();
     }
 }
 
 
 Spanner::Spanner()
 {
-  left_col_l_ = right_col_l_ = 0;
+  spanned_drul_[LEFT]=0;
+  spanned_drul_[RIGHT]=0;
 }
 
+String
+Spanner::do_TeX_output_str () const
+{
+  Offset left_off (spanned_drul_[LEFT]->absolute_coordinate(X_AXIS), 0);
+  return make_TeX_string (absolute_offset() + left_off);
+}
 
 Interval
-Spanner::do_width()const
+Spanner::do_width() const
 {
-  Real r = right_col_l_->hpos_f_;
-  Real l = left_col_l_->hpos_f_;
-  assert (*left_col_l_ < *right_col_l_);
+  Real l = spanned_drul_[LEFT]->absolute_coordinate (X_AXIS);
+  Real r = spanned_drul_[RIGHT]->absolute_coordinate (X_AXIS);
   assert (r>=l);
        
   return Interval (0, r-l);
 }
 
 Line_of_score *
-Spanner::line_l()const
+Spanner::line_l() const
 {
-  if ( left_col_l_->line_l_ != right_col_l_->line_l_)
-       return 0;
-  return left_col_l_->line_l_;
+  if (!spanned_drul_[LEFT] || !spanned_drul_[RIGHT])
+    return 0;
+  if (spanned_drul_[LEFT]->line_l() != spanned_drul_[RIGHT]->line_l())
+    return 0;
+  return spanned_drul_[LEFT]->line_l();
 }
 
 
 Spanner*
-Spanner::find_broken_piece (Line_of_score*l)const
+Spanner::find_broken_piece (Line_of_score*l) const
 {
   for (int i=0; i < broken_into_l_arr_.size(); i++)
-       if (broken_into_l_arr_[i]->line_l() == l)
-           return broken_into_l_arr_[i];
+    if (broken_into_l_arr_[i]->line_l() == l)
+      return broken_into_l_arr_[i];
   return 0;                               
          
 }
 
 bool
-Spanner::broken_b()const
+Spanner::broken_b() const
 {
   return broken_into_l_arr_.size();
 }
+
+void
+Spanner::do_unlink() 
+{
+  if (spanned_drul_[LEFT]) 
+    {
+      spanned_drul_[LEFT]->attached_span_l_arr_.substitute (this,0);
+      spanned_drul_[LEFT] =0;
+    }
+  if (spanned_drul_[RIGHT]) 
+    {
+      spanned_drul_[RIGHT]->attached_span_l_arr_.substitute (this,0);
+      spanned_drul_[RIGHT] = 0;
+    }
+}
+
+void
+Spanner::do_junk_links()
+{
+  spanned_drul_[LEFT] = spanned_drul_[RIGHT] =0;
+}