lily/spacing-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1999--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 "engraver.hh"
  21 #include "moment.hh"
  22 #include "note-spacing.hh"
  23 #include "paper-column.hh"
  24 #include "pointer-group-interface.hh"
  25 #include "pqueue.hh"
  26 #include "spanner.hh"
  27 #include "staff-spacing.hh"
  28 #include "stream-event.hh"
  29
  30 #include "translator.icc"
  31
  32 struct Rhythmic_tuple
  33 {
  34   Grob_info info_;
  35   Moment end_;
  36
  37   Rhythmic_tuple ()
  38   {
  39   }
  40   Rhythmic_tuple (Grob_info i, Moment m)
  41   {
  42     info_ = i;
  43     end_ = m;
  44   }
  45   static int time_compare (Rhythmic_tuple const &, Rhythmic_tuple const &);
  46 };
  47
  48 inline int
  49 compare (Rhythmic_tuple const &a, Rhythmic_tuple const &b)
  50 {
  51   return Rhythmic_tuple::time_compare (a, b);
  52 }
  53
  54 int
  55 Rhythmic_tuple::time_compare (Rhythmic_tuple const &h1,
  56                               Rhythmic_tuple const &h2)
  57 {
  58   return (h1.end_ - h2.end_).main_part_.sign ();
  59 }
  60
  61 /****************************************************************/
  62
  63 /*
  64   Acknowledge rhythmic elements, for initializing spacing fields in
  65   the columns.
  66 */
  67 class Spacing_engraver : public Engraver
  68 {
  69   PQueue<Rhythmic_tuple> playing_durations_;
  70   vector<Rhythmic_tuple> now_durations_;
  71   vector<Rhythmic_tuple> stopped_durations_;
  72   Moment now_;
  73   Spanner *spacing_;
  74   Stream_event *start_section_;
  75
  76   TRANSLATOR_DECLARATIONS (Spacing_engraver);
  77
  78 protected:
  79   void acknowledge_staff_spacing (Grob_info);
  80   void acknowledge_note_spacing (Grob_info);
  81   void acknowledge_rhythmic_head (Grob_info);
  82   void acknowledge_rhythmic_grob (Grob_info);
  83   void listen_spacing_section (Stream_event *);
  84
  85   void start_translation_timestep ();
  86   void stop_translation_timestep ();
  87   void process_music ();
  88   void add_starter_duration (Grob_info i);
  89
  90   virtual void finalize ();
  91
  92   void start_spanner ();
  93   void stop_spanner ();
  94 };
  95
  96 Spacing_engraver::Spacing_engraver ()
  97 {
  98   spacing_ = 0;
  99   start_section_ = 0;
 100 }
 101
 102 void
 103 Spacing_engraver::listen_spacing_section (Stream_event *ev)
 104 {
 105   ASSIGN_EVENT_ONCE (start_section_, ev);
 106 }
 107
 108 void
 109 Spacing_engraver::process_music ()
 110 {
 111   if (start_section_ && spacing_)
 112     stop_spanner ();
 113
 114   if (!spacing_)
 115     start_spanner ();
 116 }
 117
 118 void
 119 Spacing_engraver::start_spanner ()
 120 {
 121   assert (!spacing_);
 122
 123   spacing_ = make_spanner ("SpacingSpanner", SCM_EOL);
 124   spacing_->set_bound (LEFT,
 125                        unsmob<Grob> (get_property ("currentCommandColumn")));
 126 }
 127
 128 void
 129 Spacing_engraver::finalize ()
 130 {
 131   stop_spanner ();
 132 }
 133
 134 void
 135 Spacing_engraver::stop_spanner ()
 136 {
 137   if (spacing_)
 138     {
 139       Grob *p = unsmob<Grob> (get_property ("currentCommandColumn"));
 140
 141       spacing_->set_bound (RIGHT, p);
 142       spacing_ = 0;
 143     }
 144 }
 145
 146 void
 147 Spacing_engraver::acknowledge_note_spacing (Grob_info i)
 148 {
 149   Pointer_group_interface::add_grob (spacing_, ly_symbol2scm ("wishes"), i.grob ());
 150 }
 151
 152 void
 153 Spacing_engraver::acknowledge_staff_spacing (Grob_info i)
 154 {
 155   Pointer_group_interface::add_grob (spacing_, ly_symbol2scm ("wishes"), i.grob ());
 156 }
 157
 158 void
 159 Spacing_engraver::acknowledge_rhythmic_grob (Grob_info i)
 160 {
 161   add_starter_duration (i);
 162 }
 163
 164 void
 165 Spacing_engraver::acknowledge_rhythmic_head (Grob_info i)
 166 {
 167   add_starter_duration (i);
 168 }
 169
 170 void
 171 Spacing_engraver::add_starter_duration (Grob_info i)
 172 {
 173   if (i.grob ()->internal_has_interface (ly_symbol2scm ("lyric-syllable-interface"))
 174       || i.grob ()->internal_has_interface (ly_symbol2scm ("multi-measure-interface")))
 175     return;
 176
 177   /*
 178     only pay attention to durations that are not grace notes.
 179   */
 180   if (!now_.grace_part_)
 181     {
 182       Stream_event *r = i.event_cause ();
 183       if (r && r->in_event_class ("rhythmic-event"))
 184         {
 185           Moment len = get_event_length (r, now_);
 186           Rhythmic_tuple t (i, now_mom () + len);
 187           now_durations_.push_back (t);
 188         }
 189     }
 190 }
 191
 192 void
 193 Spacing_engraver::stop_translation_timestep ()
 194 {
 195   Paper_column *musical_column
 196     = unsmob<Paper_column> (get_property ("currentMusicalColumn"));
 197
 198   if (!spacing_)
 199     start_spanner ();
 200
 201   musical_column->set_object ("spacing", spacing_->self_scm ());
 202   unsmob<Grob> (get_property ("currentCommandColumn"))
 203   ->set_object ("spacing", spacing_->self_scm ());
 204
 205   SCM proportional = get_property ("proportionalNotationDuration");
 206   if (unsmob<Moment> (proportional))
 207     {
 208       musical_column->set_property ("shortest-playing-duration", proportional);
 209       musical_column->set_property ("shortest-starter-duration", proportional);
 210       musical_column->set_property ("used", SCM_BOOL_T);
 211       return;
 212     }
 213
 214   Moment shortest_playing;
 215   shortest_playing.set_infinite (1);
 216   for (vsize i = 0; i < playing_durations_.size (); i++)
 217     {
 218       Stream_event *ev = playing_durations_[i].info_.event_cause ();
 219       if (ev)
 220         {
 221           Moment m = get_event_length (ev);
 222           shortest_playing = min (shortest_playing, m);
 223         }
 224     }
 225   Moment starter;
 226   starter.set_infinite (1);
 227
 228   for (vsize i = 0; i < now_durations_.size (); i++)
 229     {
 230       Moment m = get_event_length (now_durations_[i].info_.event_cause ());
 231       if (m.to_bool ())
 232         {
 233           starter = min (starter, m);
 234           playing_durations_.insert (now_durations_[i]);
 235         }
 236     }
 237   now_durations_.clear ();
 238
 239   shortest_playing = min (shortest_playing, starter);
 240
 241   assert (starter.to_bool ());
 242   SCM sh = shortest_playing.smobbed_copy ();
 243   SCM st = starter.smobbed_copy ();
 244
 245   musical_column->set_property ("shortest-playing-duration", sh);
 246   musical_column->set_property ("shortest-starter-duration", st);
 247 }
 248
 249 void
 250 Spacing_engraver::start_translation_timestep ()
 251 {
 252   start_section_ = 0;
 253
 254   now_ = now_mom ();
 255   stopped_durations_.clear ();
 256
 257   while (playing_durations_.size () && playing_durations_.front ().end_ < now_)
 258     playing_durations_.delmin ();
 259   while (playing_durations_.size () && playing_durations_.front ().end_ == now_)
 260     stopped_durations_.push_back (playing_durations_.get ());
 261 }
 262
 263
 264 void
 265 Spacing_engraver::boot ()
 266 {
 267   ADD_LISTENER (Spacing_engraver, spacing_section);
 268   ADD_ACKNOWLEDGER (Spacing_engraver, staff_spacing);
 269   ADD_ACKNOWLEDGER (Spacing_engraver, note_spacing);
 270   ADD_ACKNOWLEDGER (Spacing_engraver, rhythmic_head);
 271   ADD_ACKNOWLEDGER (Spacing_engraver, rhythmic_grob);
 272 }
 273
 274 ADD_TRANSLATOR (Spacing_engraver,
 275                 /* doc */
 276                 "Make a @code{SpacingSpanner} and do bookkeeping of shortest"
 277                 " starting and playing notes.",
 278
 279                 /* create */
 280                 "SpacingSpanner ",
 281
 282                 /* read */
 283                 "currentMusicalColumn "
 284                 "currentCommandColumn "
 285                 "proportionalNotationDuration ",
 286
 287                 /* write */
 288                 ""
 289                );