source file of the GNU LilyPond music typesetter
- (c) 1997--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+ (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
#include "translator-group.hh"
-
+#include "context.hh"
#include "sequential-iterator.hh"
#include "music-list.hh"
Sequential_iterator::do_quit ()
{
if (iter_)
- iter_->quit();
+ iter_->quit ();
}
-Sequential_iterator::Sequential_iterator (Sequential_iterator const &src)
- : Music_iterator (src)
-{
- grace_fixups_ = copy_grace_fixups (src.grace_fixups_);
- cursor_ = src.cursor_;
- list_ = src.cursor_;
- here_mom_ = src.here_mom_;
- iter_ = 0;
- if (src.iter_)
- {
- iter_ = src.iter_->clone ();
- scm_gc_unprotect_object (iter_->self_scm());
- }
-}
void
Sequential_iterator::derived_mark ()const
{
if (iter_)
- scm_gc_mark (iter_->self_scm());
+ scm_gc_mark (iter_->self_scm ());
scm_gc_mark (list_);
scm_gc_mark (cursor_);
}
+void
+Sequential_iterator::derived_substitute (Context *f,Context *t)
+{
+ if (iter_)
+ iter_->substitute_outlet (f,t);
+
+}
+
Grace_fixup *
get_grace_fixups (SCM cursor)
{
here.grace_part_ = s.grace_part_;
}
- if (l.to_bool())
+ if (l.to_bool ())
{
last = here;
here += l;
swoop.
*/
void
-Sequential_iterator::next_element (bool side_effect)
+Sequential_iterator::next_element (bool)
{
Moment len =iter_->music_get_length () - iter_->music_start_mom ();
assert (!grace_fixups_ || grace_fixups_->start_ >= here_mom_);
cursor_ = ly_cdr (cursor_);
- iter_->quit();
+ iter_->quit ();
if (gh_pair_p (cursor_))
iter_ = unsmob_iterator (get_iterator (unsmob_music (ly_car (cursor_))));
else
void
Sequential_iterator::descend_to_child ()
{
-}
-
+ Context * child_report = child_report = iter_->get_outlet ();
+ Context * me_report = get_outlet ();
-/*
- Retrieve all music (starting at HERE), until a music with length L >
- 0 is found. From the precondition, we know that UNTIL is later than
- the earliest event. Hence we know
-
- L >= (UNTIL - HERE)
-
- so something that comes after this thing with L > 0 happens after
-
- HERE + L >= HERE + (UNTIL - HERE) = UNTIL
-
- Hence all events after the one with L>0 are uninteresting, so we
- ignore them.
-
-*/
-
-SCM
-Sequential_iterator::get_pending_events (Moment until)const
-{
- SCM s = SCM_EOL;
- if (until < pending_moment ())
- return s;
-
- Sequential_iterator * me =
- dynamic_cast<Sequential_iterator*> (clone ());
- while (me->ok ())
+ Context * c = child_report;
+ while (c && c != me_report)
{
- SCM nm = me->iter_->get_pending_events (until - me->here_mom_);
- s = gh_append2 (nm, s);
-
- Moment m = 0;
- for (SCM i = nm; gh_pair_p (i); i = ly_cdr (i))
- {
- Music *mus=unsmob_music (ly_car (i));
- m = m >? (mus->get_length () - mus->start_mom ());
- }
- if (m > Moment (0))
- break ;
- else
- me->next_element (false);
+ c= c->daddy_context_;
}
-
- scm_gc_unprotect_object (me->self_scm());
- return s;
+
+ if (c == me_report)
+ set_translator (child_report);
}
-/*
- 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
- */
-void
-Sequential_iterator::skip (Moment until)
-{
- while (ok ())
- {
- 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.
- */
- iter_->skip (iter_->music_get_length ());
- }
- else if (iter_->music_get_length () >= until - here_mom_)
- iter_->skip (until - here_mom_ + iter_->music_start_mom ());
-
- if (iter_->ok ())
- return ;
-
- next_element (false);
- }
-}
void
Sequential_iterator::process (Moment until)
iter_->process (iter_->music_get_length ());
}
else
- iter_->process (until - here_mom_ + iter_->music_start_mom ());
-
+ {
+ Moment w = until - here_mom_ + iter_->music_start_mom ();
+ // if (w >= Moment (0))
+ iter_->process (w);
+ }
+
/*
if the iter is still OK, there must be events left that have
}
IMPLEMENT_CTOR_CALLBACK (Sequential_iterator);
+
+bool
+Sequential_iterator::run_always () const
+{
+ return iter_ ? iter_->run_always () : false;
+}