X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpercent-repeat-iterator.cc;h=3c8420daa0d7a16d714e1a38c0f8c0ae38eed668;hb=b872748c6aa8bb721ced458691b38ac2fac5dfc8;hp=8bb34c4e662505d7d9d67e3697a6bea71ead04fb;hpb=e37010af17faa8b185de836664b6544bd29dc1d0;p=lilypond.git diff --git a/lily/percent-repeat-iterator.cc b/lily/percent-repeat-iterator.cc index 8bb34c4e66..3c8420daa0 100644 --- a/lily/percent-repeat-iterator.cc +++ b/lily/percent-repeat-iterator.cc @@ -1,93 +1,138 @@ -/* - percent-repeat-iterator.cc -- implement Percent_repeat_iterator - - source file of the GNU LilyPond music typesetter - - (c) 2001--2004 Han-Wen Nienhuys - - */ - -#include "percent-repeat-iterator.hh" -#include "repeated-music.hh" +/* + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 2001--2015 Han-Wen Nienhuys + Erik Sandberg + + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . +*/ + +#include "context.hh" #include "input.hh" +#include "repeated-music.hh" +#include "sequential-iterator.hh" +#include "lily-imports.hh" -IMPLEMENT_CTOR_CALLBACK (Percent_repeat_iterator); +class Percent_repeat_iterator : public Sequential_iterator +{ +public: + DECLARE_CLASSNAME (Percent_repeat_iterator); + DECLARE_SCHEME_CALLBACK (constructor, ()); + Percent_repeat_iterator (); +protected: + virtual SCM get_music_list () const; + virtual void construct_children (); + virtual void next_element (bool); + virtual void derived_mark () const; +private: + SCM child_list_; + int starting_bar_; +}; +IMPLEMENT_CTOR_CALLBACK (Percent_repeat_iterator); Percent_repeat_iterator::Percent_repeat_iterator () + : child_list_ (SCM_UNDEFINED), starting_bar_ (-1) { - child_iter_ = 0; } void -Percent_repeat_iterator::do_quit() +Percent_repeat_iterator::derived_mark () const { - if (child_iter_) - child_iter_->quit(); -} - -bool -Percent_repeat_iterator::ok () const -{ - return child_iter_; + scm_gc_mark (child_list_); + Sequential_iterator::derived_mark (); } void Percent_repeat_iterator::construct_children () { - Repeated_music * mus =dynamic_cast (get_music ()); - finish_mom_ = mus->get_length (); - child_iter_ = unsmob_iterator (get_iterator (mus->body ())); + Music *mus = get_music (); + + Music *child = Repeated_music::body (mus); + child_list_ = scm_list_1 (child->self_scm ()); + + Sequential_iterator::construct_children (); + + descend_to_bottom_context (); + if (!measure_position (get_outlet ()).main_part_) + starting_bar_ = + robust_scm2int (get_outlet ()->get_property ("internalBarNumber"), 0); } +SCM +Percent_repeat_iterator::get_music_list () const +{ + return child_list_; +} +// Arrive here when child processing has been completed. At that +// point of time, we can determine what kind of percent expression we +// are dealing with and extend the child list just in time before the +// next iterator is getting fetched. void -Percent_repeat_iterator::process (Moment m) +Percent_repeat_iterator::next_element (bool side_effect) { - if (!m.to_bool ()) + // Do nothing if we already did our processing here. + if (!scm_is_pair (child_list_)) { - Music_iterator *yeah = try_music (get_music ()); - if (yeah) - set_translator (yeah->get_outlet ()); - else - get_music ()->origin ()->warning ( _ ("no one to print a percent")); + Sequential_iterator::next_element (side_effect); + return; } - - if (child_iter_->ok ()) - child_iter_->process (m); - if (finish_mom_ <= m ) + Music *mus = get_music (); + + Music *child = Repeated_music::body (mus); + SCM length = child->get_length ().smobbed_copy (); + + int current_bar = -1; + if (!measure_position (get_outlet ()).main_part_) + current_bar = + robust_scm2int (get_outlet ()->get_property ("internalBarNumber"), 0); + + SCM child_list = SCM_EOL; + + string event_type; + SCM slash_count = SCM_EOL; + + if (starting_bar_ >= 0 && current_bar == starting_bar_ + 1) + event_type = "PercentEvent"; + else if (starting_bar_ >=0 && current_bar == starting_bar_ + 2) + event_type = "DoublePercentEvent"; + else { - child_iter_->quit(); - child_iter_ = 0; + slash_count = Lily::calc_repeat_slash_count (child->self_scm ()); + event_type = "RepeatSlashEvent"; } -} -Moment -Percent_repeat_iterator::pending_moment ()const -{ - if (child_iter_->ok ()) - return child_iter_->pending_moment (); - else - return finish_mom_ ; -} + int repeats = scm_to_int (mus->get_property ("repeat-count")); + for (int i = repeats; i > 1; i--) + { + Music *percent = make_music_by_name (ly_symbol2scm (event_type.c_str ())); + percent->set_spot (*mus->origin ()); + percent->set_property ("length", length); + if (repeats > 1) + { + percent->set_property ("repeat-count", scm_from_int (i)); + if (event_type == "RepeatSlashEvent") + percent->set_property ("slash-count", slash_count); + } -Music_iterator* -Percent_repeat_iterator::try_music_in_children (Music *m) const -{ - return child_iter_->try_music (m); -} + child_list = scm_cons (percent->unprotect (), child_list); + } -void -Percent_repeat_iterator::derived_mark()const -{ - if (child_iter_) - scm_gc_mark (child_iter_->self_scm()); -} + scm_set_cdr_x (child_list_, child_list); + child_list_ = SCM_EOL; -void -Percent_repeat_iterator::derived_substitute(Context *f,Context *t ) -{ - if (child_iter_) - child_iter_->substitute_outlet (f,t); + Sequential_iterator::next_element (side_effect); }