X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fslur.cc;h=bc8fa4b5a7212a2413195812959bcf96dc9c9bf6;hb=abc2e31b608746a1ac924085a87244cc32ee7178;hp=14edd7b3e2146d21354fd5955bbfe51fc554a32c;hpb=1cf3d59c1559fb9774c4c1c8cae155cfe54a927c;p=lilypond.git diff --git a/lily/slur.cc b/lily/slur.cc index 14edd7b3e2..bc8fa4b5a7 100644 --- a/lily/slur.cc +++ b/lily/slur.cc @@ -3,16 +3,14 @@ source file of the GNU LilyPond music typesetter - (c) 1996, 1997--1998, 1998 Han-Wen Nienhuys + (c) 1996, 1997--1999 Han-Wen Nienhuys Jan Nieuwenhuizen */ /* [TODO] - * URG: share code with tie - * begin and end should be treated as a Script. - * damping - * slur from notehead to stemend: c''()b'' + * begin and end should be treated as a/acknowledge Scripts. + * broken slur should have uniform trend */ #include "slur.hh" @@ -21,7 +19,7 @@ #include "paper-def.hh" #include "note-column.hh" #include "stem.hh" -#include "p-col.hh" +#include "paper-column.hh" #include "molecule.hh" #include "debug.hh" #include "box.hh" @@ -29,7 +27,6 @@ #include "encompass-info.hh" #include "main.hh" -IMPLEMENT_IS_TYPE_B1(Slur,Bow); Slur::Slur () { @@ -38,22 +35,28 @@ Slur::Slur () void Slur::add_column (Note_column*n) { - encompass_arr_.push (n); - add_dependency (n); + if (!n->head_l_arr_.size ()) + warning (_ ("Putting slur over rest. Ignoring")); + else + { + encompass_arr_.push (n); + add_dependency (n); + } } -void -Slur::set_default_dir () +Direction +Slur::get_default_dir () const { - dir_ = DOWN; + Direction d = DOWN; for (int i=0; i < encompass_arr_.size (); i ++) { - if (encompass_arr_[i]->dir_ < 0) + if (encompass_arr_[i]->dir () < 0) { - dir_ = UP; + d = UP; break; } } + return d; } void @@ -71,13 +74,13 @@ Slur::do_pre_processing () } void -Slur::do_substitute_dependency (Score_element*o, Score_element*n) +Slur::do_substitute_element_pointer (Score_element*o, Score_element*n) { int i; - while ((i = encompass_arr_.find_i ((Note_column*)o->access_Item ())) >=0) + while ((i = encompass_arr_.find_i (dynamic_cast (o))) >=0) { if (n) - encompass_arr_[i] = (Note_column*)n->access_Item (); + encompass_arr_[i] = dynamic_cast (n); else encompass_arr_.del (i); } @@ -94,178 +97,384 @@ Slur::do_post_processing () { encompass_arr_.sort (Note_column_compare); if (!dir_) - set_default_dir (); - - Real interline_f = paper ()->interline_f (); - Real internote_f = interline_f / 2; - Real notewidth_f = paper ()->note_width (); - Real slur_min = paper ()->get_var ("slur_x_minimum"); + dir_ = get_default_dir (); /* - [OSU]: slur and tie placement + Slur and tie placement [OSU] - slurs: - * x = centre of head (upside-down: inner raakpunt stem) - d * gap + Slurs: + * x = centre of head - d * x_gap_f - * y = length < 5ss : horizontal raakpunt + d * 0.25 ss + TODO: + * y = length < 5ss : horizontal tangent + d * 0.25 ss y = length >= 5ss : y next interline - d * 0.25 ss - --> height <= 5 length ?? we use <= 3 length, now... */ - - Real gap_f = paper ()->get_var ("slur_x_gap"); - Drul_array extrema; - extrema[LEFT] = encompass_arr_[0]; - extrema[RIGHT] = encompass_arr_.top (); + Real interline_f = paper_l ()->get_realvar (interline_scm_sym); + Real internote_f = interline_f / 2; + + Real x_gap_f = paper_l ()->get_var ("slur_x_gap"); + Real y_gap_f = paper_l ()->get_var ("slur_y_gap"); + + Drul_array note_column_drul; + note_column_drul[LEFT] = encompass_arr_[0]; + note_column_drul[RIGHT] = encompass_arr_.top (); - Direction d=LEFT; - + bool fix_broken_b = false; + Direction d = LEFT; do { - /* - broken slur - */ - if (extrema[d] != spanned_drul_[d]) + dx_f_drul_[d] = dy_f_drul_[d] = 0; + if ((note_column_drul[d] == spanned_drul_[d]) + && note_column_drul[d]->head_l_arr_.size () + && (note_column_drul[d]->stem_l_)) { - // ugh -- check if needed - dx_f_drul_[d] = -d - *(spanned_drul_[d]->width ().length () - 0.5 * notewidth_f); - - // prebreak - if (d == RIGHT) + Stem* stem_l = note_column_drul[d]->stem_l_; + /* + side directly attached to note head; + no beam getting in the way + */ + if ((stem_l->extent (Y_AXIS).empty_b () + || !((stem_l->dir_ == dir_) && (dir_ != d))) + && !((dir_ == stem_l->dir_) + && stem_l->beam_l_ && (stem_l->beams_i_drul_[-d] >= 1))) { - dx_f_drul_[LEFT] = spanned_drul_[LEFT]->width ().length (); + dx_f_drul_[d] = spanned_drul_[d]->extent (X_AXIS).length () / 2; + dx_f_drul_[d] -= d * x_gap_f; - // urg -- check if needed - if (encompass_arr_.size () > 1) - dx_f_drul_[RIGHT] += notewidth_f; + if (stem_l->dir_ != dir_) + { + dy_f_drul_[d] = note_column_drul[d]->extent (Y_AXIS)[dir_]; + } + else + { + dy_f_drul_[d] = stem_l->chord_start_f () + + dir_ * internote_f; + } + dy_f_drul_[d] += dir_ * y_gap_f; } - } - /* - normal slur - */ - else if (extrema[d]->stem_l_ && !extrema[d]->stem_l_->transparent_b_) - { - Real notewidth_f = extrema[d]->width ().length (); - dy_f_drul_[d] = (int)rint (extrema[d]->stem_l_->height ()[dir_]); - dx_f_drul_[d] += 0.5 * notewidth_f - d * gap_f; - if (dir_ == extrema[d]->stem_l_->dir_) + /* + side attached to (visible) stem + */ + else { - if (dir_ == d) - dx_f_drul_[d] += 0.5 * (dir_ * d) * d * notewidth_f; + dx_f_drul_[d] = stem_l->hpos_f () + - spanned_drul_[d]->absolute_coordinate (X_AXIS); + /* + side attached to beamed stem + */ + if (stem_l->beam_l_ && (stem_l->beams_i_drul_[-d] >= 1)) + { + dy_f_drul_[d] = stem_l->extent (Y_AXIS)[dir_]; + dy_f_drul_[d] += dir_ * 2 * y_gap_f; + } + /* + side attached to notehead, with stem getting in the way + */ else - dx_f_drul_[d] += 0.25 * (dir_ * d) * d * notewidth_f; + { + dx_f_drul_[d] -= d * x_gap_f; + + dy_f_drul_[d] = stem_l->chord_start_f () + + dir_ * internote_f; + dy_f_drul_[d] += dir_ * y_gap_f; + } } } - else - { - Real notewidth_f = extrema[d]->width ().length (); - dy_f_drul_[d] = (int)rint (extrema[d]->head_positions_interval () - [dir_]) * internote_f; - dx_f_drul_[d] += 0.5 * notewidth_f - d * gap_f; + /* + loose end + */ + else + { + /* + need break-align too. what about other spanners? + */ + if (d == LEFT) + dx_f_drul_[d] = spanned_drul_[LEFT]->extent (X_AXIS).length (); + + /* + broken: should get y from other piece, so that slur + continues up/down trend + + for now: be horizontal.. + */ + fix_broken_b = true; } - dy_f_drul_[d] += dir_ * interline_f; - if (extrema[d]->stem_l_ && (dir_ == extrema[d]->stem_l_->dir_)) - dy_f_drul_[d] -= dir_ * internote_f; } - while (flip(&d) != LEFT); + while (flip (&d) != LEFT); - // now that both are set, do dependent - do + int interstaff_i = 0; + for (int i = 0; i < encompass_arr_.size (); i++) { - /* - broken slur - */ - if (extrema[d] != spanned_drul_[d]) - { - Direction u = d; - flip(&u); - - // postbreak - if (d == LEFT) - dy_f_drul_[u] += dir_ * internote_f; + Encompass_info info (encompass_arr_[i], dir_, this); + if (info.interstaff_f_) + { + interstaff_i++; + } + } + bool interstaff_b = interstaff_i && (interstaff_i < encompass_arr_.size ()); - dy_f_drul_[d] = dy_f_drul_[(Direction)-d]; + Drul_array info_drul; + info_drul[LEFT] = Encompass_info (encompass_arr_[0], dir_, this); + info_drul[RIGHT] = Encompass_info (encompass_arr_.top (), dir_, this); + Real interstaff_f = info_drul[RIGHT].interstaff_f_ + - info_drul[LEFT].interstaff_f_; - // pre and post - if (dx_f_drul_[RIGHT] - dx_f_drul_[LEFT] < slur_min) + if (fix_broken_b) + { + Direction d = (encompass_arr_.top () != spanned_drul_[RIGHT]) ? + RIGHT : LEFT; + dy_f_drul_[d] = info_drul[d].o_[Y_AXIS]; + if (!interstaff_b) + { + dy_f_drul_[d] -= info_drul[d].interstaff_f_; + + if (interstaff_i) { - dx_f_drul_[d] -= d * slur_min - - (dx_f_drul_[RIGHT] - dx_f_drul_[LEFT]); - dx_f_drul_[d] = dx_f_drul_[(Direction)-d] + d * slur_min; + dy_f_drul_[LEFT] += info_drul[d].interstaff_f_; + dy_f_drul_[RIGHT] += info_drul[d].interstaff_f_; } } - } - while (flip(&d) != LEFT); + } + + + /* + Now we've got a fine slur + Catch and correct some ugly cases + */ + + Real height_damp_f; + Real slope_damp_f; + Real snap_f; + Real snap_max_dy_f; + + if (!interstaff_b) + { + height_damp_f = paper_l ()->get_var ("slur_height_damping"); + slope_damp_f = paper_l ()->get_var ("slur_slope_damping"); + snap_f = paper_l ()->get_var ("slur_snap_to_stem"); + snap_max_dy_f = paper_l ()->get_var ("slur_snap_max_slope_change"); + } + else + { + height_damp_f = paper_l ()->get_var ("slur_interstaff_height_damping"); + slope_damp_f = paper_l ()->get_var ("slur_interstaff_slope_damping"); + snap_f = paper_l ()->get_var ("slur_interstaff_snap_to_stem"); + snap_max_dy_f = paper_l ()->get_var ("slur_interstaff_snap_max_slope_change"); + } + + if (!fix_broken_b) + dy_f_drul_[RIGHT] += interstaff_f; + + Real dy_f = dy_f_drul_[RIGHT] - dy_f_drul_[LEFT]; + if (!fix_broken_b) + dy_f -= interstaff_f; + Real dx_f = do_width ().length () + dx_f_drul_[RIGHT] - dx_f_drul_[LEFT]; /* Avoid too steep slurs. - * slur from notehead to stemend: c''()b'' */ - Real damp_f = paper ()->get_var ("slur_slope_damping"); - Offset d_off = Offset (dx_f_drul_[RIGHT] - dx_f_drul_[LEFT], - dy_f_drul_[RIGHT] - dy_f_drul_[LEFT]); - d_off.x () += width ().length (); - - Real ratio_f = abs (d_off.y () / d_off.x ()); - if (ratio_f > damp_f) - dy_f_drul_[(Direction)(- dir_ * sign (d_off.y ()))] -= - dir_ * (damp_f - ratio_f) * d_off.x (); + Real slope_ratio_f = abs (dy_f / dx_f); + if (slope_ratio_f > slope_damp_f) + { + Direction d = (Direction)(- dir_ * (sign (dy_f))); + if (!d) + d = LEFT; + Real damp_f = (slope_ratio_f - slope_damp_f) * dx_f; + /* + must never change sign of dy + */ + damp_f = damp_f curve_xy_drul = curve_extent_drul (); + Real height_f = curve_xy_drul[Y].length (); + Real width_f = curve_xy_drul[X].length (); + + dy_f = dy_f_drul_[RIGHT] - dy_f_drul_[LEFT]; + if (!fix_broken_b) + dy_f -= interstaff_f; + + Real height_ratio_f = abs (height_f / width_f); + if (height_ratio_f > height_damp_f) + { + Direction d = (Direction)(- dir_ * (sign (dy_f))); + if (!d) + d = LEFT; + /* take third step */ + Real damp_f = (height_ratio_f - height_damp_f) * width_f / 3; + /* + if y positions at about the same height, correct both ends + */ + if (abs (dy_f / dx_f ) < slope_damp_f) + { + dy_f_drul_[-d] += dir_ * damp_f; + dy_f_drul_[d] += dir_ * damp_f; + } + /* + don't change slope too much, would have been catched by slope damping + */ + else + { + damp_f = damp_f snapy_f_drul; + snapy_f_drul[LEFT] = snapy_f_drul[RIGHT] = 0; + Drul_array snapx_f_drul; + snapx_f_drul[LEFT] = snapx_f_drul[RIGHT] = 0; + Drul_array snapped_b_drul; + snapped_b_drul[LEFT] = snapped_b_drul[RIGHT] = false; + do + { + if ((note_column_drul[d] == spanned_drul_[d]) + && (note_column_drul[d]->stem_l_) + && (note_column_drul[d]->stem_l_->dir_ == dir_) + && (abs (note_column_drul[d]->stem_l_->extent (Y_AXIS)[dir_] + - dy_f_drul_[d] + (d == LEFT ? 0 : interstaff_f)) + <= snap_f)) + { + /* + prepare to attach to stem-end + */ + Stem* stem_l = note_column_drul[d]->stem_l_; + snapx_f_drul[d] = stem_l->hpos_f () + - spanned_drul_[d]->absolute_coordinate (X_AXIS); + snapy_f_drul[d] = stem_l->extent (Y_AXIS)[dir_]; + snapy_f_drul[d] += info_drul[d].interstaff_f_; + snapy_f_drul[d] += dir_ * 2 * y_gap_f; + snapped_b_drul[d] = true; + } + } + while (flip (&d) != LEFT); + + /* + only use snapped positions if sign (dy) will not change + and dy doesn't change too much + */ + if (!fix_broken_b) + dy_f += interstaff_f; + if (snapped_b_drul[LEFT] && snapped_b_drul[RIGHT] + && ((sign (snapy_f_drul[RIGHT] - snapy_f_drul[LEFT]) == sign (dy_f))) + && (!dy_f || (abs (snapy_f_drul[RIGHT] - snapy_f_drul[LEFT] - dy_f) + < abs (dy_f * snap_max_dy_f)))) + { + do + { + dy_f_drul_[d] = snapy_f_drul[d]; + dx_f_drul_[d] = snapx_f_drul[d]; + } + while (flip (&d) != LEFT); + + } + else if (snapped_b_drul[LEFT] + && ((sign (dy_f_drul_[RIGHT] - snapy_f_drul[LEFT]) == sign (dy_f))) + && (!dy_f || (abs (dy_f_drul_[RIGHT] - snapy_f_drul[LEFT] - dy_f) + < abs (dy_f * snap_max_dy_f)))) + { + Direction d = LEFT; + dy_f_drul_[d] = snapy_f_drul[d]; + dx_f_drul_[d] = snapx_f_drul[d]; + } + else if (snapped_b_drul[RIGHT] + && ((sign (snapy_f_drul[RIGHT] - dy_f_drul_[LEFT]) == sign (dy_f))) + && (!dy_f || (abs (snapy_f_drul[RIGHT] - dy_f_drul_[LEFT] - dy_f) + < abs (dy_f * snap_max_dy_f)))) + { + Direction d = RIGHT; + dy_f_drul_[d] = snapy_f_drul[d]; + dx_f_drul_[d] = snapx_f_drul[d]; + } } Array Slur::get_encompass_offset_arr () const { - Offset left = Offset (dx_f_drul_[LEFT], dy_f_drul_[LEFT]); - left.x () += encompass_arr_[0]->stem_l_->hpos_f (); + Array offset_arr; +#if 0 + /* + check non-disturbed slur + FIXME: x of ends off by a tiny bit!! + */ + offset_arr.push (Offset (0, dy_f_drul_[LEFT])); + offset_arr.push (Offset (0, dy_f_drul_[RIGHT])); + return offset_arr; +#endif - Offset d = Offset (dx_f_drul_[RIGHT] - dx_f_drul_[LEFT], - dy_f_drul_[RIGHT] - dy_f_drul_[LEFT]); - d.x () += width ().length (); + int interstaff_i = 0; + for (int i = 0; i < encompass_arr_.size (); i++) + { + Encompass_info info (encompass_arr_[i], dir_, this); + if (info.interstaff_f_) + { + interstaff_i++; + } + } + bool interstaff_b = interstaff_i && (interstaff_i < encompass_arr_.size ()); + + Offset origin (absolute_coordinate (X_AXIS), 0); int first = 1; - int last = encompass_arr_.size () - 1; + int last = encompass_arr_.size () - 2; - // prebreak + offset_arr.push (Offset (dx_f_drul_[LEFT], dy_f_drul_[LEFT])); + /* + left is broken edge + */ if (encompass_arr_[0] != spanned_drul_[LEFT]) - first--; + { + first--; + Encompass_info left_info (encompass_arr_[0], dir_, this); + if (interstaff_b) + offset_arr[0][Y_AXIS] += left_info.interstaff_f_; + } - // postbreak + /* + right is broken edge + */ if (encompass_arr_.top () != spanned_drul_[RIGHT]) - last++; - -#define RESIZE_ICE -#ifndef RESIZE_ICE - - Array notes; - notes.push (Offset (0,0)); -// notes.push (left); + { + last++; + } - for (int i = first; i < last; i++) + for (int i = first; i <= last; i++) { - Encompass_info info (encompass_arr_[i], dir_); - notes.push (info.o_ - left); -// notes.push (info.o_ - left); + Encompass_info info (encompass_arr_[i], dir_, this); + offset_arr.push (info.o_ - origin); } - notes.push (d); -#else + offset_arr.push (Offset (do_width ().length () + dx_f_drul_[RIGHT], + dy_f_drul_[RIGHT])); - int n = last - first + 2; - Array notes (n); - notes[0] = Offset (0,0); -// notes[0] = left; + return offset_arr; +} - for (int i = first; i < last; i++) - { - Encompass_info info (encompass_arr_[i], dir_); - notes[i - first + 1] = info.o_ - left; -// notes[i - first + 1] = info.o_; - } - notes[n - 1] = Offset (d); -#endif +Array +Slur::get_rods () const +{ + Array a; + Rod r; + r.item_l_drul_ = spanned_drul_; + r.distance_f_ = paper_l ()->get_var ("slur_x_minimum"); - return notes; + a.push (r); + return a; }