X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscore-engraver.cc;h=442574125418c212a9039b419b668ce959bb7d57;hb=26aa7a02d8cad410c4b496b87891653edbba771a;hp=76ecf79872545323a3d145e54feca3974fe7d0e2;hpb=d9b43b93f2c885409bafdb157138158f65cc49aa;p=lilypond.git diff --git a/lily/score-engraver.cc b/lily/score-engraver.cc index 76ecf79872..4425741254 100644 --- a/lily/score-engraver.cc +++ b/lily/score-engraver.cc @@ -3,34 +3,35 @@ source file of the GNU LilyPond music typesetter - (c) 1997--2002 Han-Wen Nienhuys + (c) 1997--2005 Han-Wen Nienhuys */ -#include "debug.hh" - -#include "line-of-score.hh" -#include "item.hh" +#include "all-font-metrics.hh" +#include "afm.hh" +#include "warn.hh" +#include "main.hh" +#include "system.hh" #include "score-engraver.hh" #include "paper-score.hh" #include "paper-column.hh" -#include "command-request.hh" -#include "paper-def.hh" +#include "output-def.hh" #include "axis-group-interface.hh" -#include "translator-def.hh" - +#include "context-def.hh" #include "staff-spacing.hh" #include "note-spacing.hh" +#include "global-context.hh" +#include "open-type-font.hh" /* 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 @@ -38,81 +39,103 @@ Score_engraver::make_columns () { /* ugh. - */ - if (!command_column_l_) + */ + if (!command_column_) { - set_columns (new Paper_column (get_property ("NonMusicalPaperColumn")), - new Paper_column (get_property ("PaperColumn"))); - - command_column_l_->set_grob_property ("breakable", SCM_BOOL_T); + SCM nmp + = updated_grob_properties (context (), + ly_symbol2scm ("NonMusicalPaperColumn")); + + Object_key const *key1 = context ()->get_grob_key ("NonMusicalPaperColumn"); - Grob_info i1 (command_column_l_, SCM_EOL); - i1.origin_trans_l_ = this; + SCM pc = updated_grob_properties (context (), + ly_symbol2scm ("PaperColumn")); + Object_key const *key2 = context ()->get_grob_key ("PaperColumn"); + set_columns (new Paper_column (nmp, key1), new Paper_column (pc, key2)); - Grob_info i2 (musical_column_l_, SCM_EOL); - i2.origin_trans_l_ = this; + 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::prepare (Moment w) +Score_engraver::prepare (Moment m) { - Global_translator::prepare (w); - + /* + TODO: don't make columns when skipTypesetting is true. + */ make_columns (); - start_translation_timestep (); + + 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_i_%8)) - progress_indication ("[" + to_str (breaks_i_) + "]"); - - check_removal (); - removal_processing (); + if ((breaks_ % 8)) + progress_indication ("[" + to_string (breaks_) + "]"); + recurse_over_translators (context (), &Translator::finalize, UP); } +#define MUSIC_FONT "emmentaler-20" + /* use start/finish? - */ +*/ void Score_engraver::initialize () { - unsmob_translator_def (definition_)->apply_property_operations (this); + 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 ().to_str0 ()) + + "\n" + + _ ("Aborting")); + } + + pscore_ = new Paper_score (dynamic_cast (get_output_def ())); - 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 = updated_grob_properties (context (), ly_symbol2scm ("System")); - SCM props = get_property ("LineOfScore"); + Object_key const *sys_key = context ()->get_grob_key ("System"); + pscore_->typeset_system (new System (props, sys_key)); - pscore_p_->typeset_line (new Line_of_score (props)); - + system_ = pscore_->root_system (); 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); + system_->set_bound (LEFT, command_column_); + command_column_->set_property ("breakable", SCM_BOOL_T); Engraver_group_engraver::initialize (); } - void Score_engraver::finalize () { - Engraver_group_engraver::finalize (); + Score_translator::finalize (); - Grob * cc + Grob *cc = unsmob_grob (get_property ("currentCommandColumn")); - scoreline_l_->set_bound (RIGHT, cc); - cc->set_grob_property ("breakable", SCM_BOOL_T); - + system_->set_bound (RIGHT, cc); + cc->set_property ("breakable", SCM_BOOL_T); + typeset_all (); } @@ -121,77 +144,43 @@ Score_engraver::one_time_step () { if (!to_boolean (get_property ("skipTypesetting"))) { - process_music (); - announces (); + recurse_over_translators (context (), &Engraver::process_music, UP); + Engraver_group_engraver::do_announces (); } - - stop_translation_timestep (); - check_removal (); + recurse_over_translators (context (), &Translator::stop_translation_timestep, UP); } void Score_engraver::announce_grob (Grob_info info) { - announce_info_arr_.push (info); - pscore_p_->line_l_->typeset_grob (info.grob_l_); - - -} - - -void -Score_engraver::typeset_grob (Grob *elem_p) -{ - if (!elem_p) - programming_error ("Score_engraver: empty elt\n"); - else - - elem_p_arr_.push (elem_p); + announce_infos_.push (info); + pscore_->root_system ()->typeset_grob (info.grob_); + elems_.push (info.grob_); } - void Score_engraver::typeset_all () { - for (int i =0; i < elem_p_arr_.size (); i++) + for (int i = 0; i < elems_.size (); i++) { - Grob * elem_p = elem_p_arr_[i]; - - if (Spanner *s = dynamic_cast (elem_p)) - { - /* - 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_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); - } - else + Grob *elem = elems_[i]; + + if (dynamic_cast (elem)) { - if (!elem_p->get_parent (X_AXIS)) + if ((!elem->get_parent (X_AXIS) + || !unsmob_grob (elem->get_property ("axis-group-parent-X"))) + && elem != command_column_ + && elem != musical_column_) { - bool br = to_boolean (elem_p->get_grob_property ("breakable")); - Axis_group_interface::add_element (br ? command_column_l_ : musical_column_l_, elem_p); - + bool br = to_boolean (elem->get_property ("breakable")); + Axis_group_interface::add_element (br ? command_column_ : musical_column_, elem); } } - if (!elem_p->get_parent (Y_AXIS)) - Axis_group_interface::add_element (scoreline_l_, elem_p); + if (!elem->get_parent (Y_AXIS)) + Axis_group_interface::add_element (system_, elem); } - elem_p_arr_.clear (); + elems_.clear (); } void @@ -199,124 +188,132 @@ Score_engraver::stop_translation_timestep () { // this generates all items. Engraver_group_engraver::stop_translation_timestep (); - + typeset_all (); - if (to_boolean (command_column_l_->get_grob_property ("breakable"))) + 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_) + "]"); } - 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; + 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) { - 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) - set_property ("currentCommandColumn", new_command_l->self_scm ()); + assert (!command_column_ && !musical_column_); + + command_column_ = new_command; + musical_column_ = new_musical; + if (new_command) + { + context ()->set_property ("currentCommandColumn", new_command->self_scm ()); + } + + if (new_musical) + { + context ()->set_property ("currentMusicalColumn", new_musical->self_scm ()); + } + + system_->add_column (command_column_); + system_->add_column (musical_column_); } -Music_output* -Score_engraver::get_output_p () +Music_output * +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::try_music (Music*r) +Score_engraver::try_music (Music *m) { - bool gotcha = Engraver_group_engraver::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 = scm_is_number (pen) ? scm_to_double (pen) : 0.0; + SCM mpen = m->get_property ("penalty"); + if (scm_is_number (mpen)) + total_penalty += scm_to_double (mpen); - SCM pen = command_column_l_->get_grob_property ("penalty"); - Real total_penalty = gh_number_p (pen) - ? gh_scm2double (pen) - : 0.0; + command_column_->set_property ("penalty", scm_make_real (total_penalty)); - 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 (); + /* ugh. arbitrary, hardcoded */ + if (total_penalty > 10000.0) + forbid_breaks (); - command_column_l_->set_grob_property ("penalty", - gh_double2scm (total_penalty)); - } + SCM page_pen = command_column_->get_property ("page-penalty"); + Real total_pp = scm_is_number (page_pen) ? scm_to_double (page_pen) : 0.0; + SCM mpage_pen = m->get_property ("page-penalty"); + if (scm_is_number (mpage_pen)) + total_pp += scm_to_double (mpage_pen); + + command_column_->set_property ("page-penalty", scm_make_real (total_pp)); + return true; } - return gotcha; + return false; } -/* - TODO: use property Score.breakForbidden = #t - */ - void Score_engraver::forbid_breaks () { - /* - result is junked. - */ - command_column_l_->remove_grob_property ("breakable"); + if (command_column_) + command_column_->set_property ("breakable", SCM_EOL); } - + void Score_engraver::acknowledge_grob (Grob_info gi) { - if (Staff_spacing::has_interface (gi.grob_l_)) + if (Staff_spacing::has_interface (gi.grob_)) { - Pointer_group_interface::add_grob (command_column_l_, - ly_symbol2scm ("spacing-wishes"), - gi.grob_l_); + Pointer_group_interface::add_grob (command_column_, + ly_symbol2scm ("spacing-wishes"), + gi.grob_); } - if (Note_spacing::has_interface (gi.grob_l_)) + if (Note_spacing::has_interface (gi.grob_)) { - Pointer_group_interface::add_grob (musical_column_l_, + Pointer_group_interface::add_grob (musical_column_, ly_symbol2scm ("spacing-wishes"), - gi.grob_l_); + gi.grob_); } -} - - -ENTER_DESCRIPTION(Score_engraver, -/* descr */ "Top level engraver. Takes care of generating columns and the complete system (ie. LineOfScore) - - -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.) + if (Axis_group_interface::has_interface (gi.grob_) + && gi.grob_->internal_has_interface (ly_symbol2scm ("vertically-spaceable-interface"))) + { + SCM spaceable = get_property ("verticallySpacedContexts"); + Context *orig = gi.origin_contexts (this)[0]; + if (scm_memq (ly_symbol2scm (orig->context_name ().to_str0 ()), + spaceable) != SCM_BOOL_F) + { + Pointer_group_interface::add_grob (system_, + ly_symbol2scm ("spaceable-staves"), + gi.grob_); + } + } +} -", -/* creats*/ "LineOfScore PaperColumn NonMusicalPaperColumn", -/* acks */ "note-spacing-interface staff-spacing-interface", -/* reads */ "currentMusicalColumn currentCommandColumn", -/* write */ ""); +ADD_TRANSLATOR (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 axis-group-interface", + /* reads */ "currentMusicalColumn currentCommandColumn verticallySpacedContexts", + /* write */ "");