X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fnote-collision.cc;h=c0391f5015d4a51e72f40ecd266ec1d79d243482;hb=eb800248588b0ebabc8a90f34e17559be170f0b2;hp=ef591c2b6dc17ed910d6359ab89ae30ee006b505;hpb=4a401ca1c60f428daa242dbdd102fdb3f327ebfb;p=lilypond.git diff --git a/lily/note-collision.cc b/lily/note-collision.cc index ef591c2b6d..c0391f5015 100644 --- a/lily/note-collision.cc +++ b/lily/note-collision.cc @@ -1,7 +1,7 @@ /* This file is part of LilyPond, the GNU music typesetter. - Copyright (C) 1997--2011 Han-Wen Nienhuys + Copyright (C) 1997--2012 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 @@ -56,13 +56,35 @@ check_meshing_chords (Grob *me, Grob *head_up = Note_column::first_head (clash_up); Grob *head_down = Note_column::first_head (clash_down); - vector ups = Stem::note_head_positions (Note_column::get_stem (clash_up)); - vector dps = Stem::note_head_positions (Note_column::get_stem (clash_down)); + /* Staff-positions of all noteheads on each stem */ + vector ups = Stem::note_head_positions (stems[UP]); + vector dps = Stem::note_head_positions (stems[DOWN]); /* Too far apart to collide. */ if (ups[0] > dps.back () + 1) return; + /* If the chords just 'touch' their extreme noteheads, + then we can align their stems. + */ + bool touch = false; + if (ups[0] >= dps.back () + && (dps.size () < 2 || ups[0] >= dps[dps.size () - 2] + 2) + && (ups.size () < 2 || ups[1] >= dps.back () + 2)) + touch = true; + + /* Filter out the 'o's in this configuration, since they're no + * part in the collision. + * + * | + * x|o + * x|o + * x + * + */ + ups = Stem::note_head_positions (stems[UP], true); + dps = Stem::note_head_positions (stems[DOWN], true); + /* Merge heads if the notes lie the same line, or if the "stem-up-note" is above the "stem-down-note". */ bool merge_possible = (ups[0] >= dps[0]) && (ups.back () >= dps.back ()); @@ -100,33 +122,23 @@ check_meshing_chords (Grob *me, merge_possible = false; /* - this case (distant half collide), - - | - x | - | x - | - - the noteheads may be closer than this case (close half collide) - - | - | - x - x - | - | - - */ - - /* TODO: filter out the 'o's in this configuration, since they're no - part in the collision. - - | - x|o - x|o - x - - */ + * this case (distant half collide), + * + * | + * x | + * | x + * | + * + * the noteheads may be closer than this case (close half collide) + * + * | + * | + * x + * x + * | + * | + * + */ bool close_half_collide = false; bool distant_half_collide = false; @@ -163,29 +175,35 @@ check_meshing_chords (Grob *me, full_collide = full_collide || (close_half_collide && distant_half_collide); - Real shift_amount = 1; - - bool touch = (ups[0] >= dps.back ()); - /* As a special case, if the topmost part of the downstem chord is a second, - the top note of which is the same pitch as the lowest upstem note, they - shouldn't count as touching. + /* Determine which chord goes on the left, and which goes right. + Up-stem usually goes on the right, but if chords just 'touch' we can put + both stems on a common vertical line. In the presense of collisions, + right hand heads may obscure dots, so dotted heads to go the right. */ - if (dps.back () == ups[0] && dps.size () > 1 && dps[dps.size () - 2] == ups[0] - 1) - touch = false; - - if (touch) - shift_amount *= -1; - - /* For full collisions, the right hand head may obscure dots, so - make sure the dotted heads go to the right. */ + Real shift_amount = 1; bool stem_to_stem = false; - if (full_collide) + if ((full_collide + || ((close_half_collide || distant_half_collide) + && to_boolean (me->get_property ("prefer-dotted-right")))) + && Rhythmic_head::dot_count (head_up) < Rhythmic_head::dot_count (head_down)) { - if (Rhythmic_head::dot_count (head_up) > Rhythmic_head::dot_count (head_down)) - shift_amount = 1; - else if (Rhythmic_head::dot_count (head_up) < Rhythmic_head::dot_count (head_down)) + shift_amount = -1; + if (!touch) + // remember to leave clearance between stems stem_to_stem = true; } + else if (touch) + { + // Up-stem note on a line has a raised dot, so no risk of collision + Grob *staff = Staff_symbol_referencer::get_staff_symbol (me); + if ((full_collide + || (!Staff_symbol_referencer::on_line (staff, ups[0]) + && to_boolean (me->get_property ("prefer-dotted-right")))) + && Rhythmic_head::dot_count (head_up) > Rhythmic_head::dot_count (head_down)) + touch = false; + else + shift_amount = -1; + } /* The solfa is a triangle, which is inverted depending on stem direction. In case of a collision, one of them should be removed, @@ -197,7 +215,6 @@ check_meshing_chords (Grob *me, && (up_style == ly_symbol2scm ("fa") || up_style == ly_symbol2scm ("faThin")) && (down_style == ly_symbol2scm ("fa") || down_style == ly_symbol2scm ("faThin"))) { - Interval uphead_size = head_up->extent (head_up, Y_AXIS); Offset att = Offset (0.0, -1.0); head_up->set_property ("stem-attachment", ly_offset2scm (att)); head_up->set_property ("transparent", SCM_BOOL_T); @@ -260,13 +277,15 @@ check_meshing_chords (Grob *me, /* TODO: these numbers are magic; should devise a set of grob props to tune this behavior. */ else if (stem_to_stem) - shift_amount = -abs (shift_amount) * 0.65; - else if (close_half_collide && !touch) + shift_amount *= 0.65; + else if (touch) + shift_amount *= 0.5; + else if (close_half_collide) shift_amount *= 0.52; - else if (distant_half_collide && !touch) - shift_amount *= 0.4; - else if (distant_half_collide || close_half_collide || full_collide) + else if (full_collide) shift_amount *= 0.5; + else if (distant_half_collide) + shift_amount *= 0.4; /* we're meshing. */ else if (Rhythmic_head::dot_count (head_up) || Rhythmic_head::dot_count (head_down)) @@ -289,72 +308,63 @@ check_meshing_chords (Grob *me, shift_amount *= 0.75; } - /* - * Fix issue #44: - * - * Dots from left note head collide with right note head. Only occurs - * with a close half collide, if the left note head is between - * lines and the right note head is on a line, and if right note head - * hasn't got any dots. + /* If any dotted notes ended up on the left, + tell the Dot_Columnn to avoid the note heads on the right. */ - if (close_half_collide - && Rhythmic_head::dot_count (head_up) - && !Rhythmic_head::dot_count (head_down)) + if (shift_amount < -1e-6 + && Rhythmic_head::dot_count (head_up)) { - Grob *staff = Staff_symbol_referencer::get_staff_symbol (me); - if (!Staff_symbol_referencer::on_line (staff, ups[0])) - { - /* - TODO: consider junking the else body. - */ - if (to_boolean (me->get_property ("prefer-dotted-right"))) - shift_amount = 0.5; - else - { - Grob *d = unsmob_grob (head_up->get_object ("dot")); - Grob *parent = d->get_parent (X_AXIS); - if (Dot_column::has_interface (parent)) - Side_position_interface::add_support (parent, head_down); - } - } + Grob *d = unsmob_grob (head_up->get_object ("dot")); + Grob *parent = d->get_parent (X_AXIS); + if (Dot_column::has_interface (parent)) + Side_position_interface::add_support (parent, head_down); } - - /* For full or close half collisions, the right hand head may - obscure dots. Move dots to the right. */ - if (abs (shift_amount) > 1e-6 - && Rhythmic_head::dot_count (head_down) > Rhythmic_head::dot_count (head_up) - && (full_collide || close_half_collide)) + else if (Rhythmic_head::dot_count (head_down)) { Grob *d = unsmob_grob (head_down->get_object ("dot")); Grob *parent = d->get_parent (X_AXIS); - - /* - FIXME: - - | - x . o - | - - - the . is put right of o which is erroneous o force-shifted - far to the right. - */ if (Dot_column::has_interface (parent)) { Grob *stem = unsmob_grob (head_up->get_object ("stem")); + // Loop over all heads on an up-pointing-stem to see if dots + // need to clear any heads suspended on its right side. extract_grob_set (stem, "note-heads", heads); for (vsize i = 0; i < heads.size (); i++) Side_position_interface::add_support (parent, heads[i]); } } - Direction d = UP; - do + // In meshed chords with dots on the left, adjust dot direction + if (shift_amount > 1e-6 + && Rhythmic_head::dot_count (head_down)) + { + Grob *dot_down = unsmob_grob (head_down->get_object ("dot")); + Grob *col_down = dot_down->get_parent (X_AXIS); + Direction dir = UP; + if (Rhythmic_head::dot_count (head_up)) + { + Grob *dot_up = unsmob_grob (head_up->get_object ("dot")); + Grob *col_up = dot_up->get_parent (X_AXIS); + if (col_up == col_down) // let the common DotColumn arrange dots + dir = CENTER; + else // conform to the dot direction on the up-stem chord + dir = robust_scm2dir (dot_up->get_property ("direction"), UP); + } + if (dir != CENTER) + { + Grob *stem = unsmob_grob (head_down->get_object ("stem")); + extract_grob_set (stem, "note-heads", heads); + for (vsize i = 0; i < heads.size (); i++) + unsmob_grob (heads[i]->get_object ("dot")) + ->set_property ("direction", scm_from_int (dir)); + } + } + + for (UP_and_DOWN (d)) { for (vsize i = 0; i < clash_groups[d].size (); i++) (*offsets)[d][i] += d * shift_amount; } - while ((flip (&d)) != UP); } MAKE_SCHEME_CALLBACK (Note_collision_interface, calc_positioning_done, 1) @@ -366,8 +376,7 @@ Note_collision_interface::calc_positioning_done (SCM smob) Drul_array > clash_groups = get_clash_groups (me); - Direction d = UP; - do + for (UP_and_DOWN (d)) { for (vsize i = clash_groups[d].size (); i--;) { @@ -377,13 +386,12 @@ Note_collision_interface::calc_positioning_done (SCM smob) clash_groups[d][i]->extent (me, X_AXIS); } } - while (flip (&d) != UP); SCM autos (automatic_shift (me, clash_groups)); SCM hand (forced_shift (me)); Real wid = 0.0; - do + for (UP_and_DOWN (d)) { if (clash_groups[d].size ()) { @@ -393,7 +401,6 @@ Note_collision_interface::calc_positioning_done (SCM smob) wid = fh->extent (h, X_AXIS).length (); } } - while (flip (&d) != UP); vector done; Real left_most = 1e6; @@ -448,13 +455,11 @@ Note_collision_interface::get_clash_groups (Grob *me) } } - Direction d = UP; - do + for (UP_and_DOWN (d)) { vector &clashes (clash_groups[d]); vector_sort (clashes, Note_column::shift_less); } - while ((flip (&d)) != UP); return clash_groups; } @@ -470,8 +475,7 @@ Note_collision_interface::automatic_shift (Grob *me, Drul_array < vector > shifts; SCM tups = SCM_EOL; - Direction d = UP; - do + for (UP_and_DOWN (d)) { vector &shift (shifts[d]); vector &clashes (clash_groups[d]); @@ -496,12 +500,10 @@ Note_collision_interface::automatic_shift (Grob *me, } } } - while ((flip (&d)) != UP); Drul_array > extents; Drul_array > offsets; - d = UP; - do + for (UP_and_DOWN (d)) { for (vsize i = 0; i < clash_groups[d].size (); i++) { @@ -512,18 +514,17 @@ Note_collision_interface::automatic_shift (Grob *me, offsets[d].push_back (d * 0.5 * i); } } - while ((flip (&d)) != UP); /* - do horizontal shifts of each direction - - | - x|| - x|| - x| + * do horizontal shifts of each direction + * + * | + * x|| + * x|| + * x| */ - do + for (UP_and_DOWN (d)) { for (vsize i = 1; i < clash_groups[d].size (); i++) { @@ -535,7 +536,6 @@ Note_collision_interface::automatic_shift (Grob *me, offsets[d][j] += d * 0.5; } } - while ((flip (&d)) != UP); /* see input/regression/dot-up-voice-collision.ly @@ -559,14 +559,13 @@ Note_collision_interface::automatic_shift (Grob *me, check_meshing_chords (me, &offsets, extents, clash_groups); - do + for (UP_and_DOWN (d)) { for (vsize i = 0; i < clash_groups[d].size (); i++) tups = scm_cons (scm_cons (clash_groups[d][i]->self_scm (), scm_from_double (offsets[d][i])), tups); } - while (flip (&d) != UP); return tups; }