From 5d9b2be83ed111e5d858f0adbcd73126772be277 Mon Sep 17 00:00:00 2001 From: fred Date: Wed, 27 Mar 2002 01:20:53 +0000 Subject: [PATCH] lilypond-1.5.6 --- CHANGES | 45 ++++++++++++++++ VERSION | 2 +- lily/sequential-music-iterator.cc | 87 +++++++++++++++++-------------- 3 files changed, 93 insertions(+), 41 deletions(-) diff --git a/CHANGES b/CHANGES index f596eb2ffb..70dd2d3d06 100644 --- 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 53945ddb6a..05d768bbe8 100644 --- 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 13d08740d0..5d8ce337de 100644 --- 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_); } /* -- 2.39.5