X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpiano-pedal-engraver.cc;h=666cda769e3ed5842da8d0428b15f60bab8ca075;hb=675533acf58b9b863adc830f175696735ca6dc95;hp=0d2348f41b2ffa58ad24cdbcd5094f64ff564a6e;hpb=a4d7106c75b325441063fd9ba9c4131979784aa5;p=lilypond.git diff --git a/lily/piano-pedal-engraver.cc b/lily/piano-pedal-engraver.cc index 0d2348f41b..666cda769e 100644 --- a/lily/piano-pedal-engraver.cc +++ b/lily/piano-pedal-engraver.cc @@ -3,126 +3,170 @@ source file of the GNU LilyPond music typesetter - (c) 2000 Jan Nieuwenhuizen - */ + (c) 2000--2002 Jan Nieuwenhuizen + + Chris Jackson - extended to support + bracketed pedals. +*/ #include "engraver.hh" #include "musical-request.hh" -#include "score-element.hh" +#include "grob.hh" #include "item.hh" #include "lily-guile.hh" -#include "rhythmic-head.hh" -#include "stem.hh" #include "side-position-interface.hh" #include "staff-symbol-referencer.hh" #include "item.hh" +#include "axis-group-interface.hh" +#include "translator-group.hh" +#include "directional-element-interface.hh" +#include "note-column.hh" +struct Pedal_info +{ + char const * name_; + Span_req* start_req_l_; + Drul_array req_l_drul_; + Item* item_p_; + Spanner* bracket_p_; // A single portion of a pedal bracket + Spanner* finished_bracket_p_; + /* + This grob contains all the pedals of the same type on the same staff + */ + Spanner* line_spanner_; + Spanner* finished_line_spanner_; + Span_req* current_bracket_req_; +}; - -/** - engrave Piano pedals symbols. - */ class Piano_pedal_engraver : public Engraver { public: - VIRTUAL_COPY_CONS (Translator); - Piano_pedal_engraver (); + TRANSLATOR_DECLARATIONS (Piano_pedal_engraver); ~Piano_pedal_engraver (); protected: - virtual void do_creation_processing (); - virtual bool do_try_music (Music*); - void deprecated_process_music (); - virtual void do_pre_move_processing (); - virtual void do_post_move_processing (); - virtual void acknowledge_element (Score_element_info); - virtual void process_acknowledged (); + virtual void initialize (); + virtual void finalize (); + virtual bool try_music (Music*); + virtual void stop_translation_timestep (); + virtual void start_translation_timestep (); + virtual void acknowledge_grob (Grob_info); + virtual void process_acknowledged_grobs (); private: - struct Pedal_info - { - char const * name_; - Span_req* start_req_l_; - Drul_array req_l_drul_; - Item* item_p_; - }; - Pedal_info *info_list_; + + /* + Record a stack of the current pedal spanners, so if more than one pedal + occurs simultaneously then extra space can be added between them. + + + Why 4, why not 3. Why not 3423 ? ---hwn. + */ + + Spanner *previous_p_ [4]; + + int spanner_count_; + + /* + Left and right flare widths of a \___/, as specified by the grob + property edge-widen. + */ + Drul_array edge_width_drul_; + + void create_text_grobs (Pedal_info *p, SCM pedaltype); + void create_bracket_grobs (Pedal_info *p, SCM pedaltype); + void typeset_all (); }; -ADD_THIS_TRANSLATOR (Piano_pedal_engraver); Piano_pedal_engraver::Piano_pedal_engraver () { info_list_ = 0; } + void -Piano_pedal_engraver::do_creation_processing() +Piano_pedal_engraver::initialize () { info_list_ = new Pedal_info[4]; Pedal_info *p = info_list_; + spanner_count_ = 0; + for (int i = 0; i < 3; ++i) + previous_p_[i] = 0; + - char * names [] = { "Sostenuto", "Sustain", "UnaChorda", 0 }; + char * names [] = { "Sostenuto", "Sustain", "UnaCorda", 0 }; char **np = names ; do { p->name_ = *np; p->item_p_ = 0; + p->bracket_p_ = 0; + p->finished_bracket_p_ = 0; + p->line_spanner_ = 0; + p->finished_line_spanner_ = 0; + p->current_bracket_req_ = 0; p->req_l_drul_[START] = 0; p->req_l_drul_[STOP] = 0; p->start_req_l_ = 0; p++; } - while (*(np ++)); + while (* (np ++)); } -Piano_pedal_engraver::~Piano_pedal_engraver() +Piano_pedal_engraver::~Piano_pedal_engraver () { delete[] info_list_; } /* - Urg: Code dup - I'm a script - */ + Urg: Code dup + I'm a script + */ void -Piano_pedal_engraver::acknowledge_element (Score_element_info info) +Piano_pedal_engraver::acknowledge_grob (Grob_info info) { for (Pedal_info*p = info_list_; p && p->name_; p ++) { - if (p->item_p_) + if (Note_column::has_interface (info.grob_l_)) { - if (Rhythmic_head::has_interface (info.elem_l_)) + if (p->line_spanner_) { - Side_position::add_support (p->item_p_, info.elem_l_); - - if (Side_position::get_axis(p->item_p_) == X_AXIS - && !p->item_p_->parent_l (Y_AXIS)) - p->item_p_->set_parent (info.elem_l_, Y_AXIS); - } - if (Stem::has_interface (info.elem_l_)) - { - Side_position::add_support (p->item_p_,info.elem_l_); - } + Side_position_interface::add_support (p->line_spanner_, info.grob_l_); + + add_bound_item (p->line_spanner_,info.grob_l_); + } + if (p->bracket_p_) + add_bound_item (p->bracket_p_,info.grob_l_); + } } } bool -Piano_pedal_engraver::do_try_music (Music *m) +Piano_pedal_engraver::try_music (Music *m) { - if (Span_req * s = dynamic_cast(m)) + if (Span_req * s = dynamic_cast (m)) { for (Pedal_info*p = info_list_; p->name_; p ++) { + if (ly_scm2string (s->get_mus_property ("span-type")) == "abort") + { + p->req_l_drul_[START] = 0; + p->req_l_drul_[STOP] = 0; + + if (p->bracket_p_) + p->bracket_p_->suicide (); /* as in dynamic-engraver.cc */ + p->bracket_p_ = 0; + } if (scm_equal_p (s->get_mus_property ("span-type"), ly_str02scm (p->name_))==SCM_BOOL_T) { - p->req_l_drul_[s->get_span_dir()] = s; + p->req_l_drul_[s->get_span_dir ()] = s; return true; } } @@ -131,78 +175,278 @@ Piano_pedal_engraver::do_try_music (Music *m) } void -Piano_pedal_engraver::process_acknowledged () -{ - deprecated_process_music (); -} - -void -Piano_pedal_engraver::deprecated_process_music () +Piano_pedal_engraver::process_acknowledged_grobs () { for (Pedal_info*p = info_list_; p && p->name_; p ++) { - if (p->item_p_) - continue; - SCM s = SCM_EOL; - if (p->req_l_drul_[STOP] && p->req_l_drul_[START]) + if (p->req_l_drul_[STOP] || p->req_l_drul_[START]) { - if (!p->start_req_l_) + if (!p->line_spanner_) { - p->req_l_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: %s", p->name_ )); + String name = String (p->name_) + "PedalLineSpanner"; + p->line_spanner_ = new Spanner (get_property (name.ch_C ())); + Side_position_interface::set_axis (p->line_spanner_, Y_AXIS); + Music * rq = (p->req_l_drul_[START] ? p->req_l_drul_[START] : p->req_l_drul_[STOP]); + announce_grob (p->line_spanner_, rq->self_scm ()); } - else + + /* Choose the appropriate grobs to add to the line spanner + These can be text items or text-spanners + */ + SCM type = ly_cdr (scm_assoc (ly_symbol2scm ("pedal-type"), + get_property ( (String (p->name_) + "Pedal").ch_C ()))); + if (type == ly_symbol2scm ("text") || // Ped. *Ped. * + type == ly_symbol2scm ("mixed") ) // Ped. _____/\____| { - s = get_property (("stopStart" + String (p->name_ )).ch_C()); + if (! p->item_p_) + create_text_grobs (p, type); } - p->start_req_l_ = p->req_l_drul_[START]; + if (type == ly_symbol2scm ("bracket") || // |_________/\____| + type == ly_symbol2scm ("mixed") ) + { + create_bracket_grobs (p, type); + } } - else if (p->req_l_drul_[STOP]) + } +} + + +void +Piano_pedal_engraver::create_text_grobs (Pedal_info *p, SCM pedaltype) +{ + SCM b; + SCM s = SCM_EOL; + SCM strings = get_property ( ("pedal" + String (p->name_) + "Strings").ch_C ()); + + if (scm_ilength (strings) >= 3) + { + if (p->req_l_drul_[STOP] && p->req_l_drul_[START]) { - if (!p->start_req_l_) + if (pedaltype == ly_symbol2scm ("text")) { - p->req_l_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: %s", p->name_ )); + if (!p->start_req_l_) + { + p->req_l_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_)); + } + else + { + s = ly_cadr (strings); + } + p->start_req_l_ = p->req_l_drul_[START]; } - else + } + else if (p->req_l_drul_[STOP]) + { + if (pedaltype == ly_symbol2scm ("text")) { - s = get_property (("stop" + String (p->name_ )).ch_C()); + if (!p->start_req_l_) + { + p->req_l_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_)); + } + else + { + s = ly_caddr (strings); + spanner_count_ --; + } + p->start_req_l_ = 0; } - p->start_req_l_ = 0; } else if (p->req_l_drul_[START]) { p->start_req_l_ = p->req_l_drul_[START]; - s = get_property (("start" + String (p->name_ )).ch_C()); + s = ly_car (strings); + if (pedaltype == ly_symbol2scm ("text")) + { + spanner_count_ ++; + previous_p_[spanner_count_] = p->line_spanner_; + if (spanner_count_ > 1) + // add extra space below the previous already-occuring pedal + Side_position_interface::add_support (p->line_spanner_, + previous_p_[spanner_count_ - 1]); + } } - + if (gh_string_p (s)) { String propname = String (p->name_) + "Pedal"; - p->item_p_ = new Item (get_property (propname.ch_C())); - p->item_p_->set_elt_property ("text", s); + b = get_property (propname.ch_C ()); + p->item_p_ = new Item (b); + p->item_p_->set_grob_property ("text", s); + Axis_group_interface::add_element (p->line_spanner_, p->item_p_); + + announce_grob (p->item_p_, + (p->req_l_drul_[START] + ? p->req_l_drul_[START] + : p->req_l_drul_[STOP])->self_scm ()); + + } + if (pedaltype == ly_symbol2scm ("text")) + { + p->req_l_drul_[START] = 0; + p->req_l_drul_[STOP] = 0; + } + } +} - announce_element (p->item_p_, - p->req_l_drul_[START] - ? p->req_l_drul_[START] - : p->req_l_drul_[STOP]); +void +Piano_pedal_engraver::create_bracket_grobs (Pedal_info *p, SCM pedaltype) +{ + + if (p->req_l_drul_[STOP]) + { + if (!p->start_req_l_) + { + p->req_l_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_)); } + else if (!p->req_l_drul_[START]) + spanner_count_ -- ; + + assert (!p->finished_bracket_p_ && p->bracket_p_); + + Grob *cmc = unsmob_grob (get_property ("currentMusicalColumn")); + p->bracket_p_->set_bound (RIGHT, cmc); + + /* + Set properties so that the molecule-creating function will + know whether the right edge should be flared ___/ + */ + SCM eleft = ly_car (p->bracket_p_->get_grob_property ("edge-widen")); + SCM eright = (p->req_l_drul_[START] ? edge_width_drul_[RIGHT] : gh_double2scm (0)); + p->bracket_p_->set_grob_property ("edge-widen", gh_cons (eleft, eright)); + + p->finished_bracket_p_ = p->bracket_p_; + p->bracket_p_ = 0; + p->current_bracket_req_ = 0; + p->start_req_l_ = p->req_l_drul_[START]; } + + if (p->req_l_drul_[START]) + { + p->start_req_l_ = p->req_l_drul_[START]; + p->current_bracket_req_ = p->req_l_drul_[START]; + + p->bracket_p_ = new Spanner (get_property ("PianoPedalBracket")); + + /* + Set properties so that the molecule-creating function will + know whether the left edge should be flared \___ + */ + + SCM ew = p->bracket_p_->get_grob_property ("edge-widen"); + edge_width_drul_[LEFT] = ly_car (ew); + edge_width_drul_[RIGHT] = ly_cdr (ew); + + SCM eleft = ( (bool) p->req_l_drul_[STOP] ? + edge_width_drul_[LEFT] : + gh_double2scm (0)); + SCM eright = gh_double2scm (0); + p->bracket_p_->set_grob_property ("edge-widen", gh_cons (eleft, eright)); + + /* Set this property for 'mixed style' pedals, Ped._______/\ , + so the molecule function will shorten the ____ line by the length of the Ped. text. + */ + + p->bracket_p_->set_grob_property ("text-start", + pedaltype == ly_symbol2scm ("mixed") ? + gh_bool2scm ( (bool) ! p->req_l_drul_[STOP]) : + gh_bool2scm (false)); + + /* + Mixed style: Store a pointer to the preceding text for use in + calculating the length of the line + */ + if (p->item_p_) + p->bracket_p_->set_grob_property ("pedal-text", p->item_p_->self_scm ()); + + p->bracket_p_->set_bound (LEFT, unsmob_grob (get_property ("currentMusicalColumn"))); + Axis_group_interface::add_element (p->line_spanner_, p->bracket_p_); + + add_bound_item (p->line_spanner_, p->bracket_p_->get_bound (LEFT)); + announce_grob (p->bracket_p_, p->req_l_drul_[START]->self_scm ()); + + if (!p->req_l_drul_[STOP]) + { + spanner_count_ ++; + previous_p_[spanner_count_] = p->line_spanner_; + + if (spanner_count_ > 1) + // position new pedal spanner below the current one + Side_position_interface::add_support (p->line_spanner_, previous_p_[spanner_count_ - 1]); + } + } + + p->req_l_drul_[START] = 0; + p->req_l_drul_[STOP] = 0; } void -Piano_pedal_engraver::do_pre_move_processing () +Piano_pedal_engraver::finalize () +{ + for (Pedal_info*p = info_list_; p && p->name_; p ++) + { + /* + suicide? + */ + if (p->line_spanner_ + && !p->line_spanner_->live()) + p->line_spanner_ = 0; + + if (p->line_spanner_) + { + p->finished_line_spanner_ = p->line_spanner_; + typeset_all (); + } + if (p->bracket_p_ + && !p->bracket_p_->live()) + p->bracket_p_ = 0; + if (p->bracket_p_) + { + p->current_bracket_req_->origin ()->warning (_ ("unterminated pedal bracket")); + p->bracket_p_->suicide (); + p->bracket_p_ = 0; + } + } +} + + +void +Piano_pedal_engraver::stop_translation_timestep () +{ + for (Pedal_info*p = info_list_; p && p->name_; p ++) + { + if (!p->bracket_p_) + { + p->finished_line_spanner_ = p->line_spanner_; + p->line_spanner_ = 0; + } + } + + typeset_all (); +} + + +void +Piano_pedal_engraver::typeset_all () { Item * sustain = 0; for (Pedal_info*p = info_list_; p->name_; p ++) { + /* + Handle suicide. + */ + if (p->finished_line_spanner_ + && !p->finished_line_spanner_->live ()) + p->finished_line_spanner_ = 0; + if (p->finished_bracket_p_ + && !p->finished_bracket_p_->live()) + p->finished_bracket_p_ = 0; + + if (p->name_ == String ("Sustain")) sustain = p->item_p_; - } - for (Pedal_info*p = info_list_; p->name_; p ++) - { if (p->item_p_) { - Side_position::add_staff_support (p->item_p_); /* Hmm. */ @@ -210,17 +454,50 @@ Piano_pedal_engraver::do_pre_move_processing () { if (sustain) { - Side_position::add_support (p->item_p_,sustain); + Side_position_interface::add_support (p->item_p_,sustain); } } - typeset_element (p->item_p_); + typeset_grob (p->item_p_); + p->item_p_ = 0; + } + + if (p->finished_bracket_p_) + { + Grob * l = p->finished_bracket_p_->get_bound (LEFT); + Grob * r = p->finished_bracket_p_->get_bound (RIGHT); + if (!r) + { + p->finished_bracket_p_->set_bound (RIGHT, unsmob_grob (get_property ("currentMusicalColumn"))); + } + + typeset_grob (p->finished_bracket_p_); + p->finished_bracket_p_ =0; + } + + if (p->finished_line_spanner_) + { + Side_position_interface::add_staff_support (p->finished_line_spanner_); + Grob * l = p->finished_line_spanner_->get_bound (LEFT); + Grob * r = p->finished_line_spanner_->get_bound (RIGHT); + if (!r && l) + p->finished_line_spanner_->set_bound (RIGHT, l); + else if (!l && r) + p->finished_line_spanner_->set_bound (LEFT, r); + else if (!r && !l) + { + Grob * cc = unsmob_grob (get_property ("currentMusicalColumn")); + Item * ci = dynamic_cast (cc); + p->finished_line_spanner_->set_bound (RIGHT, ci); + p->finished_line_spanner_->set_bound (LEFT, ci); + } + typeset_grob (p->finished_line_spanner_); + p->finished_line_spanner_ = 0; } - p->item_p_ = 0; } } void -Piano_pedal_engraver::do_post_move_processing () +Piano_pedal_engraver::start_translation_timestep () { for (Pedal_info*p = info_list_; p->name_; p ++) { @@ -228,3 +505,9 @@ Piano_pedal_engraver::do_post_move_processing () p->req_l_drul_[START] = 0; } } +ENTER_DESCRIPTION (Piano_pedal_engraver, +/* descr */ "Engrave piano pedal symbols and brackets.", +/* creats*/ "SostenutoPedal SustainPedal UnaCordaPedal SostenutoPedalLineSpanner SustainPedalLineSpanner UnaCordaPedalLineSpanner", +/* acks */ "note-column-interface", +/* reads */ "pedalSostenutoStrings pedalSustainStrings pedalUnaCordaStrings", +/* write */ "");