X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fbeaming-pattern.cc;h=a0fa25e7f7a782b2aeba4fa045492ec6c89cfb9a;hb=689ca8e732f71bcfc117211e4a980f22b13bc1ed;hp=c32666133ba84f9b5fbb244d4fd7a9d018070326;hpb=5b4b0d6e9a197e8f9eb085b7c2ad78b8be3e5cfc;p=lilypond.git diff --git a/lily/beaming-pattern.cc b/lily/beaming-pattern.cc index c32666133b..a0fa25e7f7 100644 --- a/lily/beaming-pattern.cc +++ b/lily/beaming-pattern.cc @@ -1,20 +1,24 @@ /* - beaming-info.cc -- implement Beam_rhythmic_element, Beaming_pattern + This file is part of LilyPond, the GNU music typesetter. - A Beaming_pattern object takes a set of stems at given moments and calculates - the pattern of their beam. That is, it works out, for each stem, how many - beams should be connected to the right and left sides of that stem. In - calculating this, Beaming_pattern takes into account - - the rhythmic position of the stems - - the options that are defined in Beaming_options + Copyright (C) 1999--2011 Han-Wen Nienhuys - source file of the GNU LilyPond music typesetter + 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. - (c) 1999--2008 Han-Wen Nienhuys + 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 "beaming-pattern.hh" #include "context.hh" +#include "beaming-pattern.hh" /* Represents a stem belonging to a beam. Sometimes (for example, if the stem @@ -52,7 +56,7 @@ Beam_rhythmic_element::de_grace () { if (start_moment_.grace_part_) { - start_moment_.main_part_ = start_moment_.grace_part_; + start_moment_.main_part_ = start_moment_.grace_part_; start_moment_.grace_part_ = 0; } } @@ -78,17 +82,17 @@ Beaming_pattern::flag_direction (Beaming_options const &options, vsize i) const return CENTER; int count = infos_[i].count (LEFT); // Both directions should still be the same - int left_count = infos_[i-1].count (RIGHT); - int right_count = infos_[i+1].count (LEFT); + int left_count = infos_[i - 1].count (RIGHT); + int right_count = infos_[i + 1].count (LEFT); // If we are told to subdivide beams and we are next to a beat, point the // beamlet away from the beat. if (options.subdivide_beams_) { if (infos_[i].rhythmic_importance_ < 0) - return RIGHT; - else if (infos_[i+1].rhythmic_importance_ < 0) - return LEFT; + return RIGHT; + else if (infos_[i + 1].rhythmic_importance_ < 0) + return LEFT; } if (count <= left_count && count <= right_count) @@ -102,13 +106,13 @@ Beaming_pattern::flag_direction (Beaming_options const &options, vsize i) const return LEFT; // If all else fails, point the beamlet away from the important moment. - return (infos_[i].rhythmic_importance_ <= infos_[i+1].rhythmic_importance_) ? RIGHT : LEFT; + return (infos_[i].rhythmic_importance_ <= infos_[i + 1].rhythmic_importance_) ? RIGHT : LEFT; } void Beaming_pattern::de_grace () { - for (vsize i = 0; i < infos_.size (); i ++) + for (vsize i = 0; i < infos_.size (); i++) { infos_[i].de_grace (); } @@ -135,22 +139,22 @@ Beaming_pattern::beamify (Beaming_options const &options) { Direction non_flag_dir = other_dir (flag_direction (options, i)); if (non_flag_dir) - { - int importance = (non_flag_dir == LEFT) - ? infos_[i].rhythmic_importance_ : infos_[i+1].rhythmic_importance_; - int count = (importance < 0 && options.subdivide_beams_) - ? 1 : min (infos_[i].count (non_flag_dir), - infos_[i+non_flag_dir].count (-non_flag_dir)); - - infos_[i].beam_count_drul_[non_flag_dir] = count; - } + { + int importance = (non_flag_dir == LEFT) + ? infos_[i].rhythmic_importance_ : infos_[i + 1].rhythmic_importance_; + int count = (importance < 0 && options.subdivide_beams_) + ? 1 : min (infos_[i].count (non_flag_dir), + infos_[i + non_flag_dir].count (-non_flag_dir)); + + infos_[i].beam_count_drul_[non_flag_dir] = count; + } } } void Beaming_pattern::find_rhythmic_importance (Beaming_options const &options) { - Moment measure_pos (0); + Moment measure_pos (0); SCM grouping = options.grouping_; vsize i = 0; @@ -160,44 +164,43 @@ Beaming_pattern::find_rhythmic_importance (Beaming_options const &options) // If a beat grouping is not specified, default to 2 beats per group. int count = 2; if (scm_is_pair (grouping)) - { - count = scm_to_int (scm_car (grouping)); - grouping = scm_cdr (grouping); - } + { + count = scm_to_int (scm_car (grouping)); + grouping = scm_cdr (grouping); + } // Mark the start of this beat group if (infos_[i].start_moment_ == measure_pos) - infos_[i].rhythmic_importance_ = -2; - - // Mark the start of each beat up to the end of this beat group. - for (int beat = 1; beat <= count; beat++) - { - Moment next_measure_pos = measure_pos + options.beat_length_; - - while (i < infos_.size () && infos_[i].start_moment_ < next_measure_pos) - { - Moment dt = infos_[i].start_moment_ - measure_pos; - - // The rhythmic importance of a stem between beats depends on its fraction - // of a beat: those stems with a lower denominator are deemed more - // important. - // FIXME: This is not the right way to do things for tuplets. For example, - // in an 8th-note triplet with a quarter-note beat, 1/3 of a beat should be - // more important than 1/2. - if (infos_[i].rhythmic_importance_ >= 0) - infos_[i].rhythmic_importance_ = (dt / options.beat_length_).den (); - - i++; - } - - measure_pos = next_measure_pos; - if (i < infos_.size () && infos_[i].start_moment_ == measure_pos) - infos_[i].rhythmic_importance_ = -1; - } + infos_[i].rhythmic_importance_ = -2; + + // Mark the start of each unit up to the end of this beat group. + for (int unit = 1; unit <= count; unit++) + { + Moment next_measure_pos = measure_pos + options.base_moment_; + + while (i < infos_.size () && infos_[i].start_moment_ < next_measure_pos) + { + Moment dt = infos_[i].start_moment_ - measure_pos; + + // The rhythmic importance of a stem between beats depends on its fraction + // of a beat: those stems with a lower denominator are deemed more + // important. + // FIXME: This is not the right way to do things for tuplets. For example, + // in an 8th-note triplet with a quarter-note beat, 1/3 of a beat should be + // more important than 1/2. + if (infos_[i].rhythmic_importance_ >= 0) + infos_[i].rhythmic_importance_ = (int) (dt / options.base_moment_).den (); + + i++; + } + + measure_pos = next_measure_pos; + if (i < infos_.size () && infos_[i].start_moment_ == measure_pos) + infos_[i].rhythmic_importance_ = -1; + } } } - /* Invisible stems should be treated as though they have the same number of beams as their least-beamed neighbour. Here we go through the stems and @@ -209,21 +212,20 @@ Beaming_pattern::unbeam_invisible_stems () for (vsize i = 1; i < infos_.size (); i++) if (infos_[i].invisible_) { - int b = min (infos_[i].count (LEFT), infos_[i-1].count (LEFT)); - infos_[i].beam_count_drul_[LEFT] = b; - infos_[i].beam_count_drul_[RIGHT] = b; + int b = min (infos_[i].count (LEFT), infos_[i - 1].count (LEFT)); + infos_[i].beam_count_drul_[LEFT] = b; + infos_[i].beam_count_drul_[RIGHT] = b; } for (vsize i = infos_.size (); i--;) if (infos_[i].invisible_) { - int b = min (infos_[i].count (LEFT), infos_[i+1].count (LEFT)); - infos_[i].beam_count_drul_[LEFT] = b; - infos_[i].beam_count_drul_[RIGHT] = b; + int b = min (infos_[i].count (LEFT), infos_[i + 1].count (LEFT)); + infos_[i].beam_count_drul_[LEFT] = b; + infos_[i].beam_count_drul_[RIGHT] = b; } } - void Beaming_pattern::add_stem (Moment m, int b, bool invisible) { @@ -240,13 +242,60 @@ Beaming_pattern::beamlet_count (int i, Direction d) const return infos_.at (i).beam_count_drul_[d]; } +Moment +Beaming_pattern::start_moment (int i) const +{ + return infos_.at (i).start_moment_; +} + +Moment +Beaming_pattern::end_moment (int i) const +{ + Duration *dur = new Duration (2 + max (beamlet_count (i, LEFT), + beamlet_count (i, RIGHT)), + 0); + + return infos_.at (i).start_moment_ + dur->get_length (); +} + +bool +Beaming_pattern::invisibility (int i) const +{ + return infos_.at (i).invisible_; +} + +/* + Split a beamin pattern at index i and return a new + Beaming_pattern containing the removed elements +*/ +Beaming_pattern * +Beaming_pattern::split_pattern (int i) +{ + Beaming_pattern *new_pattern = 0; + int count; + + new_pattern = new Beaming_pattern (); + for (vsize j = i + 1; j < infos_.size (); j++) + { + count = max (beamlet_count (j, LEFT), beamlet_count (j, RIGHT)); + new_pattern->add_stem (start_moment (j), + count, + invisibility (j)); + } + for (vsize j = i + 1; j < infos_.size ();) + infos_.pop_back (); + return (new_pattern); +} + void Beaming_options::from_context (Context *context) { - grouping_ = context->get_property ("beatGrouping"); + grouping_ = context->get_property ("beatStructure"); subdivide_beams_ = to_boolean (context->get_property ("subdivideBeams")); - beat_length_ = robust_scm2moment (context->get_property ("beatLength"), Moment (1, 4)); - measure_length_ = robust_scm2moment (context->get_property ("measureLength"), Moment (1, 4)); + base_moment_ = robust_scm2moment (context->get_property ("baseMoment"), + Moment (1, 4)); + measure_length_ = robust_scm2moment (context->get_property ("measureLength"), + Moment (4, 4)); } Beaming_options::Beaming_options ()