From: fred <fred>
Date: Sun, 24 Mar 2002 19:58:11 +0000 (+0000)
Subject: lilypond-0.1.16
X-Git-Tag: release/1.5.59~3861
X-Git-Url: https://git.donarmstrong.com/?a=commitdiff_plain;h=3b6c31dd59bd73a634cbff8c11df3ac5c6e79daa;p=lilypond.git

lilypond-0.1.16
---

diff --git a/input/toccata-fuga-E.ly b/input/toccata-fuga-E.ly
index cb1f2fc770..9b9bb6fc92 100644
--- a/input/toccata-fuga-E.ly
+++ b/input/toccata-fuga-E.ly
@@ -139,12 +139,12 @@ break = \melodic{
 
 % these should be two separate scores...
 \score{
-	\multi 1 <
-		 \type Grandstaff  \multi 3 <
-		   {\toccata_right     \break   \fuga2_right }
-		   { \toccata_left  \break   \fuga2_left }
+	 <
+		 \type Grandstaff \multi 3 <
+		   { \toccata_right \break \fuga2_right }
+		   { \toccata_left \break \fuga2_left }
 		> 
-		{  \toccata_pedal    \break   \fuga2_pedal }
+		\type Staff {  \toccata_pedal \break \fuga2_pedal }
 	>
 	\paper{}
 	\midi{
diff --git a/lily/grouping.cc b/lily/grouping.cc
index 15401fced9..2c073adc63 100644
--- a/lily/grouping.cc
+++ b/lily/grouping.cc
@@ -25,10 +25,10 @@ Rhythmic_grouping::OK() const
 
   for (int i= 0; i < children.size(); i++) 
     {
-	children[i]->OK();
-	if (i>0)
-	    assert (children[i-1]->interval().right ==
-		   children[i]->interval().left);
+      children[i]->OK();
+      if (i>0)
+	assert (children[i-1]->interval().right ==
+		children[i]->interval().left);
     }
 #endif
 }
@@ -43,29 +43,29 @@ MInterval
 Rhythmic_grouping::interval() const
 {
   if (interval_)
-	return *interval_;
+    return *interval_;
   else
-	return
-	    MInterval (children[0]->interval().left,
-		     children.top()->interval ().right);
+    return
+      MInterval (children[0]->interval().left,
+		 children.top()->interval ().right);
 }
 
 void
 Rhythmic_grouping::split (Rhythmic_grouping r)
 {
   if (interval_)
-	return ;
+    return ;
   
   r.intersect (interval());
   split (r.intervals());
   
   for (int i= 0; i < children.size(); i++) 
     {
-	if (!children[i]->interval_) 
-	  {
-	    Rhythmic_grouping here (r);	
-	    children[i]->split (here);
-	  }
+      if (!children[i]->interval_) 
+	{
+	  Rhythmic_grouping here (r);	
+	  children[i]->split (here);
+	}
     }
 }
 
@@ -76,15 +76,15 @@ Rhythmic_grouping::intervals()
   Array<MInterval> r;
   if (interval_ || children.size() == 1) 
     {
-	MInterval i (interval());
-	MInterval r1(i), r2(i);
-	r1.right = r2.left = i.center();
-	r.push (r1); r.push (r2);
+      MInterval i (interval());
+      MInterval r1(i), r2(i);
+      r1.right = r2.left = i.center();
+      r.push (r1); r.push (r2);
     }
   else 
     {
-	for (int i=0; i < children.size(); i++)
-	    r.push (children[i]->interval());
+      for (int i=0; i < children.size(); i++)
+	r.push (children[i]->interval());
     }
   return r;
 }
@@ -94,29 +94,29 @@ Rhythmic_grouping::intersect (MInterval t)
 {
   if (interval_) 
     {
-	interval_->intersect (t);
-	return;
+      interval_->intersect (t);
+      return;
     }
   
   for (int i=0; i < children.size(); i++) 
     {
-	MInterval inter = intersection (t, children[i]->interval());
-	if (inter.empty_b() || inter.length () <= Rational (0)) 
-	  {
-	    delete children[i];
-	    children[i] =0;
-	  }
-	else 
-	  {
-	    children[i]->intersect (t);
-	  }
+      MInterval inter = intersection (t, children[i]->interval());
+      if (inter.empty_b() || inter.length () <= Rational (0)) 
+	{
+	  delete children[i];
+	  children[i] =0;
+	}
+      else 
+	{
+	  children[i]->intersect (t);
+	}
     }
   for (int i=0; i < children.size();) 
     {
-	if (!children[i])
-	    children.del (i);
-	else
-	    i++;
+      if (!children[i])
+	children.del (i);
+      else
+	i++;
     }
 
 }
@@ -138,44 +138,44 @@ Rhythmic_grouping::split (Array<MInterval> splitpoints)
   Array<Rhythmic_grouping*> ch;
   while (1) 
     {
-	if  (i >= children.size() || j >= splitpoints.size ())
-	    break;
+      if  (i >= children.size() || j >= splitpoints.size ())
+	break;
 	
-	assert (
-	    children[starti]->interval().left== splitpoints[startj].left);
-		if (children[i]->interval().right < splitpoints[j].right) 
-		  {
-	    i ++;
-	  }
-	else if (children[i]->interval().right > splitpoints[j].right) 
-	  {
-	    j ++;
-	  }
-	else 
-	  {
-
-	    if (i == starti) 
-	      {
-		ch.push (children[i]);
-	      }
-	    else 
-	      {
-		Rhythmic_grouping *newchild=new Rhythmic_grouping (
-		    children.slice (starti, i+1));
-
-		ch.push (newchild);
-	      }
-	    i ++;
-	    j++;
-	    starti = i;
-	    startj = j;
-
-
-	  }
+      assert (
+	      children[starti]->interval().left== splitpoints[startj].left);
+      if (children[i]->interval().right < splitpoints[j].right) 
+	{
+	  i ++;
+	}
+      else if (children[i]->interval().right > splitpoints[j].right) 
+	{
+	  j ++;
+	}
+      else 
+	{
+
+	  if (i == starti) 
+	    {
+	      ch.push (children[i]);
+	    }
+	  else 
+	    {
+	      Rhythmic_grouping *newchild=new Rhythmic_grouping (
+								 children.slice (starti, i+1));
+
+	      ch.push (newchild);
+	    }
+	  i ++;
+	  j++;
+	  starti = i;
+	  startj = j;
+
+
+	}
     }
   if (ch.size() != 1)
-	children = ch;
-    }
+    children = ch;
+}
 
 
 Rhythmic_grouping::Rhythmic_grouping (MInterval t, int n)
