X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fbeam.cc;h=23a62f4a5c4bc9f4a065c371b0554a28bbc0bd26;hb=ee513a2f7d18fc8d43e1c291350ed81856b0192d;hp=4626c1c5ee9d1d8dd9c26492b7f0113abbc80b03;hpb=42ab6ff971c06253b34f96ed122836ab88d09cc0;p=lilypond.git diff --git a/lily/beam.cc b/lily/beam.cc index 4626c1c5ee..23a62f4a5c 100644 --- a/lily/beam.cc +++ b/lily/beam.cc @@ -3,164 +3,102 @@ source file of the GNU LilyPond music typesetter - (c) 1997--1999, 1998 Han-Wen Nienhuys + (c) 1997--2000 Han-Wen Nienhuys Jan Nieuwenhuizen */ - /* [TODO] - * center beam symbol * less hairy code - * redo grouping - -TODO: + * move paper vars to scm -The relationship Stem <-> Beam is way too hairy. Let's figure who -needs what, and what information should be available when. +*/ - */ -#include +#include // tanh. -#include "proto.hh" +#include "directional-element-interface.hh" +#include "beaming.hh" #include "dimensions.hh" #include "beam.hh" #include "misc.hh" #include "debug.hh" -#include "molecule.hh" -#include "leastsquares.hh" +#include "least-squares.hh" #include "stem.hh" #include "paper-def.hh" #include "lookup.hh" -#include "rhythmic-grouping.hh" +#include "group-interface.hh" +#include "staff-symbol-referencer.hh" +#include "cross-staff.hh" +#include "lily-guile.icc" Beam::Beam () { - slope_f_ = 0; - left_y_ = 0; - quantisation_ = NORMAL; - multiple_i_ = 0; + Group_interface g (this, "stems"); + g.set_interface (); } void Beam::add_stem (Stem*s) { -#if 0 - if (!stems_.size ()) - { - dim_cache_[Y_AXIS]->parent_l_ = s->dim_cache_[Y_AXIS]; - } -#endif - stems_.push (s); + Group_interface gi (this, "stems"); + gi.add_element (s); + s->add_dependency (this); - assert (!s->beam_l_); - s->beam_l_ = this; + assert (!s->beam_l ()); + s->set_elt_property ("beam", self_scm_); - if (!spanned_drul_[LEFT]) - set_bounds (LEFT,s); + if (!get_bound (LEFT)) + set_bound (LEFT,s); else - set_bounds (RIGHT,s); -} - -Stem_info -Beam::get_stem_info (Stem *s) -{ - Stem_info i; - for (int i=0; i < sinfo_.size (); i++) - { - if (sinfo_[i].stem_l_ == s) - return sinfo_[i]; - } - assert (false); - return i; + set_bound (RIGHT,s); } -Molecule* -Beam::do_brew_molecule_p () const +int +Beam::get_multiplicity () const { - Molecule *mol_p = new Molecule; - if (!sinfo_.size ()) - return mol_p; - - Real x0 = stems_[0]->hpos_f (); - for (int j=0; j 0)? stems_[j-1] : 0; - Stem * next = (j < stems_.size ()-1) ? stems_[j+1] :0; + Score_element * sc = unsmob_element (gh_car (s)); - Molecule sb = stem_beams (i, next, prev); - Real x = i->hpos_f ()-x0; - sb.translate (Offset (x, (x * slope_f_ + left_y_) * - i->staff_line_leading_f ()/2 )); - mol_p->add_molecule (sb); + if (Stem * st = dynamic_cast (sc)) + m = m >? st->beam_count (LEFT) >? st->beam_count (RIGHT); } - mol_p->translate_axis (x0 - - spanned_drul_[LEFT]->absolute_coordinate (X_AXIS), X_AXIS); - - return mol_p; -} - -Offset -Beam::center () const -{ - Stem_info si = sinfo_[0]; - - Real w= (si.stem_l_->note_delta_f () + extent (X_AXIS).length ())/2.0; - return Offset (w, ( w* slope_f_) * - si.stem_l_->staff_line_leading_f ()/2); -} - -void -Beam::do_pre_processing () -{ - if (!dir_) - dir_ = get_default_dir (); - - - set_direction (dir_); -} - -void -Beam::do_print () const -{ -#ifndef NPRINT - DOUT << "slope_f_ " << slope_f_ << "left ypos " << left_y_; - Spanner::do_print (); -#endif + return m; } +/* + After pre-processing all directions should be set. + Several post-processing routines (stem, slur, script) need stem/beam + direction. + Currenly, this means that beam has set all stem's directions. + [Alternatively, stems could set its own directions, according to + their beam, during 'final-pre-processing'.] + */ void -Beam::do_post_processing () +Beam::before_line_breaking () { - if (stems_.size () < 2) + // Why? + if (visible_stem_count () < 2) { - warning (_ ("beam with less than two stems")); - set_elt_property (transparent_scm_sym, SCM_BOOL_T); - return ; + warning (_ ("beam has less than two stems")); + // set_elt_property ("transparent", SCM_BOOL_T); } - calculate_slope (); - set_stemlens (); -} -void -Beam::do_substitute_element_pointer (Score_element*o,Score_element*n) -{ - if (Stem * os = dynamic_cast (o)) - stems_.substitute (os, - dynamic_cast (n)); -} + if (!directional_element (this).get ()) + directional_element (this).set (get_default_dir ()); -Interval -Beam::do_width () const -{ - return Interval (stems_[0]->hpos_f (), - stems_.top ()->hpos_f ()); + auto_knees (); + set_stem_directions (); + set_stem_shorten (); } +/* + FIXME + */ Direction Beam::get_default_dir () const { @@ -170,12 +108,11 @@ Beam::get_default_dir () const count[UP] = count[DOWN] = 0; Direction d = DOWN; - Direction beamdir; - for (int i=0; i dir_ - ? (1 + d * s->dir_)/2 + for (int i=0; i get_center_distance ((Direction)-d); if (current) @@ -186,548 +123,577 @@ Beam::get_default_dir () const } while (flip(&d) != DOWN); - /* - [Ross] states that the majority of the notes dictates the - direction (and not the mean of "center distance") - - But is that because it really looks better, or because he - wants to provide some real simple hands-on rules. - - We have our doubts, so we simply provide all sensible alternatives. - */ - Dir_algorithm a = (Dir_algorithm)rint(paper_l ()->get_var ("beam_dir_algorithm")); - switch (a) - { - case MAJORITY: - beamdir = (count[UP] > count[DOWN]) ? UP : DOWN; - break; - case MEAN: - // mean center distance - beamdir = (total[UP] > total[DOWN]) ? UP : DOWN; - break; - default: - case MEDIAN: - // median center distance - if (!count[UP]) - beamdir = DOWN; - else if (!count[DOWN]) - beamdir = UP; - else - beamdir = (total[UP] / count[UP] > total[DOWN] / count[DOWN]) ? UP : DOWN; - break; - } - return beamdir; + SCM s = scm_eval (gh_list (ly_symbol2scm ("beam-dir-algorithm"), + ly_quote_scm (gh_cons (gh_int2scm (count[UP]), + gh_int2scm (count[DOWN]))), + ly_quote_scm (gh_cons (gh_int2scm (total[UP]), + gh_int2scm (total[DOWN]))), + SCM_UNDEFINED)); + if (gh_number_p (s) && gh_scm2int (s)) + return to_dir (s); + + /* + If dir is not determined: get from paper + */ + return (Direction)(int) + paper_l ()->get_var ("stem_default_neutral_direction"); } -void -Beam::set_direction (Direction d) -{ - dir_ = d; - for (int i=0; i set_elt_property (beam_dir_scm_sym, gh_int2scm (d)); - - SCM force = s->remove_elt_property (dir_forced_scm_sym); - if (force == SCM_BOOL_F) - s->dir_ = d; - } -} /* - See Documentation/tex/fonts.doc + Set all stems with non-forced direction to beam direction. + Urg: non-forced should become `without/with unforced' direction, + once stem gets cleaned-up. */ - void -Beam::solve_slope () +Beam::set_stem_directions () { - assert (sinfo_.size () > 1); - DOUT << "Beam::solve_slope: \n"; - - Least_squares l; - for (int i=0; i < sinfo_.size (); i++) + Direction d = directional_element (this).get (); + for (int i=0; i remove_elt_property ("dir-forced"); + if (!gh_boolean_p (force) || !gh_scm2bool (force)) + directional_element (s).set (d); } - l.minimise (slope_f_, left_y_); +} + +void +Beam::auto_knees () +{ + if (!auto_knee ("auto-interstaff-knee-gap", true)) + auto_knee ("auto-knee-gap", false); } /* - ugh. Naming: this doesn't check, but sets as well. + Simplistic auto-knees; only consider vertical gap between two + adjacent chords. + + `Forced' stem directions are ignored. If you don't want auto-knees, + don't set, or unset autoKneeGap/autoInterstaffKneeGap. */ - -Real -Beam::check_stemlengths_f (bool set_b) +bool +Beam::auto_knee (String gap_str, bool interstaff_b) { - Real interbeam_f = paper_l ()->interbeam_f (multiple_i_); - - Real beam_f = paper_l ()->beam_thickness_f (); - Real staffline_f = paper_l ()->rule_thickness (); - Real epsilon_f = staffline_f / 8; - Real dy_f = 0.0; - for (int i=0; i < sinfo_.size (); i++) + bool knee_b = false; + int knee_y = 0; + SCM gap = get_elt_property (gap_str); + Direction d = directional_element (this).get (); + + if (gh_number_p (gap)) { - Real y = sinfo_[i].x_ * slope_f_ + left_y_; - - // correct for knee - if (dir_ != sinfo_[i].dir_) - { - Real internote_f = sinfo_[i].stem_l_->staff_line_leading_f ()/2; - y -= dir_ * (beam_f / 2 - + (sinfo_[i].mult_i_ - 1) * interbeam_f) / internote_f; - if (!i && sinfo_[i].stem_l_->staff_symbol_l () != - sinfo_.top ().stem_l_->staff_symbol_l ()) - y += dir_ * (multiple_i_ - (sinfo_[i].stem_l_->flag_i_ - 2) >? 0) - * interbeam_f / internote_f; + int auto_gap_i = gh_scm2int (gap); + for (int i=1; i < stem_count (); i++) + { + bool is_b = (bool)(calc_interstaff_dist (stem (i), this) + - calc_interstaff_dist (stem (i-1), this)); + int l_y = (int)(stem (i-1)->head_positions()[d]) + + (int)calc_interstaff_dist (stem (i-1), this); + int r_y = (int)(stem (i)->head_positions()[d]) + + (int)calc_interstaff_dist (stem (i), this); + int gap_i = r_y - l_y; + + if ((abs (gap_i) >= auto_gap_i) && (!interstaff_b || is_b)) + { + knee_y = (r_y + l_y) / 2; + knee_b = true; + break; + } } - - if (set_b) - sinfo_[i].stem_l_->set_stemend (y - sinfo_[i].interstaff_f_); - - y *= dir_; - if (y > sinfo_[i].maxy_f_) - dy_f = dy_f ? sinfo_[i].miny_f_ - y; + } + if (knee_b) + { + for (int i=0; i < stem_count (); i++) + { + int y = (int)(stem (i)->head_positions()[d]) + + (int)calc_interstaff_dist (stem (i), this); + directional_element (stem (i)).set (y < knee_y ? UP : DOWN); + stem (i)->set_elt_property ("dir-forced", SCM_BOOL_T); } } - return dy_f; + return knee_b; } +/* + Set stem's shorten property if unset. + TODO: + take some y-position (chord/beam/nearest?) into account + scmify forced-fraction + */ void -Beam::set_steminfo () +Beam::set_stem_shorten () { - if(!stems_.size ()) + if (!visible_stem_count ()) return; - - assert (multiple_i_); - int total_count_i = 0; - int forced_count_i = 0; - for (int i=0; i < stems_.size (); i++) - { - Stem *s = stems_[i]; - s->set_default_extents (); - if (s->invisible_b ()) - continue; - if (((int)s->chord_start_f ()) && (s->dir_ != s->get_default_dir ())) - forced_count_i++; - total_count_i++; - } + Real forced_fraction = forced_stem_count () / visible_stem_count (); + if (forced_fraction < 0.5) + return; - Real internote_f = stems_[0]->staff_line_leading_f ()/2; - int stem_max = (int)rint(paper_l ()->get_var ("stem_max")); - Real shorten_f = paper_l ()->get_var (String ("forced_stem_shorten" - + to_str (multiple_i_ a; + scm_to_array (shorten, &a); + if (!a.size ()) + return; + + Staff_symbol_referencer_interface st (this); + Real staff_space = st.staff_space (); + Real shorten_f = a[multiplicity invisible_b ()) - continue; - - Stem_info info (s, multiple_i_); - if (leftx == 0) - leftx = info.x_; - info.x_ -= leftx; - if (info.dir_ == dir_) - { - if (forced_count_i == total_count_i) - info.idealy_f_ -= shorten_f; - else if (forced_count_i > total_count_i / 2) - info.idealy_f_ -= shorten_f / 2; - } - sinfo_.push (info); + continue; + if (gh_number_p (s->get_elt_property ("shorten"))) + s->set_elt_property ("shorten", gh_double2scm (shorten_f)); } } +/* + Set elt properties height and y-position if not set. + Adjust stem lengths to reach beam. + */ void -Beam::calculate_slope () +Beam::after_line_breaking () { - set_steminfo (); - if (!sinfo_.size ()) - slope_f_ = left_y_ = 0; - else if (sinfo_[0].idealy_f_ == sinfo_.top ().idealy_f_) + /* first, calculate y, dy */ + Real y, dy; + calc_position_and_height (&y, &dy); + if (visible_stem_count ()) { - slope_f_ = 0; - left_y_ = sinfo_[0].idealy_f_; - left_y_ *= dir_; + if (suspect_slope_b (y, dy)) + dy = 0; + + Real damped_dy = calc_slope_damping_f (dy); + Real quantised_dy = quantise_dy_f (damped_dy); + + y += (dy - quantised_dy) / 2; + dy = quantised_dy; } - else + /* + until here, we used only stem_info, which acts as if dir=up + */ + y *= directional_element (this).get (); + dy *= directional_element (this).get (); + + Staff_symbol_referencer_interface st (this); + Real half_space = st.staff_space () / 2; + + /* check for user-override of dy */ + SCM s = remove_elt_property ("height-hs"); + if (gh_number_p (s)) { - solve_slope (); - Real solved_slope_f = slope_f_; + dy = gh_scm2double (s) * half_space; + } + set_elt_property ("height", gh_double2scm (dy)); - /* - steep slope running against lengthened stem is suspect - */ - Real dx_f = stems_.top ()->hpos_f () - stems_[0]->hpos_f (); - - // urg, these y internote-y-dimensions - Real internote_f = stems_[0]->staff_line_leading_f ()/2; - - Real lengthened = paper_l ()->get_var ("beam_lengthened") / internote_f; - Real steep = paper_l ()->get_var ("beam_steep_slope") / internote_f; - if (((left_y_ - sinfo_[0].idealy_f_ > lengthened) - && (slope_f_ > steep)) - || ((left_y_ + slope_f_ * dx_f - sinfo_.top ().idealy_f_ > lengthened) - && (slope_f_ < -steep))) + /* check for user-override of y */ + s = remove_elt_property ("y-position-hs"); + if (gh_number_p (s)) + { + y = gh_scm2double (s) * half_space; + } + else + { + /* we can modify y, so we should quantise y */ + Real y_shift = check_stem_length_f (y, dy); + y += y_shift; + y = quantise_y_f (y, dy, 0); + set_stem_length (y, dy); + y_shift = check_stem_length_f (y, dy); + + if (y_shift > half_space / 4) { - slope_f_ = 0; + y += y_shift; + + /* + for significantly lengthened or shortened stems, + request quanting the other way. + */ + int quant_dir = 0; + if (abs (y_shift) > half_space / 2) + quant_dir = sign (y_shift) * directional_element (this).get (); + y = quantise_y_f (y, dy, quant_dir); } - - /* - This neat trick is by Werner Lemberg, - damped = tanh (slope_f_) - corresponds with some tables in [Wanske] - */ - SCM damp = remove_elt_property (damping_scm_sym); - int damping = 1; // ugh. - if (damp!= SCM_BOOL_F) - damping = gh_int2scm (SCM_CDR(damp)); - - if (damping) - slope_f_ = 0.6 * tanh (slope_f_) / damping; - - quantise_dy (); - - Real damped_slope_dy_f = (solved_slope_f - slope_f_) * dx_f / 2; - left_y_ += damped_slope_dy_f; - - left_y_ *= dir_; - slope_f_ *= dir_; } + // UGH. Y is not in staff position unit? + // Ik dacht datwe daar juist van weg wilden? + set_stem_length (y, dy); + set_elt_property ("y-position", gh_double2scm (y)); } +/* + See Documentation/tex/fonts.doc + */ void -Beam::quantise_dy () +Beam::calc_position_and_height (Real* y, Real* dy) const { - /* - [Ross] (simplification of) - Try to set slope_f_ complying with y-span of: - - zero - - beam_f / 2 + staffline_f / 2 - - beam_f + staffline_f - + n * interline - */ - - if (quantisation_ <= NONE) + *y = *dy = 0; + if (visible_stem_count () <= 1) return; - Real interline_f = stems_[0]->staff_line_leading_f (); - Real internote_f = interline_f / 2; - Real staffline_f = paper_l ()->rule_thickness (); - Real beam_f = paper_l ()->beam_thickness_f (); - - Real dx_f = stems_.top ()->hpos_f () - stems_[0]->hpos_f (); - - // dim(y) = internote; so slope = (y/internote)/x - Real dy_f = dx_f * abs (slope_f_ * internote_f); - - Real quanty_f = 0.0; + Real first_ideal = first_visible_stem ()->calc_stem_info ().idealy_f_; + if (first_ideal == last_visible_stem ()->calc_stem_info ().idealy_f_) + { + *dy = 0; + *y = first_ideal; + return; + } - /* UGR. ICE in 2.8.1; bugreport filed. */ - Array allowed_fraction (3); - allowed_fraction[0] = 0; - allowed_fraction[1] = (beam_f / 2 + staffline_f / 2); - allowed_fraction[2] = (beam_f + staffline_f); + Array ideals; + Real x0 = first_visible_stem ()->relative_coordinate (0, X_AXIS); + for (int i=0; i < stem_count (); i++) + { + Stem* s = stem (i); + if (s->invisible_b ()) + continue; + ideals.push (Offset (s->relative_coordinate (0, X_AXIS) - x0, + s->calc_stem_info ().idealy_f_)); + } + Real dydx; + minimise_least_squares (&dydx, y, ideals); // duh, takes references + Real dx = last_visible_stem ()->relative_coordinate (0, X_AXIS) - x0; + *dy = dydx * dx; +} - Interval iv = quantise_iv (allowed_fraction, interline_f, dy_f); - quanty_f = (dy_f - iv[SMALLER] <= iv[BIGGER] - dy_f) - ? iv[SMALLER] - : iv[BIGGER]; +bool +Beam::suspect_slope_b (Real y, Real dy) const +{ + /* first, calculate y, dy */ + /* + steep slope running against lengthened stem is suspect + */ + Real first_ideal = first_visible_stem ()->calc_stem_info ().idealy_f_; + Real last_ideal = last_visible_stem ()->calc_stem_info ().idealy_f_; + Real lengthened = paper_l ()->get_var ("beam_lengthened"); + Real steep = paper_l ()->get_var ("beam_steep_slope"); + Real dx = last_visible_stem ()->relative_coordinate (0, X_AXIS) - first_visible_stem ()->relative_coordinate (0, X_AXIS); + Real dydx = dy && dx ? dy/dx : 0; - slope_f_ = (quanty_f / dx_f) / internote_f * sign (slope_f_); + if (((y - first_ideal > lengthened) && (dydx > steep)) + || ((y + dy - last_ideal > lengthened) && (dydx < -steep))) + { + return true; + } + return false; } -static int test_pos = 0; - - /* - - Prevent interference from stafflines and beams. See Documentation/tex/fonts.doc - - */ -void -Beam::quantise_left_y (bool extend_b) + This neat trick is by Werner Lemberg, + damped = tanh (slope) + corresponds with some tables in [Wanske] +*/ +Real +Beam::calc_slope_damping_f (Real dy) const { - /* - we only need to quantise the start of the beam as dy is quantised too - if extend_b then stems must *not* get shorter - */ - - if (quantisation_ <= NONE) - return; + SCM damp = get_elt_property ("damping"); // remove? + int damping = 1; // ugh. + if (gh_number_p (damp)) + damping = gh_scm2int (damp); - /* - ---------------------------------------------------------- - ######## - ######## - ######## - --------------########------------------------------------ - ######## - - hang straddle sit inter hang - */ + if (damping) + { + Real dx = last_visible_stem ()->relative_coordinate (0, X_AXIS) + - first_visible_stem ()->relative_coordinate (0, X_AXIS); + Real dydx = dy && dx ? dy/dx : 0; + dydx = 0.6 * tanh (dydx) / damping; + return dydx * dx; + } + return dy; +} - Real space = stems_[0]->staff_line_leading_f (); - Real internote_f = space /2; - Real staffline_f = paper_l ()->rule_thickness (); - Real beam_f = paper_l ()->beam_thickness_f (); +Real +Beam::calc_stem_y_f (Stem* s, Real y, Real dy) const +{ + Real thick = gh_scm2double (get_elt_property ("beam-thickness")); + int beam_multiplicity = get_multiplicity (); + int stem_multiplicity = (s->flag_i () - 2) >? 0; + + Real interbeam_f = paper_l ()->interbeam_f (beam_multiplicity); + Real x0 = first_visible_stem ()->relative_coordinate (0, X_AXIS); + Real dx = last_visible_stem ()->relative_coordinate (0, X_AXIS) - x0; + Real stem_y = (dy && dx ? (s->relative_coordinate (0, X_AXIS) - x0) / dx * dy : 0) + y; + + /* knee */ + Direction dir = directional_element(this).get (); + Direction sdir = directional_element (s).get (); + + /* knee */ + if (dir!= sdir) + { + stem_y -= dir + * (thick / 2 + (beam_multiplicity - 1) * interbeam_f); - /* - [TODO] - it would be nice to have all allowed positions in a runtime matrix: - (multiplicity, minimum_beam_dy, maximum_beam_dy) - */ + Staff_symbol_referencer_interface me (s); + Staff_symbol_referencer_interface last (last_visible_stem ()); + + // huh, why not for first visible? + if (//(s != first_visible_stem ()) && + me.staff_symbol_l () != last.staff_symbol_l ()) + stem_y += directional_element (this).get () + * (beam_multiplicity - stem_multiplicity) * interbeam_f; + } + return stem_y; +} - Real straddle = 0; - Real sit = beam_f / 2 - staffline_f / 2; - Real inter = space / 2; - Real hang = space - beam_f / 2 + staffline_f / 2; +Real +Beam::check_stem_length_f (Real y, Real dy) const +{ + Real shorten = 0; + Real lengthen = 0; + Direction dir = directional_element (this).get (); + + for (int i=0; i < stem_count (); i++) + { + Stem* s = stem (i); + if (s->invisible_b ()) + continue; - /* - Put all allowed positions into an array. - Whether a position is allowed or not depends on - strictness of quantisation, multiplicity and direction. + Real stem_y = calc_stem_y_f (s, y, dy); + + stem_y *= dir; + Stem_info info = s->calc_stem_info (); - For simplicity, we'll assume dir = UP and correct if - dir = DOWN afterwards. - */ + // if (0 > info.maxy_f_ - stem_y) + shorten = shorten ? info.miny_f_ - stem_y; + } - // dim(left_y_) = internote - Real dy_f = dir_ * left_y_ * internote_f; + if (lengthen && shorten) + warning (_ ("weird beam vertical offset")); - Real beamdx_f = stems_.top ()->hpos_f () - stems_[0]->hpos_f (); - Real beamdy_f = beamdx_f * slope_f_ * internote_f; + /* when all stems are too short, normal stems win */ + return dir * ((shorten) ? shorten : lengthen); +} - Array allowed_position; - if (quantisation_ != TEST) - { - if (quantisation_ <= NORMAL) - { - if ((multiple_i_ <= 2) || (abs (beamdy_f) >= staffline_f / 2)) - allowed_position.push (straddle); - if ((multiple_i_ <= 1) || (abs (beamdy_f) >= staffline_f / 2)) - allowed_position.push (sit); - allowed_position.push (hang); - } - else - // TODO: check and fix TRADITIONAL - { - if ((multiple_i_ <= 2) || (abs (beamdy_f) >= staffline_f / 2)) - allowed_position.push (straddle); - if ((multiple_i_ <= 1) && (beamdy_f <= staffline_f / 2)) - allowed_position.push (sit); - if (beamdy_f >= -staffline_f / 2) - allowed_position.push (hang); - } - } - else +/* + Hmm. At this time, beam position and slope are determined. Maybe, + stem directions and length should set to relative to the chord's + position of the beam. */ +void +Beam::set_stem_length (Real y, Real dy) +{ + Staff_symbol_referencer_interface st (this); + Real half_space = st.staff_space ()/2; + for (int i=0; i < stem_count (); i++) { - if (test_pos == 0) - { - allowed_position.push (hang); - cout << "hang" << hang << "\n"; - } - else if (test_pos==1) - { - allowed_position.push (straddle); - cout << "straddle" << straddle << endl; - } - else if (test_pos==2) - { - allowed_position.push (sit); - cout << "sit" << sit << endl; - } - else if (test_pos==3) - { - allowed_position.push (inter); - cout << "inter" << inter << endl; - } - } - - Interval iv = quantise_iv (allowed_position, space, dy_f); + Stem* s = stem (i); + if (s->invisible_b ()) + continue; - Real quanty_f = dy_f - iv[SMALLER] <= iv[BIGGER] - dy_f ? iv[SMALLER] : iv[BIGGER]; - if (extend_b) - quanty_f = iv[BIGGER]; + Real stem_y = calc_stem_y_f (s, y, dy); - // dim(left_y_) = internote - left_y_ = dir_ * quanty_f / internote_f; + /* caution: stem measures in staff-positions */ + s->set_stemend ((stem_y + calc_interstaff_dist (s, this)) / half_space); + } } -void -Beam::set_stemlens () +/* + [Ross] (simplification of) + Set dy complying with: + - zero + - thick / 2 + staffline_f / 2 + - thick + staffline_f + + n * staff_space +*/ +Real +Beam::quantise_dy_f (Real dy) const { - Real staffline_f = paper_l ()->rule_thickness (); - // enge floots - Real epsilon_f = staffline_f / 8; + SCM quants = ly_eval_str ("beam-height-quants"); - Real dy_f = check_stemlengths_f (false); - for (int i = 0; i < 2; i++) - { - left_y_ += dy_f * dir_; - quantise_left_y (dy_f); - dy_f = check_stemlengths_f (true); - if (abs (dy_f) <= epsilon_f) - { - break; - } - } + Array a; + scm_to_array (quants, &a); + if (a.size () <= 1) + return dy; - test_pos++; - test_pos %= 4; + Staff_symbol_referencer_interface st (this); + Real staff_space = st.staff_space (); + + Interval iv = quantise_iv (a, abs (dy)/staff_space) * staff_space; + Real q = (abs (dy) - iv[SMALLER] <= iv[BIGGER] - abs (dy)) + ? iv[SMALLER] + : iv[BIGGER]; + + return q * sign (dy); } /* - FIXME - ugh. this is broken and should be rewritten. - - [c8. c32 c32] + Prevent interference from stafflines and beams. + See Documentation/tex/fonts.doc + + We only need to quantise the (left) y-position of the beam, + since dy is quantised too. + if extend_b then stems must *not* get shorter */ -void -Beam::set_grouping (Rhythmic_grouping def, Rhythmic_grouping cur) +Real +Beam::quantise_y_f (Real y, Real dy, int quant_dir) { - def.OK (); - cur.OK (); - assert (cur.children.size () == stems_.size ()); - - cur.split (def); + int multiplicity = get_multiplicity (); + Staff_symbol_referencer_interface st (this); + Real staff_space = st.staff_space (); + SCM quants = scm_eval (gh_list ( + ly_symbol2scm ("beam-vertical-position-quants"), + gh_int2scm (multiplicity), + gh_double2scm (dy/staff_space), + SCM_UNDEFINED)); + Array a; + scm_to_array (quants, &a); + if (a.size () <= 1) + return y; + + Real up_y = directional_element (this).get () * y; + Interval iv = quantise_iv (a, up_y/staff_space) * staff_space; + + Real q = up_y - iv[SMALLER] <= iv[BIGGER] - up_y + ? iv[SMALLER] : iv[BIGGER]; + if (quant_dir) + q = iv[(Direction)quant_dir]; + + return q * directional_element (this).get (); +} - Array b; - { - Array flags; - for (int j=0; j flag_i_ - 2; - assert (f>0); - flags.push (f); - } - int fi =0; - b= cur.generate_beams (flags, fi); - b.insert (0,0); - b.push (0); - assert (stems_.size () == b.size ()/2); - } - - for (int j=0, i=0; i < b.size () && j beams_i_drul_[d] < 0) - s->beams_i_drul_[d] = b[i]; - - multiple_i_ = multiple_i_ >? s->beams_i_drul_[d]; - i++; - } while ((flip (&d)) != LEFT); + do + { + if (stem (i)->beam_count (d) == 0) + stem (i)->set_beaming ( beaming->infos_.elem (i).beams_i_drul_[d],d); + } + while (flip (&d) != LEFT); } } + + /* beams to go with one stem. + + BURP + clean me up. */ Molecule Beam::stem_beams (Stem *here, Stem *next, Stem *prev) const { - assert (!next || next->hpos_f () > here->hpos_f ()); - assert (!prev || prev->hpos_f () < here->hpos_f ()); + if ((next && !(next->relative_coordinate (0, X_AXIS) > here->relative_coordinate (0, X_AXIS))) || + (prev && !(prev->relative_coordinate (0, X_AXIS) < here->relative_coordinate (0, X_AXIS)))) + programming_error ("Beams are not left-to-right"); - Real staffline_f = paper_l ()->rule_thickness (); - Real interbeam_f = paper_l ()->interbeam_f (multiple_i_); + Real staffline_f = paper_l ()->get_var ("stafflinethickness"); + int multiplicity = get_multiplicity (); - Real internote_f = here->staff_line_leading_f ()/2; - Real beam_f = paper_l ()->beam_thickness_f (); - Real dy = interbeam_f; + Real interbeam_f = paper_l ()->interbeam_f (multiplicity); + Real thick = gh_scm2double (get_elt_property ("beam-thickness")); + + Real bdy = interbeam_f; Real stemdx = staffline_f; - Real sl = slope_f_* internote_f; - lookup_l ()->beam (sl, 20 PT, 1 PT); + + Real dx = visible_stem_count () ? + last_visible_stem ()->relative_coordinate (0, X_AXIS) - first_visible_stem ()->relative_coordinate (0, X_AXIS) + : 0.0; + Real dy = gh_scm2double (get_elt_property ("height")); + Real dydx = dy && dx ? dy/dx : 0; Molecule leftbeams; Molecule rightbeams; // UGH - Real nw_f = paper_l ()->note_width () * 0.8; + Real nw_f; + if (!here->first_head ()) + nw_f = 0; + else if (here->type_i ()== 1) + nw_f = paper_l ()->get_var ("wholewidth"); + else if (here->type_i () == 2) + nw_f = paper_l ()->get_var ("notewidth") * 0.8; + else + nw_f = paper_l ()->get_var ("quartwidth"); + + Direction dir = directional_element (this).get (); + /* half beams extending to the left. */ if (prev) { - int lhalfs= lhalfs = here->beams_i_drul_[LEFT] - prev->beams_i_drul_[RIGHT] ; - int lwholebeams= here->beams_i_drul_[LEFT] beams_i_drul_[RIGHT] ; + int lhalfs= lhalfs = here->beam_count (LEFT) - prev->beam_count (RIGHT); + int lwholebeams= here->beam_count (LEFT) beam_count (RIGHT) ; /* Half beam should be one note-width, but let's make sure two half-beams never touch */ - Real w = here->hpos_f () - prev->hpos_f (); + Real w = here->relative_coordinate (0, X_AXIS) - prev->relative_coordinate (0, X_AXIS); w = w/2 beam (sl, w, beam_f); - a.translate (Offset (-w, -w * sl)); + a = lookup_l ()->beam (dydx, w, thick); + a.translate (Offset (-w, -w * dydx)); for (int j = 0; j < lhalfs; j++) { Molecule b (a); - b.translate_axis (-dir_ * dy * (lwholebeams+j), Y_AXIS); + b.translate_axis (-dir * bdy * (lwholebeams+j), Y_AXIS); leftbeams.add_molecule (b); } } if (next) { - int rhalfs = here->beams_i_drul_[RIGHT] - next->beams_i_drul_[LEFT]; - int rwholebeams = here->beams_i_drul_[RIGHT] beams_i_drul_[LEFT]; + int rhalfs = here->beam_count (RIGHT) - next->beam_count (LEFT); + int rwholebeams= here->beam_count (RIGHT) beam_count (LEFT) ; - Real w = next->hpos_f () - here->hpos_f (); - Molecule a = lookup_l ()->beam (sl, w + stemdx, beam_f); + Real w = next->relative_coordinate (0, X_AXIS) - here->relative_coordinate (0, X_AXIS); + Molecule a = lookup_l ()->beam (dydx, w + stemdx, thick); a.translate_axis( - stemdx/2, X_AXIS); int j = 0; Real gap_f = 0; - SCM gap = get_elt_property (beam_gap_scm_sym); - if (gap != SCM_BOOL_F) + SCM gap = get_elt_property ("beam-gap"); + if (gh_number_p (gap)) { - int gap_i = gh_scm2int (gap); + int gap_i = gh_scm2int ( (gap)); int nogap = rwholebeams - gap_i; for (; j < nogap; j++) { Molecule b (a); - b.translate_axis (-dir_ * dy * j, Y_AXIS); + b.translate_axis (-dir * bdy * j, Y_AXIS); rightbeams.add_molecule (b); } // TODO: notehead widths differ for different types gap_f = nw_f / 2; w -= 2 * gap_f; - a = lookup_l ()->beam (sl, w + stemdx, beam_f); + a = lookup_l ()->beam (dydx, w + stemdx, thick); } for (; j < rwholebeams; j++) { Molecule b (a); - b.translate (Offset (gap_f, -dir_ * dy * j)); + b.translate (Offset (here->invisible_b () ? 0 : gap_f, -dir * bdy * j)); rightbeams.add_molecule (b); } w = w/2 beam (sl, w, beam_f); + a = lookup_l ()->beam (dydx, w, thick); for (; j < rwholebeams + rhalfs; j++) { Molecule b (a); - b.translate_axis (-dir_ * dy * j, Y_AXIS); + b.translate_axis (- dir * bdy * j, Y_AXIS); rightbeams.add_molecule (b); } @@ -741,3 +707,126 @@ Beam::stem_beams (Stem *here, Stem *next, Stem *prev) const return leftbeams; } + +Molecule +Beam::do_brew_molecule () const +{ + Molecule mol; + if (!stem_count ()) + return mol; + Real x0,dx; + if (visible_stem_count ()) + { + x0 = first_visible_stem ()->relative_coordinate (0, X_AXIS); + dx = last_visible_stem ()->relative_coordinate (0, X_AXIS) - x0; + } + else + { + x0 = stem (0)->relative_coordinate (0, X_AXIS); + dx = stem_top ()->relative_coordinate (0, X_AXIS) - x0; + } + + + Real dy = gh_scm2double (get_elt_property ("height")); + Real dydx = dy && dx ? dy/dx : 0; + Real y = gh_scm2double (get_elt_property ("y-position")); + for (int j=0; j 0)? stem (j-1) : 0; + Stem * next = (j < stem_count ()-1) ? stem (j+1) :0; + + Molecule sb = stem_beams (i, next, prev); + Real x = i->relative_coordinate (0, X_AXIS)-x0; + sb.translate (Offset (x, x * dydx + y)); + mol.add_molecule (sb); + } + mol.translate_axis (x0 + - get_bound (LEFT)->relative_coordinate (0, X_AXIS), X_AXIS); + + return mol; +} + +int +Beam::forced_stem_count () const +{ + int f = 0; + for (int i=0; i < stem_count (); i++) + { + Stem *s = stem (i); + + if (s->invisible_b ()) + continue; + + if (((int)s->chord_start_f ()) + && (s->get_direction () != s->get_default_dir ())) + f++; + } + return f; +} + + + +/* + TODO: Fix this class. This is wildly inefficient. + And it sux. Yet another array/list 'interface'. + */ +Stem * +Beam::stem (int i) const +{ + return Group_interface__extract_elements ((Beam*) this, (Stem*) 0, "stems")[i]; +} + +int +Beam::stem_count () const +{ + Group_interface gi (this, "stems"); + return gi.count (); +} + +Stem* +Beam::stem_top () const +{ + SCM s = get_elt_property ("stems"); + + return gh_pair_p (s) ? dynamic_cast (unsmob_element (gh_car (s))) : 0; + + //Group_interface__extract_elements ((Beam*) this, (Stem*) 0, "stems")[stem_count () - 1]; +} + +/* burp */ +int +Beam::visible_stem_count () const +{ + int c = 0; + for (int i = 0; i < stem_count (); i++) + { + if (!stem (i)->invisible_b ()) + c++; + } + return c; +} + +Stem* +Beam::first_visible_stem () const +{ + for (int i = 0; i < stem_count (); i++) + { + Stem* s = stem (i); + if (!s->invisible_b ()) + return s; + } + return 0; +} + +Stem* +Beam::last_visible_stem () const +{ + for (int i = stem_count (); i > 0; i--) + { + Stem* s = stem (i - 1); + if (!s->invisible_b ()) + return s; + } + return 0; +}