lily/spacing-basic.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 2005--2010 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   Real ideal;
  45
  46   if (Paper_column::is_breakable (l) && Paper_column::is_breakable (r))
  47     {
  48       Moment *dt = unsmob_moment (l->get_property ("measure-length"));
  49       Moment mlen (1);
  50       if (dt)
  51         mlen = *dt;
  52
  53       Real incr = robust_scm2double (me->get_property ("spacing-increment"), 1);
  54
  55       ideal = min_dist + incr * double (mlen.main_part_ / options->global_shortest_) * 0.8;
  56     }
  57   else
  58     {
  59       Moment dt = Paper_column::when_mom (r) - Paper_column::when_mom (l);
  60
  61       if (dt == Moment (0, 0))
  62         {
  63           /*
  64             In this case, Staff_spacing should handle the job,
  65             using dt when it is 0 is silly.
  66           */
  67           ideal = min_dist + 0.5;
  68         }
  69       else
  70         ideal = min_dist + options->get_duration_space (dt.main_part_);
  71     }
  72   return Spring (ideal, min_dist);
  73 }
  74
  75 Moment *
  76 get_measure_length (Grob *column)
  77 {
  78   Grob * sys = column->get_parent (X_AXIS);
  79
  80   extract_grob_set (sys, "columns", cols);
  81
  82   vsize col_idx = Paper_column::get_rank (column);
  83
  84   do
  85     {
  86       if (Moment *len = unsmob_moment (cols[col_idx]->get_property ("measure-length")))
  87         {
  88           return len;
  89         }
  90     }
  91   while (col_idx-- != 0);
  92
  93   return 0;
  94 }
  95
  96 Real
  97 Spacing_spanner::note_spacing (Grob * /* me */,
  98                                Grob *lc,
  99                                Grob *rc,
 100                                Spacing_options const *options)
 101 {
 102   Moment shortest_playing_len = 0;
 103   SCM s = lc->get_property ("shortest-playing-duration");
 104
 105   if (unsmob_moment (s))
 106     shortest_playing_len = *unsmob_moment (s);
 107
 108   if (! shortest_playing_len.to_bool ())
 109     {
 110       programming_error ("cannot find a ruling note at: " + Paper_column::when_mom (lc).to_string ());
 111       shortest_playing_len = 1;
 112     }
 113
 114   Moment lwhen = Paper_column::when_mom (lc);
 115   Moment rwhen = Paper_column::when_mom (rc);
 116
 117   Moment delta_t = rwhen - lwhen;
 118
 119   /*
 120     when toying with mmrests, it is possible to have musical
 121     column on the left and non-musical on the right, spanning
 122     several measures.
 123
 124     TODO: efficiency: measure length can be cached, or stored as
 125     property in paper-column.
 126   */
 127
 128   if (Moment *measure_len = get_measure_length (lc))
 129     {
 130       delta_t = min (delta_t, *measure_len);
 131
 132       /*
 133         The following is an extra safety measure, such that
 134         the length of a mmrest event doesn't cause havoc.
 135       */
 136       shortest_playing_len = min (shortest_playing_len, *measure_len);
 137     }
 138
 139   Real dist = 0.0;
 140   if (delta_t.main_part_ && !lwhen.grace_part_)
 141     {
 142       dist = options->get_duration_space (shortest_playing_len.main_part_);
 143       dist *= double (delta_t.main_part_ / shortest_playing_len.main_part_);
 144     }
 145   else if (delta_t.grace_part_)
 146     {
 147       /*
 148         Crude hack for spacing graces: we take the shortest space
 149         available (namely the space for the global shortest note), and
 150         multiply that by grace-space-factor
 151       */
 152       dist = options->get_duration_space (options->global_shortest_) / 2.0;
 153       Grob *grace_spacing = unsmob_grob (lc->get_object ("grace-spacing"));
 154       if (grace_spacing)
 155         {
 156           Spacing_options grace_opts;
 157           grace_opts.init_from_grob (grace_spacing);
 158           dist = grace_opts.get_duration_space (delta_t.grace_part_);
 159         }
 160
 161     }
 162
 163   return dist;
 164 }
 165