X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-placement.cc;h=46c765daf2c679e42766320a9d4ecc981d41aed5;hb=5249785633e818fc67096ddda5d72de525933f2f;hp=9a0ab1fec317539dbc79556be67644ce3f892c02;hpb=9f651eaf19ec2ae978ddebae88736e4b3d54c459;p=lilypond.git diff --git a/lily/accidental-placement.cc b/lily/accidental-placement.cc index 9a0ab1fec3..46c765daf2 100644 --- a/lily/accidental-placement.cc +++ b/lily/accidental-placement.cc @@ -3,7 +3,7 @@ accidental-placement.cc -- implement Accidental_placement source file of the GNU LilyPond music typesetter -(c) 2002 Han-Wen Nienhuys +(c) 2002--2003 Han-Wen Nienhuys */ @@ -18,19 +18,7 @@ source file of the GNU LilyPond music typesetter #include "note-column.hh" #include "group-interface.hh" #include "note-collision.hh" - -MAKE_SCHEME_CALLBACK(Accidental_placement,extent_callback, 2); -SCM -Accidental_placement::extent_callback(SCM s, SCM axis) -{ - Grob * me =unsmob_grob (s); - Axis a = Axis (gh_scm2int (axis)); - - assert (a == X_AXIS); - - SCM w = position_accidentals (me); - return w; -} +#include "accidental-interface.hh" MAKE_SCHEME_CALLBACK(Accidental_placement,alignment_callback, 2); SCM @@ -39,17 +27,16 @@ Accidental_placement::alignment_callback(SCM s, SCM ) Grob * me =unsmob_grob (s); Grob * par = me->get_parent (X_AXIS); - if (!to_boolean (par->get_grob_property ("alignment-done"))) + if (!to_boolean (par->get_grob_property ("positioning-done"))) { - par->set_grob_property ("alignment-done", SCM_BOOL_T); + par->set_grob_property ("positioning-done", SCM_BOOL_T); position_accidentals (par); } - return gh_int2scm (0); + return scm_int2num (0); } - void Accidental_placement::add_accidental (Grob* me, Grob* a) { @@ -66,10 +53,10 @@ Accidental_placement::add_accidental (Grob* me, Grob* a) Pitch *p= unsmob_pitch (mcause->get_mus_property ("pitch")); - int n = p->notename_i_; + int n = p->get_notename (); - SCM accs = me->get_grob_property ("accidentals"); - SCM key = gh_int2scm (n); + SCM accs = me->get_grob_property ("accidental-grobs"); + SCM key = scm_int2num (n); SCM entry = scm_assq (key, accs); if (entry == SCM_BOOL_F) { @@ -82,9 +69,67 @@ Accidental_placement::add_accidental (Grob* me, Grob* a) accs = scm_assq_set_x (accs, key, entry); - me->set_grob_property ("accidentals", accs); + me->set_grob_property ("accidental-grobs", accs); +} + +/* + Split into break reminders. + */ +void +Accidental_placement::split_accidentals (Grob * accs, + Link_array *break_reminder, + Link_array *real_acc) +{ + for (SCM acs =accs->get_grob_property ("accidental-grobs"); gh_pair_p (acs); + acs =gh_cdr (acs)) + for (SCM s = gh_cdar (acs); gh_pair_p (s); s = gh_cdr (s)) + { + Grob *a = unsmob_grob (gh_car (s)); + + if (unsmob_grob (a->get_grob_property ("tie"))) + break_reminder->push (a); + else + real_acc->push (a); + } +} + +/* + Accidentals are special, because they appear and disappear after + ties at will. +*/ +Interval +Accidental_placement::get_relevant_accidental_extent (Grob *me, + Item *item_col, + Grob *left_object) +{ + Link_array br, ra; + Link_array *which = 0; + + Accidental_placement::split_accidentals (me, &br, &ra); + br.concat (ra); + + if (dynamic_cast(left_object)->break_status_dir () == RIGHT) + which = & br; + else + which = & ra; + + Interval extent; + for (int i = 0; i < which->size(); i++) + { + extent.unite (which->elem(i)->extent (item_col, X_AXIS)); + } + + if (!extent.is_empty ()) + { + Real p = gh_scm2double (me->get_grob_property ("left-padding")); + extent[LEFT] -= p; + } + + return extent; } + + struct Accidental_placement_entry { Array left_skyline_; @@ -104,16 +149,7 @@ struct Accidental_placement_entry static Interval all_accidental_vertical_extent; Real ape_priority (Accidental_placement_entry const * a) { - Real c = a->vertical_extent_.center(); - - /* - far from center means we can fold more. Hopefully. - */ - Real center_distance = - fabs(c - all_accidental_vertical_extent[LEFT]) >? - fabs(c - all_accidental_vertical_extent[RIGHT]); - - return 20 * a->vertical_extent_.length () + center_distance; + return a->vertical_extent_[UP]; } @@ -124,9 +160,53 @@ int ape_compare (Accidental_placement_entry *const &a, return sign (ape_priority (a) - ape_priority(b)); } +int ape_rcompare (Accidental_placement_entry *const &a, + Accidental_placement_entry *const &b) +{ + return -sign (ape_priority (a) - ape_priority(b)); +} + + /* - Return: width as SCM interval. +TODO: should favor + + b + b + +placement + +*/ +void +stagger_apes (Link_array *apes) +{ + Link_array asc = *apes; + + + asc.sort (&ape_compare); + + apes->clear(); + + int i =0; + int parity = 1; + while (i < asc.size()) + { + Accidental_placement_entry * a = 0; + if (parity) + a = asc.pop(); + else + a = asc[i++]; + + apes->push (a); + parity = !parity; + } + + apes->reverse(); +} + + + +/* This routine computes placements of accidentals. During add_accidental(), accidentals are already grouped by note, so that @@ -149,18 +229,35 @@ int ape_compare (Accidental_placement_entry *const &a, The naturals should be left of the C as well; they should be separate accs. - TODO: Try to combine Apes before sorting them: this will allow a - better placement. + Note that this placement problem looks NP hard, so we just use a + simple strategy, not an optimal choice. - Note that this placement problem is almost certainly NP hard, so we - just use a simple strategy, not an optimal choice. */ +/* + TODO: there should be more space in the following situation + + + Natural + downstem + + |_ + | | X + |_| | + | | + + */ SCM Accidental_placement::position_accidentals (Grob * me) { - SCM accs = me->get_grob_property ("accidentals"); + if (!me->live ()) + return SCM_UNSPECIFIED; + + SCM accs = me->get_grob_property ("accidental-grobs"); + /* + TODO: there is a bug in this code. If two accs are on the same + Y-position, they share an Ape, and will be printed in overstrike. + */ Link_array apes; for (SCM s = accs; gh_pair_p (s); s =gh_cdr (s)) { @@ -174,7 +271,7 @@ Accidental_placement::position_accidentals (Grob * me) } - Grob *commony =0 ; + Grob *common[] = {me, 0}; /* First we must extract *all* pointers. We can only determine @@ -187,8 +284,12 @@ Accidental_placement::position_accidentals (Grob * me) for (int j = ape->grobs_.size(); j--;) { Grob * a = ape->grobs_[j]; + + if (common[Y_AXIS]) + common[Y_AXIS] = common[Y_AXIS]->common_refpoint (a, Y_AXIS); + else + common[Y_AXIS] = a; - commony = commony->common_refpoint (a, Y_AXIS); Grob *head = a->get_parent (Y_AXIS); Grob * col = head->get_parent (X_AXIS); @@ -224,7 +325,7 @@ Accidental_placement::position_accidentals (Grob * me) } heads.default_sort(); heads.uniq(); - commony = common_refpoint_of_array (heads, commony, Y_AXIS); + common[Y_AXIS] = common_refpoint_of_array (heads, common[Y_AXIS], Y_AXIS); for (int i= apes.size (); i--;) @@ -236,18 +337,15 @@ Accidental_placement::position_accidentals (Grob * me) for (int j = apes[i]->grobs_.size(); j--;) { Grob * a = apes[i]->grobs_[j]; - Box b; - b[X_AXIS] = a->extent (me, X_AXIS); - b[Y_AXIS] = a->extent (commony, Y_AXIS); - ape->extents_.push (b); + Array boxes = Accidental_interface::accurate_boxes (a, common); - /* - TODO: replace the extents of a flat by combination of two - bboxes, so that we use the shape of the flat better. - */ - insert_extent_into_skyline (&ape->left_skyline_, b, Y_AXIS, LEFT); - insert_extent_into_skyline (&ape->right_skyline_ , b,Y_AXIS, RIGHT); + ape->extents_.concat (boxes); + for (int j = boxes.size(); j--;) + { + insert_extent_into_skyline (&ape->left_skyline_, boxes[j], Y_AXIS, LEFT); + insert_extent_into_skyline (&ape->right_skyline_ , boxes[j], Y_AXIS, RIGHT); + } } } @@ -265,16 +363,16 @@ Accidental_placement::position_accidentals (Grob * me) total.unite (y); } all_accidental_vertical_extent = total; - apes.sort (&ape_compare); + stagger_apes (&apes); Accidental_placement_entry * head_ape = new Accidental_placement_entry; - Grob *commonx = common_refpoint_of_array (heads, me, X_AXIS); + common[X_AXIS] = common_refpoint_of_array (heads, common[X_AXIS], X_AXIS); Array head_skyline (empty_skyline (LEFT)); Array head_extents; for (int i = heads.size(); i--;) { - Box b(heads[i]->extent (commonx, X_AXIS), - heads[i]->extent (commony, Y_AXIS)); + Box b(heads[i]->extent (common[X_AXIS] , X_AXIS), + heads[i]->extent (common[Y_AXIS], Y_AXIS)); insert_extent_into_skyline (&head_skyline, b , Y_AXIS, LEFT); } @@ -291,32 +389,28 @@ Accidental_placement::position_accidentals (Grob * me) SCM spad = me->get_grob_property ("padding"); if (gh_number_p (spad)) padding = gh_scm2double (spad); - - apes.push (head_ape); - for (int i= apes.size () -1 ; i-- > 0;) + + Array left_skyline = head_ape->left_skyline_; + /* + Add accs entries right-to-left. + */ + for (int i= apes.size (); i-- > 0;) { - Accidental_placement_entry *ape = apes[i]; - Real d = 0.0; - int j = i+1; - do { - d = - skyline_meshing_distance (ape->right_skyline_, - apes[j]->left_skyline_); - - if (!isinf(d) - || j + 1 == apes.size()) - break; - - j = j+ 1; - } while (1); - - if (isinf(d)) - d = 0.0; - - d -= padding; - ape->offset_ += apes[j]->offset_ + d; - } + Real offset = + -skyline_meshing_distance (apes[i]->right_skyline_, left_skyline); + if (isinf (offset)) + offset = (i < apes.size () - 1) ? apes[i+1]->offset_ : 0.0; + else + offset -= padding; + + apes[i]->offset_ = offset; + + Array new_left_skyline = apes[i]->left_skyline_; + heighten_skyline (&new_left_skyline, apes[i]->offset_); + merge_skyline (&new_left_skyline, left_skyline, LEFT); + left_skyline = new_left_skyline; + } - apes.pop(); for (int i = apes.size(); i--;) { Accidental_placement_entry* ape = apes[i]; @@ -350,10 +444,10 @@ Accidental_placement::position_accidentals (Grob * me) for (int i = apes.size(); i--;) delete apes[i]; - return scm_width; + return SCM_UNSPECIFIED; } ADD_INTERFACE(Accidental_placement, "accidental-placement-interface", "Take care of complex accidental collisions.", - "left-padding padding right-padding accidentals alignment-done") + "left-padding padding right-padding accidental-grobs positioning-done")