X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fcompletion-note-heads-engraver.cc;h=ab25e271c03771f6a9e26af72c39eb4bd9f55d77;hb=1d142bf5ed6b0df3b9f54cf65005c8ba31d219e6;hp=6f8bab9337ae62183d62a072c4299b0c99154a0f;hpb=0d3c78505a6adb958f9280509bb7fa170de54611;p=lilypond.git diff --git a/lily/completion-note-heads-engraver.cc b/lily/completion-note-heads-engraver.cc index 6f8bab9337..ab25e271c0 100644 --- a/lily/completion-note-heads-engraver.cc +++ b/lily/completion-note-heads-engraver.cc @@ -1,31 +1,42 @@ /* - completion-note-heads-engraver.cc -- Completion_heads_engraver + This file is part of LilyPond, the GNU music typesetter. - (c) 1997--2005 Han-Wen Nienhuys + Copyright (C) 1997--2011 Han-Wen Nienhuys + + 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 +using namespace std; -#include "rhythmic-head.hh" -#include "output-def.hh" -#include "music.hh" -#include "dots.hh" #include "dot-column.hh" -#include "staff-symbol-referencer.hh" +#include "dots.hh" +#include "duration.hh" +#include "global-context.hh" #include "item.hh" +#include "output-def.hh" +#include "pitch.hh" +#include "rhythmic-head.hh" #include "score-engraver.hh" -#include "warn.hh" #include "spanner.hh" +#include "staff-symbol-referencer.hh" +#include "stream-event.hh" #include "tie.hh" -#include "global-context.hh" -#include "duration.hh" -#include "pitch.hh" - - +#include "tie-column.hh" +#include "warn.hh" -/* - TODO: make matching rest engraver. -*/ +#include "translator.icc" /* How does this work? @@ -44,31 +55,33 @@ class Completion_heads_engraver : public Engraver { - Link_array notes_; - Link_array prev_notes_; - Link_array ties_; - - Link_array dots_; - Link_array note_events_; - Link_array scratch_note_events_; - + vector notes_; + vector prev_notes_; + // Must remember notes for explicit ties. + vector tie_note_candidates_; + vector tie_note_candidate_events_; + vector ties_; + vector note_events_; + Spanner *tie_column_; Moment note_end_mom_; bool is_first_; Rational left_to_do_; Rational do_nothing_until_; + Rational factor_; Moment next_barline_moment (); - Duration find_nearest_duration (Rational length); + Item *make_note_head (Stream_event *); public: TRANSLATOR_DECLARATIONS (Completion_heads_engraver); protected: virtual void initialize (); - PRECOMPUTED_VIRTUAL void start_translation_timestep (); - virtual bool try_music (Music *event); - PRECOMPUTED_VIRTUAL void process_music (); - PRECOMPUTED_VIRTUAL void stop_translation_timestep (); + void make_tie (Grob *, Grob *); + void start_translation_timestep (); + void process_music (); + void stop_translation_timestep (); + DECLARE_TRANSLATOR_LISTENER (note); }; void @@ -77,85 +90,50 @@ Completion_heads_engraver::initialize () is_first_ = false; } -bool -Completion_heads_engraver::try_music (Music *m) +IMPLEMENT_TRANSLATOR_LISTENER (Completion_heads_engraver, note); +void +Completion_heads_engraver::listen_note (Stream_event *ev) { - if (m->is_mus_type ("note-event")) - { - note_events_.push (m); - - is_first_ = true; - Moment musiclen = m->get_length (); - Moment now = now_mom (); - - if (now_mom ().grace_part_) - { - musiclen.grace_part_ = musiclen.main_part_; - musiclen.main_part_ = Rational (0, 1); - } - note_end_mom_ = max (note_end_mom_, (now + musiclen)); - do_nothing_until_ = Rational (0, 0); + note_events_.push_back (ev); - return true; - } - else if (m->is_mus_type ("busy-playing-event")) - { - return note_events_.size () && is_first_; - } + is_first_ = true; + Moment now = now_mom (); + Moment musiclen = get_event_length (ev, now); - return false; + note_end_mom_ = max (note_end_mom_, (now + musiclen)); + do_nothing_until_ = Rational (0, 0); } /* - The duration _until_ the next barline. + The duration _until_ the next bar line. */ Moment Completion_heads_engraver::next_barline_moment () { Moment *e = unsmob_moment (get_property ("measurePosition")); Moment *l = unsmob_moment (get_property ("measureLength")); - if (!e || !l) + if (!e || !l || !to_boolean (get_property ("timing"))) { - programming_error ("no timing props set?"); - return Moment (1, 1); + return Moment (0, 0); } return (*l - *e); } -Duration -Completion_heads_engraver::find_nearest_duration (Rational length) +Item * +Completion_heads_engraver::make_note_head (Stream_event *ev) { - int log_limit = 6; + Item *note = make_item ("NoteHead", ev->self_scm ()); + Pitch *pit = unsmob_pitch (ev->get_property ("pitch")); - Duration d (0, 0); + int pos = pit->steps (); + SCM c0 = get_property ("middleCPosition"); + if (scm_is_number (c0)) + pos += scm_to_int (c0); - /* - this could surely be done more efficient. Left to the reader as an - excercise. */ - while (d.get_length () > length && d.duration_log () < log_limit) - { - if (d.dot_count ()) - { - d = Duration (d.duration_log (), d.dot_count ()- 1); - continue; - } - else - { - d = Duration (d.duration_log () + 1, 2); - } - } + note->set_property ("staff-position", scm_from_int (pos)); - if (d.duration_log () >= log_limit) - { - // junk the dots. - d = Duration (d.duration_log (), 0); - - // scale up. - d = d.compressed (length / d.get_length ()); - } - - return d; + return note; } void @@ -174,127 +152,103 @@ Completion_heads_engraver::process_music () Duration *orig = 0; if (left_to_do_) { - note_dur = find_nearest_duration (left_to_do_); + /* + note that note_dur may be strictly less than left_to_do_ + (say, if left_to_do_ == 5/8) + */ + if (factor_.denominator () == 1 && factor_ > Rational (1, 1)) + note_dur = Duration (left_to_do_, false); + else + note_dur = Duration (left_to_do_ / factor_, false).compressed (factor_); } else { orig = unsmob_duration (note_events_[0]->get_property ("duration")); note_dur = *orig; + factor_ = note_dur.factor (); + left_to_do_ = orig->get_length (); } Moment nb = next_barline_moment (); - if (nb < note_dur.get_length ()) + if (nb.main_part_ && nb < note_dur.get_length ()) { - note_dur = find_nearest_duration (nb.main_part_); - - Moment next = now; - next.main_part_ += note_dur.get_length (); - - get_global_context ()->add_moment_to_process (next); - do_nothing_until_ = next.main_part_; + if (factor_.denominator () == 1 && factor_ > Rational (1, 1)) + note_dur = Duration (nb.main_part_, false); + else + note_dur = Duration (nb.main_part_ / factor_, false).compressed (factor_); } - if (orig) - { - left_to_do_ = orig->get_length (); - } + do_nothing_until_ = now.main_part_ + note_dur.get_length (); - if (orig && note_dur.get_length () != orig->get_length ()) + for (vsize i = 0; left_to_do_ && i < note_events_.size (); i++) { - if (!scratch_note_events_.size ()) - for (int i = 0; i < note_events_.size (); i++) - { - Music *m = note_events_[i]->clone (); - scratch_note_events_.push (m); - } - } + bool need_clone = !orig || *orig != note_dur; + Stream_event *event = note_events_[i]; - for (int i = 0; - left_to_do_ && i < note_events_.size (); i++) - { - Music *event = note_events_[i]; - if (scratch_note_events_.size ()) - { - event = scratch_note_events_[i]; - SCM pits = note_events_[i]->get_property ("pitch"); - event->set_property ("pitch", pits); - } + if (need_clone) + event = event->clone (); + SCM pits = note_events_[i]->get_property ("pitch"); + event->set_property ("pitch", pits); event->set_property ("duration", note_dur.smobbed_copy ()); - - Item *note = make_item ("NoteHead", event->self_scm ()); - note->set_property ("duration-log", - scm_int2num (note_dur.duration_log ())); - - int dots = note_dur.dot_count (); - if (dots) - { - Item *d = make_item ("Dots", SCM_EOL); - Rhythmic_head::set_dots (note, d); - - /* - measly attempt to save an eeny-weenie bit of memory. - */ - if (dots != scm_to_int (d->get_property ("dot-count"))) - d->set_property ("dot-count", scm_int2num (dots)); - - d->set_parent (note, Y_AXIS); - dots_.push (d); - } - - Pitch *pit = unsmob_pitch (event->get_property ("pitch")); - - int pos = pit->steps (); - SCM c0 = get_property ("middleCPosition"); - if (scm_is_number (c0)) - pos += scm_to_int (c0); - - note->set_property ("staff-position", scm_int2num (pos)); - notes_.push (note); + event->set_property ("length", Moment (note_dur.get_length ()).smobbed_copy ()); + event->set_property ("duration-log", scm_from_int (note_dur.duration_log ())); + + /* + The Completion_heads_engraver splits an event into a group of consecutive events. + For each event in the group, the property "autosplit-end" denotes whether the current event + was truncated during splitting. Based on "autosplit-end", the Tie_engraver decides whether a + tie event should be processed. + */ + event->set_property ("autosplit-end", + ly_bool2scm (left_to_do_ - note_dur.get_length () > Rational (0))); + + Item *note = make_note_head (event); + if (need_clone) + event->unprotect (); + notes_.push_back (note); } if (prev_notes_.size () == notes_.size ()) { - for (int i = 0; i < notes_.size (); i++) - { - Grob *p = make_spanner ("Tie", SCM_EOL); - Tie::set_interface (p); // cannot remove yet! + for (vsize i = 0; i < notes_.size (); i++) + make_tie (prev_notes_[i], notes_[i]); + } - Tie::set_head (p, LEFT, prev_notes_[i]); - Tie::set_head (p, RIGHT, notes_[i]); + if (ties_.size () && !tie_column_) + tie_column_ = make_spanner ("TieColumn", ties_[0]->self_scm ()); - ties_.push (p); - } - } + if (tie_column_) + for (vsize i = ties_.size (); i--;) + Tie_column::add_tie (tie_column_, ties_[i]); left_to_do_ -= note_dur.get_length (); - + if (left_to_do_) + get_global_context ()->add_moment_to_process (now.main_part_ + note_dur.get_length ()); /* don't do complicated arithmetic with grace notes. */ - if (orig - && now_mom ().grace_part_) - { - left_to_do_ = Rational (0, 0); - } + if (orig && now_mom ().grace_part_) + left_to_do_ = Rational (0, 0); +} + +void +Completion_heads_engraver::make_tie (Grob *left, Grob *right) +{ + Grob *p = make_spanner ("Tie", SCM_EOL); + Tie::set_head (p, LEFT, left); + Tie::set_head (p, RIGHT, right); + ties_.push_back (p); } void Completion_heads_engraver::stop_translation_timestep () { ties_.clear (); + tie_column_ = 0; if (notes_.size ()) prev_notes_ = notes_; notes_.clear (); - - dots_.clear (); - - for (int i = scratch_note_events_.size (); i--;) - { - scratch_note_events_[i]->unprotect (); - } - - scratch_note_events_.clear (); } void @@ -303,22 +257,38 @@ Completion_heads_engraver::start_translation_timestep () Moment now = now_mom (); if (note_end_mom_.main_part_ <= now.main_part_) { + tie_note_candidate_events_ = note_events_; + tie_note_candidates_ = prev_notes_; + note_events_.clear (); prev_notes_.clear (); } + context ()->set_property ("completionBusy", + ly_bool2scm (note_events_.size ())); } Completion_heads_engraver::Completion_heads_engraver () { + tie_column_ = 0; } -#include "translator.icc" - ADD_TRANSLATOR (Completion_heads_engraver, - /* descr */ "This engraver replaces " - "@code{Note_heads_engraver}. It plays some trickery to " - "break long notes and automatically tie them into the next measure.", - /* creats*/ "NoteHead Dots Tie", - /* accepts */ "busy-playing-event note-event", - /* reads */ "middleCPosition measurePosition measureLength", - /* write */ ""); + /* doc */ + "This engraver replaces @code{Note_heads_engraver}. It plays" + " some trickery to break long notes and automatically tie them" + " into the next measure.", + + /* create */ + "NoteHead " + "Tie " + "TieColumn ", + + /* read */ + "measureLength " + "measurePosition " + "middleCPosition " + "timing ", + + /* write */ + "completionBusy " + );