lily/score-engraver.cc

   1 /*
   2   score-grav.cc -- implement Score_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "debug.hh"
  10 #include "dimension-cache.hh"
  11 #include "line-of-score.hh"
  12 #include "item.hh"
  13 #include "score-engraver.hh"
  14 #include "paper-score.hh"
  15 #include "musical-request.hh"
  16 #include "paper-column.hh"
  17 #include "command-request.hh"
  18 #include "paper-def.hh"
  19
  20 ADD_THIS_TRANSLATOR (Score_engraver);
  21
  22 Score_engraver::Score_engraver ()
  23 {
  24   scoreline_l_ =0;
  25   command_column_l_ =0;
  26   musical_column_l_ =0;
  27   breaks_i_ =0;
  28   pscore_p_ = 0;
  29 }
  30
  31 void
  32 Score_engraver::prepare (Moment w)
  33 {
  34   Global_translator::prepare (w);
  35   set_columns (new Paper_column (w),  new Paper_column (w));
  36
  37   command_column_l_->set_elt_property ("breakable", SCM_BOOL_T);
  38   post_move_processing();
  39 }
  40
  41 void
  42 Score_engraver::finish()
  43 {
  44   if ((breaks_i_%8))
  45     progress_indication ("[" + to_str ( breaks_i_) + "]");
  46
  47   check_removal();
  48   removal_processing();
  49 }
  50
  51 /*
  52   use start/finish?
  53  */
  54 void
  55 Score_engraver::do_creation_processing ()
  56 {
  57   scoreline_l_ = pscore_p_->line_l_;
  58
  59   scoreline_l_->set_bounds(LEFT, command_column_l_);
  60
  61   command_column_l_->set_elt_property ("breakable", SCM_BOOL_T);
  62
  63   Engraver_group_engraver::do_creation_processing();
  64 }
  65
  66
  67 void
  68 Score_engraver::do_removal_processing()
  69 {
  70   Engraver_group_engraver::do_removal_processing();
  71   scoreline_l_->set_bounds(RIGHT,command_column_l_);
  72   command_column_l_->set_elt_property ("breakable", SCM_BOOL_T);
  73
  74   typeset_all ();
  75   set_columns (0,0);
  76 }
  77
  78 void
  79 Score_engraver::process()
  80 {
  81   process_requests();
  82   do_announces();
  83   pre_move_processing();
  84   check_removal();
  85 }
  86
  87 void
  88 Score_engraver::announce_element (Score_element_info info)
  89 {
  90   announce_info_arr_.push (info);
  91   info.origin_trans_l_arr_.push (this);
  92   pscore_p_->typeset_element (info.elem_l_);
  93 }
  94
  95 /* All elements are propagated to the top upon announcement. If
  96    something was created during one run of
  97    Engraver_group_engraver::do_announces, then
  98    announce_info_arr_.size() will be nonzero again
  99 */
 100 /* junkme? Done by Engraver_group_engraver::do_announces ()?
 101  */
 102
 103 void
 104 Score_engraver::do_announces()
 105 {
 106   while (announce_info_arr_.size())
 107     Engraver_group_engraver::do_announces();
 108 }
 109
 110
 111 void
 112 Score_engraver::typeset_element (Score_element *elem_p)
 113 {
 114   elem_p_arr_.push (elem_p);
 115 }
 116
 117
 118 void
 119 Score_engraver::typeset_all()
 120 {
 121   for  (int i =0; i < elem_p_arr_.size(); i++)
 122     {
 123       Score_element * elem_p = elem_p_arr_[i];
 124       elem_p->add_processing ();
 125
 126
 127       if (Spanner *s = dynamic_cast <Spanner *> (elem_p))
 128         {
 129             /*
 130             do something sensible if spanner not
 131             spanned on 2 items.
 132            */
 133           Direction d = LEFT;
 134           do {
 135             if (!s->spanned_drul_[d])
 136               {
 137                 s->set_bounds(d, command_column_l_);
 138                 ::warning (_f ("unbound spanner `%s'", classname(s)));
 139               }
 140           } while (flip(&d) != LEFT);
 141         }
 142       else
 143         {
 144           Item *item_p = dynamic_cast <Item *> (elem_p);
 145
 146           if (!item_p->parent_l (X_AXIS))
 147             {
 148               bool br = to_boolean (item_p->remove_elt_property ("breakable"));
 149               if (br)
 150                 command_column_l_->add_element(item_p);
 151               else
 152                 musical_column_l_->add_element(item_p);
 153             }
 154         }
 155       if (!elem_p->parent_l(Y_AXIS))
 156         scoreline_l_->add_element (elem_p);
 157     }
 158   elem_p_arr_.clear();
 159 }
 160
 161 void
 162 Score_engraver::do_pre_move_processing()
 163 {
 164   if (to_boolean (command_column_l_->get_elt_property ("breakable")))
 165     {
 166       breaks_i_ ++;
 167       if (! (breaks_i_%8))
 168         progress_indication ("[" + to_str ( breaks_i_) + "]");
 169     }
 170   // this generates all items.
 171   Engraver_group_engraver::do_pre_move_processing();
 172
 173   typeset_all();
 174 }
 175
 176 void
 177 Score_engraver::set_columns (Paper_column *new_command_l,
 178                              Paper_column *new_musical_l)
 179 {
 180   if (command_column_l_ && command_column_l_->linked_b())
 181     {
 182       pscore_p_->add_column (command_column_l_);
 183       scoreline_l_->add_column (command_column_l_);
 184     }
 185   else
 186     command_column_l_ =0;
 187
 188   if (new_command_l)
 189     command_column_l_ = new_command_l;
 190
 191   if (musical_column_l_ && musical_column_l_->linked_b())
 192     {
 193       pscore_p_->add_column (musical_column_l_);
 194       scoreline_l_->add_column (musical_column_l_);
 195     }
 196   else
 197     musical_column_l_ = 0;
 198
 199   if (new_musical_l)
 200     {
 201       musical_column_l_ = new_musical_l;
 202     }
 203 }
 204
 205 Staff_info
 206 Score_engraver::get_staff_info() const
 207 {
 208   Staff_info inf = Engraver_group_engraver::get_staff_info();
 209
 210   inf.command_l_ = command_column_l_;
 211   inf.musical_l_ = musical_column_l_;
 212
 213   return inf;
 214 }
 215
 216 Music_output*
 217 Score_engraver::get_output_p ()
 218 {
 219   Music_output * o = pscore_p_;
 220   pscore_p_=0;
 221   return o;
 222 }
 223
 224 bool
 225 Score_engraver::do_try_music (Music*r)
 226 {
 227   bool gotcha = Engraver_group_engraver::do_try_music (r);
 228
 229   if (!gotcha)
 230     {
 231       if (Break_req* b = dynamic_cast<Break_req *> (r))
 232         {
 233           gotcha = true;
 234
 235
 236           SCM pen = command_column_l_->get_elt_property  ("penalty");
 237           Real total_penalty = gh_number_p (pen)
 238             ? gh_scm2double(pen)
 239             : 0.0;
 240
 241           total_penalty += b->penalty_f_;
 242           if (b->penalty_f_ > 10000.0) //  ugh. arbitrary.
 243             forbid_breaks ();
 244
 245           command_column_l_->set_elt_property ("penalty",
 246                                                gh_double2scm (total_penalty));
 247         }
 248     }
 249    return gotcha;
 250 }
 251
 252 void
 253 Score_engraver::forbid_breaks ()
 254 {
 255   /*
 256     result is junked.
 257    */
 258   command_column_l_->remove_elt_property ("breakable");
 259 }
 260
 261 void
 262 Score_engraver::do_add_processing ()
 263 {
 264   Translator_group::do_add_processing ();
 265   assert (dynamic_cast<Paper_def *> (output_def_l_));
 266   assert (!daddy_trans_l_);
 267   pscore_p_ = new Paper_score;
 268   pscore_p_->paper_l_ = dynamic_cast<Paper_def*>(output_def_l_);
 269 }
 270