lily/spacing-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1999--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 "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   DECLARE_ACKNOWLEDGER (staff_spacing);
  80   DECLARE_ACKNOWLEDGER (note_spacing);
  81   DECLARE_ACKNOWLEDGER (rhythmic_head);
  82   DECLARE_ACKNOWLEDGER (rhythmic_grob);
  83   DECLARE_TRANSLATOR_LISTENER (spacing_section);
  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 IMPLEMENT_TRANSLATOR_LISTENER (Spacing_engraver, spacing_section);
 103 void
 104 Spacing_engraver::listen_spacing_section (Stream_event *ev)
 105 {
 106   ASSIGN_EVENT_ONCE (start_section_, ev);
 107 }
 108
 109 void
 110 Spacing_engraver::process_music ()
 111 {
 112   if (start_section_ && spacing_)
 113     stop_spanner ();
 114
 115   if (!spacing_)
 116     start_spanner ();
 117 }
 118
 119 void
 120 Spacing_engraver::start_spanner ()
 121 {
 122   assert (!spacing_);
 123
 124
 125   spacing_ = make_spanner ("SpacingSpanner", SCM_EOL);
 126   spacing_->set_bound (LEFT,
 127                        unsmob_grob (get_property ("currentCommandColumn")));
 128 }
 129
 130 void
 131 Spacing_engraver::finalize ()
 132 {
 133   stop_spanner ();
 134 }
 135
 136 void
 137 Spacing_engraver::stop_spanner ()
 138 {
 139   if (spacing_)
 140     {
 141       Grob *p = unsmob_grob (get_property ("currentCommandColumn"));
 142
 143       spacing_->set_bound (RIGHT, p);
 144       spacing_ = 0;
 145     }
 146 }
 147
 148 void
 149 Spacing_engraver::acknowledge_note_spacing (Grob_info i)
 150 {
 151   Pointer_group_interface::add_grob (spacing_, ly_symbol2scm ("wishes"), i.grob ());
 152 }
 153
 154 void
 155 Spacing_engraver::acknowledge_staff_spacing (Grob_info i)
 156 {
 157   Pointer_group_interface::add_grob (spacing_, ly_symbol2scm ("wishes"), i.grob ());
 158 }
 159
 160 void
 161 Spacing_engraver::acknowledge_rhythmic_grob (Grob_info i)
 162 {
 163  add_starter_duration (i);
 164 }
 165
 166 void
 167 Spacing_engraver::acknowledge_rhythmic_head (Grob_info i)
 168 {
 169   add_starter_duration (i);
 170 }
 171
 172
 173 void
 174 Spacing_engraver::add_starter_duration (Grob_info i)
 175 {
 176   if (i.grob ()->internal_has_interface (ly_symbol2scm ("lyric-syllable-interface"))
 177       || i.grob ()->internal_has_interface (ly_symbol2scm ("multi-measure-interface")))
 178     return;
 179
 180   /*
 181     only pay attention to durations that are not grace notes.
 182   */
 183   if (!now_.grace_part_)
 184     {
 185       Stream_event *r = i.event_cause ();
 186       if (r && r->in_event_class ("rhythmic-event"))
 187         {
 188           Moment len = get_event_length (r, now_);
 189           Rhythmic_tuple t (i, now_mom () + len);
 190           now_durations_.push_back (t);
 191         }
 192     }
 193 }
 194
 195 void
 196 Spacing_engraver::stop_translation_timestep ()
 197 {
 198   Paper_column *musical_column
 199     = dynamic_cast<Paper_column *> (unsmob_grob (get_property ("currentMusicalColumn")));
 200
 201
 202   if (!spacing_)
 203     start_spanner ();
 204
 205   musical_column->set_object ("spacing", spacing_->self_scm ());
 206   unsmob_grob (get_property ("currentCommandColumn"))
 207     ->set_object ("spacing", spacing_->self_scm ());
 208
 209   SCM proportional = get_property ("proportionalNotationDuration");
 210   if (unsmob_moment (proportional))
 211     {
 212       musical_column->set_property ("shortest-playing-duration", proportional);
 213       musical_column->set_property ("shortest-starter-duration", proportional);
 214       musical_column->set_property ("used", SCM_BOOL_T);
 215       return;
 216     }
 217
 218   Moment shortest_playing;
 219   shortest_playing.set_infinite (1);
 220   for (vsize i = 0; i < playing_durations_.size (); i++)
 221     {
 222       Stream_event *ev = playing_durations_[i].info_.event_cause ();
 223       if (ev)
 224         {
 225           Moment now = now_mom ();
 226           Moment m = get_event_length (ev);
 227           shortest_playing = min (shortest_playing, m);
 228         }
 229     }
 230   Moment starter;
 231   starter.set_infinite (1);
 232
 233   for (vsize i = 0; i < now_durations_.size (); i++)
 234     {
 235       Moment m = get_event_length (now_durations_[i].info_.event_cause ());
 236       if (m.to_bool ())
 237         {
 238           starter = min (starter, m);
 239           playing_durations_.insert (now_durations_[i]);
 240         }
 241     }
 242   now_durations_.clear ();
 243
 244   shortest_playing = min (shortest_playing, starter);
 245
 246   assert (starter.to_bool ());
 247   SCM sh = shortest_playing.smobbed_copy ();
 248   SCM st = starter.smobbed_copy ();
 249
 250   musical_column->set_property ("shortest-playing-duration", sh);
 251   musical_column->set_property ("shortest-starter-duration", st);
 252 }
 253
 254
 255
 256 void
 257 Spacing_engraver::start_translation_timestep ()
 258 {
 259   start_section_ = 0;
 260
 261   now_ = now_mom ();
 262   stopped_durations_.clear ();
 263
 264   while (playing_durations_.size () && playing_durations_.front ().end_ < now_)
 265     playing_durations_.delmin ();
 266   while (playing_durations_.size () && playing_durations_.front ().end_ == now_)
 267     stopped_durations_.push_back (playing_durations_.get ());
 268 }
 269
 270 ADD_ACKNOWLEDGER (Spacing_engraver, staff_spacing);
 271 ADD_ACKNOWLEDGER (Spacing_engraver, note_spacing);
 272 ADD_ACKNOWLEDGER (Spacing_engraver, rhythmic_head);
 273 ADD_ACKNOWLEDGER (Spacing_engraver, rhythmic_grob);
 274
 275 ADD_TRANSLATOR (Spacing_engraver,
 276                 /* doc */
 277                 "Make a @code{SpacingSpanner} and do bookkeeping of shortest"
 278                 " starting and playing notes.",
 279
 280                 /* create */
 281                 "SpacingSpanner ",
 282
 283                 /* read */
 284                 "currentMusicalColumn "
 285                 "currentCommandColumn "
 286                 "proportionalNotationDuration ",
 287
 288                 /* write */
 289                 ""
 290                 );