lily/coherent-ligature-engraver.cc

   1 /*
   2   coherent-ligature-engraver.cc -- implement Coherent_ligature_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2003--2005 Juergen Reuter <reuter@ipd.uka.de>
   7 */
   8
   9 #include "coherent-ligature-engraver.hh"
  10
  11 #include "warn.hh"
  12 #include "staff-symbol-referencer.hh"
  13 #include "spanner.hh"
  14 #include "paper-column.hh"
  15 #include "pitch.hh"
  16 #include "pointer-group-interface.hh"
  17
  18 /*
  19  * This abstract class serves as common superclass for all ligature
  20  * engravers thet produce a single connected graphical object of fixed
  21  * width, consisting of noteheads and other primitives (see class
  22  * Ligature_engraver for more information on the interaction between
  23  * this class and its superclass).  In particular, it cares for the
  24  * following tasks:
  25  *
  26  * - provide a function for putting all grobs of the ligature into a
  27  * single paper column,
  28  *
  29  * - delegate actual creation of ligature to concrete subclass,
  30  *
  31  * - collect all accidentals that occur within the ligature and put
  32  * them at the left side of the ligature (TODO; see function
  33  * collect_accidentals ()),
  34  *
  35  * - collapse superflous space after each ligature (TODO).
  36  *
  37  * Concrete subclasses must implement function build_ligature (Spanner
  38  * *, Array<Grob_info>).  This function is responsible for actually
  39  * building the ligature by transforming the array of noteheads.
  40  *
  41  * Currently, there are two subclasses: Gregorian_ligature_engraver
  42  * for Gregorian chant notation (also known as plain song or cantus
  43  * planus) and Mensural_ligature_engraver for white mensural notation.
  44  * Subclasses for other music notation styles such as modal notation
  45  * or ars nova notation may eventually be added.
  46  */
  47
  48 /*
  49  * TODO: local accidentals: collect accidentals that occur within a
  50  * ligature and put them before the ligature.  If an accidental
  51  * changes within a ligature, print a warning (user error) and ignore
  52  * any further accidental for that pitch within that ligature
  53  * (actually, in such a case, the user should split the ligature into
  54  * two separate ligatures).  Similarly, any object that, in ordinary
  55  * notation, may be put to the left or to the right of a note-head,
  56  * should be collected and put before or after the ligature.
  57  *
  58  * TODO: make spacing more robust: do not screw up spacing if user
  59  * erroneously puts rest in ligature.
  60  *
  61  * TODO: for each ligature, add Rod that represents the total length
  62  * of the ligature (to preemptively avoid collision with adjacent
  63  * notes); or maybe just additionally create a
  64  * mensural/vaticana/whatever-ligature grob (e.g. via
  65  * Mensural_ligature::print (SCM)) that just consists of a
  66  * bounding box around all primitives of the ligature.
  67  *
  68  * TODO: Maybe move functions fold_up_primitives () and
  69  * join_primitives () from subclasses to here?  N.B. it is not
  70  * appropriate to put these into Ligature_engraver, since, for
  71  * example, Ligature_bracket_engraver does not share any of this code.
  72  */
  73
  74 /*
  75  * TODO: Let superflous space after each ligature collapse.  The
  76  * following code should help in doing so (though it does not yet
  77  * fully work).  Just put the following code into
  78  * Spacing_spanner::do_measure ().  I put it temporarily here as memo
  79  * until it really works and I also get Han-Wen's/Jan's permission to
  80  * add it to the spacing spanner code.
  81  */
  82 #if 0 /* experimental code to collapse spacing after ligature */
  83 SCM incr_scm = lc->get_property ("forced-spacing");
  84 if (incr_scm != SCM_EOL) /* (Paper_column::is_musical (l)) */
  85   {
  86     me->warning (_f ("gotcha: ptr=%ul", lc));//debug
  87     ly_display_scm (lc->self_scm ());
  88     Real distance;
  89     if (incr_scm != SCM_EOL)
  90       {
  91         distance = scm_to_double (incr_scm);
  92       }
  93     else
  94       {
  95         me->warning (_ ("distance undefined, assuming 0.1"));
  96         distance = 0.1;
  97       }
  98     me->warning (_f ("distance=%f", distance));//debug
  99     Real inverse_strength = 1.0;
 100     Spaceable_grob::add_spring (lc, rc, distance, inverse_strength);
 101     if (Item *rb = r->find_prebroken_piece (LEFT))
 102       Spaceable_grob::add_spring (lc, rb, distance, inverse_strength);
 103
 104     continue;
 105   }
 106 #endif
 107
 108 /*
 109  * TODO: move this function to class Item?
 110  */
 111 void
 112 Coherent_ligature_engraver::get_set_column (Item *item, Paper_column *column)
 113 {
 114   Item *parent = dynamic_cast<Item *> (item->get_parent (X_AXIS));
 115   if (!parent)
 116     {
 117       programming_error ("failed tweaking paper column in ligature");
 118       return;
 119     }
 120
 121   String name = parent->name ();
 122   if (!String::compare (name, "PaperColumn"))
 123     {
 124       // Change column not only for targeted item (NoteColumn), but
 125       // also for all associated grobs (NoteSpacing, SeparationItem).
 126       Grob *sl = Staff_symbol_referencer::get_staff_symbol (item);
 127
 128       extract_item_set (parent, "elements", elements);
 129
 130       for (int i = elements.size (); i--;)
 131         {
 132           Item *sibling = elements[i];
 133           if ((sibling)
 134               && (Staff_symbol_referencer::get_staff_symbol (sibling) == sl))
 135             {
 136 #if 0 /* experimental code to collapse spacing after ligature */
 137               Grob *sibling_parent = sibling->get_parent (X_AXIS);
 138               sibling_parent->warning (_f ("Coherent_ligature_engraver: "
 139                                            "setting `spacing-increment="
 140                                            "0.01': ptr=%ul", parent));
 141               sibling_parent->set_property ("forced-spacing",
 142                                             scm_from_double (0.01));
 143 #endif
 144               sibling->set_parent (column, X_AXIS);
 145             }
 146         }
 147     }
 148   else
 149     {
 150       get_set_column (parent, column);
 151     }
 152 }
 153
 154 /*
 155  * TODO: This function should collect all accidentals that occur
 156  * within the ligature (by scanning through the primitives array) and
 157  * place all of them at the left of the ligature.  If there is an
 158  * alteration within the ligature (e.g. an "f" followed by a "fis"
 159  * somewhere later in the ligature), issue a warning (and maybe create
 160  * an additional natural symbol to explicitly make clear that there is
 161  * an "f" first?).  The warning should suggest the user to break the
 162  * ligature into two or more smaller ligatures such that no alteration
 163  * occurs within the broken ligatures any more.
 164  */
 165 void
 166 Coherent_ligature_engraver::collect_accidentals (Spanner *, Array<Grob_info>)
 167 {
 168   /* TODO */
 169 }
 170
 171 void
 172 compute_delta_pitches (Array<Grob_info> primitives)
 173 {
 174   int prev_pitch = 0;
 175   int delta_pitch = 0;
 176   Item *prev_primitive = 0, *primitive = 0;
 177   for (int i = 0; i < primitives.size (); i++)
 178     {
 179       primitive = dynamic_cast<Item *> (primitives[i].grob ());
 180       Music *music_cause = primitives[i].music_cause ();
 181       int pitch
 182         = unsmob_pitch (music_cause->get_property ("pitch"))->steps ();
 183       if (prev_primitive)
 184         {
 185           delta_pitch = pitch - prev_pitch;
 186           prev_primitive->set_property ("delta-pitch",
 187                                         scm_from_int (delta_pitch));
 188         }
 189       prev_pitch = pitch;
 190       prev_primitive = primitive;
 191     }
 192   primitive->set_property ("delta-pitch", scm_from_int (0));
 193 }
 194
 195 void
 196 Coherent_ligature_engraver::typeset_ligature (Spanner *ligature,
 197                                               Array<Grob_info> primitives)
 198 {
 199   // compute some commonly needed context info stored as grob
 200   // properties
 201   compute_delta_pitches (primitives);
 202
 203   // prepare ligature for typesetting
 204   build_ligature (ligature, primitives);
 205   collect_accidentals (ligature, primitives);
 206 }
 207
 208 // no ADD_ACKNOWLEDGER / ADD_ACKNOWLEDGER / ADD_TRANSLATOR macro calls
 209 // since this class is abstract