@@ -183,13 +183,13 @@ Rhythmic_grouping::Rhythmic_grouping (MInterval t, int n)
   init();
   if (n == 1 || !n) 
     {
-	interval_ = new MInterval (t);
-	return;
+      interval_ = new MInterval (t);
+      return;
     }
   Moment dt = t.length()/Rational (n);
   MInterval basic = MInterval (t.left, t.left+dt);
   for (int i= 0; i < n; i++)
-	children.push (new Rhythmic_grouping (dt*Rational (i) + basic));
+    children.push (new Rhythmic_grouping (dt*Rational (i) + basic));
 }
 
 
@@ -209,7 +209,7 @@ Rhythmic_grouping::copy (Rhythmic_grouping const&s)
 {
   interval_ =  (s.interval_)? new MInterval (*s.interval_) : 0;
   for (int i=0; i < s.children.size(); i++)
-     children.push (new Rhythmic_grouping (*s.children[i]));
+    children.push (new Rhythmic_grouping (*s.children[i]));
 }
 
 void
@@ -230,7 +230,7 @@ Rhythmic_grouping::junk()
 {
   delete interval_;
   for (int i=0; i < children.size(); i++)
-	delete children[i];
+    delete children[i];
   init();
 }
 
@@ -240,10 +240,10 @@ Rhythmic_grouping::print() const
 #ifndef NPRINT
   DOUT << "{ \n";
   if (interval_)
-	DOUT <<" Interval "<< interval_->str();
+    DOUT <<" Interval "<< interval_->str();
   for (int i=0; i < children.size(); i++) 
     {
-	children[i]->print();
+      children[i]->print();
     }
   DOUT << "}\n";
 #endif
@@ -253,7 +253,7 @@ bool
 Rhythmic_grouping::child_fit_b (Moment start)
 {
   if (children.size())
-	return (children.top()->interval ().right== start);
+    return (children.top()->interval ().right== start);
 
   return true;
 }  
@@ -277,7 +277,7 @@ min_elt (Array<int> v)
 {
   int i = 1000;		// ugh
   for (int j = 0 ; j <  v.size(); j++)
-	i = i <? v[j];
+    i = i <? v[j];
   return i;
 }
 
