X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fpaper-column.cc;h=d86caaa735b14395648abe0b6e1f45a89557b89b;hb=2c22efe5a46a37065b10c3f51c5d7db00d07d318;hp=b9393c411e245a7de78598ef1d5d8d94c113c66f;hpb=eb3a20402b80c40a63b0d37200d179c930a1cf25;p=lilypond.git diff --git a/lily/paper-column.cc b/lily/paper-column.cc index b9393c411e..d86caaa735 100644 --- a/lily/paper-column.cc +++ b/lily/paper-column.cc @@ -3,42 +3,44 @@ source file of the GNU LilyPond music typesetter - (c) 1997--2002 Han-Wen Nienhuys + (c) 1997--2005 Han-Wen Nienhuys */ -#include "moment.hh" #include "paper-column.hh" + +#include "moment.hh" #include "paper-score.hh" #include "warn.hh" #include "axis-group-interface.hh" #include "spaceable-grob.hh" -#include "molecule.hh" -#include "text-item.hh" +#include "text-interface.hh" #include "lookup.hh" #include "font-interface.hh" +#include "output-def.hh" +#include "pointer-group-interface.hh" +#include "grob-array.hh" - - - +Grob * +Paper_column::clone (int count) const +{ + return new Paper_column (*this, count); +} ADD_INTERFACE (Paper_column, "paper-column-interface", - " Paper_columns form the top-most item parent. (The Paper_columns X\n" -" parent is System, which is a spanner.)\n" -"\n" -" Paper_columns form the units for the spacing engine. 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" -"\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" -" Don't be confused by right-items: each spacing wish can also contain\n" -" a number of items, with which a spacing constraint may be kept. It's\n" -" a little baroque, but it might come in handy later on?\n" -"\n", - "between-cols between-system-string when bounded-by-me shortest-playing-duration shortest-starter-duration"); - + "@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 when bounded-by-me " + "page-penalty shortest-playing-duration shortest-starter-duration"); void Paper_column::do_break_processing () @@ -47,121 +49,137 @@ Paper_column::do_break_processing () Item::do_break_processing (); } - int -Paper_column::get_rank (Grob*me) +Paper_column::get_rank (Grob *me) { - return dynamic_cast (me)->rank_; + return dynamic_cast (me)->rank_; } -System* +System * Paper_column::get_system () const { return system_; } -Paper_column* +Paper_column * Paper_column::get_column () const { - return (Paper_column*) (this); + return (Paper_column *) (this); } -Paper_column::Paper_column (SCM l) - : Item (l) // guh.? +Paper_column::Paper_column (SCM l, Object_key const *key) + : Item (l, key) // guh.? { - system_=0; + system_ = 0; rank_ = -1; } +Paper_column::Paper_column (Paper_column const &src, int count) + : Item (src, count) +{ + system_ = 0; + rank_ = src.rank_; +} + Moment -Paper_column::when_mom (Grob*me) +Paper_column::when_mom (Grob *me) { - SCM m = me->get_grob_property ("when"); - Moment s (0); - if (unsmob_moment (m)) - { - return *unsmob_moment (m); - } - return s; + SCM m = me->get_property ("when"); + if (Moment *when = unsmob_moment (m)) + return *when; + return Moment (0); } bool -Paper_column::musical_b (Grob *me) +Paper_column::is_musical (Grob *me) { - SCM m = me->get_grob_property ("shortest-starter-duration"); + SCM m = me->get_property ("shortest-starter-duration"); Moment s (0); if (unsmob_moment (m)) { s = *unsmob_moment (m); } return s != Moment (0); - } - bool -Paper_column::used_b (Grob*me) +Paper_column::is_used (Grob *me) { - return gh_pair_p (me->get_grob_property ("elements")) || Item::breakable_b (me) - || gh_pair_p (me->get_grob_property ("bounded-by-me")) - ; + extract_grob_set (me, "elements", elts); + if (elts.size ()) + return true; + + extract_grob_set (me, "bounded-by-me", bbm); + if (bbm.size ()) + return true; + return Item::is_breakable (me); } /* - Print a vertical line and the rank number, to aid debugging. - */ + Print a vertical line and the rank number, to aid debugging. +*/ -MAKE_SCHEME_CALLBACK(Paper_column,brew_molecule,1); +MAKE_SCHEME_CALLBACK (Paper_column, print, 1); SCM -Paper_column::brew_molecule (SCM p) +Paper_column::print (SCM p) { Grob *me = unsmob_grob (p); String r = to_string (Paper_column::get_rank (me)); - SCM properties = Font_interface::font_alist_chain (me); - - Molecule t = Text_item::text2molecule (me, scm_makfrom0str (r.to_str0 ()), - properties); + + Moment *mom = unsmob_moment (me->get_property ("when")); + String when = mom ? mom->to_string () : "?/?"; + + SCM properties = Font_interface::text_font_alist_chain (me); + + SCM scm_mol = Text_interface::interpret_markup (me->get_layout ()->self_scm (), + properties, + scm_makfrom0str (r.to_str0 ())); + SCM when_mol = Text_interface::interpret_markup (me->get_layout ()->self_scm (), + properties, + scm_makfrom0str (when.to_str0 ())); + Stencil t = *unsmob_stencil (scm_mol); + t.add_at_edge (Y_AXIS, DOWN, *unsmob_stencil (when_mol), 0.1, 0.1); t.align_to (X_AXIS, CENTER); t.align_to (Y_AXIS, DOWN); - - Molecule l = Lookup::filledbox (Box (Interval (-0.01, 0.01), + + Stencil l = Lookup::filled_box (Box (Interval (-0.01, 0.01), Interval (-2, -1))); - t.add_molecule (l); - return t.smobbed_copy (); + 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 falls apart again, because suicided spanners are still in + bounded-by-me - THIS IS BROKEN KLUDGE. WE SHOULD INVENT SOMETHING BETTER. - */ -MAKE_SCHEME_CALLBACK(Paper_column,before_line_breaking,1); + 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_grob_property ("bounded-by-me"); - SCM *ptrptr = &c; + SCM bbm = me->get_object ("bounded-by-me"); + Grob_array *ga = unsmob_grob_array (bbm); + if (!ga) + return SCM_UNSPECIFIED; + + Link_array &array (ga->array_reference ()); - while (gh_pair_p (*ptrptr)) + for (int i = array.size (); i--;) { - Grob * g = unsmob_grob (gh_car (*ptrptr)); + Grob *g = array[i]; - if (!g || !g->live ()) - { - *ptrptr = gh_cdr (*ptrptr); - } - else - { - ptrptr = SCM_CDRLOC (*ptrptr); + if (!g || !g->is_live ()) + { // UGH . potentially quadratic. + array.del (i); } } - me->set_grob_property ("bounded-by-me", c); return SCM_UNSPECIFIED; }