X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscript-engraver.cc;h=db1df11e9b2a85fc5ba9f1fc4963ed0ac5d0f39e;hb=48eb640005f5abb84b3d6f8db2e1704d4bff7645;hp=70844dc5b6f62558d834012dc7c24330e92c4830;hpb=5b6181075e3615dce049711973d3cd5caa60e5db;p=lilypond.git diff --git a/lily/script-engraver.cc b/lily/script-engraver.cc index 70844dc5b6..db1df11e9b 100644 --- a/lily/script-engraver.cc +++ b/lily/script-engraver.cc @@ -1,172 +1,250 @@ /* - script-engraver.cc -- implement Script_engraver + script-engraver.cc -- engrave Scripts: Articulations. - (c) 1997--2001 Han-Wen Nienhuys + source file of the GNU LilyPond music typesetter + + (c) 1997--2004 Han-Wen Nienhuys */ -#include "script.hh" +#include "context.hh" +#include "directional-element-interface.hh" +#include "engraver.hh" +#include "event.hh" +#include "slur.hh" +#include "note-column.hh" +#include "paper-column.hh" +#include "rhythmic-head.hh" +#include "script-interface.hh" #include "side-position-interface.hh" -#include "musical-request.hh" +#include "staff-symbol-referencer.hh" #include "stem.hh" -#include "rhythmic-head.hh" -#include "engraver.hh" +#include "warn.hh" -class Script_engraver : public Engraver +struct Script_tuple { - Link_array script_p_arr_; - Link_array script_req_l_arr_; + Music *event_; + Grob *script_; + bool follow_into_staff_; + Script_tuple () + { + follow_into_staff_ = false; + event_ = 0; + script_ = 0; + } +}; -public: - VIRTUAL_COPY_CONS (Translator); +class Script_engraver : public Engraver +{ + Array scripts_; + Spanner *slur_; protected: virtual bool try_music (Music*); - virtual void initialize (); virtual void stop_translation_timestep (); - virtual void start_translation_timestep (); virtual void process_music (); virtual void acknowledge_grob (Grob_info); + +public: + TRANSLATOR_DECLARATIONS (Script_engraver); }; -void -Script_engraver::initialize () +Script_engraver::Script_engraver () { - script_req_l_arr_.clear (); + slur_ = 0; } bool -Script_engraver::try_music (Music *r_l) +Script_engraver::try_music (Music *m) { - if (Articulation_req *mr = dynamic_cast (r_l)) + if (m->is_mus_type ("articulation-event")) { - for (int i=0; i < script_req_l_arr_.size (); i++) - { - if (script_req_l_arr_[i]->equal_b (mr)) - return true; - } - script_req_l_arr_.push (mr); + /* Discard double articulations for part-combining. */ + int script_count = scripts_.size (); + for (int i = 0; i < script_count; i++) + if (ly_c_equal_p (scripts_[i].event_ + ->get_property ("articulation-type"), + m->get_property ("articulation-type"))) + return true; + + Script_tuple t; + t.event_ = m; + scripts_.push (t); return true; } return false; } void -Script_engraver::process_music () +copy_property (Grob *g, SCM sym, SCM alist) { - for (int i=0; i < script_req_l_arr_.size (); i++) + if (g->internal_get_property (sym) == SCM_EOL) { - Articulation_req* l=script_req_l_arr_[i]; + SCM entry = scm_assoc (sym, alist); + if (scm_is_pair (entry)) + g->internal_set_property (sym, scm_cdr (entry)); + } +} - SCM alist = get_property ("scriptDefinitions"); - SCM art = scm_assoc (l->get_mus_property ("articulation-type"), alist); +/* Add the properties, one by one for each Script. A little memory + could be saved by tacking the props onto the Script grob (i.e. make + ScriptStaccato , ScriptMarcato, etc. ). - if (art == SCM_BOOL_F) - { - String a = ly_scm2string (l->get_mus_property ("articulation-type")); - l->origin ()->warning (_f ("Don't know how to interpret articulation `%s'", a.ch_C ())); - - continue; - } - // todo -> use result of articulation-to-scriptdef directly as basic prop list. - Grob *p =new Item (get_property ("Script")); - art = gh_cdr (art); - p->set_grob_property ("molecule", gh_car (art)); - - art = gh_cdr (art); - bool follow_staff = gh_scm2bool (gh_car (art)); - art = gh_cdr (art); - SCM relative_stem_dir = gh_car (art); - art = gh_cdr (art); - - SCM force_dir = l->get_mus_property ("direction"); - if (isdir_b (force_dir) && !to_dir (force_dir)) - force_dir = gh_car (art); - - art = gh_cdr (art); - SCM priority = gh_car (art); +*/ +void make_script_from_event (Grob *p, bool * follow, Context *tg, + SCM art_type, int index) +{ + SCM alist = tg->get_property ("scriptDefinitions"); + SCM art = scm_assoc (art_type, alist); + + if (art == SCM_BOOL_F) + { + /* FIXME: */ + warning (_ ("Do not know how to interpret articulation: ")); + warning (_ ("Scheme encoding: ")); + scm_write (art_type, scm_current_error_port ()); + return; + } - if (isdir_b (force_dir) && to_dir (force_dir)) - p->set_grob_property ("direction", force_dir); - else if (to_dir (relative_stem_dir)) - p->set_grob_property ("side-relative-direction", relative_stem_dir); + art = scm_cdr (art); + SCM follow_scm = scm_assoc (ly_symbol2scm ("follow-into-staff"), + art); - /* - FIXME: should figure this out in relation with basic props! - */ - SCM axisprop = get_property ("scriptHorizontal"); - bool xaxis = to_boolean (axisprop); - Side_position_interface::set_axis (p, xaxis ? X_AXIS : Y_AXIS); + *follow = scm_is_pair (follow_scm) && to_boolean (scm_cdr (follow_scm)); + bool priority_found = false ; + + for (SCM s = art ; scm_is_pair (s); s = scm_cdr (s)) + { + SCM sym = scm_caar (s); + SCM type = scm_object_property (sym, ly_symbol2scm ("backend-type?")); + if (!ly_c_procedure_p (type)) + continue; - if (!follow_staff && ! xaxis) - p->set_grob_property ("staff-support", SCM_BOOL_T); + SCM val = scm_cdar (s); - if (!xaxis && follow_staff) - p->add_offset_callback (Side_position_interface::quantised_position_proc, Y_AXIS); - - - p->set_grob_property ("script-priority", priority); + if (sym == ly_symbol2scm ("script-priority")) + { + priority_found = true; + /* Make sure they're in order of user input by adding index i. + Don't use the direction in this priority. Smaller means closer + to the head. */ + int prio = scm_to_int (val) + index; + + + val = scm_int2num (prio); + } + if (p->internal_get_property (sym) == SCM_EOL) + p->internal_set_property (sym, val); + } + + if (!priority_found) + { + p->set_property ("script-priority", + scm_int2num (index)); + } - script_p_arr_.push (p); - - announce_grob (p, l); + Side_position_interface::set_axis (p, Y_AXIS); + +} + +void +Script_engraver::process_music () +{ + int script_count = scripts_.size (); + for (int i = 0; i < script_count; i++) + { + Music *m = scripts_[i].event_; + + Grob *p = make_item ("Script", m->self_scm ()); + + make_script_from_event (p, &scripts_[i].follow_into_staff_, context (), + m->get_property ("articulation-type"), + i); + + scripts_[i].script_ = p; + + SCM force_dir = m->get_property ("direction"); + if (is_direction (force_dir) && to_dir (force_dir)) + p->set_property ("direction", force_dir); } } void -Script_engraver::acknowledge_grob (Grob_info inf) +Script_engraver::acknowledge_grob (Grob_info info) { - if (Stem::has_interface (inf.elem_l_)) + int script_count = scripts_.size (); + if (Stem::has_interface (info.grob_)) { - for (int i=0; i < script_p_arr_.size (); i++) + for (int i = 0; i < script_count; i++) { - Grob*e = script_p_arr_[i]; + Grob *e = scripts_[i].script_; + + if (to_dir (e->get_property ("side-relative-direction"))) + e->set_property ("direction-source", info.grob_->self_scm ()); - e->set_grob_property ("direction-source", inf.elem_l_->self_scm ()); - e->add_dependency (inf.elem_l_); - Side_position_interface::add_support (e, inf.elem_l_); + /* FIXME: add dependency */ + e->add_dependency (info.grob_); + Side_position_interface::add_support (e, info.grob_); } } - else if (Rhythmic_head::has_interface (inf.elem_l_)) + else if (Rhythmic_head::has_interface (info.grob_) + && info.music_cause ()) { - for (int i=0; i < script_p_arr_.size (); i++) + for (int i = 0; i < script_count; i++) { - Grob *e = script_p_arr_[i]; - - if (!e->parent_l (X_AXIS)) + Grob *e = scripts_[i].script_; + + if (Side_position_interface::get_axis (e) == X_AXIS + && !e->get_parent (Y_AXIS)) { - e->set_parent (inf.elem_l_, X_AXIS); + e->set_parent (info.grob_, Y_AXIS); + e->add_dependency (info.grob_); } - if (Side_position_interface::get_axis (e) == X_AXIS - && !e->parent_l (Y_AXIS)) - e->set_parent (inf.elem_l_, Y_AXIS); - - Side_position_interface::add_support (e,inf.elem_l_); + Side_position_interface::add_support (e,info.grob_); } - } -} - -void -Script_engraver::stop_translation_timestep () -{ - for (int i=0; i < script_p_arr_.size (); i++) + } + else if (Note_column::has_interface (info.grob_)) { - Grob * sc = script_p_arr_[i]; - if (to_boolean (sc->get_grob_property ("staff-support"))) + /* Make note column the parent of the script. That is not + correct, but due to seconds in a chord, noteheads may be + swapped around horizontally. + + As the note head to put it on is not known now, postpone this + decision to Script_interface::before_line_breaking (). */ + for (int i = 0; i < script_count; i++) { - Side_position_interface::add_staff_support (sc); + Grob *e = scripts_[i].script_; + + if (!e->get_parent (X_AXIS) + && Side_position_interface::get_axis (e) == Y_AXIS) + e->set_parent (info.grob_, X_AXIS); } - typeset_grob (sc); } - script_p_arr_.clear (); + else if (Slur::has_interface (info.grob_)) + slur_ = dynamic_cast (info.grob_); } void -Script_engraver::start_translation_timestep () +Script_engraver::stop_translation_timestep () { - script_req_l_arr_.clear (); + int script_count = scripts_.size (); + for (int i = 0; i < script_count; i++) + if (scripts_[i].follow_into_staff_) + { + Grob *sc = scripts_[i].script_; + sc->add_offset_callback (Side_position_interface + ::quantised_position_proc, Y_AXIS); + sc->set_property ("staff-padding", SCM_EOL); + } + + scripts_.clear (); } -ADD_THIS_TRANSLATOR (Script_engraver); - - +ENTER_DESCRIPTION (Script_engraver, +/* descr */ "Handles note scripted articulations.", +/* creats*/ "Script", +/* accepts */ "script-event articulation-event", +/* acks */ "stem-interface rhythmic-head-interface " + "slur-interface note-column-interface", +/* reads */ "scriptDefinitions", +/* write */ "");