X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpaper-column.cc;h=21ec714301b4751bfe9cb62db593dc4b5470fc1d;hb=829caefcc215ddffe25806d0ff87bcc577c3286e;hp=a399a6aceae73c304a056d5a1d330895b4a057e9;hpb=e7d84e6728ecfdf74d8f214486a29c2aca199819;p=lilypond.git diff --git a/lily/paper-column.cc b/lily/paper-column.cc index a399a6acea..21ec714301 100644 --- a/lily/paper-column.cc +++ b/lily/paper-column.cc @@ -3,136 +3,164 @@ source file of the GNU LilyPond music typesetter - (c) 1997--2000 Han-Wen Nienhuys + (c) 1997--2004 Han-Wen Nienhuys */ + #include "moment.hh" #include "paper-column.hh" #include "paper-score.hh" -#include "debug.hh" +#include "warn.hh" #include "axis-group-interface.hh" +#include "spaceable-grob.hh" +#include "stencil.hh" +#include "text-item.hh" +#include "lookup.hh" +#include "font-interface.hh" +#include "paper-def.hh" + + + + +ADD_INTERFACE (Paper_column, "paper-column-interface", + "@code{Paper_column} objects form the top-most X-parents for items. " + " The are two types of columns: musical columns, where are attached to, and " + " non-musical columns, where bar-lines, clefs etc. are attached to. " + " The spacing engine determines the X-positions of these objects." + "\n\n" + "They are\n" + " numbered, the first (leftmost) is column 0. Numbering happens before\n" + " line-breaking, and columns are not renumbered after line breaking.\n" + " Since many columns go unused, you should only use the rank field to\n" + " get ordering information. Two adjacent columns may have\n" + " non-adjacent numbers.\n" + "\n" + , + "between-cols between-system-string when bounded-by-me " + "shortest-playing-duration shortest-starter-duration"); void -Paper_column::add_rod (Paper_column * p, Real d) +Paper_column::do_break_processing () { - Direction dir = Direction (sign (p->rank_i () - rank_i ())); - - if (dir != RIGHT) - { - programming_error ("Must set minimum distance LTOR."); - return; - } - - for (int i=0; i < minimal_dists_.size (); i++) - { - Column_rod &rod = minimal_dists_[i]; - if (rod.other_l_ == p) - { - rod.distance_f_ = rod.distance_f_ >? d; - return ; - } - } - - Column_rod cr; - cr.distance_f_ = d; - cr.other_l_ = p; - - minimal_dists_.push (cr); + Spaceable_grob::remove_interface (this); + Item::do_break_processing (); } -void -Paper_column::add_spring (Paper_column * p, Real d, Real s) -{ - Direction dir = Direction (sign (p->rank_i () - rank_i ())); - - if (dir != RIGHT) - { - programming_error ("Must set springs LTOR"); - return; - } - - for (int i=0; i < springs_.size (); i++) - { - Column_spring &spring = springs_[i]; - if (spring.other_l_ == p) - { - spring.distance_f_ = spring.distance_f_ >? d; - return ; - } - } - - Column_spring cr; - cr.distance_f_ = d; - cr.strength_f_ = s; - cr.other_l_ = p; - - springs_.push (cr); -} int -Paper_column::rank_i() const +Paper_column::get_rank (Grob*me) { - return rank_i_; + return dynamic_cast (me)->rank_; } -void -Paper_column::set_rank (int i) -{ - rank_i_ = i; -} - - - -Line_of_score* -Paper_column::line_l() const +System* +Paper_column::get_system () const { - return line_l_; + return system_; } Paper_column* -Paper_column::column_l () const +Paper_column::get_column () const { - return (Paper_column*)(this); + return (Paper_column*) (this); } -Paper_column::Paper_column (Moment w) +Paper_column::Paper_column (SCM l) + : Item (l) // guh.? { - SCM when = (new Moment (w))->smobify_self (); - scm_unprotect_object (when); - set_elt_property ("when", when); - - Axis_group_interface (this).set_interface (); - Axis_group_interface (this).set_axes (X_AXIS, X_AXIS); - - line_l_=0; - rank_i_ = -1; + system_=0; + rank_ = -1; } Moment -Paper_column::when_mom () const +Paper_column::when_mom (Grob*me) { - SCM m = get_elt_property ("when"); + SCM m = me->get_property ("when"); Moment s (0); - if (SMOB_IS_TYPE_B(Moment, m)) + if (unsmob_moment (m)) { - s = *SMOB_TO_TYPE (Moment,m); + return *unsmob_moment (m); } return s; } - + bool -Paper_column::musical_b () const +Paper_column::is_musical (Grob *me) { - SCM m = get_elt_property ("shortest-starter-duration"); + SCM m = me->get_property ("shortest-starter-duration"); Moment s (0); - if (SMOB_IS_TYPE_B(Moment, m)) + if (unsmob_moment (m)) { - s = *SMOB_TO_TYPE (Moment,m); + s = *unsmob_moment (m); } - return s != Moment(0); + return s != Moment (0); } + bool -Paper_column::used_b ()const +Paper_column::is_used (Grob*me) { - return gh_pair_p (get_elt_pointer ("elements")) || breakable_b (); + return gh_pair_p (me->get_property ("elements")) || Item::is_breakable (me) + || gh_pair_p (me->get_property ("bounded-by-me")) + ; +} + +/* + Print a vertical line and the rank number, to aid debugging. + */ + +MAKE_SCHEME_CALLBACK (Paper_column,print,1); +SCM +Paper_column::print (SCM p) +{ + Grob *me = unsmob_grob (p); + + String r = to_string (Paper_column::get_rank (me)); + SCM properties = Font_interface::text_font_alist_chain (me); + + SCM scm_mol = Text_item::interpret_markup (me->get_paper ()->self_scm (), + properties, + scm_makfrom0str (r.to_str0 ())); + Stencil t = *unsmob_stencil (scm_mol); + t.align_to (X_AXIS, CENTER); + t.align_to (Y_AXIS, DOWN); + + Stencil l = Lookup::filled_box (Box (Interval (-0.01, 0.01), + Interval (-2, -1))); + + t.add_stencil (l); + return t.smobbed_copy (); +} + +/* + This is all too hairy. We use bounded-by-me to make sure that some + columns are kept "alive". Unfortunately, when spanners are suicided, + this falls apart again. (sigh.) + + THIS IS BROKEN KLUDGE. WE SHOULD INVENT SOMETHING BETTER. + */ +MAKE_SCHEME_CALLBACK (Paper_column,before_line_breaking,1); +SCM +Paper_column::before_line_breaking (SCM grob) +{ + Grob *me = unsmob_grob (grob); + + SCM c = me->get_property ("bounded-by-me"); + SCM *ptrptr = &c; + + while (gh_pair_p (*ptrptr)) + { + Grob * g = unsmob_grob (gh_car (*ptrptr)); + + if (!g || !g->live ()) + { + *ptrptr = gh_cdr (*ptrptr); + } + else + { + ptrptr = SCM_CDRLOC (*ptrptr); + } + } + + me->set_property ("bounded-by-me", c); + return SCM_UNSPECIFIED; }