X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Ftie-column.cc;h=6e0eaecec0e09fa987aeb4b73bf70f57fea38eca;hb=d8c3e0af38c0a9645fec2e49ecf32c8170f70e0b;hp=6d4ad0e2932163bbd83fc533ec673fb3f71e0820;hpb=7aabfb20c46e0a1de41698ddc6859ccd3a6dea85;p=lilypond.git diff --git a/lily/tie-column.cc b/lily/tie-column.cc index 6d4ad0e293..6e0eaecec0 100644 --- a/lily/tie-column.cc +++ b/lily/tie-column.cc @@ -1,119 +1,128 @@ -/* - tie-column.cc -- implement Tie_column - - source file of the GNU LilyPond music typesetter - - (c) 2000--2003 Han-Wen Nienhuys - - */ +/* + This file is part of LilyPond, the GNU music typesetter. -#include "spanner.hh" -#include "tie-column.hh" -#include "group-interface.hh" -#include "tie.hh" -#include "directional-element-interface.hh" -#include "rhythmic-head.hh" + Copyright (C) 2000--2011 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 -/* - tie dir depends on what Tie_column does. -*/ +#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 "tie-column-format.hh" +#include "tie-formatting-problem.hh" +#include "tie-configuration.hh" + +using namespace std; void -Tie_column::add_tie (Grob*me,Grob *s) +Tie_column::add_tie (Grob *tc, Grob *tie) { - if (! Pointer_group_interface ::count (me, "ties")) - { - dynamic_cast (me)->set_bound (LEFT, Tie::head (s,LEFT)); - dynamic_cast (me)->set_bound (RIGHT, Tie::head (s,RIGHT)); - } + Spanner *me = dynamic_cast (tc); - Pointer_group_interface::add_grob (me, ly_symbol2scm ("ties"), s); - s->add_dependency (me); -} - + if (tie->get_parent (Y_AXIS) + && Tie_column::has_interface (tie->get_parent (Y_AXIS))) + return; -int -tie_compare (Grob* const & s1, - Grob* const & s2) -{ - return sign (Tie::get_position (s1) - Tie::get_position (s2)); + 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 ()))) + { + me->set_bound (LEFT, Tie::head (tie, LEFT)); + me->set_bound (RIGHT, Tie::head (tie, RIGHT)); + } + + tie->set_parent (me, Y_AXIS); + Pointer_group_interface::add_grob (me, ly_symbol2scm ("ties"), tie); } /* - See [Ross p. 138]. - - - In normal chord cases, the outer ties point outwards, and the - direction of the rest is determined by their staff position. - - 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 (Grob*me) + Extend the spanner over its Tie constituents. +*/ +MAKE_SCHEME_CALLBACK (Tie_column, before_line_breaking, 1); +SCM +Tie_column::before_line_breaking (SCM smob) { - Link_array ties = - Pointer_group_interface__extract_grobs (me, (Grob*)0, "ties"); - - for (int i = ties.size (); i--;) - if (Directional_element_interface::get (ties[i])) - ties.del (i); - - - if (!ties.size ()) - return ; - - - Direction d = Directional_element_interface::get (me); - if (d) + Spanner *me = dynamic_cast (unsmob_grob (smob)); + for (SCM s = me->get_property ("ties"); scm_is_pair (s); s = scm_cdr (s)) { - for (int i = ties.size (); i--;) + Spanner *tie = dynamic_cast (unsmob_grob (scm_car (s))); + Direction dir = LEFT; + do { - Grob * t = ties[i]; - Directional_element_interface::set (t, d); + 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)); } - return; - } - - if (ties.size () == 1) - { - Grob * t = ties[0]; - Directional_element_interface::set (t,Tie::get_default_dir (t)); - return; - } - - ties.sort (tie_compare); - Directional_element_interface::set (ties[0], DOWN); - ties.del (0); - - Directional_element_interface ::set (ties.pop (), UP); - for (int i=ties.size (); i--;) - { - Grob * t = ties[i]; - Real p = Tie::get_position (t); - Direction d = (Direction) sign (p); - if (!d) - d = UP; - Directional_element_interface::set (t, d); + while (flip (&dir) != LEFT); } + return SCM_UNSPECIFIED; } -MAKE_SCHEME_CALLBACK (Tie_column,after_line_breaking,1); +MAKE_SCHEME_CALLBACK (Tie_column, calc_positioning_done, 1) SCM -Tie_column::after_line_breaking (SCM smob) +Tie_column::calc_positioning_done (SCM smob) { - set_directions (unsmob_grob (smob)); - return SCM_UNSPECIFIED; + Grob *me = unsmob_grob (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); + + Tie_formatting_problem problem; + problem.from_ties (ties); + + 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++) + { + 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; } -ADD_INTERFACE (Tie_column,"tie-column-interface", - "that sets tie directions in a tied chord", - "direction"); +ADD_INTERFACE (Tie_column, + "Object that sets directions of multiple ties in a tied" + " chord.", + + /* properties */ + "positioning-done " + "tie-configuration " + );