lily/kievan-ligature-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2013--2015 Aleksandr Andreev <aleksandr.andreev@gmail.com>
   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 "coherent-ligature-engraver.hh"
  21 #include "font-interface.hh"
  22 #include "international.hh"
  23 #include "kievan-ligature.hh"
  24 #include "paper-column.hh"
  25 #include "rhythmic-head.hh"
  26 #include "spanner.hh"
  27 #include "stream-event.hh"
  28 #include "warn.hh"
  29
  30 #include "translator.icc"
  31
  32 class Kievan_ligature_engraver : public Coherent_ligature_engraver
  33 {
  34
  35 protected:
  36   virtual Spanner *create_ligature_spanner ();
  37   virtual void build_ligature (Spanner *ligature,
  38                                vector<Grob_info> const &primitives);
  39
  40 public:
  41   TRANSLATOR_DECLARATIONS (Kievan_ligature_engraver);
  42   TRANSLATOR_INHERIT (Coherent_ligature_engraver);
  43
  44 private:
  45   void fold_up_primitives (vector<Grob_info> const &primitives, Real padding, Real &min_length);
  46 };
  47
  48 Kievan_ligature_engraver::Kievan_ligature_engraver (Context *c)
  49   : Coherent_ligature_engraver (c)
  50 {
  51
  52 }
  53
  54 Spanner *
  55 Kievan_ligature_engraver::create_ligature_spanner ()
  56 {
  57   return make_spanner ("KievanLigature", SCM_EOL);
  58 }
  59
  60 void
  61 Kievan_ligature_engraver::fold_up_primitives (vector<Grob_info> const &primitives,
  62                                                 Real padding, Real &min_length)
  63 {
  64   Item *first = 0;
  65   Real accumul_acc_space = 0.0;
  66   // start us off with some padding on the left
  67   min_length = padding;
  68
  69   for (vsize i = 0; i < primitives.size (); i++)
  70     {
  71       Item *current = dynamic_cast<Item *> (primitives[i].grob ());
  72       Interval my_ext = current->extent (current, X_AXIS);
  73       Real head_width = my_ext.length ();
  74       if (i == 0)
  75          first = current;
  76
  77       // must keep track of accidentals in spacing problem
  78       Grob *acc_gr = unsmob<Grob> (current->get_object ("accidental-grob"));
  79       if (acc_gr && i > 0)
  80         {
  81            Interval acc_ext = acc_gr->extent (acc_gr, X_AXIS);
  82            accumul_acc_space += acc_ext.length();
  83         }
  84
  85       move_related_items_to_column (current, first->get_column (),
  86                                     min_length);
  87
  88       // check if we have any dots
  89       if (size_t const dot_count = Rhythmic_head::dot_count (current))
  90         {
  91           Grob *dot_gr = Rhythmic_head::get_dots (current);
  92
  93           head_width += Font_interface::get_default_font (current)->
  94               find_by_name ("dots.dotkievan").extent (X_AXIS).length() -
  95               0.5 * (padding - accumul_acc_space);
  96
  97           dot_gr->translate_axis (0.5 * (padding - accumul_acc_space), X_AXIS);
  98         }
  99
 100       // add more padding if we have an accidental coming up
 101       if (i < primitives.size () - 1)
 102         {
 103            Item *next = dynamic_cast<Item *> (primitives[i + 1].grob ());
 104            Grob *acc_gr = unsmob<Grob> (next->get_object ("accidental-grob"));
 105            if (acc_gr)
 106              {
 107                 Interval acc_ext = acc_gr->extent (acc_gr, X_AXIS);
 108                 padding += acc_ext.length();
 109              }
 110         }
 111
 112       min_length += head_width + padding - accumul_acc_space;
 113
 114     }
 115
 116 }
 117
 118 void
 119 Kievan_ligature_engraver::build_ligature (Spanner *ligature,
 120                                             vector<Grob_info> const &primitives)
 121 {
 122   Real min_length;
 123
 124   Real padding = robust_scm2double (ligature->get_property ("padding"), 0.0);
 125   fold_up_primitives (primitives, padding, min_length);
 126   if (robust_scm2double (ligature->get_property ("minimum-length"), 0.0)
 127       < min_length)
 128     ligature->set_property ("minimum-length", scm_from_double (min_length));
 129
 130 }
 131
 132
 133 void
 134 Kievan_ligature_engraver::boot ()
 135 {
 136   ADD_LISTENER (Kievan_ligature_engraver, ligature);
 137   ADD_ACKNOWLEDGER (Kievan_ligature_engraver, rest);
 138   ADD_ACKNOWLEDGER (Kievan_ligature_engraver, ligature_head);
 139 }
 140
 141 ADD_TRANSLATOR (Kievan_ligature_engraver,
 142                 /* doc */
 143                 "Handle @code{Kievan_ligature_events} by glueing Kievan"
 144                 " heads together.",
 145
 146                 /* create */
 147                 "KievanLigature ",
 148
 149                 /* read */
 150                 "",
 151
 152                 /* write */
 153                 ""
 154                );