@@ -289,48 +289,48 @@ Rhythmic_grouping::generate_beams (Array<int> flags, int &flagidx)
   Array< Array<int> > children_beams;
   for (int i=0; i < children.size(); i++) 
     {
-	Array<int> child_beams;
-	if (children[i]->interval_) 
-	  {
-	    int f = flags[flagidx++];
-	    child_beams.push (f);
-	  }
-	else 
-	  {
-	    child_beams = children[i]->
-		generate_beams (flags, flagidx);
-	  }
-	children_beams.push (child_beams);
+      Array<int> child_beams;
+      if (children[i]->interval_) 
+	{
+	  int f = flags[flagidx++];
+	  child_beams.push (f);
+	}
+      else 
+	{
+	  child_beams = children[i]->
+	    generate_beams (flags, flagidx);
+	}
+      children_beams.push (child_beams);
     }
   Array<int> beams;
   int lastm, m, nextm;
   for (int i=0; i  < children_beams.size(); i++) 
     {
-	bool add_left =  (i >0);
-	bool add_right = (i  < children_beams.size() -1);
+      bool add_left =  (i >0);
+      bool add_right = (i  < children_beams.size() -1);
 
-	if (!i)
-	    m =  min_elt (children_beams[i]);
-	if (add_right)
-	    nextm = min_elt (children_beams[i+1]);
+      if (!i)
+	m =  min_elt (children_beams[i]);
+      if (add_right)
+	nextm = min_elt (children_beams[i+1]);
 	
-	if (children_beams[i].size() == 1) 
-	  {
-	    if (add_right)
-		beams.push (m);
-	    if (add_left)
-		beams.push (m);
-	  }
-	else 
-	  {
-	    if (add_left) 
-		beams.push (lastm <? m);
-	    beams.concat (children_beams[i]);
-	    if (add_right)
-		beams.push (m <? nextm);
-	  }
-	lastm = m;
-	m = nextm;	
+      if (children_beams[i].size() == 1) 
+	{
+	  if (add_right)
+	    beams.push (m);
+	  if (add_left)
+	    beams.push (m);
+	}
+      else 
+	{
+	  if (add_left) 
+	    beams.push (lastm <? m);
+	  beams.concat (children_beams[i]);
+	  if (add_right)
+	    beams.push (m <? nextm);
+	}
+      lastm = m;
+      m = nextm;	
     }
   assert (!(beams.size()%2));
   return beams;
@@ -340,10 +340,10 @@ void
 Rhythmic_grouping::translate (Moment m)
 {
   if (interval_)
-	*interval_ += m;
+    *interval_ += m;
   else
-	for (int i=0; i < children.size(); i++)
-	    children[i]->translate (m);
+    for (int i=0; i < children.size(); i++)
+      children[i]->translate (m);
 }
 
 void
@@ -352,13 +352,13 @@ Rhythmic_grouping::extend (MInterval m) const
   assert (m.left >= interval().left);
   while (m.right  >interval().right) 
     {
-	Array<Rhythmic_grouping*> a (children);
-	for (int i=0; i < a.size(); i++) 
-	  {
-	    a[i] =new Rhythmic_grouping (*children[i]);
-	    a[i]->translate (children.top()->interval ().right);	    
-	  }
-	((Rhythmic_grouping*)this)->children.concat (a);
+      Array<Rhythmic_grouping*> a (children);
+      for (int i=0; i < a.size(); i++) 
+	{
+	  a[i] =new Rhythmic_grouping (*children[i]);
+	  a[i]->translate (children.top()->interval ().right);	    
+	}
+      ((Rhythmic_grouping*)this)->children.concat (a);
     }
   assert (m.right <= interval().right);
   OK();
@@ -373,11 +373,11 @@ parse_grouping (Array<int> beat_i_arr, Array<Moment> elt_length_arr)
   Array<Rhythmic_grouping*> children;
   for (int i=0; i < beat_i_arr.size(); i++) 
     {
-	Moment last = here;
-	here += elt_length_arr[i] * Moment (beat_i_arr[i]);
-	children.push (
-	    new Rhythmic_grouping (MInterval (last, here),
-				  beat_i_arr[i]));
+      Moment last = here;
+      here += elt_length_arr[i] * Moment (beat_i_arr[i]);
+      children.push (
+		     new Rhythmic_grouping (MInterval (last, here),
+					    beat_i_arr[i]));
     }
   return Rhythmic_grouping (children);
 }