X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Ftie-column.cc;h=5f111a8581274bc026c21059f09da714f836a214;hb=f0d12fbf7c856815a25c1cb0508ab0409a1f68e0;hp=cd3badc526d83dd2cae796d88b3a89d40e500a27;hpb=3c2f386f1385a10dafbb811be245f5a75d6b132c;p=lilypond.git diff --git a/lily/tie-column.cc b/lily/tie-column.cc index cd3badc526..5f111a8581 100644 --- a/lily/tie-column.cc +++ b/lily/tie-column.cc @@ -1,116 +1,124 @@ -/* - tie-column.cc -- implement Tie_column - - source file of the GNU LilyPond music typesetter - - (c) 2000 Han-Wen Nienhuys - - */ +/* + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 2000--2015 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 "tie-column.hh" -#include "group-interface.hh" + +#include + +#include "output-def.hh" +#include "skyline.hh" +#include "warn.hh" +#include "paper-column.hh" +#include "spanner.hh" +#include "pointer-group-interface.hh" #include "tie.hh" #include "directional-element-interface.hh" -#include "rhythmic-head.hh" - +#include "tie-formatting-problem.hh" +#include "tie-configuration.hh" +using namespace std; void -Tie_column::set_interface (Score_element*me) +Tie_column::add_tie (Grob *tc, Spanner *tie) { - me-> set_elt_property ("ties", SCM_EOL); - me->set_interface (ly_symbol2scm ("tie-column")); - me->set_extent_callback (0, X_AXIS); - me->set_extent_callback (0, Y_AXIS); -} + Spanner *me = dynamic_cast (tc); -bool -Tie_column::has_interface (Score_element*me) -{ - return me->has_interface (ly_symbol2scm ("tie-column")); -} + if (tie->get_parent (Y_AXIS) + && has_interface (tie->get_parent (Y_AXIS))) + return; -void -Tie_column::add_tie (Score_element*me,Tie *s) -{ - Pointer_group_interface g (me, "ties"); - if (!g.count ()) + if (!me->get_bound (LEFT) + || (Paper_column::get_rank (me->get_bound (LEFT)->get_column ()) + > Paper_column::get_rank (dynamic_cast (tie)->get_bound (LEFT)->get_column ()))) { - dynamic_cast (me)->set_bound (LEFT, Tie::head (s,LEFT)); - dynamic_cast (me)->set_bound (RIGHT, Tie::head (s,RIGHT)); + me->set_bound (LEFT, Tie::head (tie, LEFT)); + me->set_bound (RIGHT, Tie::head (tie, RIGHT)); } - - Pointer_group_interface (me, "ties").add_element (s); - s->add_dependency (me); -} - -int -tie_compare (Tie* const & s1, - Tie* const & s2) -{ - return sign (Tie::position_f (s1) - Tie::position_f(s2)); + tie->set_parent (me, Y_AXIS); + Pointer_group_interface::add_grob (me, ly_symbol2scm ("ties"), tie); } /* - See [Ross p. 138]. - + Extend the spanner over its Tie constituents. +*/ +MAKE_SCHEME_CALLBACK (Tie_column, before_line_breaking, 1); +SCM +Tie_column::before_line_breaking (SCM smob) +{ + Spanner *me = unsmob (smob); + for (SCM s = me->get_property ("ties"); scm_is_pair (s); s = scm_cdr (s)) + { + Spanner *tie = unsmob (scm_car (s)); + for (LEFT_and_RIGHT (dir)) + { + if (dir * tie->get_bound (dir)->get_column ()->get_rank () + > dir * me->get_bound (dir)->get_column ()->get_rank ()) + me->set_bound (dir, Tie::head (tie, dir)); + } + } - In normal chord cases, the outer ties point outwards, and the - direction of the rest is determined by their staff position. + return SCM_UNSPECIFIED; +} - Ross forgets about the tie that is *on* the middle staff line. We - assume it goes UP. (TODO: make me settable) */ -void -Tie_column::set_directions (Score_element*me) +MAKE_SCHEME_CALLBACK (Tie_column, calc_positioning_done, 1) +SCM +Tie_column::calc_positioning_done (SCM smob) { - Link_array ties = - Pointer_group_interface__extract_elements (me, (Tie*)0, "ties"); + Grob *me = unsmob (smob); + extract_grob_set (me, "ties", ro_ties); + vector ties (ro_ties); + if (!ties.size ()) + return SCM_BOOL_T; + me->set_property ("positioning-done", SCM_BOOL_T); + vector_sort (ties, Tie::less); - Direction d = Directional_element_interface (me).get (); + Tie_formatting_problem problem; + problem.from_ties (ties); - if (d) - { - for (int i = ties.size (); i--;) - { - Tie * t = ties[i]; - Directional_element_interface (t).set (d); - } - return; - } - - if (ties.size () == 1) - { - Tie * t = ties[0]; - Directional_element_interface (t).set (Tie::get_default_dir (t)); - return; - } - - ties.sort (tie_compare); - Directional_element_interface tie0(ties[0]); - tie0.set (DOWN); - ties.del (0); - - Directional_element_interface tietop(ties.pop ()); - tietop.set (UP); - - for (int i=ties.size(); i--; ) + SCM manual_configs = me->get_property ("tie-configuration"); + problem.set_manual_tie_configuration (manual_configs); + + Ties_configuration base = problem.generate_optimal_configuration (); + for (vsize i = 0; i < base.size (); i++) { - Tie * t = ties[i]; - Real p = Tie::position_f (t); - Direction d = (Direction) sign (p); - if (!d) - d = UP; - Directional_element_interface (t).set (d); + SCM cp = Tie::get_control_points (ties[i], problem.common_x_refpoint (), + base[i], + problem.details_); + + ties[i]->set_property ("control-points", cp); + set_grob_direction (ties[i], + base[i].dir_); + + problem.set_debug_scoring (base); } - + return SCM_BOOL_T; } -MAKE_SCHEME_CALLBACK(Tie_column,after_line_breaking); -SCM -Tie_column::after_line_breaking (SCM smob) -{ - set_directions (unsmob_element (smob)); - return SCM_UNDEFINED; -} +ADD_INTERFACE (Tie_column, + "Object that sets directions of multiple ties in a tied" + " chord.", + + /* properties */ + "positioning-done " + "tie-configuration " + "ties " + ); +