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.grob_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   Engraver_group_engraver::do_announces ();
 149 }
 150
 151
 152 void
 153 Score_engraver::typeset_grob (Grob *elem_p)
 154 {
 155   if (!elem_p)
 156     programming_error ("Score_engraver: empty elt\n");
 157   else
 158
 159     elem_p_arr_.push (elem_p);
 160 }
 161
 162
 163 void
 164 Score_engraver::typeset_all ()
 165 {
 166   for (int i =0; i < elem_p_arr_.size (); i++)
 167     {
 168       Grob * elem_p = elem_p_arr_[i];
 169
 170       if (Spanner *s = dynamic_cast <Spanner *> (elem_p))
 171         {
 172             /*
 173             do something sensible if spanner not
 174             spanned on 2 items.
 175            */
 176           Direction d = LEFT;
 177           do {
 178             if (!s->get_bound (d))
 179               {
 180                 s->set_bound (d, command_column_l_);
 181                 /* don't warn for empty/suicided spanners,
 182                    it makes real warningsinvisible.
 183                    maybe should be junked earlier? */
 184                 if (elem_p->immutable_property_alist_ == SCM_EOL)
 185                   ; // gdb hook
 186                 else
 187                   ::warning (_f ("unbound spanner `%s'", s->name ().ch_C ()));
 188               }
 189           } while (flip (&d) != LEFT);
 190         }
 191       else
 192         {
 193           if (!elem_p->parent_l (X_AXIS))
 194             {
 195               bool br = to_boolean (elem_p->get_grob_property ("breakable"));
 196               Axis_group_interface::add_element (br ? command_column_l_ : musical_column_l_, elem_p);
 197
 198             }
 199         }
 200       if (!elem_p->parent_l (Y_AXIS))
 201         Axis_group_interface::add_element (scoreline_l_, elem_p);
 202     }
 203   elem_p_arr_.clear ();
 204 }
 205
 206 void
 207 Score_engraver::stop_translation_timestep ()
 208 {
 209   // this generates all items.
 210   Engraver_group_engraver::stop_translation_timestep ();
 211
 212   typeset_all ();
 213   if (to_boolean (command_column_l_->get_grob_property ("breakable")))
 214     {
 215       breaks_i_ ++;
 216       if (! (breaks_i_%8))
 217         progress_indication ("[" + to_str (breaks_i_) + "]");
 218     }
 219
 220   command_column_l_->set_grob_property ("when", now_mom_.smobbed_copy ());
 221   musical_column_l_->set_grob_property ("when", now_mom_.smobbed_copy ());
 222
 223   scoreline_l_->add_column (command_column_l_);
 224   scoreline_l_->add_column (musical_column_l_);
 225
 226   command_column_l_ = 0;
 227   musical_column_l_ = 0;
 228 }
 229
 230 void
 231 Score_engraver::set_columns (Paper_column *new_command_l,
 232                              Paper_column *new_musical_l)
 233 {
 234   assert (!command_column_l_ && !musical_column_l_);
 235   command_column_l_ = new_command_l;
 236   musical_column_l_ = new_musical_l;
 237
 238   if (new_musical_l)
 239     set_property ("currentMusicalColumn", new_musical_l->self_scm ());
 240   if (new_command_l)
 241     set_property ("currentCommandColumn", new_command_l->self_scm ());
 242 }
 243
 244 Music_output*
 245 Score_engraver::get_output_p ()
 246 {
 247   Music_output * o = pscore_p_;
 248   pscore_p_=0;
 249   return o;
 250 }
 251
 252 bool
 253 Score_engraver::try_music (Music*r)
 254 {
 255   bool gotcha = Engraver_group_engraver::try_music (r);
 256
 257   if (!gotcha)
 258     {
 259       if (Break_req* b = dynamic_cast<Break_req *> (r))
 260         {
 261           gotcha = true;
 262
 263
 264           SCM pen = command_column_l_->get_grob_property ("penalty");
 265           Real total_penalty = gh_number_p (pen)
 266             ? gh_scm2double (pen)
 267             : 0.0;
 268
 269           SCM rpen = b->get_mus_property ("penalty");
 270           if (gh_number_p (rpen))
 271             total_penalty +=  gh_scm2double (rpen);
 272
 273           if (total_penalty > 10000.0) //  ugh. arbitrary.
 274             forbid_breaks ();
 275
 276           command_column_l_->set_grob_property ("penalty",
 277                                                gh_double2scm (total_penalty));
 278         }
 279     }
 280    return gotcha;
 281 }
 282
 283 /*
 284   TODO:  use property Score.breakForbidden = #t
 285  */
 286
 287 void
 288 Score_engraver::forbid_breaks ()
 289 {
 290   /*
 291     result is junked.
 292    */
 293   command_column_l_->remove_grob_property ("breakable");
 294 }
 295
 296
 297
 298
 299 ENTER_DESCRIPTION(Score_engraver,
 300 /* descr */       "Top level engraver. Takes care of generating columns and the complete  system (ie. LineOfScore)
 301
 302
 303 This engraver decides whether a column is breakable. The default is
 304 that a column is always breakable. However, when every Bar_engraver
 305 that does not have a barline at a certain point will call
 306 Score_engraver::forbid_breaks to stop linebreaks.  In practice, this
 307 means that you can make a breakpoint by creating a barline (assuming
 308 that there are no beams or notes that prevent a breakpoint.)
 309
 310
 311 ",
 312 /* creats*/       "LineOfScore PaperColumn NonMusicalPaperColumn",
 313 /* acks  */       "grob-interface",
 314 /* reads */       "currentMusicalColumn currentCommandColumn",
 315 /* write */       "");