lily/spacing-basic.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2005--2011 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 Real
 105 Spacing_spanner::note_spacing (Grob * /* me */,
 106                                Grob *lc,
 107                                Grob *rc,
 108                                Spacing_options const *options)
 109 {
 110   Moment shortest_playing_len = 0;
 111   SCM s = lc->get_property ("shortest-playing-duration");
 112
 113   if (unsmob_moment (s))
 114     shortest_playing_len = *unsmob_moment (s);
 115
 116   if (! shortest_playing_len.to_bool ())
 117     {
 118       programming_error ("cannot find a ruling note at: " + Paper_column::when_mom (lc).to_string ());
 119       shortest_playing_len = 1;
 120     }
 121
 122   Moment lwhen = Paper_column::when_mom (lc);
 123   Moment rwhen = Paper_column::when_mom (rc);
 124
 125   Moment delta_t = rwhen - lwhen;
 126
 127   /*
 128     when toying with mmrests, it is possible to have musical
 129     column on the left and non-musical on the right, spanning
 130     several measures.
 131
 132     TODO: efficiency: measure length can be cached, or stored as
 133     property in paper-column.
 134   */
 135
 136   if (Moment *measure_len = get_measure_length (lc))
 137     {
 138       delta_t = min (delta_t, *measure_len);
 139
 140       /*
 141         The following is an extra safety measure, such that
 142         the length of a mmrest event doesn't cause havoc.
 143       */
 144       shortest_playing_len = min (shortest_playing_len, *measure_len);
 145     }
 146
 147   Real dist = 0.0;
 148   if (delta_t.main_part_ && !lwhen.grace_part_)
 149     {
 150       dist = options->get_duration_space (shortest_playing_len.main_part_);
 151       dist *= double (delta_t.main_part_ / shortest_playing_len.main_part_);
 152     }
 153   else if (delta_t.grace_part_)
 154     {
 155       /*
 156         Crude hack for spacing graces: we take the shortest space
 157         available (namely the space for the global shortest note), and
 158         multiply that by grace-space-factor
 159       */
 160       dist = options->get_duration_space (options->global_shortest_) / 2.0;
 161       Grob *grace_spacing = unsmob_grob (lc->get_object ("grace-spacing"));
 162       if (grace_spacing)
 163         {
 164           Spacing_options grace_opts;
 165           grace_opts.init_from_grob (grace_spacing);
 166           dist = grace_opts.get_duration_space (delta_t.grace_part_);
 167         }
 168
 169     }
 170
 171   return dist;
 172 }
 173