lily/gregorian-ligature-engraver.cc

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