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 ()
  49 {
  50
  51 }
  52
  53 Spanner *
  54 Kievan_ligature_engraver::create_ligature_spanner ()
  55 {
  56   return make_spanner ("KievanLigature", SCM_EOL);
  57 }
  58
  59 void
  60 Kievan_ligature_engraver::fold_up_primitives (vector<Grob_info> const &primitives,
  61                                                 Real padding, Real &min_length)
  62 {
  63   Item *first = 0;
  64   Real accumul_acc_space = 0.0;
  65   // start us off with some padding on the left
  66   min_length = padding;
  67
  68   for (vsize i = 0; i < primitives.size (); i++)
  69     {
  70       Item *current = dynamic_cast<Item *> (primitives[i].grob ());
  71       Interval my_ext = current->extent (current, X_AXIS);
  72       Real head_width = my_ext.length ();
  73       if (i == 0)
  74          first = current;
  75
  76       // must keep track of accidentals in spacing problem
  77       Grob *acc_gr = unsmob<Grob> (current->get_object ("accidental-grob"));
  78       if (acc_gr && i > 0)
  79         {
  80            Interval acc_ext = acc_gr->extent (acc_gr, X_AXIS);
  81            accumul_acc_space += acc_ext.length();
  82         }
  83
  84       move_related_items_to_column (current, first->get_column (),
  85                                     min_length);
  86
  87       // check if we have any dots
  88       if (size_t const dot_count = Rhythmic_head::dot_count (current))
  89         {
  90           Grob *dot_gr = Rhythmic_head::get_dots (current);
  91
  92           head_width += Font_interface::get_default_font (current)->
  93               find_by_name ("dots.dotkievan").extent (X_AXIS).length() -
  94               0.5 * (padding - accumul_acc_space);
  95
  96           dot_gr->translate_axis (0.5 * (padding - accumul_acc_space), X_AXIS);
  97         }
  98
  99       // add more padding if we have an accidental coming up
 100       if (i < primitives.size () - 1)
 101         {
 102            Item *next = dynamic_cast<Item *> (primitives[i + 1].grob ());
 103            Grob *acc_gr = unsmob<Grob> (next->get_object ("accidental-grob"));
 104            if (acc_gr)
 105              {
 106                 Interval acc_ext = acc_gr->extent (acc_gr, X_AXIS);
 107                 padding += acc_ext.length();
 108              }
 109         }
 110
 111       min_length += head_width + padding - accumul_acc_space;
 112
 113     }
 114
 115 }
 116
 117 void
 118 Kievan_ligature_engraver::build_ligature (Spanner *ligature,
 119                                             vector<Grob_info> const &primitives)
 120 {
 121   Real min_length;
 122
 123   Real padding = robust_scm2double (ligature->get_property ("padding"), 0.0);
 124   fold_up_primitives (primitives, padding, min_length);
 125   if (robust_scm2double (ligature->get_property ("minimum-length"), 0.0)
 126       < min_length)
 127     ligature->set_property ("minimum-length", scm_from_double (min_length));
 128
 129 }
 130
 131
 132 void
 133 Kievan_ligature_engraver::boot ()
 134 {
 135   ADD_LISTENER (Kievan_ligature_engraver, ligature);
 136   ADD_ACKNOWLEDGER (Kievan_ligature_engraver, rest);
 137   ADD_ACKNOWLEDGER (Kievan_ligature_engraver, ligature_head);
 138 }
 139
 140 ADD_TRANSLATOR (Kievan_ligature_engraver,
 141                 /* doc */
 142                 "Handle @code{Kievan_ligature_events} by glueing Kievan"
 143                 " heads together.",
 144
 145                 /* create */
 146                 "KievanLigature ",
 147
 148                 /* read */
 149                 "",
 150
 151                 /* write */
 152                 ""
 153                );