lilypond-0.1.16

diff --git a/input/toccata-fuga-E.ly b/input/toccata-fuga-E.ly
index cb1f2fc770a61aa6ede2be6dc2754b62d3cd1057..9b9bb6fc9207be8afa4a2f2a3a2e88fedf5bce73 100644 (file)
--- 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 15401fced94581d929e41531601992163a92a9ed..2c073adc630a708759ff0a13a5ee946dfbe660a9 100644 (file)
--- 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);
 }