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