lily/spacing-basic.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2005--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
   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 "spacing-spanner.hh"
  21
  22 #include "spacing-options.hh"
  23 #include "moment.hh"
  24 #include "paper-column.hh"
  25 #include "warn.hh"
  26 #include "pointer-group-interface.hh"
  27 #include "system.hh"
  28 #include "spacing-interface.hh"
  29 #include "spring.hh"
  30
  31 /*
  32   LilyPond spaces by taking a simple-minded spacing algorithm, and
  33   adding subtle adjustments to that. This file does the simple-minded
  34   spacing routines.
  35 */
  36 /*
  37   The one-size-fits all spacing. It doesn't take into account
  38   different spacing wishes from one to the next column.
  39 */
  40 Spring
  41 Spacing_spanner::standard_breakable_column_spacing (Grob *me, Item *l, Item *r, Spacing_options const *options)
  42 {
  43   Real min_dist = max (0.0, Paper_column::minimum_distance (l, r));
  44
  45   if (Paper_column::is_breakable (l) && Paper_column::is_breakable (r))
  46     {
  47       Moment *dt = unsmob<Moment> (l->get_property ("measure-length"));
  48       Moment mlen (1);
  49       if (dt)
  50         mlen = *dt;
  51
  52       Real incr = robust_scm2double (me->get_property ("spacing-increment"), 1);
  53       Real space = incr * double (mlen.main_part_ / options->global_shortest_) * 0.8;
  54       Spring spring = Spring (min_dist + space, min_dist);
  55
  56       /*
  57         By default, the spring will have an inverse_stretch_strength of space+min_dist.
  58         However, we don't want stretchability to scale with min_dist or else an
  59         empty first measure on a line (which has a large min_dist because of the clef)
  60         will stretch much more than an empty measure later in the line.
  61       */
  62       spring.set_inverse_stretch_strength (space);
  63       return spring;
  64     }
  65
  66   Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
  67   Real ideal;
  68
  69   if (dt == Moment (0, 0))
  70     {
  71       /*
  72         In this case, Staff_spacing should handle the job,
  73         using dt when it is 0 is silly.
  74       */
  75       ideal = min_dist + 0.5;
  76     }
  77   else
  78     ideal = min_dist + options->get_duration_space (dt.main_part_);
  79
  80   return Spring (ideal, min_dist);
  81 }
  82
  83 Moment *
  84 get_measure_length (Grob *column)
  85 {
  86   Grob *sys = column->get_parent (X_AXIS);
  87
  88   extract_grob_set (sys, "columns", cols);
  89
  90   vsize col_idx = Paper_column::get_rank (column);
  91
  92   do
  93     {
  94       if (Moment *len = unsmob<Moment> (cols[col_idx]->get_property ("measure-length")))
  95         {
  96           return len;
  97         }
  98     }
  99   while (col_idx-- != 0);
 100
 101   return 0;
 102 }
 103
 104 /* Basic spring based on duration alone */
 105 Spring
 106 Spacing_spanner::note_spacing (Grob * /* me */,
 107                                Grob *lc,
 108                                Grob *rc,
 109                                Spacing_options const *options)
 110 {
 111   Moment shortest_playing_len = 0;
 112   SCM s = lc->get_property ("shortest-playing-duration");
 113
 114   if (unsmob<Moment> (s))
 115     shortest_playing_len = *unsmob<Moment> (s);
 116
 117   if (! shortest_playing_len.to_bool ())
 118     {
 119       programming_error ("cannot find a ruling note at: " + Paper_column::when_mom (lc).to_string ());
 120       shortest_playing_len = 1;
 121     }
 122
 123   Moment lwhen = Paper_column::when_mom (lc);
 124   Moment rwhen = Paper_column::when_mom (rc);
 125
 126   Moment delta_t = rwhen - lwhen;
 127
 128   /*
 129     when toying with mmrests, it is possible to have musical
 130     column on the left and non-musical on the right, spanning
 131     several measures.
 132
 133     TODO: efficiency: measure length can be cached, or stored as
 134     property in paper-column.
 135   */
 136
 137   if (Moment *measure_len = get_measure_length (lc))
 138     {
 139       delta_t = min (delta_t, *measure_len);
 140
 141       /*
 142         The following is an extra safety measure, such that
 143         the length of a mmrest event doesn't cause havoc.
 144       */
 145       shortest_playing_len = min (shortest_playing_len, *measure_len);
 146     }
 147
 148   Spring ret;
 149   if (delta_t.main_part_ && !lwhen.grace_part_)
 150     {
 151       // A spring of length and stiffness based on the controlling duration
 152       Real len = options->get_duration_space (shortest_playing_len.main_part_);
 153       Real min = options->increment_;  // canonical notehead width
 154
 155       // The portion of that spring proportional to the time between lc and rc
 156       Real fraction = (delta_t.main_part_ / shortest_playing_len.main_part_);
 157       ret = Spring (fraction * len, fraction * min);
 158
 159       // Stretch proportional to the space between canonical bare noteheads
 160       ret.set_inverse_stretch_strength (fraction * max (0.1, (len - min)));
 161     }
 162   else if (delta_t.grace_part_)
 163     {
 164       Grob *grace_spacing = unsmob<Grob> (lc->get_object ("grace-spacing"));
 165       if (grace_spacing)
 166         {
 167           Spacing_options grace_opts;
 168           grace_opts.init_from_grob (grace_spacing);
 169           Real len = grace_opts.get_duration_space (delta_t.grace_part_);
 170           Real min = grace_opts.increment_;
 171           ret = Spring (len, min);
 172           // Grace notes should not stretch very much
 173           ret.set_inverse_stretch_strength (grace_opts.increment_ / 2.0);
 174         }
 175       else // Fallback to the old grace spacing: half that of the shortest note
 176         ret = Spring (options->
 177                       get_duration_space (options->global_shortest_) / 2.0,
 178                       options->increment_ / 2.0);
 179     }
 180
 181   return ret;
 182 }
 183