X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Frest.cc;h=f562f69534a1689d648efabb5d90051c9b0a42d3;hb=90e4d7057f3857da049dfda3d130017d4719bd6b;hp=fa9fdb166070cf8cca38f04c07608bd0f1854056;hpb=4b975f3177880e16e759f67be4517f67109c2633;p=lilypond.git diff --git a/lily/rest.cc b/lily/rest.cc index fa9fdb1660..f562f69534 100644 --- a/lily/rest.cc +++ b/lily/rest.cc @@ -1,103 +1,208 @@ /* - rest.cc -- implement Rest + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 1997--2015 Han-Wen Nienhuys - (c) 1997--2005 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 "rest.hh" -#include "stencil.hh" -#include "output-def.hh" -#include "font-interface.hh" +#include "directional-element-interface.hh" #include "dots.hh" +#include "font-interface.hh" +#include "international.hh" +#include "output-def.hh" #include "paper-score.hh" #include "staff-symbol-referencer.hh" -#include "directional-element-interface.hh" +#include "staff-symbol.hh" +#include "stencil.hh" +#include "grob.hh" // -> offset callback -MAKE_SCHEME_CALLBACK (Rest, after_line_breaking, 1); +MAKE_SCHEME_CALLBACK (Rest, y_offset_callback, 1); SCM -Rest::after_line_breaking (SCM smob) +Rest::y_offset_callback (SCM smob) { - Grob *me = unsmob_grob (smob); - int bt = scm_to_int (me->get_property ("duration-log")); - int lc = Staff_symbol_referencer::line_count (me); + Grob *me = unsmob (smob); + int duration_log = scm_to_int (me->get_property ("duration-log")); Real ss = Staff_symbol_referencer::staff_space (me); - if (lc % 2) - { - if (bt == 0 && lc > 1) - { - me->translate_axis (ss, Y_AXIS); - } - } - else + + return scm_from_double (ss * 0.5 * Rest::staff_position_internal (me, duration_log, get_grob_direction (me))); +} + +Real +Rest::staff_position_internal (Grob *me, int duration_log, int dir) +{ + if (!me) + return 0; + + bool position_override = scm_is_number (me->get_property ("staff-position")); + Real pos; + + if (position_override) { - me->translate_axis (ss / 2, Y_AXIS); + pos + = robust_scm2double (me->get_property ("staff-position"), 0); + + /* + semibreve rests are positioned one staff line off + */ + if (duration_log == 0) + return pos + 2; + + /* + trust the client on good positioning; + would be tempting to adjust position of rests longer than a quarter + to be properly aligned to staff lines, + but custom rest shapes may not need that sort of care. + */ + + return pos; } - Grob *d = unsmob_grob (me->get_object ("dot")); - if (d && bt > 4) // UGH. + Real vpos = dir * robust_scm2int (me->get_property ("voiced-position"), 0); + pos = vpos; + + if (duration_log > 1) + /* Only half notes or longer want alignment with staff lines */ + return pos; + + /* + We need a staff symbol for actually aligning anything + */ + Grob *staff = Staff_symbol_referencer::get_staff_symbol (me); + if (!staff) + return pos; + + std::vector linepos = Staff_symbol::line_positions (staff); + + if (linepos.empty ()) + return pos; + + std::sort (linepos.begin (), linepos.end ()); + + if (duration_log == 0) { - d->set_property ("staff-position", - scm_from_int ((bt == 7) ? 4 : 3)); + /* + lower voice semibreve rests generally hang a line lower + */ + + if (dir < 0) + pos -= 2; + + /* + make a semibreve rest hang from the next available line, + except when there is none. + */ + + std::vector::const_iterator it + = std::upper_bound (linepos.begin (), linepos.end (), pos); + if (it != linepos.end ()) + pos = *it; + else + pos = linepos.back (); } - if (d && bt >= -1 && bt <= 1) // UGH again. + else { - d->set_property ("staff-position", - scm_from_int ((bt == 0) ? -1 : 1)); + std::vector::const_iterator it + = std::upper_bound (linepos.begin (), linepos.end (), pos); + if (it != linepos.begin ()) + --it; + pos = *it; } - return SCM_UNSPECIFIED; + + /* Finished for neutral position */ + if (!dir) + return pos; + + /* If we have a voiced position, make sure that it's on the + proper side of neutral before using it. + */ + + Real neutral = staff_position_internal (me, duration_log, 0); + + if (dir * (pos - neutral) > 0) + return pos; + else + return neutral + vpos; +} + +/* A rest might lie under a beam, in which case it should be cross-staff if + the beam is cross-staff because the rest's position depends on the + formatting of the beam. */ +MAKE_SCHEME_CALLBACK (Rest, calc_cross_staff, 1); +SCM +Rest::calc_cross_staff (SCM smob) +{ + Grob *me = unsmob (smob); + Grob *stem = unsmob (me->get_object ("stem")); + + if (!stem) + return SCM_BOOL_F; + + return stem->get_property ("cross-staff"); } /* make this function easily usable in C++ */ -String -Rest::glyph_name (Grob *me, int balltype, String style, bool try_ledgers) +string +Rest::glyph_name (Grob *me, int durlog, const string &style, bool try_ledgers, + Real offset) { - bool ledgered_b = false; - if (try_ledgers && (balltype == 0 || balltype == 1)) + bool is_ledgered = false; + if (try_ledgers && (durlog == -1 || durlog == 0 || durlog == 1)) { - Real rad = Staff_symbol_referencer::staff_radius (me) * 2.0; - Real pos = Staff_symbol_referencer::get_position (me); - + int const pos = int (Staff_symbol_referencer::get_position (me) + + offset); /* - Figure out when the rest is far enough outside the staff. This - could bemore generic, but hey, we understand this even after - dinner. + half rests need ledger if not lying on a staff line, + whole rests need ledger if not hanging from a staff line, + breve rests need ledger if neither lying on nor hanging from a staff line */ - ledgered_b |= (balltype == 0) && (pos >= +rad + 2 || pos < -rad); - ledgered_b |= (balltype == 1) && (pos <= -rad - 2 || pos > +rad); + if (-1 <= durlog && durlog <= 1) + is_ledgered = !Staff_symbol_referencer::on_staff_line (me, pos) + && !(durlog == -1 + && Staff_symbol_referencer::on_staff_line (me, pos + 2)); } - String actual_style (style.to_str0 ()); + string actual_style (style.c_str ()); if ((style == "mensural") || (style == "neomensural")) { /* - FIXME: Currently, ancient font does not provide ledgered rests; - hence the "o" suffix in the glyph name is bogus. But do we need - ledgered rests at all now that we can draw ledger lines with - variable width, length and blotdiameter? -- jr + FIXME: Currently, ancient font does not provide ledgered rests; + hence the "o" suffix in the glyph name is bogus. But do we need + ledgered rests at all now that we can draw ledger lines with + variable width, length and blotdiameter? -- jr */ - ledgered_b = 0; + is_ledgered = 0; /* - There are no 32th/64th/128th mensural/neomensural rests. In - these cases, revert back to default style. + There are no 32th/64th/128th mensural/neomensural rests. In + these cases, revert back to default style. */ - if (balltype > 4) - actual_style = ""; + if (durlog > 4) + actual_style = ""; } - if ((style == "classical") && (balltype != 2)) + if (((style == "classical") || (style == "z")) && (durlog != 2)) { /* - classical style: revert back to default style for any rest other - than quarter rest + these styles differ from the default in quarter rests only */ actual_style = ""; } @@ -105,58 +210,81 @@ Rest::glyph_name (Grob *me, int balltype, String style, bool try_ledgers) if (style == "default") { /* - Some parts of lily still prefer style "default" over "". - Correct this here. -- jr + Some parts of lily still prefer style "default" over "". + Correct this here. -- jr */ actual_style = ""; } - return ("rests." + to_string (balltype) + (ledgered_b ? "o" : "") - + actual_style); + return ("rests." + ::to_string (durlog) + (is_ledgered ? "o" : "") + + actual_style); } MAKE_SCHEME_CALLBACK (Rest, print, 1); - SCM -Rest::brew_internal_stencil (SCM smob, bool ledgered) +Rest::brew_internal_stencil (Grob *me, bool ledgered) { - Grob *me = unsmob_grob (smob); - - SCM balltype_scm = me->get_property ("duration-log"); - if (!scm_is_number (balltype_scm)) + SCM durlog_scm = me->get_property ("duration-log"); + if (!scm_is_number (durlog_scm)) return Stencil ().smobbed_copy (); - int balltype = scm_to_int (balltype_scm); + int durlog = scm_to_int (durlog_scm); - String style; - SCM style_scm = me->get_property ("style"); - if (scm_is_symbol (style_scm)) - style = ly_scm2string (scm_symbol_to_string (style_scm)); + string style = robust_symbol2string (me->get_property ("style"), "default"); Font_metric *fm = Font_interface::get_default_font (me); - String font_char = glyph_name (me, balltype, style, ledgered); + string font_char = glyph_name (me, durlog, style, ledgered, 0.0); Stencil out = fm->find_by_name (font_char); if (out.is_empty ()) - me->warning (_f ("rest `%s' not found", font_char.to_str0 ())); + me->warning (_f ("rest `%s' not found", font_char.c_str ())); return out.smobbed_copy (); } +/** + translate the rest vertically by amount DY, but only if + it doesn't have staff-position set. +*/ +void +Rest::translate (Grob *me, int dy) +{ + if (!scm_is_number (me->get_property ("staff-position"))) + { + me->translate_axis (dy * Staff_symbol_referencer::staff_space (me) / 2.0, Y_AXIS); + Grob *p = me->get_parent (Y_AXIS); + p->flush_extent_cache (Y_AXIS); + } +} + SCM Rest::print (SCM smob) { - return brew_internal_stencil (smob, true); + return brew_internal_stencil (unsmob (smob), true); } -MAKE_SCHEME_CALLBACK (Rest, extent_callback, 2); +MAKE_SCHEME_CALLBACK (Rest, width, 1); /* We need the callback. The real stencil has ledgers depending on Y-position. The Y-position is known only after line breaking. */ SCM -Rest::extent_callback (SCM smob, SCM ax) +Rest::width (SCM smob) +{ + return generic_extent_callback (unsmob (smob), X_AXIS); +} + +MAKE_SCHEME_CALLBACK (Rest, height, 1); +SCM +Rest::height (SCM smob) { - Axis a = (Axis) scm_to_int (ax); + return generic_extent_callback (unsmob (smob), Y_AXIS); +} +/* + We need the callback. The real stencil has ledgers depending on + Y-position. The Y-position is known only after line breaking. */ +SCM +Rest::generic_extent_callback (Grob *me, Axis a) +{ /* Don't want ledgers: ledgers depend on Y position, which depends on rest collision, which depends on stem size which depends on beam @@ -165,27 +293,29 @@ Rest::extent_callback (SCM smob, SCM ax) consequence: we get too small extents and potential collisions with ledgered rests. */ - SCM m = brew_internal_stencil (smob, a != X_AXIS); - return ly_interval2scm (unsmob_stencil (m)->extent (a)); + SCM m = brew_internal_stencil (me, a != X_AXIS); + return ly_interval2scm (unsmob (m)->extent (a)); } -MAKE_SCHEME_CALLBACK (Rest, polyphonic_offset_callback, 2); +MAKE_SCHEME_CALLBACK (Rest, pure_height, 3); SCM -Rest::polyphonic_offset_callback (SCM smob, SCM) +Rest::pure_height (SCM smob, + SCM /* start */, + SCM /* end */) { - Grob *me = unsmob_grob (smob); - if (scm_is_number (me->get_property ("staff-position"))) - return scm_from_double (0); - - Direction d = get_grob_direction (me); - Real off = 2 * d; - if (off) - off *= Staff_symbol_referencer::staff_space (me); - - return scm_from_double (off); + Grob *me = unsmob (smob); + SCM m = brew_internal_stencil (me, false); + return ly_interval2scm (unsmob (m)->extent (Y_AXIS)); } -ADD_INTERFACE (Rest, "rest-interface", - "A rest symbol.", - "style direction minimum-distance"); +ADD_INTERFACE (Rest, + "A rest symbol. The property @code{style} can be" + " @code{default}, @code{mensural}, @code{neomensural} or" + " @code{classical}.", + /* properties */ + "direction " + "minimum-distance " + "style " + "voiced-position " + );