X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpart-combine-music-iterator.cc;h=b249224f3b368ed4da4d051daf2e0b8597b19e13;hb=d7dc509525cc1f5b8b670e5d38db44a546674b86;hp=7c6b0d6c7091149e3ad72b899cd7a9bb67ce1f3f;hpb=2804f8f79e01dc606ce067bffda2d966524e6e36;p=lilypond.git diff --git a/lily/part-combine-music-iterator.cc b/lily/part-combine-music-iterator.cc index 7c6b0d6c70..b249224f3b 100644 --- a/lily/part-combine-music-iterator.cc +++ b/lily/part-combine-music-iterator.cc @@ -3,41 +3,63 @@ source file of the GNU LilyPond music typesetter - (c) 2000--2002 Jan Nieuwenhuizen + (c) 2000--2003 Jan Nieuwenhuizen */ -#include "part-combine-music.hh" #include "part-combine-music-iterator.hh" #include "translator-group.hh" -#include "musical-request.hh" +#include "event.hh" #include "music-sequence.hh" #include "lily-guile.hh" #include "warn.hh" Part_combine_music_iterator::Part_combine_music_iterator () { - first_iter_p_ = 0; - second_iter_p_ = 0; + first_iter_ = 0; + second_iter_ = 0; first_until_ = 0; second_until_ = 0; + state_ = 0; } -Part_combine_music_iterator::~Part_combine_music_iterator () +void +Part_combine_music_iterator::derived_mark () const +{ + if (first_iter_) + scm_gc_mark (first_iter_->self_scm()); + if (second_iter_) + scm_gc_mark(second_iter_->self_scm()); +} + +void +Part_combine_music_iterator::do_quit () { - delete second_iter_p_; - delete first_iter_p_; + if (first_iter_) + first_iter_->quit(); + if (second_iter_) + second_iter_->quit(); } Part_combine_music_iterator::Part_combine_music_iterator (Part_combine_music_iterator const &src) : Music_iterator (src) { - second_iter_p_ = src.second_iter_p_ ? src.second_iter_p_->clone () : 0; - first_iter_p_ = src.first_iter_p_ ? src.first_iter_p_->clone () : 0; + first_iter_ = 0; + second_iter_ = 0; + + if(src.first_iter_) + first_iter_ = src.first_iter_->clone (); + if (src.second_iter_) + second_iter_ = src.second_iter_->clone (); first_until_ = src.first_until_; second_until_ = src.second_until_; state_ = src.state_; suffix_ = src.suffix_; + + if (first_iter_) + scm_gc_unprotect_object (first_iter_->self_scm()); + if (second_iter_) + scm_gc_unprotect_object (second_iter_->self_scm()); } Moment @@ -45,34 +67,35 @@ Part_combine_music_iterator::pending_moment () const { Moment p; p.set_infinite (1); - if (first_iter_p_->ok ()) - p = p pending_moment (); + if (first_iter_->ok ()) + p = p pending_moment (); - if (second_iter_p_->ok ()) - p = p pending_moment (); + if (second_iter_->ok ()) + p = p pending_moment (); return p; } bool Part_combine_music_iterator::ok () const { - return first_iter_p_->ok () || second_iter_p_->ok (); + return first_iter_->ok () || second_iter_->ok (); } + void Part_combine_music_iterator::construct_children () { - Part_combine_music const * m = dynamic_cast (music_l ()); - - first_iter_p_ = get_iterator_p (m->first_l ()); - second_iter_p_ = get_iterator_p (m->second_l ()); + SCM lst = get_music ()->get_mus_property ("elements"); + + first_iter_ = unsmob_iterator (get_iterator (unsmob_music (gh_car (lst)))); + second_iter_ = unsmob_iterator (get_iterator (unsmob_music (gh_cadr (lst)))); } void Part_combine_music_iterator::change_to (Music_iterator *it, String to_type, String to_id) { - Translator_group * current = it->report_to_l (); + Translator_group * current = it->report_to (); Translator_group * last = 0; /* @@ -85,13 +108,13 @@ Part_combine_music_iterator::change_to (Music_iterator *it, String to_type, If \translator Staff = bass, then look for Staff = * */ - while (current && current->type_str_ != to_type) + while (current && current->type_string_ != to_type) { last = current; - current = current->daddy_trans_l_; + current = current->daddy_trans_; } - if (current && current->id_str_ == to_id) + if (current && current->id_string_ == to_id) { String msg; msg += _ ("Can't switch translators, I'm there already"); @@ -101,8 +124,8 @@ Part_combine_music_iterator::change_to (Music_iterator *it, String to_type, if (last) { Translator_group * dest = - it->report_to_l ()->find_create_translator_l (to_type, to_id); - current->remove_translator_p (last); + it->report_to ()->find_create_translator (to_type, to_id); + current->remove_translator (last); dest->add_used_group_translator (last); } else @@ -111,12 +134,12 @@ Part_combine_music_iterator::change_to (Music_iterator *it, String to_type, We could change the current translator's id, but that would make errors hard to catch - last->translator_id_str_ = change_l ()->change_to_id_str_; + last->translator_id_string_ = get_change ()->change_to_id_string_; */ - error (_f ("I'm one myself: `%s'", to_type.ch_C ())); + error (_f ("I'm one myself: `%s'", to_type.to_str0 ())); } else - error (_f ("none of these in my family: `%s'", to_id.ch_C ())); + error (_f ("none of these in my family: `%s'", to_id.to_str0 ())); } @@ -126,27 +149,30 @@ get_music_info (Moment m, Music_iterator* iter, SCM *pitches, SCM *durations) { if (iter->ok ()) { - for (SCM i = iter->get_music (m); gh_pair_p (i); i = ly_cdr (i)) + for (SCM i = iter->get_pending_events (m); gh_pair_p (i); i = ly_cdr (i)) { Music *m = unsmob_music (ly_car (i)); - if (Melodic_req *r = dynamic_cast (m)) - *pitches = gh_cons (r->get_mus_property ("pitch"), *pitches); - if (Rhythmic_req *r = dynamic_cast (m)) - *durations = gh_cons (r->get_mus_property ("duration"), *durations); + SCM p = m->get_mus_property ("pitch"); + SCM d = m->get_mus_property ("duration"); + if (unsmob_pitch (p)) + *pitches = gh_cons (p, *pitches); + if (unsmob_duration (d)) + *durations = gh_cons (d, *durations); } } } - + int Part_combine_music_iterator::get_state (Moment) { int state = UNKNOWN; - Part_combine_music const *p = dynamic_cast (music_l ()); + + Music *p = get_music (); String w = ly_scm2string (p->get_mus_property ("what")); - Translator_group *first_translator = first_iter_p_->report_to_l ()->find_create_translator_l (w, "one" + suffix_); + Translator_group *first_translator = first_iter_->report_to ()->find_create_translator (w, "one" + suffix_); SCM s = first_translator->get_property ("changeMoment"); if (!gh_pair_p (s)) @@ -169,10 +195,11 @@ Part_combine_music_iterator::get_state (Moment) Moment second_mom = second_until_; Moment diff_until = diff_mom + now; - bool first = true; - Music_iterator *first_iter = first_iter_p_->clone (); - Music_iterator *second_iter = second_iter_p_->clone (); + bool first = true; + Music_iterator *first_iter = first_iter_->clone (); + Music_iterator *second_iter = second_iter_->clone (); + Moment last_pending (-1); Moment pending = now; while (now < diff_until @@ -201,27 +228,25 @@ Part_combine_music_iterator::get_state (Moment) if (first_pitches != SCM_EOL && second_pitches != SCM_EOL) { - scm_sort_list_x (first_pitches, - scm_primitive_eval (ly_str02scm ("Pitch::less_p"))); - scm_sort_list_x (second_pitches, - scm_primitive_eval (ly_str02scm ("Pitch::less_p"))); + scm_sort_list_x (first_pitches, Pitch::less_p_proc); + scm_sort_list_x (second_pitches, Pitch::less_p_proc); interval = gh_int2scm (unsmob_pitch (ly_car (first_pitches))->steps () - unsmob_pitch (ly_car (scm_last_pair (second_pitches)))->steps ()); } - + if (first_durations != SCM_EOL) { scm_sort_list_x (first_durations, - scm_primitive_eval (ly_str02scm ("Duration::less_p"))); - first_mom += unsmob_duration (ly_car (first_durations))->length_mom (); + Duration::less_p_proc); + first_mom += unsmob_duration (ly_car (first_durations))->get_length (); } if (second_durations != SCM_EOL) { scm_sort_list_x (second_durations, - scm_primitive_eval (ly_str02scm ("Duration::less_p"))); - second_mom += unsmob_duration (ly_car (second_durations))->length_mom (); + Duration::less_p_proc); + second_mom += unsmob_duration (ly_car (second_durations))->get_length (); } if (first_pitches != SCM_EOL && second_pitches == SCM_EOL @@ -304,13 +329,14 @@ Part_combine_music_iterator::get_state (Moment) second_iter->skip (pending); now = pending; } - delete first_iter; - delete second_iter; + scm_gc_unprotect_object (first_iter->self_scm ()); + scm_gc_unprotect_object (second_iter->self_scm ()); } + return state; } -static Span_req* abort_req = NULL; +static Music* abort_req = NULL; void Part_combine_music_iterator::process (Moment m) @@ -324,13 +350,14 @@ Part_combine_music_iterator::process (Moment m) **** Tried this, but won't work: - Consider thread switching: threads "one", "two" and "both". +s Consider thread switching: threads "one", "two" and "both". User can't pre-set the (most important) stem direction at thread level! */ if (suffix_.empty_b ()) - suffix_ = first_iter_p_->report_to_l ()->daddy_trans_l_->id_str_.cut_str (3, INT_MAX); + suffix_ = first_iter_->report_to () + ->daddy_trans_->id_string_.cut_string (3, INT_MAX); int state = get_state (m); if (state) @@ -338,11 +365,11 @@ Part_combine_music_iterator::process (Moment m) else state = state_; - Part_combine_music const *p = dynamic_cast (music_l ()); + Music *p =get_music (); - bool previously_combined_b = first_iter_p_->report_to_l ()->daddy_trans_l_ - == second_iter_p_->report_to_l ()->daddy_trans_l_; + bool previously_combined_b = first_iter_->report_to ()->daddy_trans_ + == second_iter_->report_to ()->daddy_trans_; bool combine_b = previously_combined_b; @@ -359,22 +386,21 @@ Part_combine_music_iterator::process (Moment m) if (!abort_req) { - abort_req = new Span_req; - abort_req->set_mus_property ("span-type", ly_str02scm ("abort")); + abort_req = make_music_by_name (ly_symbol2scm ("AbortEvent")); } if (combine_b && combine_b != previously_combined_b) { - if (second_iter_p_ && second_iter_p_->ok ()) - second_iter_p_->try_music (abort_req); + if (second_iter_ && second_iter_->ok ()) + second_iter_->try_music (abort_req); } String w = ly_scm2string (p->get_mus_property ("what")); if (combine_b != previously_combined_b) - change_to (second_iter_p_, w, (combine_b ? "one" : "two") + change_to (second_iter_, w, (combine_b ? "one" : "two") + suffix_); - Translator_group *first_translator = first_iter_p_->report_to_l ()->find_create_translator_l (w, "one" + suffix_); - Translator_group *second_translator = second_iter_p_->report_to_l ()->find_create_translator_l (w, "two" + suffix_); + Translator_group *first_translator = first_iter_->report_to ()->find_create_translator (w, "one" + suffix_); + Translator_group *second_translator = second_iter_->report_to ()->find_create_translator (w, "two" + suffix_); /* Hmm */ @@ -406,32 +432,36 @@ Part_combine_music_iterator::process (Moment m) first_translator->set_property ("solo", b1); second_translator->set_property ("solo", b2); - if (first_iter_p_->ok ()) - first_iter_p_->process (m); + /* Can't these be computed? */ + first_translator->set_property ("othersolo", b2); + second_translator->set_property ("othersolo", b1); + + if (first_iter_->ok ()) + first_iter_->process (m); - if (second_iter_p_->ok ()) - second_iter_p_->process (m); + if (second_iter_->ok ()) + second_iter_->process (m); } Music_iterator* Part_combine_music_iterator::try_music_in_children (Music *m) const { - Music_iterator * i = first_iter_p_->try_music (m); + Music_iterator * i = first_iter_->try_music (m); if (i) return i; else - return second_iter_p_->try_music (m); + return second_iter_->try_music (m); } SCM -Part_combine_music_iterator::get_music (Moment m)const +Part_combine_music_iterator::get_pending_events (Moment m)const { SCM s = SCM_EOL; - if (first_iter_p_) - s = gh_append2 (s,first_iter_p_->get_music (m)); - if (second_iter_p_) - s = gh_append2 (second_iter_p_->get_music (m),s); + if (first_iter_) + s = gh_append2 (s,first_iter_->get_pending_events (m)); + if (second_iter_) + s = gh_append2 (second_iter_->get_pending_events (m),s); return s; }