X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscore-engraver.cc;h=258b55bd22d2dc43de820ebf016feecf8741243a;hb=e8748c4f6cc4d4a3f5ce7661a6b8fadaa0aa5943;hp=31349ad2cf3b7add88629e247c90d2c84a3e7a3a;hpb=7e72a1e50e94a7f9738d62599de79fe7745f600c;p=lilypond.git diff --git a/lily/score-engraver.cc b/lily/score-engraver.cc index 31349ad2cf..258b55bd22 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--2004 Han-Wen Nienhuys + (c) 1997--2005 Han-Wen Nienhuys */ #include "all-font-metrics.hh" @@ -11,341 +11,172 @@ #include "warn.hh" #include "main.hh" #include "system.hh" -#include "item.hh" #include "score-engraver.hh" #include "paper-score.hh" #include "paper-column.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 "global-context.hh" +#include "open-type-font.hh" +#include "paper-column-engraver.hh" /* TODO: the column creation logic is rather hairy. Revise it. - */ +*/ Score_engraver::Score_engraver () { - system_ =0; - command_column_ =0; - musical_column_ =0; - breaks_ =0; + system_ = 0; pscore_ = 0; } void -Score_engraver::make_columns () +Score_engraver::derived_mark () const { - /* - ugh. - */ - if (!command_column_) - { - set_columns (new Paper_column (get_property ("NonMusicalPaperColumn")), - new Paper_column (get_property ("PaperColumn"))); - - command_column_->set_grob_property ("breakable", SCM_BOOL_T); - - - 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); - } + if (pscore_) + scm_gc_mark (pscore_->self_scm ()); + Score_translator::derived_mark (); + Engraver_group::derived_mark (); } void -Score_engraver::prepare (Moment w) +Score_engraver::prepare (Moment m) { - Global_translator::prepare (w); - - /* - TODO: don't make columns when skipTypesetting is true. - */ - make_columns (); - - command_column_->set_grob_property ("when", now_mom_.smobbed_copy ()); - musical_column_->set_grob_property ("when", now_mom_.smobbed_copy ()); + (void) m; - - Translator_group::start_translation_timestep(); + precomputed_recurse_over_translators (context (), START_TRANSLATION_TIMESTEP, DOWN); } void Score_engraver::finish () { - if ((breaks_%8)) - progress_indication ("[" + to_string (breaks_) + "]"); - - check_removal (); - finalize (); + recurse_over_translators (context (), &Translator::finalize, + &Translator_group::finalize, + UP); } +#define MUSIC_FONT "emmentaler-20" + /* use start/finish? - */ +*/ void Score_engraver::initialize () { - Font_metric *fm = all_fonts_global->find_afm("feta20"); + Font_metric *fm = all_fonts_global->find_otf (MUSIC_FONT); if (!fm) - error (_f ("can't find `%s'", "feta20.afm") - + "\n" +_ ("Fonts have not been installed properly. Aborting")); - - unsmob_context_def (definition_)->apply_default_property_operations (this); + { + 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 ().to_str0 ()) + + "\n" + + _ ("Aborting")); + } - assert (dynamic_cast (output_def_)); - assert (!daddy_trans_); - pscore_ = new Paper_score; - pscore_->paper_ = dynamic_cast (output_def_); + pscore_ = new Paper_score (dynamic_cast (context ()->get_output_def ())); + pscore_->unprotect (); - SCM props = get_property ("System"); + SCM props = updated_grob_properties (context (), ly_symbol2scm ("System")); - pscore_->typeset_line (new System (props)); - - make_columns (); - system_ = pscore_->system_; - system_->set_bound (LEFT, command_column_); - command_column_->set_grob_property ("breakable", SCM_BOOL_T); + Object_key const *sys_key = context ()->get_grob_key ("System"); + pscore_->typeset_system (new System (props, sys_key)); + system_ = pscore_->root_system (); + context ()->set_property ("rootSystem", system_->self_scm ()); - Engraver_group_engraver::initialize (); + Engraver_group::initialize (); } - void Score_engraver::finalize () { - Engraver_group_engraver::finalize (); + Score_translator::finalize (); - Grob * cc - = unsmob_grob (get_property ("currentCommandColumn")); - system_->set_bound (RIGHT, cc); - cc->set_grob_property ("breakable", SCM_BOOL_T); - typeset_all (); } void Score_engraver::one_time_step () { - if (!to_boolean (get_property ("skipTypesetting"))) + if (!to_boolean (context ()->get_property ("skipTypesetting"))) { - process_music (); - do_announces (); + precomputed_recurse_over_translators (context (), PROCESS_MUSIC, UP); + Engraver_group::do_announces (); } - - stop_translation_timestep (); - - apply_finalizations (); - check_removal (); - - for (int i = announce_infos_.size(); i--;) - { - Grob *g = announce_infos_[i].grob_; - if (!dynamic_cast (g)) // ugh. - { - String msg= "Grob " - + g->name() - + " was created too late!"; - g->programming_error (msg); - } - } - announce_infos_.clear (); + precomputed_recurse_over_translators (context (), STOP_TRANSLATION_TIMESTEP, UP); + typeset_all (); } void Score_engraver::announce_grob (Grob_info info) { announce_infos_.push (info); - pscore_->system_->typeset_grob (info.grob_); -} - -void -Score_engraver::typeset_grob (Grob *elem) -{ - if (!elem) - programming_error ("Score_engraver: empty elt\n"); - else - elems_.push (elem); + pscore_->root_system ()->typeset_grob (info.grob ()); + elems_.push (info.grob ()); } void Score_engraver::typeset_all () { - for (int i =0; i < elems_.size (); i++) + for (int i = 0; i < elems_.size (); i++) { - Grob * elem = elems_[i]; - - if (Spanner *s = dynamic_cast (elem)) - { - /* - do something sensible if spanner not - spanned on 2 items. - */ - Direction d = LEFT; - do { - if (!s->get_bound (d)) - { - s->set_bound (d, command_column_); - /* don't warn for empty/suicided spanners, - it makes real warningsinvisible. - maybe should be junked earlier? */ - if (!elem->live()) - ; // gdb hook - else - elem->warning (_f ("unbound spanner `%s'", s->name ().to_str0 ())); - } - } - while (flip (&d) != LEFT); - - if (dynamic_cast (s->get_parent (Y_AXIS))) - programming_error ("Spanner Y-parent is an item."); - } - else - { - if (!elem->get_parent (X_AXIS)) - { - bool br = to_boolean (elem->get_grob_property ("breakable")); - Axis_group_interface::add_element (br ? command_column_ : musical_column_, elem); + Grob *elem = elems_[i]; - } - } if (!elem->get_parent (Y_AXIS)) Axis_group_interface::add_element (system_, elem); } elems_.clear (); } -void -Score_engraver::stop_translation_timestep () -{ - // this generates all items. - Engraver_group_engraver::stop_translation_timestep (); - - typeset_all (); - if (to_boolean (command_column_->get_grob_property ("breakable"))) - { - breaks_ ++; - if (! (breaks_%8)) - progress_indication ("[" + to_string (breaks_) + "]"); - } - - - system_->add_column (command_column_); - system_->add_column (musical_column_); - - command_column_ = 0; - musical_column_ = 0; -} - -void -Score_engraver::set_columns (Paper_column *new_command, - Paper_column *new_musical) -{ - assert (!command_column_ && !musical_column_); - - command_column_ = new_command; - musical_column_ = new_musical; - if (new_command) - { - set_property ("currentCommandColumn", new_command->self_scm ()); - } - - if (new_musical) - { - set_property ("currentMusicalColumn", new_musical->self_scm ()); - } -} - -Music_output* +SCM Score_engraver::get_output () { - Music_output * o = pscore_; - pscore_=0; - return o; -} - -bool -Score_engraver::try_music (Music*r) -{ - bool gotcha = Engraver_group_engraver::try_music (r); - - if (!gotcha && r->is_mus_type ("break-event")) - { - gotcha = true; - - SCM pen = command_column_->get_grob_property ("penalty"); - Real total_penalty = gh_number_p (pen) - ? gh_scm2double (pen) - : 0.0; - - SCM rpen = r->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_->set_grob_property ("penalty", - gh_double2scm (total_penalty)); - } - return gotcha; + Music_output *o = pscore_; + return o->self_scm (); } /* - TODO: use property Score.breakForbidden = #t - */ + UGH UGH +*/ void Score_engraver::forbid_breaks () { - /* - result is junked. - */ - if (command_column_) - command_column_->set_grob_property ("breakable", SCM_EOL); -} - -void -Score_engraver::acknowledge_grob (Grob_info gi) -{ - 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_)) + for (SCM s = simple_trans_list_; scm_is_pair (s); s = scm_cdr (s)) { - Pointer_group_interface::add_grob (musical_column_, - ly_symbol2scm ("spacing-wishes"), - gi.grob_); + Translator *tr = unsmob_translator (scm_car (s)); + if (Paper_column_engraver *pce = dynamic_cast (tr)) + pce->forbid_breaks (); } } - - -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 */ ""); +bool +Score_engraver::try_music (Music *m) +{ + if (Engraver_group::try_music (m)) + return true; + + return false; +} + +ADD_TRANSLATOR_GROUP (Score_engraver, + /* doc */ "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.) ", + /* create */ + "System ", + + /* accept */ + "break-event", + /* read */ + "currentMusicalColumn " + "currentCommandColumn " + "verticallySpacedContexts", + /* write */ + "");