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