From b3735dc71a2d69d87a52fdc363cdef3039c4e325 Mon Sep 17 00:00:00 2001 From: Jan Nieuwenhuizen Date: Tue, 27 Jan 1998 19:26:37 +0100 Subject: [PATCH] partial: 0.1.42.jcn --- lily/include/plet-engraver.hh | 39 +++++++++++ lily/include/plet-spanner.hh | 44 ++++++++++++ lily/plet-engraver.cc | 95 +++++++++++++++++++++++++ lily/plet-spanner.cc | 128 ++++++++++++++++++++++++++++++++++ lily/ps-plet.cc | 32 +++++++++ 5 files changed, 338 insertions(+) create mode 100644 lily/include/plet-engraver.hh create mode 100644 lily/include/plet-spanner.hh create mode 100644 lily/plet-engraver.cc create mode 100644 lily/plet-spanner.cc create mode 100644 lily/ps-plet.cc diff --git a/lily/include/plet-engraver.hh b/lily/include/plet-engraver.hh new file mode 100644 index 0000000000..3a4e4d31c6 --- /dev/null +++ b/lily/include/plet-engraver.hh @@ -0,0 +1,39 @@ +/* + plet-engraver.hh -- declare Plet_engraver + + source file of the GNU LilyPond music typesetter + + (c) 1997 Jan Nieuwenhuizen +*/ + +#ifndef PLET_ENGRAVER_HH +#define PLET_ENGRAVER_HH + +#include "engraver.hh" +#include "drul-array.hh" +#include "plet-spanner.hh" + +/** + Generate a plet. + Should make a Plet_spanner that typesets a nice bracket. + */ +class Plet_engraver : public Engraver +{ +public: + TRANSLATOR_CLONE(Plet_engraver); + DECLARE_MY_RUNTIME_TYPEINFO; + Plet_engraver (); + +protected: + virtual void acknowledge_element (Score_elem_info); + virtual void do_removal_processing(); + virtual void do_process_requests(); + virtual bool do_try_request (Request*); + virtual void do_pre_move_processing(); + +private: + Drul_array span_reqs_drul_; + Plet_spanner* plet_spanner_p_; +}; + +#endif // PLET_ENGRAVER_HH diff --git a/lily/include/plet-spanner.hh b/lily/include/plet-spanner.hh new file mode 100644 index 0000000000..cae64729d5 --- /dev/null +++ b/lily/include/plet-spanner.hh @@ -0,0 +1,44 @@ +/* + plet-spanner.hh -- part of GNU LilyPond + + (c) 1997 Jan Nieuwenhuizen +*/ + +#ifndef PLET_SPANNER_HH +#define PLET_SPANNER_HH + +#include "bow.hh" + +/** supportable plet: triplets, eentweetjes, ottava, etc. */ + +class Plet_spanner : public Bow +{ +public: + + Plet_spanner (); + virtual ~Plet_spanner (); + + void set_stem (Direction, Stem*); + + Text_def* tdef_p_; + Drul_array stem_l_drul_; + +protected: + virtual Molecule* brew_molecule_p () const; + +private: + + +protected: + + DECLARE_MY_RUNTIME_TYPEINFO; + SCORE_ELEM_CLONE(Plet_spanner); + + virtual void do_add_processing (); + virtual void do_post_processing (); + virtual void set_default_dir (); + virtual void do_substitute_dependency (Score_elem*,Score_elem*); +}; + +#endif // PLET_SPANNER_HH + diff --git a/lily/plet-engraver.cc b/lily/plet-engraver.cc new file mode 100644 index 0000000000..16caaf6333 --- /dev/null +++ b/lily/plet-engraver.cc @@ -0,0 +1,95 @@ +/* + plet-engraver.cc -- implement Plet_engraver + + (c) 1997 Jan Nieuwenhuizen +*/ + +#include "proto.hh" +#include "musical-request.hh" +#include "plet-engraver.hh" +#include "plet-spanner.hh" +#include "text-def.hh" +#include "stem.hh" + +IMPLEMENT_IS_TYPE_B1 (Plet_engraver,Engraver); +ADD_THIS_TRANSLATOR (Plet_engraver); + +Plet_engraver::Plet_engraver () +{ + plet_spanner_p_ = 0; + span_reqs_drul_[RIGHT] = span_reqs_drul_[LEFT] = 0; +} + +void +Plet_engraver::acknowledge_element (Score_elem_info i) +{ + if (!i.elem_l_->is_type_b (Stem::static_name ())) + return; + if (!plet_spanner_p_) + return; + if (!span_reqs_drul_[LEFT]) + return; + + if (!plet_spanner_p_->stem_l_drul_[LEFT]) + plet_spanner_p_->set_stem (LEFT, (Stem*)i.elem_l_->item ()); + else + if (span_reqs_drul_[RIGHT] && !plet_spanner_p_->stem_l_drul_[RIGHT]) + plet_spanner_p_->set_stem (RIGHT, (Stem*)i.elem_l_->item()); +} + +bool +Plet_engraver::do_try_request (Request* req_l) +{ + Musical_req* mus_l = req_l->musical (); + if (!mus_l) + return false; + + Plet_req* p = mus_l->plet (); + if (!p) + return false; + + if (bool (plet_spanner_p_) == bool (p->spantype == Span_req::START)) + return false; + + Direction d = (!plet_spanner_p_) ? LEFT : RIGHT; + if (span_reqs_drul_[d] && !span_reqs_drul_[d]->equal_b (mus_l)) + return false; + + span_reqs_drul_[d] = p; + return true; +} + +void +Plet_engraver::do_removal_processing () +{ + if (plet_spanner_p_) + { + span_reqs_drul_[LEFT]->warning (_("unterminated plet")); + typeset_element (plet_spanner_p_); + plet_spanner_p_ = 0; + } +} + +void +Plet_engraver::do_process_requests () +{ + if (plet_spanner_p_ || !span_reqs_drul_[LEFT]) + return; + + plet_spanner_p_ = new Plet_spanner; + plet_spanner_p_->tdef_p_->text_str_ = span_reqs_drul_[LEFT]->plet_i_; + + announce_element (Score_elem_info (plet_spanner_p_, span_reqs_drul_[LEFT])); +} + +void +Plet_engraver::do_pre_move_processing () +{ + if (!plet_spanner_p_ || !span_reqs_drul_[RIGHT]) + return; + + typeset_element (plet_spanner_p_); + plet_spanner_p_ = 0; + span_reqs_drul_[RIGHT] = span_reqs_drul_[LEFT] = 0; +} + diff --git a/lily/plet-spanner.cc b/lily/plet-spanner.cc new file mode 100644 index 0000000000..1290f63cf9 --- /dev/null +++ b/lily/plet-spanner.cc @@ -0,0 +1,128 @@ +/* + plet-spanner.cc -- implement Plet_spanner + + source file of the GNU LilyPond music typesetter + + (c) 1997 Jan Nieuwenhuizen +*/ + +#include "atom.hh" +#include "boxes.hh" +#include "debug.hh" +#include "lookup.hh" +#include "molecule.hh" +#include "p-col.hh" +#include "paper-def.hh" +#include "plet-spanner.hh" +#include "stem.hh" +#include "text-def.hh" + +IMPLEMENT_IS_TYPE_B1 (Plet_spanner,Bow); + +Plet_spanner::Plet_spanner () + : Bow () +{ + stem_l_drul_[RIGHT] =0; + stem_l_drul_[LEFT] =0; + + tdef_p_ = new Text_def; + tdef_p_->align_i_ = CENTER; + tdef_p_->style_str_ = "italic"; +} + +Plet_spanner::~Plet_spanner () +{ + delete tdef_p_; +} + +Molecule* +Plet_spanner::brew_molecule_p () const +{ + Molecule* mol_p = new Molecule; + Real w = width ().length (); + + Real dy_f = dy_f_drul_[RIGHT] - dy_f_drul_[LEFT]; + + // ugh + Real nwc_f = (dir_ > 0 ? paper ()->note_width () : 0) * 0.8; + + w += (dx_f_drul_[RIGHT] - dx_f_drul_[LEFT]); + + Atom a = paper ()->lookup_l ()->plet (dy_f, w, dir_); + + a.translate (Offset ( (dx_f_drul_[LEFT] + nwc_f), dy_f_drul_[LEFT])); + mol_p->add (a); + + Real interline_f = paper ()->interline_f (); + Real numy_f = (dir_ > 0 ? 0 : -interline_f / 2); + Real numx_f = interline_f / 1.5; + Atom num (tdef_p_->get_atom (paper (), CENTER)); + num.translate (Offset (width ().length ()/ 2 + nwc_f - numx_f + + dx_f_drul_[LEFT], + dy_f_drul_[LEFT] + dy_f / width ().length () / 2 + + dir_ * interline_f / 2 + numy_f)); + mol_p->add (num); + + return mol_p; +} + +void +Plet_spanner::do_add_processing () +{ + if (! (stem_l_drul_[LEFT] && stem_l_drul_[RIGHT])) + warning (_ ("Lonely plet.. ")); + + Direction d = LEFT; + Drul_array new_stem_drul = stem_l_drul_; + do { + if (!stem_l_drul_[d]) + new_stem_drul[d] = stem_l_drul_[(Direction)-d]; + } while ( (d *= -1) != LEFT); + stem_l_drul_ = new_stem_drul; +} + +void +Plet_spanner::do_post_processing () +{ + Real interline_f = paper ()->interline_f (); + assert (stem_l_drul_[LEFT] || stem_l_drul_[RIGHT]); + + Direction d = LEFT; + do + { + dy_f_drul_[d] = .5 * interline_f * (stem_l_drul_[d] + ? stem_l_drul_[d]->stem_end_f () + : stem_l_drul_[(Direction)-d]->stem_end_f ()); + dy_f_drul_[d] += dir_ * interline_f; + } + while ( (d *= -1) != LEFT); +} + +void +Plet_spanner::do_substitute_dependency (Score_elem* o, Score_elem* n) +{ + Stem* new_l = n ? (Stem*)n->item () : 0; + if (o->item () == stem_l_drul_[LEFT]) + stem_l_drul_[LEFT] = new_l; + else if (o->item () == stem_l_drul_[RIGHT]) + stem_l_drul_[RIGHT] = new_l; +} + +void +Plet_spanner::set_default_dir () +{ + Real m = (stem_l_drul_[LEFT]->stem_end_f () + + stem_l_drul_[RIGHT]->stem_end_f ()) / 2; + dir_ = (m < 0) ? DOWN : UP; +} + +void +Plet_spanner::set_stem (Direction d, Stem* stem_l) +{ + assert (!stem_l_drul_[d]); + stem_l_drul_[d] = stem_l; + set_bounds (d, stem_l); + + add_dependency (stem_l); +} + diff --git a/lily/ps-plet.cc b/lily/ps-plet.cc new file mode 100644 index 0000000000..8d08783f15 --- /dev/null +++ b/lily/ps-plet.cc @@ -0,0 +1,32 @@ +/* + ps-plet.cc -- implement Lookup::*plet + + source file of the GNU LilyPond music typesetter + + (c) 1997 Jan Nieuwenhuizen +*/ + +#include +#include "main.hh" +#include "misc.hh" +#include "lookup.hh" +#include "molecule.hh" +#include "dimen.hh" +#include "debug.hh" +#include "paper-def.hh" +#include "string-convert.hh" + +Atom +Lookup::plet (Real& dy , Real& dx, Direction dir) const +{ + String ps = "\\embeddedps{\n"; + + ps += String_convert::double_str (dx) + " " + + String_convert::double_str (dy) + " " + + String_convert::int_str ((int)dir) + + " draw_plet}"; + + Atom s; + s.tex_ = ps; + return s; +} -- 2.39.5