lily/gregorian-ligature-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2003--2010 Juergen Reuter <reuter@ipd.uka.de>
   5
   6   LilyPond is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   LilyPond is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "gregorian-ligature-engraver.hh"
  21
  22 #include "gregorian-ligature.hh"
  23 #include "international.hh"
  24 #include "paper-column.hh"
  25 #include "pitch.hh"
  26 #include "spanner.hh"
  27 #include "staff-symbol-referencer.hh"
  28 #include "stream-event.hh"
  29 #include "warn.hh"
  30
  31 /* ASSIGN_EVENT_ONCE */
  32 #include "translator.icc"
  33
  34 /*
  35  * This abstract class is the common superclass for all ligature
  36  * engravers for Gregorian chant notation.  It cares for the musical
  37  * handling of the neumes, such as checking for valid combinations of
  38  * neumes and providing context information.  Notational aspects such
  39  * as the glyphs to use or calculating the total width of a ligature,
  40  * are left to the concrete subclass.  Currently, there is only a
  41  * single subclass, Vaticana_ligature_engraver.  Other ligature
  42  * engravers for Gregorian chant will be added in the future, such as
  43  * Medicaea_ligature_engraver or Hufnagel_ligature_engraver.
  44  */
  45 Gregorian_ligature_engraver::Gregorian_ligature_engraver ()
  46 {
  47   pes_or_flexa_req_ = 0;
  48 }
  49
  50 void
  51 Gregorian_ligature_engraver::listen_pes_or_flexa (Stream_event *ev)
  52 {
  53   ASSIGN_EVENT_ONCE (pes_or_flexa_req_, ev);
  54 }
  55
  56 void fix_prefix (char const *name, int mask,
  57                  int *current_set, int min_set, int max_set,
  58                  Grob *primitive)
  59 {
  60   bool current = *current_set & mask;
  61   bool min = min_set & mask;
  62   bool max = max_set & mask;
  63   if (max < min)
  64     {
  65       programming_error ("min_set > max_set");
  66       return;
  67     }
  68   if (min && !current)
  69     {
  70       primitive->warning (_f ("\\%s ignored", name));
  71       *current_set &= ~mask;
  72     }
  73   if (!max && current)
  74     {
  75       primitive->warning (_f ("implied \\%s added", name));
  76       *current_set |= mask;
  77     }
  78 }
  79
  80 void fix_prefix_set (int *current_set, int min_set, int max_set, Grob *primitive)
  81 {
  82   fix_prefix ("virga", VIRGA, current_set, min_set, max_set, primitive);
  83   fix_prefix ("stropha", STROPHA, current_set, min_set, max_set, primitive);
  84   fix_prefix ("inclinatum", INCLINATUM, current_set, min_set, max_set, primitive);
  85   fix_prefix ("auctum", AUCTUM, current_set, min_set, max_set, primitive);
  86   fix_prefix ("descendens", DESCENDENS, current_set, min_set, max_set, primitive);
  87   fix_prefix ("ascendens", ASCENDENS, current_set, min_set, max_set, primitive);
  88   fix_prefix ("oriscus", ORISCUS, current_set, min_set, max_set, primitive);
  89   fix_prefix ("quilisma", QUILISMA, current_set, min_set, max_set, primitive);
  90   fix_prefix ("deminutum", DEMINUTUM, current_set, min_set, max_set, primitive);
  91   fix_prefix ("cavum", CAVUM, current_set, min_set, max_set, primitive);
  92   fix_prefix ("linea", LINEA, current_set, min_set, max_set, primitive);
  93   fix_prefix ("pes_or_flexa", LINEA, current_set, min_set, max_set, primitive);
  94 }
  95
  96 void check_and_fix_all_prefixes (vector<Grob_info> primitives)
  97 {
  98   /* Check for invalid head modifier combinations */
  99   for (vsize i = 0; i < primitives.size (); i++)
 100     {
 101       Grob *primitive = primitives[i].grob ();
 102
 103       /* compute head prefix set by inspecting primitive grob properties */
 104       int prefix_set
 105         = (VIRGA *to_boolean (primitive->get_property ("virga")))
 106         | (STROPHA *to_boolean (primitive->get_property ("stropha")))
 107         | (INCLINATUM *to_boolean (primitive->get_property ("inclinatum")))
 108         | (AUCTUM *to_boolean (primitive->get_property ("auctum")))
 109         | (DESCENDENS *to_boolean (primitive->get_property ("descendens")))
 110         | (ASCENDENS *to_boolean (primitive->get_property ("ascendens")))
 111         | (ORISCUS *to_boolean (primitive->get_property ("oriscus")))
 112         | (QUILISMA *to_boolean (primitive->get_property ("quilisma")))
 113         | (DEMINUTUM *to_boolean (primitive->get_property ("deminutum")))
 114         | (CAVUM *to_boolean (primitive->get_property ("cavum")))
 115         | (LINEA *to_boolean (primitive->get_property ("linea")))
 116         | (PES_OR_FLEXA *to_boolean (primitive->get_property ("pes-or-flexa")));
 117
 118       /* check: ascendens and descendens exclude each other; same with
 119          auctum and deminutum */
 120       if (prefix_set & DESCENDENS)
 121         {
 122           fix_prefix_set (&prefix_set,
 123                           prefix_set & ~ASCENDENS,
 124                           prefix_set & ~ASCENDENS,
 125                           primitive);
 126         }
 127       if (prefix_set & AUCTUM)
 128         {
 129           fix_prefix_set (&prefix_set,
 130                           prefix_set & ~DEMINUTUM,
 131                           prefix_set & ~DEMINUTUM,
 132                           primitive);
 133         }
 134
 135       /* check: virga, quilisma and oriscus cannot be combined with any
 136          other prefix, but may be part of a pes or flexa */
 137       if (prefix_set & VIRGA)
 138         {
 139           fix_prefix_set (&prefix_set,
 140                           VIRGA,
 141                           VIRGA | PES_OR_FLEXA,
 142                           primitive);
 143         }
 144       if (prefix_set & QUILISMA)
 145         {
 146           fix_prefix_set (&prefix_set,
 147                           QUILISMA,
 148                           QUILISMA | PES_OR_FLEXA,
 149                           primitive);
 150         }
 151       if (prefix_set & ORISCUS)
 152         {
 153           fix_prefix_set (&prefix_set,
 154                           ORISCUS,
 155                           ORISCUS | PES_OR_FLEXA,
 156                           primitive);
 157         }
 158
 159       /* check: auctum is the only valid optional prefix for stropha */
 160       if (prefix_set & STROPHA)
 161         {
 162           fix_prefix_set (&prefix_set,
 163                           STROPHA,
 164                           STROPHA | AUCTUM,
 165                           primitive);
 166         }
 167
 168       /* check: inclinatum may be prefixed with auctum or deminutum only */
 169       if (prefix_set & INCLINATUM)
 170         {
 171           fix_prefix_set (&prefix_set,
 172                           INCLINATUM,
 173                           INCLINATUM | AUCTUM | DEMINUTUM,
 174                           primitive);
 175         }
 176       /* check: semivocalis (deminutum but not inclinatum) must occur in
 177          combination with and only with pes or flexa */
 178       else if (prefix_set & DEMINUTUM)
 179         {
 180           fix_prefix_set (&prefix_set,
 181                           DEMINUTUM | PES_OR_FLEXA,
 182                           DEMINUTUM | PES_OR_FLEXA,
 183                           primitive);
 184         }
 185
 186       /* check: cavum and linea (either or both) may be applied only
 187          upon core punctum */
 188       if (prefix_set & (CAVUM | LINEA))
 189         {
 190           fix_prefix_set (&prefix_set,
 191                           0,
 192                           CAVUM | LINEA,
 193                           primitive);
 194         }
 195
 196       /* all other combinations should be valid (unless I made a
 197          mistake) */
 198
 199       primitive->set_property ("prefix-set", scm_from_int (prefix_set));
 200     }
 201 }
 202
 203 /*
 204  * Marks those heads that participate in a pes or flexa.
 205  */
 206 void
 207 provide_context_info (vector<Grob_info> primitives)
 208 {
 209   Grob *prev_primitive = 0;
 210   int prev_prefix_set = 0;
 211   int prev_context_info = 0;
 212   int prev_pitch = 0;
 213   for (vsize i = 0; i < primitives.size (); i++)
 214     {
 215       Grob *primitive = primitives[i].grob ();
 216       Stream_event *event_cause = primitives[i].event_cause ();
 217       int context_info = 0;
 218       int pitch = unsmob_pitch (event_cause->get_property ("pitch"))->steps ();
 219       int prefix_set = scm_to_int (primitive->get_property ("prefix-set"));
 220
 221       if (prefix_set & PES_OR_FLEXA)
 222         {
 223           if (!i) // ligature may not start with 2nd head of pes or flexa
 224             primitive->warning (_ ("cannot apply `\\~' on first head of ligature"));
 225           else if (pitch > prev_pitch) // pes
 226             {
 227               prev_context_info |= PES_LOWER;
 228               context_info |= PES_UPPER;
 229             }
 230           else if (pitch < prev_pitch) // flexa
 231             {
 232               prev_context_info |= FLEXA_LEFT;
 233               context_info |= FLEXA_RIGHT;
 234             }
 235           else // (pitch == prev_pitch)
 236             primitive->warning (_ ("cannot apply `\\~' on heads with identical pitch"));
 237         }
 238       if (prev_prefix_set & DEMINUTUM)
 239         context_info |= AFTER_DEMINUTUM;
 240
 241       if (prev_primitive)
 242         prev_primitive->set_property ("context-info",
 243                                       scm_from_int (prev_context_info));
 244       prev_primitive = primitive;
 245       prev_prefix_set = prefix_set;
 246       prev_context_info = context_info;
 247       prev_pitch = pitch;
 248     }
 249   if (prev_primitive)
 250     prev_primitive->set_property ("context-info",
 251                                   scm_from_int (prev_context_info));
 252 }
 253
 254 void
 255 Gregorian_ligature_engraver::build_ligature (Spanner *ligature,
 256                                              vector<Grob_info> primitives)
 257 {
 258   // apply style-independent checking and transformation
 259   check_and_fix_all_prefixes (primitives);
 260   provide_context_info (primitives);
 261
 262   // apply style-specific transformation (including line-up); to be
 263   // implemented by subclass
 264   transform_heads (ligature, primitives);
 265 }
 266
 267 void
 268 Gregorian_ligature_engraver::stop_translation_timestep ()
 269 {
 270   Ligature_engraver::stop_translation_timestep ();
 271   pes_or_flexa_req_ = 0;
 272 }
 273
 274 // no ADD_ACKNOWLEDGER / ADD_ACKNOWLEDGER / ADD_TRANSLATOR macro calls
 275 // since this class is abstract