lily/fingering-column.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2012 Mike Solomon <mike@mikesolomon.org>
   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 "directional-element-interface.hh"
  21 #include "grob.hh"
  22 #include "fingering-column.hh"
  23 #include "pointer-group-interface.hh"
  24 #include "staff-symbol-referencer.hh"
  25 #include "item.hh"
  26 #include "paper-column.hh"
  27
  28 using std::vector;
  29
  30 #define EPS 1e-5
  31
  32 struct Fingering_and_offset
  33 {
  34   Grob *fingering_;
  35   Real offset_;
  36   Fingering_and_offset (Grob *fingering, Real offset);
  37 };
  38
  39 Fingering_and_offset::Fingering_and_offset (Grob *fingering, Real offset) :
  40   fingering_ (fingering), offset_ (offset)
  41 {
  42 }
  43
  44 bool
  45 fingering_and_offset_less (Fingering_and_offset fo0, Fingering_and_offset fo1)
  46 {
  47   return fo0.offset_ < fo1.offset_;
  48 }
  49
  50 MAKE_SCHEME_CALLBACK (Fingering_column, calc_positioning_done, 1);
  51 SCM
  52 Fingering_column::calc_positioning_done (SCM smob)
  53 {
  54   Grob *me = unsmob<Grob> (smob);
  55   if (!me->is_live ())
  56     return SCM_BOOL_T;
  57
  58   me->set_property ("positioning-done", SCM_BOOL_T);
  59
  60   do_y_positioning (me);
  61   do_x_positioning (me);
  62
  63   return SCM_BOOL_T;
  64 }
  65
  66 void
  67 Fingering_column::do_y_positioning (Grob *me)
  68 {
  69   extract_grob_set (me, "fingerings", const_fingerings);
  70
  71   if (const_fingerings.size () < 2)
  72     {
  73       me->programming_error ("This FingeringColumn should have never been created.");
  74       return;
  75     }
  76
  77   vector<Grob *> fingerings;
  78   for (vsize i = 0; i < const_fingerings.size (); i++)
  79     fingerings.push_back (const_fingerings[i]);
  80
  81
  82   Grob *common[2] = {common_refpoint_of_array (fingerings, me, X_AXIS),
  83                      common_refpoint_of_array (fingerings, me, Y_AXIS)};
  84
  85   Real padding = robust_scm2double (me->get_property ("padding"), 0.2);
  86
  87   // order the fingerings from bottom to top
  88   vector_sort (fingerings, pure_position_less);
  89
  90  vector<Real> shift(fingerings.size());
  91
  92   // Try stacking the fingerings top-to-bottom, and then bottom-to-top.
  93   // Use the average of the resulting stacked locations as the final positions
  94   for (UP_and_DOWN (d))
  95      {
  96       Real stack_end = -d * infinity_f;
  97       Interval prev_x_ext;
  98       for (vsize i = (d == UP)? 0 : fingerings.size() - 1;
  99            i < fingerings.size ();
 100            i += d)
 101         {
 102           Interval x_ext = fingerings[i]->extent(common[X_AXIS], X_AXIS);
 103           Interval y_ext = fingerings[i]->extent(fingerings[i], Y_AXIS);
 104           Real parent_y = fingerings[i]->get_parent(Y_AXIS)
 105                          ->relative_coordinate(common[Y_AXIS], Y_AXIS);
 106
 107           // Checking only between sequential neighbors, seems good enough
 108           if (!intersection(x_ext, prev_x_ext).is_empty())
 109             stack_end += d * (y_ext.length() + padding);
 110           // minmax() returns whichever is further along in direction d
 111           stack_end = minmax(d, stack_end, parent_y);
 112
 113           shift[i] += 0.5 * (stack_end - y_ext[d] - parent_y);
 114
 115           prev_x_ext = x_ext;
 116         }
 117      }
 118
 119   for (vsize i = 0; i < fingerings.size (); i++)
 120     fingerings[i]->translate_axis(shift[i], Y_AXIS);
 121 }
 122
 123 void
 124 Fingering_column::do_x_positioning (Grob *me)
 125 {
 126   extract_grob_set (me, "fingerings", fingerings);
 127   if (!fingerings.size ())
 128     return;
 129
 130   Grob *common_x = common_refpoint_of_array (fingerings, me, X_AXIS);
 131
 132   Real snap = robust_scm2double (me->get_property ("snap-radius"), 0.3);
 133   vector<Fingering_and_offset> fos;
 134
 135   for (vsize i = 0; i < fingerings.size (); i++)
 136     fos.push_back (Fingering_and_offset (fingerings[i], fingerings[i]->relative_coordinate (common_x, X_AXIS)));
 137
 138   vector_sort (fos, fingering_and_offset_less);
 139   Direction dir = get_grob_direction (fingerings[0]);
 140   if (dir == RIGHT)
 141     reverse (fos);
 142
 143   Real prev = infinity_f * dir;
 144   for (vsize i = 0; i < fos.size (); i++)
 145     {
 146       if ((fabs (fos[i].offset_ - prev) < snap)
 147                 && (fabs (fos[i].offset_ - prev) > EPS))
 148         fos[i].offset_ = prev;
 149
 150       prev = fos[i].offset_;
 151     }
 152
 153   for (vsize i = 0; i < fos.size (); i++)
 154     fos[i].fingering_->translate_axis (fos[i].offset_ - fos[i].fingering_->relative_coordinate (common_x, X_AXIS), X_AXIS);
 155 }
 156
 157 void
 158 Fingering_column::add_fingering (Grob *fc, Grob *f)
 159 {
 160   Pointer_group_interface::add_grob (fc, ly_symbol2scm ("fingerings"), f);
 161   f->set_parent (fc, X_AXIS);
 162   f->set_property ("Y-offset", Grob::x_parent_positioning_proc);
 163 }
 164
 165 ADD_INTERFACE (Fingering_column,
 166                "Makes sure that fingerings placed laterally"
 167                " do not collide and that they are flush if"
 168                " necessary.",
 169
 170                /* properties */
 171                "padding "
 172                "positioning-done "
 173                "snap-radius "
 174               );