X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fscript-engraver.cc;h=3085f4f1553feebc4a3a2fa07d891b6fd1691783;hb=a9bb3b4c5d19638083d833cd084280c73e095c16;hp=921b43c0e7b9b32dcade45c1fa0c06c546f56c64;hpb=8aad615ea7bb31f49a0c2afc21eea5ff5de20437;p=lilypond.git diff --git a/lily/script-engraver.cc b/lily/script-engraver.cc index 921b43c0e7..3085f4f155 100644 --- a/lily/script-engraver.cc +++ b/lily/script-engraver.cc @@ -1,92 +1,298 @@ /* - script-engraver.cc -- implement Script_engraver + This file is part of LilyPond, the GNU music typesetter. - (c) 1997--1999 Han-Wen Nienhuys + Copyright (C) 1997--2012 Han-Wen Nienhuys + + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ -#include "script-engraver.hh" -#include "script.hh" -#include "musical-request.hh" +#include "engraver.hh" + +#include "context.hh" +#include "directional-element-interface.hh" +#include "international.hh" +#include "note-column.hh" +#include "paper-column.hh" +#include "rhythmic-head.hh" +#include "script-interface.hh" +#include "side-position-interface.hh" +#include "slur.hh" +#include "staff-symbol-referencer.hh" #include "stem.hh" -#include "staff-sym.hh" -#include "general-script-def.hh" -#include "text-def.hh" +#include "stream-event.hh" +#include "warn.hh" + +#include "translator.icc" + +struct Script_tuple +{ + Stream_event *event_; + Grob *script_; + Script_tuple () + { + event_ = 0; + script_ = 0; + } +}; + +class Script_engraver : public Engraver +{ + vector scripts_; + +protected: + void stop_translation_timestep (); + void process_music (); + + DECLARE_TRANSLATOR_LISTENER (articulation); + DECLARE_ACKNOWLEDGER (rhythmic_head); + DECLARE_ACKNOWLEDGER (stem); + DECLARE_ACKNOWLEDGER (stem_tremolo); + DECLARE_ACKNOWLEDGER (tie); + DECLARE_END_ACKNOWLEDGER (tie); + DECLARE_ACKNOWLEDGER (note_column); + DECLARE_ACKNOWLEDGER (inline_accidental); + +public: + TRANSLATOR_DECLARATIONS (Script_engraver); +}; + +Script_engraver::Script_engraver () +{ +} + +IMPLEMENT_TRANSLATOR_LISTENER (Script_engraver, articulation); +void +Script_engraver::listen_articulation (Stream_event *ev) +{ + /* Discard double articulations for part-combining. */ + for (vsize i = 0; i < scripts_.size (); i++) + if (ly_is_equal (scripts_[i].event_ + ->get_property ("articulation-type"), + ev->get_property ("articulation-type"))) + return; + + Script_tuple t; + t.event_ = ev; + scripts_.push_back (t); +} + +void +copy_property (Grob *g, SCM sym, SCM alist) +{ + if (g->internal_get_property (sym) == SCM_EOL) + { + SCM entry = scm_assoc (sym, alist); + if (scm_is_pair (entry)) + g->set_property (sym, scm_cdr (entry)); + } +} + +/* 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. ). +*/ +void +make_script_from_event (Grob *p, 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 ()); + message (""); + return; + } + + art = scm_cdr (art); + + 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_is_procedure (type)) + continue; + + SCM val = scm_cdar (s); + + 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_from_int (prio); + } + + SCM preset = p->get_property_data (sym); + if (val == SCM_EOL + || scm_call_1 (type, preset) == SCM_BOOL_F) + p->set_property (sym, val); + } + if (!priority_found) + { + p->set_property ("script-priority", + scm_from_int (index)); + } +} + +void +Script_engraver::process_music () +{ + for (vsize i = 0; i < scripts_.size (); i++) + { + Stream_event *ev = scripts_[i].event_; + + Grob *p = make_item ("Script", ev->self_scm ()); + + make_script_from_event (p, context (), + ev->get_property ("articulation-type"), + i); + + scripts_[i].script_ = p; + + SCM force_dir = ev->get_property ("direction"); + if (is_direction (force_dir) && to_dir (force_dir)) + p->set_property ("direction", force_dir); + } +} + +void +Script_engraver::acknowledge_stem (Grob_info info) +{ + for (vsize i = 0; i < scripts_.size (); i++) + { + Grob *e = scripts_[i].script_; + + if (to_dir (e->get_property ("side-relative-direction"))) + e->set_object ("direction-source", info.grob ()->self_scm ()); + + Side_position_interface::add_support (e, info.grob ()); + } +} -Script_engraver::Script_engraver() +void +Script_engraver::acknowledge_stem_tremolo (Grob_info info) { - do_post_move_processing(); + for (vsize i = 0; i < scripts_.size (); i++) + { + Grob *e = scripts_[i].script_; + Side_position_interface::add_support (e, info.grob ()); + } } -bool -Script_engraver::do_try_music (Music *r_l) +void +Script_engraver::acknowledge_tie (Grob_info info) { - if (Musical_script_req *mr = dynamic_cast (r_l)) + for (vsize i = 0; i < scripts_.size (); i++) { - 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); - return true; + Grob *e = scripts_[i].script_; + Side_position_interface::add_support (e, info.grob ()); } - return false; } void -Script_engraver::do_process_requests() +Script_engraver::acknowledge_end_tie (Grob_info info) { - if (script_p_arr_.size ()) - return ; - - for (int i=0; i < script_req_l_arr_.size(); i++) + for (vsize i = 0; i < scripts_.size (); i++) { - Script_req* l=script_req_l_arr_[i]; - Script *p =new Script; - p->dir_ = l->dir_; - p->specs_p_ = l->scriptdef_p_->clone (); - script_p_arr_.push (p); - announce_element (Score_element_info (p, l)); + Grob *e = scripts_[i].script_; + Side_position_interface::add_support (e, info.grob ()); } } void -Script_engraver::do_pre_move_processing() +Script_engraver::acknowledge_inline_accidental (Grob_info info) { - Staff_symbol* s_l = get_staff_info().staff_sym_l_; - for (int i=0; i < script_p_arr_.size(); i++) + for (vsize i = 0; i < scripts_.size (); i++) { - Script*script_p = script_p_arr_[i]; - if (!script_p->specs_p_->inside_b()) - script_p->add_support (s_l); - - if (Text_def*td_l = dynamic_cast (script_p->specs_p_)) // UGH - { - if (!td_l->style_str_.length_i ()) - { - Scalar style = get_property ("textstyle", 0); - if (style.to_bool ()) - td_l->style_str_= style; - } - // urg, what if this is already set? in-band signaling... - Scalar alignment = get_property ("textalignment", 0); - if (alignment.isnum_b()) - { - td_l->align_dir_= (Direction)(int)alignment; - } - } - typeset_element (script_p); + Grob *e = scripts_[i].script_; + Side_position_interface::add_support (e, info.grob ()); } - script_p_arr_.clear(); } void -Script_engraver::do_post_move_processing() +Script_engraver::acknowledge_rhythmic_head (Grob_info info) { - script_req_l_arr_.clear(); + if (info.event_cause ()) + { + for (vsize i = 0; i < scripts_.size (); i++) + { + Grob *e = scripts_[i].script_; + + if (Side_position_interface::get_axis (e) == X_AXIS + && !e->get_parent (Y_AXIS)) + { + e->set_parent (info.grob (), Y_AXIS); + } + Side_position_interface::add_support (e, info.grob ()); + } + } } +void +Script_engraver::acknowledge_note_column (Grob_info info) +{ + /* 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::calc_direction (). */ + for (vsize i = 0; i < scripts_.size (); i++) + { + 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); + } +} + +void +Script_engraver::stop_translation_timestep () +{ + scripts_.clear (); +} + +ADD_ACKNOWLEDGER (Script_engraver, rhythmic_head); +ADD_ACKNOWLEDGER (Script_engraver, stem); +ADD_ACKNOWLEDGER (Script_engraver, tie); +ADD_END_ACKNOWLEDGER (Script_engraver, tie); +ADD_ACKNOWLEDGER (Script_engraver, note_column); +ADD_ACKNOWLEDGER (Script_engraver, stem_tremolo); +ADD_ACKNOWLEDGER (Script_engraver, inline_accidental); + +ADD_TRANSLATOR (Script_engraver, + /* doc */ + "Handle note scripted articulations.", + + /* create */ + "Script ", + /* read */ + "scriptDefinitions ", -ADD_THIS_TRANSLATOR(Script_engraver); + /* write */ + "" + );