X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscore-engraver.cc;h=733aa5a3c045400fefae61d2ed8387c2191a3b8b;hb=54404c570a48ddf9772c5ca64a154d0c0149e61e;hp=66b759e7d237bc7c9cd31c67ce45afd7fbdd1b35;hpb=b0fc2bbf6d5f9b64c8bba3b7b5e4e50297c36e00;p=lilypond.git diff --git a/lily/score-engraver.cc b/lily/score-engraver.cc index 66b759e7d2..733aa5a3c0 100644 --- a/lily/score-engraver.cc +++ b/lily/score-engraver.cc @@ -3,7 +3,7 @@ source file of the GNU LilyPond music typesetter - (c) 1997--2000 Han-Wen Nienhuys + (c) 1997--2001 Han-Wen Nienhuys */ #include "debug.hh" @@ -12,13 +12,17 @@ #include "item.hh" #include "score-engraver.hh" #include "paper-score.hh" -#include "musical-request.hh" #include "paper-column.hh" #include "command-request.hh" #include "paper-def.hh" #include "axis-group-interface.hh" +#include "translator-def.hh" -Score_engraver::Score_engraver() + +/* + TODO: the column creation logic is rather hairy. Revise it. + */ +Score_engraver::Score_engraver () { scoreline_l_ =0; command_column_l_ =0; @@ -26,114 +30,144 @@ Score_engraver::Score_engraver() breaks_i_ =0; pscore_p_ = 0; } - + +void +Score_engraver::make_columns () +{ + /* + ugh. + */ + if (!command_column_l_) + // || *unsmob_moment (command_column_l_->get_grob_property ("when")) != w) + { + set_columns (new Paper_column (get_property (ly_symbol2scm ("NonMusicalPaperColumn"))), + new Paper_column (get_property (ly_symbol2scm ("PaperColumn")))); + + command_column_l_->set_grob_property ("breakable", SCM_BOOL_T); + + Grob_info i1 (command_column_l_, 0), i2 (musical_column_l_,0); + + i1.origin_trans_l_ = this; + i2.origin_trans_l_ = this; + announce_grob (i1); + announce_grob (i2); + } +} + void Score_engraver::prepare (Moment w) { Global_translator::prepare (w); - SCM props = get_property (ly_symbol2scm ("basicPaperColumnProperties")); - set_columns (new Paper_column (props), new Paper_column (props)); - - command_column_l_->set_elt_property ("when", w.make_scm()); - musical_column_l_->set_elt_property ("when", w.make_scm()); - command_column_l_->set_elt_property ("breakable", SCM_BOOL_T); - - Score_element_info i1(command_column_l_, 0), i2 (musical_column_l_,0); - - i1.origin_trans_l_ = this; - i2.origin_trans_l_ = this; - announce_element (i1); - announce_element (i2); - - post_move_processing(); + make_columns (); + start_translation_timestep (); } void -Score_engraver::finish() +Score_engraver::finish () { if ((breaks_i_%8)) - progress_indication ("[" + to_str ( breaks_i_) + "]"); + progress_indication ("[" + to_str (breaks_i_) + "]"); - check_removal(); - removal_processing(); + check_removal (); + removal_processing (); + } /* use start/finish? */ void -Score_engraver::do_creation_processing () +Score_engraver::initialize () { - scoreline_l_ = pscore_p_->line_l_; + unsmob_translator_def (definition_)->apply_property_operations (this); - scoreline_l_->set_bound(LEFT, command_column_l_); + assert (dynamic_cast (output_def_l_)); + assert (!daddy_trans_l_); + pscore_p_ = new Paper_score; + pscore_p_->paper_l_ = dynamic_cast (output_def_l_); + + SCM props = get_property (ly_symbol2scm ("LineOfScore")); + + pscore_p_->typeset_line (new Line_of_score (props)); - command_column_l_->set_elt_property ("breakable", SCM_BOOL_T); + make_columns (); + scoreline_l_ = pscore_p_->line_l_; + scoreline_l_->set_bound (LEFT, command_column_l_); + command_column_l_->set_grob_property ("breakable", SCM_BOOL_T); - Engraver_group_engraver::do_creation_processing(); + Engraver_group_engraver::initialize (); } void -Score_engraver::do_removal_processing() +Score_engraver::finalize () { - Engraver_group_engraver::do_removal_processing(); - scoreline_l_->set_bound(RIGHT,command_column_l_); - command_column_l_->set_elt_property ("breakable", SCM_BOOL_T); + Engraver_group_engraver::finalize (); + + Grob * cc + = unsmob_grob (get_property (ly_symbol2scm ("currentCommandColumn"))); + scoreline_l_->set_bound (RIGHT, cc); + cc->set_grob_property ("breakable", SCM_BOOL_T); typeset_all (); - - set_columns (0,0); } void -Score_engraver::process() +Score_engraver::one_time_step () { - process_music(); - do_announces(); - pre_move_processing(); - check_removal(); + if (!to_boolean (get_property (ly_symbol2scm("skipTypesetting")))) + { + process_music (); + announces (); + } + + + stop_translation_timestep (); + check_removal (); } void -Score_engraver::announce_element (Score_element_info info) +Score_engraver::announce_grob (Grob_info info) { announce_info_arr_.push (info); - pscore_p_->line_l_->typeset_element (info.elem_l_); + pscore_p_->line_l_->typeset_grob (info.elem_l_); } /* All elements are propagated to the top upon announcement. If something was created during one run of Engraver_group_engraver::do_announces, then - announce_info_arr_.size() will be nonzero again + announce_info_arr_.size () will be nonzero again */ /* junkme? Done by Engraver_group_engraver::do_announces ()? */ void -Score_engraver::do_announces() +Score_engraver::do_announces () { - while (announce_info_arr_.size()) - Engraver_group_engraver::do_announces(); + ////// do + Engraver_group_engraver::do_announces (); + //////while (announce_info_arr_.size ()); } void -Score_engraver::typeset_element (Score_element *elem_p) +Score_engraver::typeset_grob (Grob *elem_p) { - elem_p_arr_.push (elem_p); + if (!elem_p) + programming_error ("Score_engraver: empty elt\n"); + else + + elem_p_arr_.push (elem_p); } void -Score_engraver::typeset_all() +Score_engraver::typeset_all () { - for (int i =0; i < elem_p_arr_.size(); i++) + for (int i =0; i < elem_p_arr_.size (); i++) { - Score_element * elem_p = elem_p_arr_[i]; - elem_p->add_processing (); - + Grob * elem_p = elem_p_arr_[i]; if (Spanner *s = dynamic_cast (elem_p)) { @@ -145,68 +179,64 @@ Score_engraver::typeset_all() do { if (!s->get_bound (d)) { - s->set_bound(d, command_column_l_); - ::warning (_f ("unbound spanner `%s'", s->name().ch_C())); + s->set_bound (d, command_column_l_); + /* don't warn for empty/suicided spanners, + it makes real warningsinvisible. + maybe should be junked earlier? */ + if (elem_p->immutable_property_alist_ == SCM_EOL) + ; // gdb hook + else + ::warning (_f ("unbound spanner `%s'", s->name ().ch_C ())); } - } while (flip(&d) != LEFT); + } while (flip (&d) != LEFT); } else { if (!elem_p->parent_l (X_AXIS)) { - bool br = to_boolean (elem_p->get_elt_property ("breakable")); + bool br = to_boolean (elem_p->get_grob_property ("breakable")); Axis_group_interface::add_element (br ? command_column_l_ : musical_column_l_, elem_p); } } - if (!elem_p->parent_l(Y_AXIS)) + if (!elem_p->parent_l (Y_AXIS)) Axis_group_interface::add_element (scoreline_l_, elem_p); } - elem_p_arr_.clear(); + elem_p_arr_.clear (); } void -Score_engraver::do_pre_move_processing() +Score_engraver::stop_translation_timestep () { // this generates all items. - Engraver_group_engraver::do_pre_move_processing(); + Engraver_group_engraver::stop_translation_timestep (); - typeset_all(); - if (to_boolean (command_column_l_->get_elt_property ("breakable"))) + typeset_all (); + if (to_boolean (command_column_l_->get_grob_property ("breakable"))) { breaks_i_ ++; if (! (breaks_i_%8)) - progress_indication ("[" + to_str ( breaks_i_) + "]"); + progress_indication ("[" + to_str (breaks_i_) + "]"); } + + command_column_l_->set_grob_property ("when", now_mom_.smobbed_copy ()); + musical_column_l_->set_grob_property ("when", now_mom_.smobbed_copy ()); + + scoreline_l_->add_column (command_column_l_); + scoreline_l_->add_column (musical_column_l_); + + command_column_l_ = 0; + musical_column_l_ = 0; } void Score_engraver::set_columns (Paper_column *new_command_l, Paper_column *new_musical_l) { - Paper_column * news[] = {new_command_l, new_musical_l}; - Paper_column **current[] = {&command_column_l_, &musical_column_l_}; - - for (int i=00; i< 2; i++) - { - if (*current[i]) - { - scoreline_l_->add_column ((*current[i])); -#if 0 - /* - TODO: delay this decision. - */ - if (!Paper_column::used_b (*current[i])) - { - (*current[i])->suicide (); - *current[i] =0; - } -#endif - } - if (news[i]) - *current[i] = news[i]; - } - + assert (!command_column_l_ && !musical_column_l_); + command_column_l_ = new_command_l; + musical_column_l_ = new_musical_l; + if (new_musical_l) set_property ("currentMusicalColumn", new_musical_l->self_scm ()); if (new_command_l) @@ -222,9 +252,9 @@ Score_engraver::get_output_p () } bool -Score_engraver::do_try_music (Music*r) +Score_engraver::try_music (Music*r) { - bool gotcha = Engraver_group_engraver::do_try_music (r); + bool gotcha = Engraver_group_engraver::try_music (r); if (!gotcha) { @@ -233,44 +263,38 @@ Score_engraver::do_try_music (Music*r) gotcha = true; - SCM pen = command_column_l_->get_elt_property ("penalty"); + SCM pen = command_column_l_->get_grob_property ("penalty"); Real total_penalty = gh_number_p (pen) - ? gh_scm2double(pen) + ? gh_scm2double (pen) : 0.0; - total_penalty += b->penalty_f_; - if (b->penalty_f_ > 10000.0) // ugh. arbitrary. + SCM rpen = b->get_mus_property ("penalty"); + if (gh_number_p (rpen)) + total_penalty += gh_scm2double (rpen); + + if (total_penalty > 10000.0) // ugh. arbitrary. forbid_breaks (); - command_column_l_->set_elt_property ("penalty", + command_column_l_->set_grob_property ("penalty", gh_double2scm (total_penalty)); } } return gotcha; } +/* + TODO: use property Score.breakForbidden = #t + */ + void Score_engraver::forbid_breaks () { /* result is junked. */ - command_column_l_->remove_elt_property ("breakable"); + command_column_l_->remove_grob_property ("breakable"); } -ADD_THIS_TRANSLATOR(Score_engraver); +ADD_THIS_TRANSLATOR (Score_engraver); -void -Score_engraver::do_add_processing () -{ - Translator_group::do_add_processing (); - assert (dynamic_cast (output_def_l_)); - assert (!daddy_trans_l_); - pscore_p_ = new Paper_score; - pscore_p_->paper_l_ = dynamic_cast(output_def_l_); - - SCM props = get_property(ly_symbol2scm ("basicLineOfScoreProperties")); - - pscore_p_->typeset_line (new Line_of_score (props)); -}