lily/unfolded-repeat-iterator.cc

   1 /*
   2 unfolded-repeat-iterator.cc --  implement Unfolded_repeat_iterator, Volta_repeat_iterator
   3
   4 source file of the GNU LilyPond music typesetter
   5
   6
   7 (c) 2002--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   8 */
   9
  10
  11 #include "music.hh"
  12 #include "sequential-iterator.hh"
  13 #include "context.hh"
  14
  15 class Unfolded_repeat_iterator : public Sequential_iterator
  16 {
  17 public:
  18   DECLARE_SCHEME_CALLBACK (constructor, ());
  19 protected:
  20   virtual SCM get_music_list () const;
  21 };
  22
  23
  24 SCM
  25 Unfolded_repeat_iterator::get_music_list () const
  26 {
  27   SCM l = SCM_EOL;
  28   SCM *tail = &l;
  29
  30   SCM body = get_music ()->get_property ("element");
  31   SCM alts = get_music ()->get_property ("elements");
  32   int alt_count = scm_ilength (alts);
  33   int rep_count = ly_scm2int (get_music ()->get_property ("repeat-count"));
  34
  35   for (int i = 0; i < rep_count; i++)
  36     {
  37       if (unsmob_music (body))
  38         *tail = scm_cons (body, SCM_EOL) ;
  39
  40       tail = SCM_CDRLOC (*tail);
  41
  42       if (alt_count)
  43         {
  44           *tail = scm_cons (ly_car (alts), SCM_EOL);
  45           tail = SCM_CDRLOC (*tail);
  46           if (i >= rep_count - alt_count)
  47
  48             alts = ly_cdr (alts);
  49         }
  50     }
  51
  52   return l;
  53 }
  54
  55 class Volta_repeat_iterator : public Sequential_iterator
  56 {
  57 public:
  58   DECLARE_SCHEME_CALLBACK (constructor, ());
  59   Volta_repeat_iterator ();
  60
  61   void add_repeat_command (SCM);
  62 protected:
  63   virtual SCM get_music_list () const;
  64   virtual void next_element (bool);
  65   virtual void construct_children ();
  66   virtual void process (Moment);
  67
  68   bool first_time_;
  69   int alt_count_;
  70   int rep_count_;
  71   int done_count_;
  72 };
  73
  74
  75 Volta_repeat_iterator::Volta_repeat_iterator ()
  76 {
  77   done_count_ = alt_count_ = rep_count_= 0;
  78   first_time_ = true;
  79 }
  80
  81 SCM
  82 Volta_repeat_iterator::get_music_list ()const
  83 {
  84   return scm_cons (get_music ()->get_property ("element"),
  85                   get_music ()->get_property ("elements"));
  86 }
  87
  88 void
  89 Volta_repeat_iterator::construct_children ()
  90 {
  91   Sequential_iterator::construct_children ();
  92
  93   SCM alts = get_music ()->get_property ("elements");
  94
  95   alt_count_ = scm_ilength (alts);
  96   rep_count_ = ly_scm2int (get_music ()->get_property ("repeat-count"));
  97   done_count_ = 0;
  98 }
  99
 100
 101 /*
 102   TODO: add source information for debugging
 103  */
 104 void
 105 Volta_repeat_iterator::add_repeat_command (SCM what)
 106 {
 107   SCM reps = ly_symbol2scm ("repeatCommands");
 108   SCM current_reps = get_outlet ()->internal_get_property (reps);
 109
 110   Context * where = get_outlet ()->where_defined (reps);
 111   if (where
 112       && current_reps == SCM_EOL || ly_pair_p (current_reps))
 113     {
 114       current_reps = scm_cons (what, current_reps);
 115       where->internal_set_property (reps, current_reps);
 116     }
 117 }
 118
 119
 120 void
 121 Volta_repeat_iterator::next_element (bool side_effect)
 122 {
 123   done_count_ ++;
 124
 125   Sequential_iterator::next_element (side_effect);
 126
 127   if (side_effect)
 128     {
 129       if (alt_count_)
 130         {
 131           String repstr = to_string (rep_count_ - alt_count_ + done_count_) + ".";
 132           if (done_count_ > 1)
 133             {
 134               add_repeat_command (scm_list_n (ly_symbol2scm ("volta"), SCM_BOOL_F, SCM_UNDEFINED));
 135
 136               if (done_count_ - 1 < alt_count_)
 137                 add_repeat_command (ly_symbol2scm ("end-repeat"));
 138             }
 139
 140
 141
 142           if (done_count_ == 1 && alt_count_ < rep_count_)
 143             {
 144               repstr = "1.--" + to_string (rep_count_ - alt_count_ + done_count_) + ".";
 145             }
 146
 147           if (done_count_ <= alt_count_)
 148             add_repeat_command (scm_list_n (ly_symbol2scm ("volta"),
 149                                             scm_makfrom0str (repstr.to_str0 ()), SCM_UNDEFINED));
 150         }
 151       else
 152         {
 153           add_repeat_command (ly_symbol2scm ("end-repeat"));
 154         }
 155     }
 156 }
 157
 158
 159 void
 160 Volta_repeat_iterator::process (Moment m)
 161 {
 162   if (first_time_)
 163     {
 164       add_repeat_command (ly_symbol2scm ("start-repeat"));
 165       first_time_ = false;
 166     }
 167   Sequential_iterator::process (m);
 168 }
 169
 170
 171 IMPLEMENT_CTOR_CALLBACK (Volta_repeat_iterator);
 172 IMPLEMENT_CTOR_CALLBACK (Unfolded_repeat_iterator);