lily/score-engraver.cc

   1 /*
   2   score-engraver.cc -- implement Score_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--2001 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "debug.hh"
  10
  11 #include "line-of-score.hh"
  12 #include "item.hh"
  13 #include "score-engraver.hh"
  14 #include "paper-score.hh"
  15 #include "paper-column.hh"
  16 #include "command-request.hh"
  17 #include "paper-def.hh"
  18 #include "axis-group-interface.hh"
  19 #include "translator-def.hh"
  20
  21
  22 /*
  23   TODO: the column creation logic is rather hairy. Revise it.
  24  */
  25 Score_engraver::Score_engraver ()
  26 {
  27   scoreline_l_ =0;
  28   command_column_l_ =0;
  29   musical_column_l_ =0;
  30   breaks_i_ =0;
  31   pscore_p_ = 0;
  32 }
  33
  34 void
  35 Score_engraver::make_columns ()
  36 {
  37   /*
  38     ugh.
  39    */
  40   if (!command_column_l_)
  41     //      || *unsmob_moment (command_column_l_->get_grob_property ("when")) != w)
  42     {
  43       set_columns (new Paper_column (get_property (ly_symbol2scm ("NonMusicalPaperColumn"))),
  44                    new Paper_column (get_property (ly_symbol2scm ("PaperColumn"))));
  45
  46       command_column_l_->set_grob_property ("breakable", SCM_BOOL_T);
  47
  48       Grob_info i1 (command_column_l_, 0), i2 (musical_column_l_,0);
  49
  50       i1.origin_trans_l_ = this;
  51       i2.origin_trans_l_ = this;
  52       announce_grob (i1);
  53       announce_grob (i2);
  54     }
  55 }
  56
  57 void
  58 Score_engraver::prepare (Moment w)
  59 {
  60   Global_translator::prepare (w);
  61
  62   make_columns ();
  63   start_translation_timestep ();
  64 }
  65
  66 void
  67 Score_engraver::finish ()
  68 {
  69   if ((breaks_i_%8))
  70     progress_indication ("[" + to_str (breaks_i_) + "]");
  71
  72   check_removal ();
  73   removal_processing ();
  74
  75 }
  76
  77 /*
  78   use start/finish?
  79  */
  80 void
  81 Score_engraver::initialize ()
  82 {
  83   unsmob_translator_def (definition_)->apply_property_operations (this);
  84
  85   assert (dynamic_cast<Paper_def *> (output_def_l_));
  86   assert (!daddy_trans_l_);
  87   pscore_p_ = new Paper_score;
  88   pscore_p_->paper_l_ = dynamic_cast<Paper_def*> (output_def_l_);
  89
  90   SCM props = get_property (ly_symbol2scm ("LineOfScore"));
  91
  92   pscore_p_->typeset_line (new Line_of_score (props));
  93
  94   make_columns ();
  95   scoreline_l_ = pscore_p_->line_l_;
  96   scoreline_l_->set_bound (LEFT, command_column_l_);
  97   command_column_l_->set_grob_property ("breakable", SCM_BOOL_T);
  98
  99   Engraver_group_engraver::initialize ();
 100 }
 101
 102
 103 void
 104 Score_engraver::finalize ()
 105 {
 106   Engraver_group_engraver::finalize ();
 107
 108   Grob * cc
 109     = unsmob_grob (get_property (ly_symbol2scm ("currentCommandColumn")));
 110   scoreline_l_->set_bound (RIGHT, cc);
 111   cc->set_grob_property ("breakable", SCM_BOOL_T);
 112
 113   typeset_all ();
 114 }
 115
 116 void
 117 Score_engraver::one_time_step ()
 118 {
 119   if (!to_boolean (get_property (ly_symbol2scm("skipTypesetting"))))
 120     {
 121       process_music ();
 122       announces ();
 123     }
 124
 125
 126   stop_translation_timestep ();
 127   check_removal ();
 128 }
 129
 130 void
 131 Score_engraver::announce_grob (Grob_info info)
 132 {
 133   announce_info_arr_.push (info);
 134   pscore_p_->line_l_->typeset_grob (info.elem_l_);
 135 }
 136
 137 /* All elements are propagated to the top upon announcement. If
 138    something was created during one run of
 139    Engraver_group_engraver::do_announces, then
 140    announce_info_arr_.size () will be nonzero again
 141 */
 142 /* junkme? Done by Engraver_group_engraver::do_announces ()?
 143  */
 144
 145 void
 146 Score_engraver::do_announces ()
 147 {
 148   //////  do
 149     Engraver_group_engraver::do_announces ();
 150     //////while (announce_info_arr_.size ());
 151 }
 152
 153
 154 void
 155 Score_engraver::typeset_grob (Grob *elem_p)
 156 {
 157   if (!elem_p)
 158     programming_error ("Score_engraver: empty elt\n");
 159   else
 160
 161     elem_p_arr_.push (elem_p);
 162 }
 163
 164
 165 void
 166 Score_engraver::typeset_all ()
 167 {
 168   for (int i =0; i < elem_p_arr_.size (); i++)
 169     {
 170       Grob * elem_p = elem_p_arr_[i];
 171
 172       if (Spanner *s = dynamic_cast <Spanner *> (elem_p))
 173         {
 174             /*
 175             do something sensible if spanner not
 176             spanned on 2 items.
 177            */
 178           Direction d = LEFT;
 179           do {
 180             if (!s->get_bound (d))
 181               {
 182                 s->set_bound (d, command_column_l_);
 183                 /* don't warn for empty/suicided spanners,
 184                    it makes real warningsinvisible.
 185                    maybe should be junked earlier? */
 186                 if (elem_p->immutable_property_alist_ == SCM_EOL)
 187                   ; // gdb hook
 188                 else
 189                   ::warning (_f ("unbound spanner `%s'", s->name ().ch_C ()));
 190               }
 191           } while (flip (&d) != LEFT);
 192         }
 193       else
 194         {
 195           if (!elem_p->parent_l (X_AXIS))
 196             {
 197               bool br = to_boolean (elem_p->get_grob_property ("breakable"));
 198               Axis_group_interface::add_element (br ? command_column_l_ : musical_column_l_, elem_p);
 199
 200             }
 201         }
 202       if (!elem_p->parent_l (Y_AXIS))
 203         Axis_group_interface::add_element (scoreline_l_, elem_p);
 204     }
 205   elem_p_arr_.clear ();
 206 }
 207
 208 void
 209 Score_engraver::stop_translation_timestep ()
 210 {
 211   // this generates all items.
 212   Engraver_group_engraver::stop_translation_timestep ();
 213
 214   typeset_all ();
 215   if (to_boolean (command_column_l_->get_grob_property ("breakable")))
 216     {
 217       breaks_i_ ++;
 218       if (! (breaks_i_%8))
 219         progress_indication ("[" + to_str (breaks_i_) + "]");
 220     }
 221
 222   command_column_l_->set_grob_property ("when", now_mom_.smobbed_copy ());
 223   musical_column_l_->set_grob_property ("when", now_mom_.smobbed_copy ());
 224
 225   scoreline_l_->add_column (command_column_l_);
 226   scoreline_l_->add_column (musical_column_l_);
 227
 228   command_column_l_ = 0;
 229   musical_column_l_ = 0;
 230 }
 231
 232 void
 233 Score_engraver::set_columns (Paper_column *new_command_l,
 234                              Paper_column *new_musical_l)
 235 {
 236   assert (!command_column_l_ && !musical_column_l_);
 237   command_column_l_ = new_command_l;
 238   musical_column_l_ = new_musical_l;
 239
 240   if (new_musical_l)
 241     set_property ("currentMusicalColumn", new_musical_l->self_scm ());
 242   if (new_command_l)
 243     set_property ("currentCommandColumn", new_command_l->self_scm ());
 244 }
 245
 246 Music_output*
 247 Score_engraver::get_output_p ()
 248 {
 249   Music_output * o = pscore_p_;
 250   pscore_p_=0;
 251   return o;
 252 }
 253
 254 bool
 255 Score_engraver::try_music (Music*r)
 256 {
 257   bool gotcha = Engraver_group_engraver::try_music (r);
 258
 259   if (!gotcha)
 260     {
 261       if (Break_req* b = dynamic_cast<Break_req *> (r))
 262         {
 263           gotcha = true;
 264
 265
 266           SCM pen = command_column_l_->get_grob_property ("penalty");
 267           Real total_penalty = gh_number_p (pen)
 268             ? gh_scm2double (pen)
 269             : 0.0;
 270
 271           SCM rpen = b->get_mus_property ("penalty");
 272           if (gh_number_p (rpen))
 273             total_penalty +=  gh_scm2double (rpen);
 274
 275           if (total_penalty > 10000.0) //  ugh. arbitrary.
 276             forbid_breaks ();
 277
 278           command_column_l_->set_grob_property ("penalty",
 279                                                gh_double2scm (total_penalty));
 280         }
 281     }
 282    return gotcha;
 283 }
 284
 285 /*
 286   TODO:  use property Score.breakForbidden = #t
 287  */
 288
 289 void
 290 Score_engraver::forbid_breaks ()
 291 {
 292   /*
 293     result is junked.
 294    */
 295   command_column_l_->remove_grob_property ("breakable");
 296 }
 297
 298 ADD_THIS_TRANSLATOR (Score_engraver);
 299
 300