lilypond-1.5.6

diff --git a/CHANGES b/CHANGES
index f596eb2ffb79ae4ed41a1d532854321e5efe841c..70dd2d3d061799c89374e625f1d64d777187d2af 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,48 @@
+1.4.6.mb1
+=========
+
+* Allow for duplicated articulation scripts with different direction.
+
+* Added new ornaments: \upmordent, \downmordent, \pralldown, \prallup,
+  \lineprall, \thumb, \comma (to be used with scriptHorizontal = ##t),
+  see also input/test/trill.ly. [WARNING: FONT UPDATE!]
+
+* Bug fix: staccato dot placement.
+
+1.5.5.jr1
+=========
+
+* recent ancient-font.ly development branches manually merged and
+  updated;
+
+* added enhanced mensural minima/fusa noteheads (30 degrees rhomb
+  style); the former 45 degrees quadratic shapes are now available
+  under notehead style "neo_mensural"; [WARNING: FONT UPDATE] 
+
+* minor ancient font corrections (in particular, enhanced set_char_box()
+  arguments).
+
+
+1.5.5.jcn2
+==========
+
+* input/bugs:
+  - Autogenerate bugs document from all .ly's.
+  - Add texidoc to lots of examples.
+  - Junk or move fixed examples to regression test.
+  - Move examples that crash lilypond to input/no-notation.
+  - Update examples.
+
+1.5.5.hwn1
+==========
+
+* Grace property fixes.
+
+* More grace nesting bugfixes.
+
+1.5.5
+=====
+
 1.5.4.jcn2
 ==========
 

diff --git a/VERSION b/VERSION
index 53945ddb6a6019c31cc6e17fdad82b41236eb101..05d768bbe81c84ffe8a9ca963195a0b02c20af35 100644 (file)
--- a/VERSION
+++ b/VERSION
@@ -1,7 +1,7 @@
 PACKAGE_NAME=LilyPond
 MAJOR_VERSION=1
 MINOR_VERSION=5
-PATCH_LEVEL=5
+PATCH_LEVEL=6
 MY_PATCH_LEVEL=
 
 # use the above to send patches: MY_PATCH_LEVEL is always empty for a

diff --git a/lily/sequential-music-iterator.cc b/lily/sequential-music-iterator.cc
index 13d08740d0773f084326ef8500d40e15291ec1cc..5d8ce337de7cbd604b3c928fa350c2e826aa022a 100644 (file)
--- a/lily/sequential-music-iterator.cc
+++ b/lily/sequential-music-iterator.cc
@@ -20,6 +20,20 @@
 
 */
 
+/*
+
+  TODO: the grace note handling hasn't been done for skip() and
+  get_music(), meaning that staff-switching and partcombining will be
+  broken with grace notes.
+  
+ */
+/*
+
+  TODO: the grace note handling hasn't been done for skip() and
+  get_music(), meaning that staff-switching and partcombining will be
+  broken with grace notes.
+  
+ */
 /*
   Invariant for the data structure.
 
@@ -39,14 +53,14 @@ Sequential_music_iterator::Sequential_music_iterator ()
 {
   cursor_ = SCM_EOL;
   here_mom_ = Moment (0);
-  grace_skips_ = 0;
+  grace_fixups_ = 0;
   iter_p_ =0;
 }
 
 Sequential_music_iterator::Sequential_music_iterator (Sequential_music_iterator const &src)
   : Music_iterator (src)
 {
-  grace_skips_ = src.grace_skips_;
+  grace_fixups_ = src.grace_fixups_;
   cursor_ = src.cursor_;
   here_mom_ = src.here_mom_;
   if (src.iter_p_)
@@ -72,14 +86,14 @@ Sequential_music_iterator::~Sequential_music_iterator ()
   
  */
 
-Grace_skip *
-get_grace_skips (SCM cursor)
+Grace_fixup *
+get_grace_fixups (SCM cursor)
 {
-  Moment here (0);  
+  Moment here;
   Moment last (-1);
-  Grace_skip *head = 0;
-  Grace_skip **tail = &head;
-  
+  Grace_fixup *head = 0;
+  Grace_fixup **tail = &head;
+
   for (; gh_pair_p (cursor); cursor = gh_cdr (cursor))
     {
       Music * mus = unsmob_music (gh_car (cursor));
@@ -90,9 +104,9 @@ get_grace_skips (SCM cursor)
        {
          if (last != Moment (-1))
            {
-             Grace_skip *p =new Grace_skip;
+             Grace_fixup *p =new Grace_fixup;
              p->start_ = last;
-             p->length_ = (here - last).main_part_;
+             p->length_ = here - last;
              p->grace_start_ = s.grace_part_;
              p->next_ = 0;
              *tail = p;
@@ -122,9 +136,8 @@ Sequential_music_iterator::construct_children ()
       next_element ();
     }
 
-  grace_skips_ = get_grace_skips (cursor_);
-
   here_mom_ = music_l ()->start_mom ();
+  grace_fixups_ = get_grace_fixups (cursor_);
 
   /*
     iter_p_->ok () is tautology, but what the heck.
@@ -142,20 +155,17 @@ void
 Sequential_music_iterator::next_element ()
 {
   Moment len =iter_p_->music_length_mom ();
-  Moment start  = iter_p_->music_start_mom ();
-  assert (!grace_skips_  || grace_skips_->start_ >= here_mom_);
+  assert (!grace_fixups_  || grace_fixups_->start_ >= here_mom_);
   
-  if (len.main_part_ && grace_skips_ &&
-      grace_skips_->start_.main_part_ == here_mom_.main_part_)
+  if (len.main_part_ && grace_fixups_ &&
+      grace_fixups_->start_ == here_mom_)
     {
-      Moment sk;
-      sk.main_part_ = grace_skips_->length_;
-      here_mom_ +=  sk;
-      here_mom_.grace_part_ = grace_skips_->grace_start_;
-
-      Grace_skip * n =grace_skips_->next_;
-      delete grace_skips_;
-      grace_skips_ = n;
+      here_mom_ += grace_fixups_->length_;
+      here_mom_.grace_part_ += grace_fixups_->grace_start_;
+
+      Grace_fixup * n =grace_fixups_->next_;
+      delete grace_fixups_;
+      grace_fixups_ = n;
     }
   else if (len.grace_part_ && !len.main_part_)
     {
@@ -167,10 +177,10 @@ Sequential_music_iterator::next_element ()
        !len.grace_part_ || len.main_part_
 
        We skip over a big chunk (mainpart != 0). Any starting graces
-       in that chunk are compensated by subtracting START.
+       in that chunk should be in len.grace_part_
 
       */
-      here_mom_ += len - start;
+      here_mom_ += len;
     }
   
   delete iter_p_;
@@ -250,7 +260,7 @@ Sequential_music_iterator::get_music (Moment until)const
   Skip events till UNTIL. We don't do any other side effects such as
   descending to child iterator contexts, because they might depend on
   \context specs and \translator changes being executed
-    
+  TODO: build support for grace notes here.
  */
 void
 Sequential_music_iterator::skip (Moment until)
@@ -273,17 +283,17 @@ Sequential_music_iterator::process (Moment until)
 {
   while (iter_p_)
     {
-      if (grace_skips_ &&
-         grace_skips_->start_ == here_mom_
-         && (grace_skips_->start_ + grace_skips_->length_).main_part_ ==
-         until.main_part_)
+      if (grace_fixups_ &&
+         grace_fixups_->start_ == here_mom_
+         && (grace_fixups_->start_ + grace_fixups_->length_
+             + Moment (Rational (0), grace_fixups_->grace_start_) == until))
        {
          /*
            do the stuff/note/rest preceding a grace.
           */
-         Moment u = until;
-         u.grace_part_ = 0;
-         iter_p_->process (u - here_mom_);
+         iter_p_->process (iter_p_->music_length_mom ()+ 
+                           iter_p_->music_start_mom ());
+
        }
       else
        iter_p_->process (until - here_mom_ + iter_p_->music_start_mom ());
@@ -310,13 +320,10 @@ Sequential_music_iterator::pending_moment () const
   /*
     Fix-up a grace note halfway in the music.
   */
-  if (grace_skips_ && here_mom_ == grace_skips_->start_
-      && cp.main_part_ >=  grace_skips_->length_)
+  if (grace_fixups_ && here_mom_ == grace_fixups_->start_
+      && grace_fixups_->length_ + iter_p_->music_start_mom () == cp)
     {
-      cp += here_mom_ ;
-      cp.grace_part_ = grace_skips_->grace_start_;
-      return cp;
-
+      return here_mom_ + grace_fixups_->length_ + Moment (0, grace_fixups_->grace_start_);
     }
 
   /*