X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fcoherent-ligature-engraver.cc;h=ea535a3237335f37051b5625ed0b973d39263887;hb=0b544cfb7332615ef809b71b57ab656741311ae1;hp=b898920950f73184e5873ea0be370ec4dc1dec78;hpb=527f75649e7c6a1a45af5b3aa933885033d773eb;p=lilypond.git diff --git a/lily/coherent-ligature-engraver.cc b/lily/coherent-ligature-engraver.cc index b898920950..ea535a3237 100644 --- a/lily/coherent-ligature-engraver.cc +++ b/lily/coherent-ligature-engraver.cc @@ -1,17 +1,31 @@ /* - coherent-ligature-engraver.cc -- implement Coherent_ligature_engraver - - source file of the GNU LilyPond music typesetter - - (c) 2003 Juergen Reuter - */ + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 2003--2014 Juergen Reuter + + 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 "coherent-ligature-engraver.hh" -#include "item.hh" + #include "warn.hh" -#include "staff-symbol-referencer.hh" -#include "spanner.hh" #include "paper-column.hh" +#include "pitch.hh" +#include "pointer-group-interface.hh" +#include "spanner.hh" +#include "staff-symbol-referencer.hh" +#include "stream-event.hh" /* * This abstract class serves as common superclass for all ligature @@ -26,14 +40,14 @@ * * - delegate actual creation of ligature to concrete subclass, * - * - collect all accidentals that occur within the ligature and put - * them at the left side of the ligature (TODO; see function - * collect_accidentals()), + * - except in Kievan notation, collect all accidentals that occur + * within the ligature and put them at the left side of the ligature + * (TODO; see function collect_accidentals ()), * * - collapse superflous space after each ligature (TODO). * * Concrete subclasses must implement function build_ligature (Spanner - * *, Array). This function is responsible for actually + * *, vector). This function is responsible for actually * building the ligature by transforming the array of noteheads. * * Currently, there are two subclasses: Gregorian_ligature_engraver @@ -60,95 +74,48 @@ * of the ligature (to preemptively avoid collision with adjacent * notes); or maybe just additionally create a * mensural/vaticana/whatever-ligature grob (e.g. via - * Mensural_ligature::brew_molecule(SCM)) that just consists of a + * Mensural_ligature::print (SCM)) that just consists of a * bounding box around all primitives of the ligature. * - * TODO: Maybe move functions fold_up_primitives() and - * join_primitives() from subclasses to here? N.B. it is not + * TODO: Maybe move functions fold_up_primitives () and + * join_primitives () from subclasses to here? N.B. it is not * appropriate to put these into Ligature_engraver, since, for * example, Ligature_bracket_engraver does not share any of this code. */ -/* - * TODO: Let superflous space after each ligature collapse. The - * following code should help in doing so (though it does not yet - * fully work). Just put the following code into - * Spacing_spanner::do_measure(). I put it temporarily here as memo - * until it really works and I also get Han-Wen's/Jan's permission to - * add it to the spacing spanner code. - */ -#if 0 // experimental code to collapse spacing after ligature - SCM incr_scm = lc->get_grob_property ("forced-spacing"); - if (incr_scm != SCM_EOL) /* (Paper_column::musical_b (l)) */ - { - me->warning (_f ("gotcha: ptr=%ul", lc));//debug - ly_display_scm (lc->self_scm ()); - Real distance; - if (incr_scm != SCM_EOL) - { - distance = gh_scm2double (incr_scm); - } - else - { - me->warning ("distance undefined, assuming 0.1"); - distance = 0.1; - } - me->warning (_f ("distance=%f", distance));//debug - Real strength = 1.0; - Spaceable_grob::add_spring (lc, rc, distance, strength, false); - if (Item *rb = r->find_prebroken_piece (LEFT)) - Spaceable_grob::add_spring (lc, rb, distance, strength, false); - - continue; - } -#endif - -Coherent_ligature_engraver::Coherent_ligature_engraver () -{ -} - /* * TODO: move this function to class Item? */ void -Coherent_ligature_engraver::get_set_column (Item *item, Paper_column *column) +Coherent_ligature_engraver::move_related_items_to_column +(Item *item, Paper_column *target_column, Real offset) { - Item *parent = dynamic_cast (item->get_parent (X_AXIS)); - if (!parent) + Paper_column *source_column = item->get_column (); + Grob *staff_symbol = Staff_symbol_referencer::get_staff_symbol (item); + extract_item_set (source_column, "elements", elements); + for (vsize i = elements.size (); i--;) { - programming_error ("failed tweaking paper column in ligature"); - return; - } + Item *sibling = elements[i]; + if (!sibling) + // should not occur, but who knows... -jr + continue; - String name = parent->name (); - if (!String::compare (name, "PaperColumn")) - { - // Change column not only for targeted item (NoteColumn), but - // also for all associated grobs (NoteSpacing, SeparationItem). - Grob *sl = Staff_symbol_referencer::get_staff_symbol (item); - for (SCM tail = parent->get_grob_property ("elements"); - gh_pair_p (tail); - tail = ly_cdr (tail)) - { - Item *sibling = unsmob_item (ly_car (tail)); - if ((sibling) && - (Staff_symbol_referencer::get_staff_symbol (sibling) == sl)) - { -#if 0 // experimental code to collapse spacing after ligature - Grob *sibling_parent = sibling->get_parent (X_AXIS); - sibling_parent->warning (_f ("Coherent_ligature_engraver: " - "setting `spacing-increment = " - "0.01': ptr=%ul", parent)); - sibling_parent->set_grob_property("forced-spacing", - gh_double2scm (0.01)); + if (Staff_symbol_referencer::get_staff_symbol (sibling) != staff_symbol) + // sibling is from a staff different than that of the item of + // interest + continue; + +#if 0 /* experimental code to collapse spacing after ligature */ + Grob *sibling_parent = sibling->get_parent (X_AXIS); + sibling_parent->warning (_f ("Coherent_ligature_engraver: " + "setting `spacing-increment=" + "0.01': ptr=%ul", parent)); + sibling_parent->set_property ("forced-spacing", + scm_from_double (0.01)); #endif - sibling->set_parent (column, X_AXIS); - } - } - } - else - { - get_set_column (parent, column); + + sibling->set_parent (target_column, X_AXIS); + sibling->translate_axis (offset, X_AXIS); } } @@ -164,38 +131,51 @@ Coherent_ligature_engraver::get_set_column (Item *item, Paper_column *column) * occurs within the broken ligatures any more. */ void -Coherent_ligature_engraver::collect_accidentals (Spanner *, Array) +Coherent_ligature_engraver::collect_accidentals (Spanner *, + vector const &) { /* TODO */ + /* NOTE: if implementing such a function, note that in Kievan notation, + * the B-flat accidental should not be "collected", but rather prints + * immediately before the note head as usual. */ } void -Coherent_ligature_engraver::build_ligature (Spanner *, Array) +compute_delta_pitches (vector const &primitives) { - programming_error ("Coherent_ligature_engraver::build_ligature (): " - "this is an abstract method that should not be called, " - "but overridden by a subclass"); + int prev_pitch = 0; + int delta_pitch = 0; + Item *prev_primitive = 0, *primitive = 0; + for (vsize i = 0; i < primitives.size (); i++) + { + primitive = dynamic_cast (primitives[i].grob ()); + Stream_event *cause = primitives[i].event_cause (); + int pitch + = unsmob_pitch (cause->get_property ("pitch"))->steps (); + if (prev_primitive) + { + delta_pitch = pitch - prev_pitch; + prev_primitive->set_property ("delta-position", + scm_from_int (delta_pitch)); + } + prev_pitch = pitch; + prev_primitive = primitive; + } + primitive->set_property ("delta-position", scm_from_int (0)); } void Coherent_ligature_engraver::typeset_ligature (Spanner *ligature, - Array primitives) + vector const &primitives) { + // compute some commonly needed context info stored as grob + // properties + compute_delta_pitches (primitives); + // prepare ligature for typesetting build_ligature (ligature, primitives); collect_accidentals (ligature, primitives); - - // now actually typeset - for (int i = 0; i < primitives.size (); i++) - { - typeset_grob (primitives[i].grob_); - } } -ENTER_DESCRIPTION (Coherent_ligature_engraver, -/* descr */ "This is an abstract class. Subclasses such as Gregorian_ligature_engraver handle ligatures by glueing special ligature heads together.", -/* creats*/ "", -/* accepts */ "ligature-event abort-event", -/* acks */ "note-head-interface rest-interface", -/* reads */ "", -/* write */ ""); +// no ADD_ACKNOWLEDGER / ADD_ACKNOWLEDGER / ADD_TRANSLATOR macro calls +// since this class is abstract