X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscore-engraver.cc;h=9321423219f981385853e2d338b1f9db502e6b3a;hb=95e91ffb8d0d82efbda9d266c63d4ccf0bcc5133;hp=6208952db812a69c61ca6ba316d4cdfec503a69d;hpb=2fd5f86de0500ecd9a3f47a2540c3b304f835ef4;p=lilypond.git diff --git a/lily/score-engraver.cc b/lily/score-engraver.cc index 6208952db8..9321423219 100644 --- a/lily/score-engraver.cc +++ b/lily/score-engraver.cc @@ -1,270 +1,306 @@ /* - score-grav.cc -- implement Score_engraver + score-engraver.cc -- implement Score_engraver source file of the GNU LilyPond music typesetter - (c) 1997--1999 Han-Wen Nienhuys + (c) 1997--2004 Han-Wen Nienhuys */ -#include "debug.hh" -#include "dimension-cache.hh" -#include "line-of-score.hh" +#include "all-font-metrics.hh" +#include "afm.hh" +#include "warn.hh" +#include "main.hh" +#include "system.hh" #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 "output-def.hh" +#include "axis-group-interface.hh" +#include "context-def.hh" +#include "staff-spacing.hh" +#include "note-spacing.hh" +#include "context.hh" +#include "global-context.hh" -ADD_THIS_TRANSLATOR (Score_engraver); + + +/* + TODO: the column creation logic is rather hairy. Revise it. + */ Score_engraver::Score_engraver () { - scoreline_l_ =0; - command_column_l_ =0; - musical_column_l_ =0; - breaks_i_ =0; - pscore_p_ = 0; + system_ =0; + command_column_ =0; + musical_column_ =0; + breaks_ =0; + pscore_ = 0; } - + void -Score_engraver::prepare (Moment w) +Score_engraver::make_columns () { - Global_translator::prepare (w); - set_columns (new Paper_column (w), new Paper_column (w)); + /* + ugh. + */ + if (!command_column_) + { + SCM nmp + = updated_grob_properties (context (), + ly_symbol2scm ("NonMusicalPaperColumn")); + SCM pc = updated_grob_properties (context (), + ly_symbol2scm ("PaperColumn")); + + set_columns (new Paper_column (nmp), new Paper_column (pc)); - command_column_l_->set_elt_property ("breakable", SCM_BOOL_T); - post_move_processing(); + Grob_info i1; + i1.grob_ = command_column_; + i1.origin_trans_ = this; + + announce_grob (i1); + + Grob_info i2; + i2.grob_ = musical_column_; + i2.origin_trans_ = this; + + announce_grob (i2); + } } void -Score_engraver::finish() +Score_engraver::prepare (Moment m) { - if ((breaks_i_%8)) - progress_indication ("[" + to_str ( breaks_i_) + "]"); - - check_removal(); - removal_processing(); + /* + TODO: don't make columns when skipTypesetting is true. + */ + make_columns (); + + SCM w = m.smobbed_copy (); + command_column_->set_property ("when", w); + musical_column_->set_property ("when", w); + + recurse_over_translators (context (), &Translator::start_translation_timestep, DOWN); +} + +void +Score_engraver::finish () +{ + if ((breaks_%8)) + progress_indication ("[" + to_string (breaks_) + "]"); + + recurse_over_translators (context (), &Translator::finalize, UP); } /* use start/finish? */ void -Score_engraver::do_creation_processing () +Score_engraver::initialize () { - scoreline_l_ = pscore_p_->line_l_; + Font_metric *fm = all_fonts_global->find_afm ("feta20"); + if (!fm) + error (_f ("can't find `%s'", "feta20.afm") + + "\n" +_ ("Fonts have not been installed properly. Aborting")); + + + pscore_ = new Paper_score; + pscore_->paper_ = dynamic_cast (get_output_def ()); - scoreline_l_->set_bounds(LEFT, command_column_l_); + SCM props = updated_grob_properties (context (), ly_symbol2scm ("System")); + + pscore_->typeset_line (new System (props)); - command_column_l_->set_elt_property ("breakable", SCM_BOOL_T); + make_columns (); + system_ = pscore_->system_; + system_->set_bound (LEFT, command_column_); + command_column_->set_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_bounds(RIGHT,command_column_l_); - command_column_l_->set_elt_property ("breakable", SCM_BOOL_T); + Score_translator::finalize (); + Grob * cc + = unsmob_grob (get_property ("currentCommandColumn")); + system_->set_bound (RIGHT, cc); + cc->set_property ("breakable", SCM_BOOL_T); + typeset_all (); - set_columns (0,0); } -void -Score_engraver::process() -{ - process_requests(); - do_announces(); - pre_move_processing(); - check_removal(); -} void -Score_engraver::announce_element (Score_element_info info) -{ - announce_info_arr_.push (info); - info.origin_trans_l_arr_.push (this); - pscore_p_->typeset_element (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 -*/ -/* junkme? Done by Engraver_group_engraver::do_announces ()? - */ - -void -Score_engraver::do_announces() +Score_engraver::one_time_step () { - while (announce_info_arr_.size()) - Engraver_group_engraver::do_announces(); + if (!to_boolean (get_property ("skipTypesetting"))) + { + recurse_over_translators (context (), &Engraver::process_music, UP); + recurse_over_translators (context (), &Engraver::do_announces, UP); + } + + recurse_over_translators (context (), &Translator::stop_translation_timestep, UP); } - void -Score_engraver::typeset_element (Score_element *elem_p) +Score_engraver::announce_grob (Grob_info info) { - elem_p_arr_.push (elem_p); + announce_infos_.push (info); + pscore_->system_->typeset_grob (info.grob_); + elems_.push (info.grob_); } void -Score_engraver::typeset_all() +Score_engraver::typeset_all () { - for (int i =0; i < elem_p_arr_.size(); i++) + for (int i =0; i < elems_.size (); i++) { - Score_element * elem_p = elem_p_arr_[i]; - elem_p->add_processing (); + Grob * elem = elems_[i]; - if (Spanner *s = dynamic_cast (elem_p)) + if (dynamic_cast (elem)) { - /* - do something sensible if spanner not - spanned on 2 items. - */ - Direction d = LEFT; - do { - if (!s->spanned_drul_[d]) - { - s->set_bounds(d, command_column_l_); - ::warning (_f ("unbound spanner `%s'", classname(s))); - } - } while (flip(&d) != LEFT); - } - else - { - Item *item_p = dynamic_cast (elem_p); - - if (!item_p->parent_l (X_AXIS)) + if (!elem->get_parent (X_AXIS) + && elem != command_column_ + && elem != musical_column_ + ) { - bool br = to_boolean (item_p->remove_elt_property ("breakable")); - if (br) - command_column_l_->add_element(item_p); - else - musical_column_l_->add_element(item_p); + bool br = to_boolean (elem->get_property ("breakable")); + Axis_group_interface::add_element (br ? command_column_ : musical_column_, elem); + } } - if (!elem_p->parent_l(Y_AXIS)) - scoreline_l_->add_element (elem_p); + if (!elem->get_parent (Y_AXIS)) + Axis_group_interface::add_element (system_, elem); } - elem_p_arr_.clear(); + elems_.clear (); } void -Score_engraver::do_pre_move_processing() +Score_engraver::stop_translation_timestep () { - if (to_boolean (command_column_l_->get_elt_property ("breakable"))) + // this generates all items. + Engraver_group_engraver::stop_translation_timestep (); + + typeset_all (); + if (to_boolean (command_column_->get_property ("breakable"))) { - breaks_i_ ++; - if (! (breaks_i_%8)) - progress_indication ("[" + to_str ( breaks_i_) + "]"); + breaks_ ++; + if (! (breaks_%8)) + progress_indication ("[" + to_string (breaks_) + "]"); } - // this generates all items. - Engraver_group_engraver::do_pre_move_processing(); + + + system_->add_column (command_column_); + system_->add_column (musical_column_); - typeset_all(); + command_column_ = 0; + musical_column_ = 0; } void -Score_engraver::set_columns (Paper_column *new_command_l, - Paper_column *new_musical_l) +Score_engraver::set_columns (Paper_column *new_command, + Paper_column *new_musical) { - if (command_column_l_ && command_column_l_->linked_b()) - { - pscore_p_->add_column (command_column_l_); - scoreline_l_->add_column (command_column_l_); - } - else - command_column_l_ =0; - - if (new_command_l) - command_column_l_ = new_command_l; + assert (!command_column_ && !musical_column_); - if (musical_column_l_ && musical_column_l_->linked_b()) + command_column_ = new_command; + musical_column_ = new_musical; + if (new_command) { - pscore_p_->add_column (musical_column_l_); - scoreline_l_->add_column (musical_column_l_); + context ()->set_property ("currentCommandColumn", new_command->self_scm ()); } - else - musical_column_l_ = 0; - if (new_musical_l) + if (new_musical) { - musical_column_l_ = new_musical_l; + context ()->set_property ("currentMusicalColumn", new_musical->self_scm ()); } } -Staff_info -Score_engraver::get_staff_info() const -{ - Staff_info inf = Engraver_group_engraver::get_staff_info(); - - inf.command_l_ = command_column_l_; - inf.musical_l_ = musical_column_l_; - - return inf; -} - Music_output* -Score_engraver::get_output_p () +Score_engraver::get_output () { - Music_output * o = pscore_p_; - pscore_p_=0; + Music_output *o = pscore_; + ///FIXME WTF? pscore_ = 0; return o; } bool -Score_engraver::do_try_music (Music*r) +Score_engraver::try_music (Music *m) { - bool gotcha = Engraver_group_engraver::do_try_music (r); + if (Engraver_group_engraver::try_music (m)) + return true; - if (!gotcha) + if (m->is_mus_type ("break-event")) { - if (Break_req* b = dynamic_cast (r)) - { - gotcha = true; + SCM pen = command_column_->get_property ("penalty"); + Real total_penalty = ly_c_number_p (pen) ? ly_scm2double (pen) : 0.0; + SCM mpen = m->get_property ("penalty"); + if (ly_c_number_p (mpen)) + total_penalty += ly_scm2double (mpen); - SCM pen = command_column_l_->get_elt_property ("penalty"); - Real total_penalty = gh_number_p (pen) - ? gh_scm2double(pen) - : 0.0; + command_column_->set_property ("penalty", scm_make_real (total_penalty)); - total_penalty += b->penalty_f_; - if (b->penalty_f_ > 10000.0) // ugh. arbitrary. - forbid_breaks (); + /* ugh. arbitrary, hardcoded */ + if (total_penalty > 10000.0) + forbid_breaks (); - command_column_l_->set_elt_property ("penalty", - gh_double2scm (total_penalty)); - } + SCM page_pen = command_column_->get_property ("page-penalty"); + Real total_pp = ly_c_number_p (page_pen) ? ly_scm2double (page_pen) : 0.0; + SCM mpage_pen = m->get_property ("page-penalty"); + if (ly_c_number_p (mpage_pen)) + total_pp += ly_scm2double (mpage_pen); + + command_column_->set_property ("page-penalty", scm_make_real (total_pp)); + return true; } - return gotcha; + return false; } void Score_engraver::forbid_breaks () { - /* - result is junked. - */ - command_column_l_->remove_elt_property ("breakable"); + if (command_column_) + command_column_->set_property ("breakable", SCM_EOL); } - + void -Score_engraver::do_add_processing () +Score_engraver::acknowledge_grob (Grob_info gi) { - 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_); + if (Staff_spacing::has_interface (gi.grob_)) + { + Pointer_group_interface::add_grob (command_column_, + ly_symbol2scm ("spacing-wishes"), + gi.grob_); + } + if (Note_spacing::has_interface (gi.grob_)) + { + Pointer_group_interface::add_grob (musical_column_, + ly_symbol2scm ("spacing-wishes"), + gi.grob_); + } } + + +ENTER_DESCRIPTION (Score_engraver, +/* descr */ "Top level engraver. Takes care of generating columns and the complete system (ie. System) " +"\n\n " +"This engraver decides whether a column is breakable. The default is " +"that a column is always breakable. However, when every Bar_engraver " +"that does not have a barline at a certain point will call " +"Score_engraver::forbid_breaks to stop linebreaks. In practice, this " +"means that you can make a breakpoint by creating a barline (assuming " +"that there are no beams or notes that prevent a breakpoint.) " +, +/* creats*/ "System PaperColumn NonMusicalPaperColumn", +/* accepts */ "break-event", +/* acks */ "note-spacing-interface staff-spacing-interface", +/* reads */ "currentMusicalColumn currentCommandColumn", +/* write */ "");