X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscore-engraver.cc;h=227c86c41e29753a842f9260ca66e1ee34f67ffb;hb=1ecdd56060e34a00b2be6b38029b286a601ea6f8;hp=1b30731fd710d69d6e5f80516fb1e6adf5433d2d;hpb=59ed0cee2aae58a3f0483f21261c68aee406fa10;p=lilypond.git diff --git a/lily/score-engraver.cc b/lily/score-engraver.cc index 1b30731fd7..227c86c41e 100644 --- a/lily/score-engraver.cc +++ b/lily/score-engraver.cc @@ -1,274 +1,207 @@ /* - score-grav.cc -- implement Score_engraver + This file is part of LilyPond, the GNU music typesetter. - source file of the GNU LilyPond music typesetter + Copyright (C) 1997--2011 Han-Wen Nienhuys - (c) 1997--1998 Han-Wen Nienhuys + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ -#include "super-element.hh" -#include "line-of-score.hh" -#include "debug.hh" -#include "item.hh" #include "score-engraver.hh" -#include "p-score.hh" -#include "musical-request.hh" -#include "score-column.hh" -#include "command-request.hh" -#include "paper-def.hh" +#include "all-font-metrics.hh" +#include "axis-group-interface.hh" +#include "context-def.hh" +#include "dispatcher.hh" +#include "global-context.hh" +#include "international.hh" +#include "main.hh" +#include "open-type-font.hh" +#include "output-def.hh" +#include "paper-column-engraver.hh" +#include "paper-column.hh" +#include "paper-score.hh" +#include "system.hh" +#include "warn.hh" -Score_engraver::Score_engraver() +Score_engraver::Score_engraver () { - break_penalty_i_ = 0; - scoreline_l_ =0; - command_column_l_ =0; - musical_column_l_ =0; - breaks_i_ =0; - pscore_p_ = 0; + system_ = 0; + pscore_ = 0; } - + void -Score_engraver::prepare (Moment w) +Score_engraver::derived_mark () const { - Global_translator::prepare (w); - set_columns (new Score_column (w), new Score_column (w)); - - break_penalty_i_ = 0; - post_move_processing(); + if (pscore_) + scm_gc_mark (pscore_->self_scm ()); + Engraver_group::derived_mark (); } +IMPLEMENT_LISTENER (Score_engraver, prepare); void -Score_engraver::finish() +Score_engraver::prepare (SCM) { - if ((breaks_i_%8)) - *mlog << "[" << breaks_i_ << "]" << flush; - - check_removal(); - removal_processing(); + precomputed_recurse_over_translators (context (), START_TRANSLATION_TIMESTEP, DOWN); } +IMPLEMENT_LISTENER (Score_engraver, finish); void -Score_engraver::do_creation_processing() +Score_engraver::finish (SCM) { - scoreline_l_ = pscore_p_->line_l_; - scoreline_l_->set_bounds(LEFT,get_staff_info().command_pcol_l ()); - command_column_l_->breakable_b_ = true; - Engraver_group_engraver::do_creation_processing(); + recurse_over_translators (context (), &Translator::finalize, + &Translator_group::finalize, + UP); } +#define MUSIC_FONT "emmentaler-20" + +/* + use start/finish? +*/ void -Score_engraver::do_removal_processing() +Score_engraver::initialize () { - Engraver_group_engraver::do_removal_processing(); - scoreline_l_->set_bounds(RIGHT,get_staff_info().command_pcol_l ()); - command_column_l_->breakable_b_ = true; + Font_metric *fm = all_fonts_global->find_otf (MUSIC_FONT); + if (!fm) + { + error (_f ("cannot find `%s'", MUSIC_FONT ".otf") + + "\n" + + _ ("Music font has not been installed properly.") + + "\n" + + _f ("Search path `%s'", global_path.to_string ().c_str ()) + + "\n" + + _ ("Aborting")); + } - typeset_all (); - set_columns (0,0); -} + pscore_ = new Paper_score (dynamic_cast (context ()->get_output_def ())); + pscore_->unprotect (); + context ()->set_property ("output", pscore_->self_scm ()); -void -Score_engraver::process() -{ - process_requests(); - do_announces(); - pre_move_processing(); - check_removal(); + SCM props = updated_grob_properties (context (), ly_symbol2scm ("System")); + + pscore_->typeset_system (new System (props)); + + system_ = pscore_->root_system (); + context ()->set_property ("rootSystem", system_->self_scm ()); + + Engraver_group::initialize (); } void -Score_engraver::announce_element (Score_element_info info) +Score_engraver::connect_to_context (Context *c) { - announce_info_arr_.push (info); - info.origin_grav_l_arr_.push (this); + Engraver_group::connect_to_context (c); + + Dispatcher *d = c->get_global_context ()->event_source (); + d->add_listener (GET_LISTENER (one_time_step), ly_symbol2scm ("OneTimeStep")); + d->add_listener (GET_LISTENER (prepare), ly_symbol2scm ("Prepare")); + d->add_listener (GET_LISTENER (finish), ly_symbol2scm ("Finish")); } +/* + uncovered: + + check_removal always returns false for Score contexts, it has been that way +since I joined the project. There is a reason for this: The typeset score is +stored in the Score_engraver, which in turn is accessed through the +Global_context returned by ly:run-translator. So the score-translator must be +connected to the score-context after run-translator finishes. + +I plan to change this: we should junk run-translator, and instead keep track +of both context and translator in the SCM code, and access the typeset score +directly via the created global-translator. Then it would be possible to +disconnect score-translators at iteration time. -es + */ void -Score_engraver::do_announces() +Score_engraver::disconnect_from_context () { - /* 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 + Dispatcher *d = context ()->get_global_context ()->event_source (); + d->remove_listener (GET_LISTENER (one_time_step), ly_symbol2scm ("OneTimeStep")); + d->remove_listener (GET_LISTENER (prepare), ly_symbol2scm ("Prepare")); + d->remove_listener (GET_LISTENER (finish), ly_symbol2scm ("Finish")); - */ - while (announce_info_arr_.size()) - { - for (int i=0; i < announce_info_arr_.size(); i++) - /* - TODO - - More subtle spacing - */ - if (announce_info_arr_[i].req_l_) - { - Musical_req *m = announce_info_arr_[i].req_l_->access_Musical_req (); - if (m && m->access_Rhythmic_req ()) - { - musical_column_l_->add_duration (m->duration()); - } - } - Engraver_group_engraver::do_announces(); - } + Engraver_group::disconnect_from_context (); } - void -Score_engraver::typeset_element (Score_element *elem_p) +Score_engraver::finalize () { - elem_p_arr_.push(elem_p); + Engraver_group::finalize (); + + typeset_all (); } +IMPLEMENT_LISTENER (Score_engraver, one_time_step); void -Score_engraver::typeset_all() +Score_engraver::one_time_step (SCM) { - for (int i =0; i < elem_p_arr_.size(); i++) + if (!to_boolean (context ()->get_property ("skipTypesetting"))) { - Score_element * elem_p = elem_p_arr_[i]; - if (elem_p->access_Spanner ()) - { - Spanner *s = elem_p->access_Spanner (); - pscore_p_->typeset_unbroken_spanner (s); - - - - /* - 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\'", s->name ())); - } - } while (flip(&d) != LEFT); - } - else - { - Item *item_p = elem_p->access_Item (); - pscore_p_->typeset_element (item_p); - if (!item_p->axis_group_l_a_[X_AXIS]) { - if (item_p->breakable_b_) - command_column_l_->add_element(item_p); - else - musical_column_l_->add_element(item_p); - } - } - scoreline_l_->add_element (elem_p); + precomputed_recurse_over_translators (context (), PROCESS_MUSIC, UP); + Engraver_group::do_announces (); } - elem_p_arr_.clear(); + + precomputed_recurse_over_translators (context (), STOP_TRANSLATION_TIMESTEP, UP); + typeset_all (); } void -Score_engraver::do_pre_move_processing() +Score_engraver::announce_grob (Grob_info info) { - if (break_penalty_i_ > Break_req::DISALLOW) + Engraver_group::announce_grob (info); + if (info.start_end () == START) { - get_staff_info().command_pcol_l ()-> breakable_b_ = true; - breaks_i_ ++; - if (! (breaks_i_%8)) - *mlog << "[" << breaks_i_ << "]" << flush; + pscore_->root_system ()->typeset_grob (info.grob ()); + elems_.push_back (info.grob ()); } - // this generates all items. - Engraver_group_engraver::do_pre_move_processing(); - - typeset_all(); } void -Score_engraver::set_columns (Score_column *new_command_l, - Score_column *new_musical_l) +Score_engraver::typeset_all () { - if (command_column_l_ && command_column_l_->linked_b()) - { - pscore_p_->add_column (command_column_l_); - scoreline_l_->add_element (command_column_l_); - } - else - { - delete command_column_l_ ; - command_column_l_ =0; - } - if (new_command_l) + for (vsize i = 0; i < elems_.size (); i++) { - command_column_l_ = new_command_l; - command_column_l_->musical_b_ = false; - } - if (musical_column_l_ && musical_column_l_->linked_b()) - { - pscore_p_->add_column (musical_column_l_); - scoreline_l_->add_element (musical_column_l_); - } - else - { - delete musical_column_l_; - musical_column_l_ = 0; - } - - if (new_musical_l) - { - musical_column_l_ = new_musical_l; - musical_column_l_->musical_b_ = true; - } -} - - -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; -} - + Grob *elem = elems_[i]; - -Music_output* -Score_engraver::get_output_p () -{ - Music_output * o = pscore_p_; - pscore_p_=0; - return o; -} - -bool -Score_engraver::do_try_request (Request*r) -{ - bool gotcha = Engraver_group_engraver::do_try_request (r); - - if (gotcha || !r->access_Command_req ()) - return gotcha; - - Command_req * c = r->access_Command_req (); - if (c->access_Break_req ()) - { - Break_req* b = (Break_req*)c->access_Break_req (); - if (b->penalty_i_ <= Break_req::DISALLOW) - break_penalty_i_ = b->penalty_i_; - else if (b->penalty_i_ >= Break_req::FORCE) - { - command_column_l_->break_penalty_i_ = b->penalty_i_; - gotcha = true; - } + if (!elem->get_parent (Y_AXIS)) + Axis_group_interface::add_element (system_, elem); } - return gotcha; -} - -IMPLEMENT_IS_TYPE_B1(Score_engraver,Engraver_group_engraver); -ADD_THIS_TRANSLATOR(Score_engraver); - -void -Score_engraver::do_add_processing () -{ - Translator_group::do_add_processing (); - assert (output_def_l_->is_type_b (Paper_def::static_name ())); - assert (!daddy_trans_l_); - pscore_p_ = new Paper_score; - pscore_p_->paper_l_ = (Paper_def*)output_def_l_; -} + elems_.clear (); +} + +ADD_TRANSLATOR_GROUP (Score_engraver, + /* doc */ + "The top-level engraver. Takes care of generating" + " columns and the complete system (i.e.," + " @code{System}).\n" + "\n" + "This engraver decides whether a column is breakable." + " The default is that a column is always breakable." + " However, every @code{Bar_engraver} that does not have" + " a bar line at a certain point sets @code{forbidBreaks}" + " to stop line breaks. In practice, this means that you" + " can make a break point by creating a bar line" + " (assuming that there are no beams or notes that" + " prevent a break point).", + + /* create */ + "System ", + + /* read */ + "currentMusicalColumn " + "currentCommandColumn ", + + /* write */ + "" + );