lily/vaticana-ligature-engraver.cc

   1 /*
   2   vaticana-ligature-engraver.cc -- implement Vaticana_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 "gregorian-ligature-engraver.hh"
  10 #include "gregorian-ligature.hh"
  11 #include "vaticana-ligature.hh"
  12 #include "spanner.hh"
  13 #include "staff-symbol-referencer.hh"
  14 #include "font-interface.hh"
  15 #include "warn.hh"
  16 #include "output-def.hh"
  17 #include "paper-column.hh"
  18
  19 #include "translator.icc"
  20
  21 /*
  22  * This class implements the notation specific aspects of Vaticana
  23  * style ligatures for Gregorian chant notation.
  24  */
  25
  26 class Vaticana_ligature_engraver : public Gregorian_ligature_engraver
  27 {
  28
  29 private:
  30   static bool
  31   need_extra_horizontal_space (int prev_prefix_set, int prefix_set,
  32                                int context_info, int delta_pitch);
  33   bool is_stacked_head (int prefix_set,
  34                         int context_info);
  35   Real align_heads (Array<Grob_info> primitives,
  36                     Real flexa_width,
  37                     Real thickness);
  38
  39 public:
  40   TRANSLATOR_DECLARATIONS (Vaticana_ligature_engraver);
  41
  42 protected:
  43   virtual Spanner *create_ligature_spanner ();
  44   virtual void transform_heads (Spanner *ligature,
  45                                 Array<Grob_info> primitives);
  46 };
  47
  48 Vaticana_ligature_engraver::Vaticana_ligature_engraver ()
  49 {
  50 }
  51
  52 Spanner *
  53 Vaticana_ligature_engraver::create_ligature_spanner ()
  54 {
  55   return make_spanner ("VaticanaLigature", SCM_EOL);
  56 }
  57
  58 bool
  59 Vaticana_ligature_engraver::is_stacked_head (int prefix_set,
  60                                              int context_info)
  61 {
  62   bool is_stacked_b;
  63
  64   // upper head of pes is stacked upon lower head of pes ...
  65   is_stacked_b = context_info & PES_UPPER;
  66
  67   // ... unless this note starts a flexa
  68   if (context_info & FLEXA_LEFT)
  69     is_stacked_b = false;
  70
  71   // ... or another pes
  72   if (context_info & PES_LOWER)
  73     is_stacked_b = false;
  74
  75   // ... or the previous note is a semivocalis or inclinatum
  76   if (context_info & AFTER_DEMINUTUM)
  77     is_stacked_b = false;
  78
  79   // auctum head is never stacked upon preceding note
  80   if (prefix_set & AUCTUM)
  81     is_stacked_b = false;
  82
  83   // virga is never stacked upon preceding note
  84   if (prefix_set & VIRGA)
  85     is_stacked_b = false;
  86
  87   // oriscus is never stacked upon preceding note
  88   if (prefix_set & ORISCUS)
  89     is_stacked_b = false;
  90
  91   if ((prefix_set & DEMINUTUM)
  92       && ! (prefix_set & INCLINATUM)
  93       && (context_info & FLEXA_RIGHT))
  94     is_stacked_b = true; // semivocalis head of deminutus form
  95
  96   return is_stacked_b;
  97 }
  98
  99 /*
 100  * When aligning the heads, sometimes extra space is needed, e.g. to
 101  * avoid clashing with the appendix of an adjacent notehead or with an
 102  * adjacent notehead itself if it has the same pitch.  Extra space is
 103  * added at most once between to heads.
 104  */
 105 bool
 106 Vaticana_ligature_engraver::need_extra_horizontal_space (int prev_prefix_set, int prefix_set,
 107                                                          int context_info, int delta_pitch)
 108 {
 109   if (prev_prefix_set & VIRGA)
 110     /*
 111      * After a virga, make a an additional small space such that the
 112      * appendix on the right side of the head does not touch the
 113      * following head.
 114      */
 115     return true;
 116
 117   if ((prefix_set & INCLINATUM)
 118       && ! (prev_prefix_set & INCLINATUM))
 119     /*
 120      * Always start a series of inclinatum heads with an extra space.
 121      */
 122     return true;
 123
 124   if ((context_info & FLEXA_LEFT) && ! (context_info & PES_UPPER))
 125     /*
 126      * Before a flexa (but not within a torculus), make a an
 127      * additional small space such that the appendix on the left side
 128      * of the flexa does not touch the this head.
 129      */
 130     return true;
 131
 132   if (delta_pitch == 0)
 133     /*
 134      * If there are two adjacent noteheads with the same pitch, add
 135      * additional small space between them, such that they do not
 136      * touch each other.
 137      */
 138     return true;
 139
 140   return false;
 141 }
 142
 143 Real
 144 Vaticana_ligature_engraver::align_heads (Array<Grob_info> primitives,
 145                                          Real flexa_width,
 146                                          Real thickness)
 147 {
 148   if (!primitives.size ())
 149     {
 150       programming_error ("Vaticana_ligature: "
 151                          "empty ligature [ignored]");
 152       return 0.0;
 153     }
 154
 155   /*
 156    * The paper column where we put the whole ligature into.
 157    */
 158   Paper_column *column
 159     = dynamic_cast<Item *> (primitives[0].grob ())->get_column ();
 160
 161   Real join_thickness
 162     = thickness * column->get_layout ()->get_dimension (ly_symbol2scm ("linethickness"));
 163
 164   /*
 165    * Amount of extra space two put between some particular
 166    * configurations of adjacent heads.
 167    *
 168    * TODO: make this a property of primtive grobs.
 169    */
 170   Real extra_space = 4.0 * join_thickness;
 171
 172   /*
 173    * Keep track of the total width of the ligature.
 174    */
 175   Real ligature_width = 0.0;
 176
 177   Item *prev_primitive = 0;
 178   int prev_prefix_set = 0;
 179   for (int i = 0; i < primitives.size (); i++)
 180     {
 181       Item *primitive = dynamic_cast<Item *> (primitives[i].grob ());
 182       int prefix_set
 183         = scm_to_int (primitive->get_property ("prefix-set"));
 184       int context_info
 185         = scm_to_int (primitive->get_property ("context-info"));
 186
 187       /*
 188        * Get glyph_name, delta_pitch and context_info for this head.
 189        */
 190
 191       SCM glyph_name_scm = primitive->get_property ("glyph-name");
 192       if (glyph_name_scm == SCM_EOL)
 193         {
 194           primitive->programming_error ("Vaticana_ligature:"
 195                                         "undefined glyph-name -> "
 196                                         "ignoring grob");
 197           continue;
 198         }
 199       String glyph_name = ly_scm2string (glyph_name_scm);
 200
 201       int delta_pitch = 0;
 202       if (prev_primitive) /* urgh, need prev_primitive only here */
 203         {
 204           SCM delta_pitch_scm = prev_primitive->get_property ("delta-pitch");
 205           if (delta_pitch_scm != SCM_EOL)
 206             {
 207               delta_pitch = scm_to_int (delta_pitch_scm);
 208             }
 209           else
 210             {
 211               primitive->programming_error ("Vaticana_ligature:"
 212                                             "delta-pitch undefined -> "
 213                                             "ignoring grob");
 214               continue;
 215             }
 216         }
 217
 218       /*
 219        * Now determine width and x-offset of head.
 220        */
 221
 222       Real head_width;
 223       Real x_offset;
 224
 225       if (context_info & STACKED_HEAD)
 226         {
 227           /*
 228            * This head is stacked upon the previous one; hence, it
 229            * does not contribute to the total width of the ligature,
 230            * and its width is assumed to be 0.0.  Moreover, it is
 231            * shifted to the left by its width such that the right side
 232            * of this and the other head are horizontally aligned.
 233            */
 234           head_width = 0.0;
 235           x_offset = join_thickness
 236             - Font_interface::get_default_font (primitive)->
 237             find_by_name ("noteheads." + glyph_name).extent (X_AXIS).length ();
 238         }
 239       else if (!String::compare (glyph_name, "flexa")
 240                || !String::compare (glyph_name, ""))
 241         {
 242           /*
 243            * This head represents either half of a flexa shape.
 244            * Hence, it is assigned half the width of this shape.
 245            */
 246           head_width = 0.5 * flexa_width;
 247           x_offset = 0.0;
 248         }
 249       else
 250         {
 251           /*
 252            * This is a regular head, placed right to the previous one.
 253            * Retrieve its width from corresponding font.
 254            */
 255           head_width
 256             = Font_interface::get_default_font (primitive)->
 257             find_by_name ("noteheads." + glyph_name).extent (X_AXIS).length ();
 258           x_offset = 0.0;
 259         }
 260
 261       /*
 262        * Save the head's final x-offset.
 263        */
 264       primitive->set_property ("x-offset",
 265                                scm_from_double (x_offset));
 266
 267       /*
 268        * If the head is the 2nd head of a pes or flexa (but not a
 269        * flexa shape), mark this head to be joined with the left-side
 270        * neighbour head (i.e. the previous head) by a vertical beam.
 271        */
 272       if ((context_info & PES_UPPER)
 273           || ((context_info & FLEXA_RIGHT)
 274               && ! (context_info & PES_LOWER)))
 275         {
 276           if (!prev_primitive)
 277             {
 278               primitive->programming_error ("vaticana ligature: add-join: "
 279                                             "missing previous primitive");
 280             }
 281           else
 282             {
 283               prev_primitive->set_property ("add-join",
 284                                             ly_bool2scm (true));
 285
 286               /*
 287                * Create a small overlap of adjacent heads so that the join
 288                * can be drawn perfectly between them.
 289                */
 290               ligature_width -= join_thickness;
 291             }
 292         }
 293       else if (!String::compare (glyph_name, ""))
 294         {
 295           /*
 296            * This is the 2nd (virtual) head of flexa shape.  Join it
 297            * tightly with 1st head, i.e. do *not* add additional
 298            * space, such that next head will not be off from the flexa
 299            * shape.
 300            */
 301         }
 302
 303       if (need_extra_horizontal_space (prev_prefix_set, prefix_set,
 304                                        context_info, delta_pitch))
 305         ligature_width += extra_space;
 306
 307       /*
 308        * Horizontally line-up this head to form a ligature.
 309        */
 310       get_set_column (primitive, column);
 311       primitive->translate_axis (ligature_width, X_AXIS);
 312       ligature_width += head_width;
 313
 314       prev_primitive = primitive;
 315       prev_prefix_set = prefix_set;
 316     }
 317
 318   /*
 319    * Add extra horizontal padding space after ligature, such that
 320    * neighbouring ligatures do not touch each other.
 321    */
 322   ligature_width += extra_space;
 323
 324   return ligature_width;
 325 }
 326
 327 /*
 328  * Depending on the typographical features of a particular ligature
 329  * style, some prefixes may be ignored.  In particular, if a curved
 330  * flexa shape is produced, any prefixes to either of the two
 331  * contributing heads that would select a head other than punctum, is
 332  * by definition ignored.
 333  *
 334  * This function prints a warning, if the given primitive is prefixed
 335  * such that a head other than punctum would be chosen, if this
 336  * primitive were engraved as a stand-alone head.
 337  */
 338 void
 339 check_for_prefix_loss (Item *primitive)
 340 {
 341   int prefix_set
 342     = scm_to_int (primitive->get_property ("prefix-set"));
 343   if (prefix_set & ~PES_OR_FLEXA)
 344     {
 345       String prefs = Gregorian_ligature::prefixes_to_str (primitive);
 346       primitive->warning (_f ("ignored prefix (es) `%s' of this head according "
 347                               "to restrictions of the selected ligature style",
 348                               prefs.to_str0 ()));
 349     }
 350 }
 351
 352 void
 353 Vaticana_ligature_engraver::transform_heads (Spanner *ligature,
 354                                              Array<Grob_info> primitives)
 355 {
 356   Real flexa_width = robust_scm2double (ligature->get_property ("flexa-width"), 2);
 357
 358   Real thickness = robust_scm2double (ligature->get_property ("thickness"), 1);
 359
 360   Item *prev_primitive = 0;
 361   int prev_prefix_set = 0;
 362   int prev_context_info = 0;
 363   int prev_delta_pitch = 0;
 364   String prev_glyph_name = "";
 365   for (int i = 0; i < primitives.size (); i++)
 366     {
 367       Item *primitive = dynamic_cast<Item *> (primitives[i].grob ());
 368
 369       int delta_pitch;
 370       SCM delta_pitch_scm = primitive->get_property ("delta-pitch");
 371       if (delta_pitch_scm != SCM_EOL)
 372         {
 373           delta_pitch = scm_to_int (delta_pitch_scm);
 374         }
 375       else
 376         {
 377           primitive->programming_error ("Vaticana_ligature:"
 378                                         "delta-pitch undefined -> "
 379                                         "ignoring grob");
 380           continue;
 381         }
 382
 383       /* retrieve & complete prefix_set and context_info */
 384       int prefix_set
 385         = scm_to_int (primitive->get_property ("prefix-set"));
 386       int context_info
 387         = scm_to_int (primitive->get_property ("context-info"));
 388       if (is_stacked_head (prefix_set, context_info))
 389         {
 390           context_info |= STACKED_HEAD;
 391           primitive->set_property ("context-info",
 392                                    scm_from_int (context_info));
 393         }
 394
 395       /*
 396        * Now determine which head to typeset (this is context sensitive
 397        * information, since it depends on neighbouring heads; therefore,
 398        * this decision must be made here in the engraver rather than in
 399        * the backend).
 400        */
 401       String glyph_name;
 402       if (prefix_set & VIRGA)
 403         {
 404           glyph_name = "svaticana.punctum";
 405           primitive->set_property ("add-stem", ly_bool2scm (true));
 406         }
 407       else if (prefix_set & QUILISMA)
 408         glyph_name = "svaticana.quilisma";
 409       else if (prefix_set & ORISCUS)
 410         glyph_name = "ssolesmes.oriscus";
 411       else if (prefix_set & STROPHA)
 412         if (prefix_set & AUCTUM)
 413           glyph_name = "ssolesmes.stropha.aucta";
 414         else glyph_name = "ssolesmes.stropha";
 415       else if (prefix_set & INCLINATUM)
 416         if (prefix_set & AUCTUM)
 417           glyph_name = "ssolesmes.incl.auctum";
 418         else if (prefix_set & DEMINUTUM)
 419           glyph_name = "ssolesmes.incl.parvum";
 420         else
 421           glyph_name = "svaticana.inclinatum";
 422       else if (prefix_set & DEMINUTUM)
 423         if (i == 0)
 424           {
 425             // initio debilis
 426             glyph_name = "svaticana.reverse.plica";
 427           }
 428         else if (prev_delta_pitch > 0)
 429           {
 430             // epiphonus
 431             if (! (prev_context_info & FLEXA_RIGHT))
 432               /* correct head of previous primitive */
 433               if (prev_delta_pitch > 1)
 434                 {
 435                   prev_glyph_name = "svaticana.epiphonus";
 436                   glyph_name = "svaticana.plica";
 437                 }
 438               else
 439                 {
 440                   prev_glyph_name = "svaticana.vepiphonus";
 441                   glyph_name = "svaticana.vplica";
 442                 }
 443           }
 444         else if (prev_delta_pitch < 0)
 445           {
 446             // cephalicus
 447             if (! (prev_context_info & FLEXA_RIGHT))
 448               /* correct head of previous primitive */
 449               {
 450                 if (i > 1)
 451                   {
 452                     /* cephalicus head with fixed size cauda */
 453                     prev_glyph_name = "svaticana.inner.cephalicus";
 454                   }
 455                 else
 456                   {
 457                     /* cephalicus head without cauda */
 458                     prev_glyph_name = "svaticana.cephalicus";
 459                   }
 460
 461                 /*
 462                  * Flexa has no variable size cauda if its left head is
 463                  * stacked on the right head.  This is true for
 464                  * cephalicus.  Hence, remove the cauda.
 465                  *
 466                  * Urgh: for the current implementation, this rule only
 467                  * applies for cephalicus; but it is a fundamental rule.
 468                  * Therefore, the following line of code should be
 469                  * placed somewhere else.
 470                  */
 471                 prev_primitive->set_property ("add-cauda",
 472                                               ly_bool2scm (false));
 473               }
 474               if (prev_delta_pitch < - 1)
 475                 {
 476                   glyph_name = "svaticana.reverse.plica";
 477                 }
 478               else
 479                 {
 480                   glyph_name = "svaticana.reverse.vplica";
 481                 }
 482           }
 483         else // (prev_delta_pitch == 0)
 484           {
 485             primitive->programming_error ("Vaticana_ligature:"
 486                                           "deminutum head must have different "
 487                                           "pitch -> ignoring grob");
 488           }
 489       else if (prefix_set & (CAVUM | LINEA))
 490         if ((prefix_set & CAVUM) && (prefix_set & LINEA))
 491           glyph_name = "svaticana.linea.punctum.cavum";
 492         else if (prefix_set & CAVUM)
 493           glyph_name = "svaticana.punctum.cavum";
 494         else
 495           glyph_name = "svaticana.linea.punctum";
 496       else if (prefix_set & AUCTUM)
 497         if (prefix_set & ASCENDENS)
 498           glyph_name = "ssolesmes.auct.asc";
 499         else
 500           glyph_name = "ssolesmes.auct.desc";
 501       else if ((context_info & STACKED_HEAD)
 502                && (context_info & PES_UPPER))
 503         if (prev_delta_pitch > 1)
 504           glyph_name = "svaticana.upes";
 505         else
 506           glyph_name = "svaticana.vupes";
 507       else
 508         glyph_name = "svaticana.punctum";
 509
 510       /*
 511        * This head needs a cauda, if it starts a flexa, is not the upper
 512        * head of a pes, and if it is a punctum.
 513        */
 514       if ((context_info & FLEXA_LEFT) && ! (context_info & PES_UPPER))
 515         if (!String::compare (glyph_name, "svaticana.punctum"))
 516           primitive->set_property ("add-cauda", ly_bool2scm (true));
 517
 518       /*
 519        * Execptional rule for porrectus:
 520        *
 521        * If the current head is preceded by a \flexa and succeded by a
 522        * \pes (e.g. "a \flexa g \pes a"), then join the current head and
 523        * the previous head into a single curved flexa shape.
 524        */
 525       if ((context_info & FLEXA_RIGHT) && (context_info & PES_LOWER))
 526         {
 527           check_for_prefix_loss (prev_primitive);
 528           prev_glyph_name = "flexa";
 529           prev_primitive->set_property ("flexa-height",
 530                                         scm_from_int (prev_delta_pitch));
 531           prev_primitive->set_property ("flexa-width",
 532                                         scm_from_double (flexa_width));
 533           bool add_cauda = !(prev_prefix_set && PES_OR_FLEXA);
 534           prev_primitive->set_property ("add-cauda",
 535                                         ly_bool2scm (add_cauda));
 536           check_for_prefix_loss (primitive);
 537           glyph_name = "";
 538           primitive->set_property ("flexa-width",
 539                                    scm_from_double (flexa_width));
 540         }
 541
 542       /*
 543        * Exceptional rule for pes:
 544        *
 545        * If this head is stacked on the previous one due to a \pes, then
 546        * set the glyph of the previous head to that for this special
 547        * case, thereby avoiding potential vertical collision with the
 548        * current head.
 549        */
 550       if (prefix_set & PES_OR_FLEXA)
 551         {
 552           if ((context_info & PES_UPPER) && (context_info & STACKED_HEAD))
 553             {
 554               if (!String::compare (prev_glyph_name, "svaticana.punctum"))
 555                 if (prev_delta_pitch > 1)
 556                   prev_glyph_name = "svaticana.lpes";
 557                 else
 558                   prev_glyph_name = "svaticana.vlpes";
 559             }
 560         }
 561
 562       if (prev_primitive)
 563         prev_primitive->set_property ("glyph-name",
 564                                       scm_makfrom0str (prev_glyph_name.to_str0 ()));
 565
 566       /*
 567        * In the backend, flexa shapes and joins need to know about line
 568        * thickness.  Hence, for simplicity, let's distribute the
 569        * ligature grob's value for thickness to each ligature head (even
 570        * if not all of them need to know).
 571        */
 572       primitive->set_property ("thickness", scm_from_double (thickness));
 573
 574       prev_primitive = primitive;
 575       prev_prefix_set = prefix_set;
 576       prev_context_info = context_info;
 577       prev_delta_pitch = delta_pitch;
 578       prev_glyph_name = glyph_name;
 579     }
 580
 581   prev_primitive->set_property ("glyph-name",
 582                                 scm_makfrom0str (prev_glyph_name.to_str0 ()));
 583
 584   align_heads (primitives, flexa_width, thickness);
 585
 586 #if 0 // experimental code to collapse spacing after ligature
 587   /* TODO: set to max (old/new spacing-increment), since other
 588      voices/staves also may want to set this property. */
 589   Item *first_primitive = dynamic_cast<Item *> (primitives[0].grob ());
 590   Paper_column *paper_column = first_primitive->get_column ();
 591   paper_column->warning (_f ("Vaticana_ligature_engraver: "
 592                              "setting `spacing-increment = %f': ptr =%ul",
 593                              ligature_width, paper_column));
 594   paper_column->
 595     set_property ("forced-spacing", scm_from_double (ligature_width));
 596 #endif
 597 }
 598
 599 ADD_ACKNOWLEDGER(Vaticana_ligature_engraver, rest);
 600 ADD_ACKNOWLEDGER(Vaticana_ligature_engraver, note_head);
 601 ADD_TRANSLATOR (Vaticana_ligature_engraver,
 602                 /* descr */ "Handles ligatures by glueing special ligature heads together.",
 603                 /* creats*/ "VaticanaLigature",
 604                 /* accepts */ "ligature-event",
 605                 /* reads */ "",
 606                 /* write */ "");