X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;ds=sidebyside;f=lily%2Fnote-column.cc;h=8dca8fc0610632b10737a4d088423cf70256438c;hb=ffe548cfbb3c3b37c8969f49b5aba04ef998d080;hp=770157d0738b4f2c369474758763b5734e4008e2;hpb=f3467e6b78be6d8497cf4d0a43ffd01656a33300;p=lilypond.git diff --git a/lily/note-column.cc b/lily/note-column.cc index 770157d073..8dca8fc061 100644 --- a/lily/note-column.cc +++ b/lily/note-column.cc @@ -3,146 +3,224 @@ source file of the GNU LilyPond music typesetter - (c) 1997--1999 Han-Wen Nienhuys + (c) 1997--2000 Han-Wen Nienhuys */ +#include // ceil + + #include "dot-column.hh" #include "note-column.hh" -#include "script.hh" +#include "beam.hh" #include "note-head.hh" #include "stem.hh" #include "rest.hh" #include "debug.hh" +#include "paper-def.hh" +#include "group-interface.hh" +#include "staff-symbol-referencer.hh" bool Note_column::rest_b () const { - return rest_l_arr_.size (); + SCM r = get_elt_property ("rests"); + + return gh_pair_p (r); +} + +int +Note_column::shift_compare (Note_column *const &p1, Note_column*const&p2) +{ + SCM s1 = p1->get_elt_property ("horizontal-shift"); + SCM s2 = p2->get_elt_property ("horizontal-shift"); + + int h1 = (gh_number_p (s1))? gh_scm2int (s1) :0; + int h2 = (gh_number_p (s2)) ? gh_scm2int (s2):0; + return h1 - h2; } Note_column::Note_column() { - stem_l_ = 0; - h_shift_b_ = false; - dir_ =CENTER; + set_elt_property ("rests", SCM_EOL); + set_elt_property ("note-heads", SCM_EOL); + set_axes (X_AXIS, Y_AXIS); } -void -Note_column::sort() +Stem * +Note_column::stem_l () const { - head_l_arr_.sort (Note_head::compare); + SCM s = get_elt_property ("stem"); + return dynamic_cast (unsmob_element (s)); + } + -Interval_t +Slice Note_column::head_positions_interval() const { - ((Note_column*)this)->sort(); - Interval_t iv; + Slice iv; iv.set_empty (); - if (head_l_arr_.size ()) - iv = Interval_t(head_l_arr_[0]->position_i_, - head_l_arr_.top()->position_i_); - + SCM h = get_elt_property ("note-heads"); + for (; gh_pair_p (h); h = gh_cdr (h)) + { + Score_element *se = unsmob_element (gh_car (h)); + Staff_symbol_referencer_interface si (se); + + int j = int (si.position_f ()); + iv.unite (Slice (j,j)); + } return iv; } -void -Note_column::do_pre_processing() +Direction +Note_column::dir () const { - if (!dir_) - { - if (stem_l_) - dir_ = stem_l_->dir_; - else if (head_l_arr_.size ()) - { - // assert (false); // looks obsolete? - dir_ = sign (head_positions_interval().center ()); - } - } - Script_column::do_pre_processing(); + if (stem_l ()) + return stem_l ()->get_direction (); + else if (gh_pair_p (get_elt_property ("note-heads"))) + return (Direction)sign (head_positions_interval().center ()); + + programming_error ("Note column without heads and stem!"); + return CENTER; } - void Note_column::set_stem (Stem * stem_l) { - add_support (stem_l); - stem_l_ = stem_l; - /* - don't add stem to support; mostly invisible for rest-columns (and possibly taken . .) - */ - Score_element::add_dependency (stem_l); - for (int i=0; i < script_l_arr_.size(); i++) - script_l_arr_[i]->set_stem (stem_l); -} + set_elt_property ("stem", stem_l->self_scm_); -void -Note_column::add_script (Script *script_l) -{ - Script_column::add_script (script_l) ; - if (stem_l_) - script_l->set_stem (stem_l_); + add_dependency (stem_l); + add_element (stem_l); } -void -Note_column::do_substitute_element_pointer (Score_element*o, Score_element*n) -{ - if (stem_l_ == o) - { - stem_l_ = n ? dynamic_cast (n):0; - } - if (dynamic_cast (o)) - { - head_l_arr_.substitute (dynamic_cast (o), - (n)? dynamic_cast (n) : 0); - } - Script_column::do_substitute_element_pointer (o,n); - if (dynamic_cast (o)) - { - rest_l_arr_.substitute (dynamic_cast (o), - (n)? dynamic_cast (n) : 0); - } -} + void Note_column::add_head (Rhythmic_head *h) { if (Rest*r=dynamic_cast (h)) { - rest_l_arr_.push (r); - add_support (r); + Group_interface gi (this, "rests"); + gi.add_element (h); } if (Note_head *nh=dynamic_cast (h)) { - head_l_arr_.push (nh); - add_support (nh); + Group_interface gi (this, "note-heads"); + gi.add_element (nh); } + add_element (h); } /** - translate the rest symbols + translate the rest symbols vertically by amount DY_I. */ void Note_column::translate_rests (int dy_i) { - invalidate_cache (Y_AXIS); - for (int i=0; i < rest_l_arr_.size(); i++) - rest_l_arr_[i]->position_i_ += dy_i; + SCM s = get_elt_property ("rests"); + for (; gh_pair_p (s); s = gh_cdr (s)) + { + Score_element * se = unsmob_element (gh_car (s)); + Staff_symbol_referencer_interface si (se); + + se->translate_axis (dy_i * si.staff_space ()/2.0, Y_AXIS); + } } + void -Note_column::do_print() const +Note_column::set_dotcol (Dot_column *d) { -#ifndef NPRINT - DOUT << "rests: " << rest_l_arr_.size() << ", "; - DOUT << "heads: " << head_l_arr_.size(); -#endif + add_element (d); } +/* + [TODO] + handle rest under beam (do_post: beams are calculated now) + what about combination of collisions and rest under beam. + + Should lookup + + rest -> stem -> beam -> interpolate_y_position () +*/ + void -Note_column::set_dotcol (Dot_column *d) +Note_column::do_post_processing () { - add_element (d); + if (!stem_l () || !rest_b ()) + return; + + Beam * b = stem_l ()->beam_l (); + if (!b || !b->visible_stem_count ()) + return; + + /* ugh. Should be done by beam. + (what? should be done --jcn) + scary too?: height is calculated during post_processing + */ + Real beam_dy = 0; + Real beam_y = 0; + + SCM s = b->get_elt_property ("height"); + if (gh_number_p (s)) + beam_dy = gh_scm2double (s); + + s = b->get_elt_property ("y-position"); + if (gh_number_p (s)) + beam_y = gh_scm2double (s); + + + Real x0 = b->first_visible_stem ()->hpos_f (); + Real dx = b->last_visible_stem ()->hpos_f () - x0; + Real dydx = beam_dy && dx ? beam_dy/dx : 0; + + Direction d = stem_l ()->get_direction (); + Real beamy = (stem_l ()->hpos_f () - x0) * dydx + beam_y; + + s = get_elt_property ("rests"); + Score_element * se = unsmob_element (gh_car (s)); + Staff_symbol_referencer_interface si (se); + + Real staff_space = si.staff_space (); + Real rest_dim = extent (Y_AXIS)[d]*2.0 /staff_space ; + + Real minimum_dist + = paper_l ()->get_var ("restcollision_minimum_beamdist") ; + Real dist = + minimum_dist + -d * (beamy - rest_dim) >? 0; + + int stafflines = si.line_count (); + + // move discretely by half spaces. + int discrete_dist = int (ceil (dist )); + + // move by whole spaces inside the staff. + if (discrete_dist < stafflines+1) + discrete_dist = int (ceil (discrete_dist / 2.0)* 2.0); + + translate_rests (-d * discrete_dist); +} + + +Interval +Note_column::rest_dim () const +{ + Interval restdim; + SCM s = get_elt_property ("rests"); + for (; gh_pair_p (s); s = gh_cdr (s)) + { + Score_element * sc = unsmob_element ( gh_car (s)); + restdim.unite (sc->extent (Y_AXIS)); + } + + return restdim; +} + +Note_head* +Note_column::first_head () const +{ + Stem * st = stem_l (); + return st? st->first_head (): 0; }