X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpiano-pedal-engraver.cc;h=0ff11c4b58851079f2489e40f5c5a3327d80066b;hb=1d1f85702652995fe2531ed26a2db8756fb3b4ee;hp=0a7bf172c2634d28f5bf6163f0fd657f4e9f9aa0;hpb=b8ef428503e626c3a5a7adc65282baf5e7dda205;p=lilypond.git diff --git a/lily/piano-pedal-engraver.cc b/lily/piano-pedal-engraver.cc index 0a7bf172c2..0ff11c4b58 100644 --- a/lily/piano-pedal-engraver.cc +++ b/lily/piano-pedal-engraver.cc @@ -1,188 +1,173 @@ /* - piano-pedal-engraver.cc -- implement Piano_pedal_engraver + piano-pedal-engraver.cc -- implement Piano_pedal_engraver - source file of the GNU LilyPond music typesetter + source file of the GNU LilyPond music typesetter - (c) 2000 Jan Nieuwenhuizen - */ + (c) 2000--2004 Jan Nieuwenhuizen + + Chris Jackson - extended to support + bracketed pedals. +*/ #include "engraver.hh" -#include "musical-request.hh" -#include "score-element.hh" +#include "event.hh" +#include "grob.hh" #include "item.hh" -#include "lookup.hh" #include "lily-guile.hh" -#include "note-head.hh" -#include "stem.hh" #include "side-position-interface.hh" #include "staff-symbol-referencer.hh" -#include "dictionary.hh" -#include "dictionary-iter.hh" -#include "text-item.hh" +#include "item.hh" +#include "axis-group-interface.hh" +#include "context.hh" + +#include "directional-element-interface.hh" +#include "note-column.hh" +#include "warn.hh" /* - Urg. - This is almost text - Problem is: - * we have no kerning - * symbols are at wrong place in font + Urgh. This engraver is too complex. rewrite. --hwn */ -class Sustain_pedal : public Item +struct Pedal_info { -public: - VIRTUAL_COPY_CONS (Score_element); + char const * name_; -protected: - virtual Molecule do_brew_molecule () const; - virtual void after_line_breaking (); -}; + /* + Event for currently running pedal. + */ + Music* current_bracket_ev_; -void -Sustain_pedal::after_line_breaking () -{ - Side_position_interface i (this); - Direction d = i.get_direction (); - i.set_direction (d); -} + /* + Event for currently starting pedal, (necessary? + + distinct from current_bracket_ev_, since current_bracket_ev_ only + necessary for brackets, not for text style. + */ + Music* start_ev_; -Molecule -Sustain_pedal::do_brew_molecule () const -{ - Molecule mol; - SCM glyph = get_elt_property ("glyph"); - if (glyph == SCM_UNDEFINED) - return mol; - String text = ly_scm2string (glyph); - for (int i = 0; i < text.length_i (); i++) - { - // leuke koor dump door tiepo, snapnie helemaal: - //String idx = ("pedal-") + text[i]; - // urg, Byte* ?? - // braak: waarom vindt String het zo moeilijk om - // String + char te doen? - //String idx = "pedal-" + String (&text.byte_C ()[i], 1); - String idx = String ("pedal-") + String (&text.byte_C ()[i], 1); - Molecule m = lookup_l ()->afm_find (idx); - if (m.empty_b ()) - continue; - Real kern = 0; - if (i) - { - SCM s = scm_eval (gh_list (ly_symbol2scm ("pedal-kerning"), - ly_str02scm (String (&text.byte_C ()[i - 1], 1).ch_C ()), - ly_str02scm (String (&text.byte_C ()[i], 1).ch_C ()), - SCM_UNDEFINED)); - if (gh_number_p (s)) - { - Staff_symbol_referencer_interface st (this); - Real staff_space = st.staff_space (); - kern = gh_scm2double (s) * staff_space; - } - } - mol.add_at_edge (X_AXIS, RIGHT, m, kern); - } - - return mol; -} + + /* + Events that were found in this timestep. + */ + Drul_array event_drul_; + Item* item_; + Spanner* bracket_; // A single portion of a pedal bracket + Spanner* finished_bracket_; + /* + This grob contains all the pedals of the same type on the same staff + */ + Spanner* line_spanner_; + Spanner* finished_line_spanner_; +}; -/* - TODO: - * it would be real cool if an engraver could be initialised with a - string, ie: - - Piano_pedal_engraver::"sostenuto" - Piano_pedal_engraver::"sustain" - Piano_pedal_engraver::"una-chorda" - */ - -/** - engrave Piano pedals - */ class Piano_pedal_engraver : public Engraver { - struct Pedal_info - { - Span_req* start_req_l_; - Drul_array req_l_drul_; - Item* item_p_; - }; - public: - VIRTUAL_COPY_CONS (Translator); - Piano_pedal_engraver (); - + TRANSLATOR_DECLARATIONS (Piano_pedal_engraver); + ~Piano_pedal_engraver (); protected: - virtual bool do_try_music (Music*); - virtual void do_process_music (); - virtual void do_pre_move_processing (); - virtual void do_post_move_processing (); - virtual void acknowledge_element (Score_element_info); + virtual void initialize (); + virtual void finalize (); + virtual bool try_music (Music*); + virtual void stop_translation_timestep (); + virtual void acknowledge_grob (Grob_info); + virtual void process_music (); private: - Dictionary info_dict_; + + 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. + */ + + Link_array previous_; + void del_linespanner (Spanner*); + + void create_text_grobs (Pedal_info *p, bool); + void create_bracket_grobs (Pedal_info *p, bool); + void typeset_all (Pedal_info*p); }; -ADD_THIS_TRANSLATOR (Piano_pedal_engraver); Piano_pedal_engraver::Piano_pedal_engraver () { - (void)info_dict_["Sostenuto"]; - (void)info_dict_["Sustain"]; - (void)info_dict_["UnaChorda"]; - for (Dictionary_iter i (info_dict_); i.ok (); i++) + info_list_ = 0; +} + +void +Piano_pedal_engraver::initialize () +{ + char * names [] = { "Sostenuto", "Sustain", "UnaCorda", 0 }; + + info_list_ = new Pedal_info[sizeof (names)/ sizeof (const char*)]; + Pedal_info *p = info_list_; + + char **np = names ; + do { - Pedal_info& p = i.val_ref (); - p.item_p_ = 0; - p.req_l_drul_[START] = 0; - p.req_l_drul_[STOP] = 0; - p.start_req_l_ = 0; + p->name_ = *np; + p->item_ = 0; + p->bracket_ = 0; + p->finished_bracket_ = 0; + p->line_spanner_ = 0; + p->finished_line_spanner_ = 0; + p->current_bracket_ev_ = 0; + p->event_drul_[START] = 0; + p->event_drul_[STOP] = 0; + p->start_ev_ = 0; + + p++; } + while (* (np ++)); +} + +Piano_pedal_engraver::~Piano_pedal_engraver () +{ + delete[] info_list_; } /* 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 (Dictionary_iter i (info_dict_); i.ok (); i++) + for (Pedal_info*p = info_list_; p && p->name_; p ++) { - Pedal_info& p = i.val_ref (); - if (p.item_p_) + if (Note_column::has_interface (info.grob_)) { - if (Note_head* n = dynamic_cast (info.elem_l_)) + if (p->line_spanner_) { - Side_position_interface st (p.item_p_); - st.add_support (n); - if (st.get_axis( ) == X_AXIS - && !p.item_p_->parent_l (Y_AXIS)) - p.item_p_->set_parent (n, Y_AXIS); - } - if (Stem* s = dynamic_cast (info.elem_l_)) - { - Side_position_interface st (p.item_p_); - st.add_support (s); - } + Side_position_interface::add_support (p->line_spanner_, info.grob_); + add_bound_item (p->line_spanner_,info.grob_); + } + if (p->bracket_) + add_bound_item (p->bracket_,info.grob_); + if (p->finished_bracket_) + add_bound_item (p->finished_bracket_,info.grob_); } } } bool -Piano_pedal_engraver::do_try_music (Music *m) +Piano_pedal_engraver::try_music (Music *m) { - for (Dictionary_iter i (info_dict_); i.ok (); i++) + if (m->is_mus_type ("pedal-event")) { - Pedal_info& p = i.val_ref (); - if (Span_req * s = dynamic_cast(m)) + for (Pedal_info*p = info_list_; p->name_; p ++) { - if (s->span_type_str_ == i.key ()) + String nm = p->name_ + String ("Event"); + if (ly_c_equal_p (m->get_property ("name") , + scm_str2symbol(nm.to_str0()))) { - p.req_l_drul_[s->span_dir_] = s; + Direction d = to_dir (m->get_property ("span-direction")); + p->event_drul_[d] = m; return true; } } @@ -191,98 +176,380 @@ Piano_pedal_engraver::do_try_music (Music *m) } void -Piano_pedal_engraver::do_process_music () +Piano_pedal_engraver::process_music () { - for (Dictionary_iter i (info_dict_); i.ok (); i++) + for (Pedal_info*p = info_list_; p && p->name_; p ++) { - Pedal_info& p = i.val_ref (); - SCM s = SCM_UNDEFINED; - if (p.req_l_drul_[STOP] && p.req_l_drul_[START]) + if (p->event_drul_[STOP] || p->event_drul_[START]) { - if (!p.start_req_l_) + if (!p->line_spanner_) { - p.req_l_drul_[STOP]->warning (_f ("can't find start of piano pedal: %s", i.key ())); + String name = String (p->name_) + "PedalLineSpanner"; + Music * rq = (p->event_drul_[START] ? p->event_drul_[START] : p->event_drul_[STOP]); + p->line_spanner_ = make_spanner (name.to_str0 (), rq->self_scm ()); + + + + } + + /* Choose the appropriate grobs to add to the line spanner + These can be text items or text-spanners + */ + + /* + ugh, code dup, should read grob to create from other + property. + + bracket: |_________/\____| + text: Ped. *Ped. * + mixed: Ped. _____/\____| + */ + + + String prop = String ("pedal") + p->name_ + "Style"; + SCM style = get_property (prop.to_str0 ()); + + bool mixed = style == ly_symbol2scm ("mixed"); + bool bracket = (mixed + || style == ly_symbol2scm ("bracket")); + bool text = (style == ly_symbol2scm ("text") + || mixed); + + if (text && !p->item_) + create_text_grobs (p, mixed); + if (bracket) + create_bracket_grobs (p, mixed); + } + } +} + +void +Piano_pedal_engraver::create_text_grobs (Pedal_info *p, bool mixed) +{ + SCM s = SCM_EOL; + SCM strings = get_property ( ("pedal" + String (p->name_) + "Strings").to_str0 ()); + + if (scm_ilength (strings) < 3) + { + Music * m = p->event_drul_[START]; + if (!m) m = p->event_drul_ [STOP]; + + String msg = _ ("Need 3 strings for piano pedals. No pedal made. "); + if (m) + m->origin ()->warning (msg); + else + warning (msg); + + return ; + } + + if (p->event_drul_[STOP] && p->event_drul_[START]) + { + if (!mixed) + { + if (!p->start_ev_) + { + p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_)); } else { - s = get_property ("stopStart" + i.key ()); + s = ly_cadr (strings); } - p.start_req_l_ = p.req_l_drul_[START]; + p->start_ev_ = p->event_drul_[START]; } - else if (p.req_l_drul_[STOP]) + } + else if (p->event_drul_[STOP]) + { + if (!mixed) { - if (!p.start_req_l_) + if (!p->start_ev_) { - p.req_l_drul_[STOP]->warning (_f ("can't find start of piano pedal: %s", i.key ())); + p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_)); } else { - s = get_property ("stop" + i.key ()); + s = ly_caddr (strings); } - p.start_req_l_ = 0; + p->start_ev_ = 0; } - else if (p.req_l_drul_[START]) + } + else if (p->event_drul_[START]) + { + p->start_ev_ = p->event_drul_[START]; + s = ly_car (strings); + if (!mixed) { - p.start_req_l_ = p.req_l_drul_[START]; - s = get_property ("start" + i.key ()); + /* + Code dup?! see below. + */ + if (previous_.size ()) + // add extra space below the previous already-occuring pedal + Side_position_interface::add_support (p->line_spanner_, + previous_.top ()); + previous_.push (p->line_spanner_); } + } + + if (scm_is_string (s)) + { + String propname = String (p->name_) + "Pedal"; - if (s != SCM_UNDEFINED) + p->item_ = make_item (propname.to_str0 (), (p->event_drul_[START] + ? p->event_drul_[START] + : p->event_drul_[STOP])->self_scm ()); + + p->item_->set_property ("text", s); + Axis_group_interface::add_element (p->line_spanner_, p->item_); + } + + if (!mixed) + { + p->event_drul_[START] = 0; + p->event_drul_[STOP] = 0; + } +} + + +void +Piano_pedal_engraver::create_bracket_grobs (Pedal_info *p, bool mixed) +{ + if (!p->bracket_ && p->event_drul_[STOP]) + { + String msg =_f ("can't find start of piano pedal bracket: `%s'", p->name_); + p->event_drul_[STOP]->origin ()->warning (msg); + p->event_drul_[STOP] = 0; + } + + if (p->event_drul_[STOP]) + { + assert (!p->finished_bracket_); + + Grob *cmc = unsmob_grob (get_property ("currentMusicalColumn")); + + if (!p->bracket_->get_bound (RIGHT)) + p->bracket_->set_bound (RIGHT, cmc); + + /* + Set properties so that the stencil-creating function will + know whether the right edge should be flared ___/ + */ + + if (!p->event_drul_[START]) { - if (i.key () == "Sustain") - { - p.item_p_ = new Sustain_pedal; - p.item_p_->set_elt_property ("glyph", s); - } - else + SCM flare = p->bracket_->get_property ("bracket-flare"); + p->bracket_->set_property ("bracket-flare", scm_cons (ly_car (flare), + scm_make_real (0))); + } + + p->finished_bracket_ = p->bracket_; + p->bracket_ = 0; + p->current_bracket_ev_ = 0; + } + + if (p->event_drul_[START]) + { + p->start_ev_ = p->event_drul_[START]; + p->current_bracket_ev_ = p->event_drul_[START]; + + p->bracket_ = make_spanner ("PianoPedalBracket", p->event_drul_[START]->self_scm ()); + + /* + Set properties so that the stencil-creating function will + know whether the left edge should be flared \___ + */ + + if (!p->finished_bracket_) + { + SCM flare = p->bracket_->get_property ("bracket-flare"); + p->bracket_->set_property ("bracket-flare", scm_cons (scm_make_real (0),ly_cdr (flare))); + } + + + /* Set this property for 'mixed style' pedals, Ped._______/\ , + so the stencil function will shorten the ____ line by the length of the Ped. text. + */ + + if (mixed) + { + /* + Mixed style: Store a pointer to the preceding text for use in + calculating the length of the line + + + TODO: + + WTF is pedal-text not the bound of the object? --hwn + */ + if (p->item_) + p->bracket_->set_property ("pedal-text", p->item_->self_scm ()); + } + + + /* + We do not use currentMusicalColumn for the left span-point. + If the column as accidentals (eg on a different stave), the + currentMusicalColumn is too wide, making the bracket too big. + + TODO: + + Hmm. What do we do when there are no notes when the spanner starts? + + TODO: + + what about the right span point? + + */ + Axis_group_interface::add_element (p->line_spanner_, p->bracket_); + + if (!p->event_drul_[STOP]) + { + + /* + code dup. --hwn. + + // position new pedal spanner below the current one + */ + if (previous_.size ()) + Side_position_interface::add_support (p->line_spanner_, previous_.top ()); + + previous_.push (p->line_spanner_); + } + } + + p->event_drul_[START] = 0; + p->event_drul_[STOP] = 0; +} + +void +Piano_pedal_engraver::finalize () +{ + for (Pedal_info*p = info_list_; p && p->name_; p ++) + { + /* + suicide? + */ + if (p->line_spanner_ + && !p->line_spanner_->is_live ()) + p->line_spanner_ = 0; + + if (p->bracket_ + && !p->bracket_->is_live ()) + p->bracket_ = 0; + + if (p->bracket_) + { + SCM cc = get_property ("currentCommandColumn"); + Item *c = unsmob_item (cc); + if (p->line_spanner_) { - p.item_p_ = new Text_item; - p.item_p_->set_elt_property ("text", s); - // guh - p.item_p_->set_elt_property ("style", ly_str02scm ("italic")); + p->line_spanner_->set_bound (RIGHT, c); } + p->bracket_ ->set_bound (RIGHT, c); - Side_position_interface si (p.item_p_); - si.set_axis (Y_AXIS); + p->finished_bracket_ = p->bracket_; + p->bracket_ = 0; + p->finished_line_spanner_ = p->line_spanner_; + p->line_spanner_ = 0; + typeset_all (p); + } - /* Hmm, - If set to empty, it can't be centred - Howto centre non-fat text? - p.item_p_->set_empty (X_AXIS); - */ - p.item_p_->set_elt_property ("self-alignment-X", gh_int2scm (0)); - p.item_p_->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS); - p.item_p_->add_offset_callback (Side_position_interface::centered_on_parent, X_AXIS); - announce_element (Score_element_info (p.item_p_, - p.req_l_drul_[START] - ? p.req_l_drul_[START] - : p.req_l_drul_[STOP])); + if (p->line_spanner_) + { + p->finished_line_spanner_ = p->line_spanner_; + typeset_all (p); } } } void -Piano_pedal_engraver::do_pre_move_processing () +Piano_pedal_engraver::del_linespanner (Spanner *g) { - for (Dictionary_iter i (info_dict_); i.ok (); i++) + int idx = previous_.find_index (g); + if (idx >= 0) + previous_.del (idx); +} + +void +Piano_pedal_engraver::stop_translation_timestep () +{ + for (Pedal_info*p = info_list_; p && p->name_; p ++) { - Pedal_info& p = i.val_ref (); - if (p.item_p_) + if (!p->bracket_) { - side_position (p.item_p_).add_staff_support (); - typeset_element (p.item_p_); + p->finished_line_spanner_ = p->line_spanner_; + p->line_spanner_ = 0; + del_linespanner (p->finished_line_spanner_); } - p.item_p_ = 0; + + typeset_all (p); + } + + + for (Pedal_info*p = info_list_; p->name_; p ++) + { + p->event_drul_[STOP] = 0; + p->event_drul_[START] = 0; } } + void -Piano_pedal_engraver::do_post_move_processing () +Piano_pedal_engraver::typeset_all (Pedal_info * p) { - for (Dictionary_iter i (info_dict_); i.ok (); i++) + /* + Handle suicide. + */ + if (p->finished_line_spanner_ + && !p->finished_line_spanner_->is_live ()) + p->finished_line_spanner_ = 0; + if (p->finished_bracket_ + && !p->finished_bracket_->is_live ()) + p->finished_bracket_ = 0; + + + if (p->item_) { - Pedal_info& p = i.val_ref (); - p.req_l_drul_[STOP] = 0; - p.req_l_drul_[START] = 0; + p->item_ = 0; + } + + if (p->finished_bracket_) + { + Grob * r = p->finished_bracket_->get_bound (RIGHT); + if (!r) + { + p->finished_bracket_->set_bound (RIGHT, unsmob_grob (get_property ("currentMusicalColumn"))); + } + + p->finished_bracket_ = 0; + } + + if (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); + } + + p->finished_line_spanner_ = 0; } } + +ENTER_DESCRIPTION (Piano_pedal_engraver, + /* descr */ "Engrave piano pedal symbols and brackets.", + /* creats*/ "SostenutoPedal SustainPedal UnaCordaPedal SostenutoPedalLineSpanner SustainPedalLineSpanner UnaCordaPedalLineSpanner", + /* accepts */ "pedal-event", + /* acks */ "note-column-interface", + /* reads */ "currentCommandColumn " + "pedalSostenutoStrings pedalSustainStrings " + "pedalUnaCordaStrings pedalSostenutoStyle " + "pedalSustainStyle pedalUnaCordaStyle", + /* write */ "");