X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-placement.cc;h=02f0a2a6094c00d30bd2148d624dd82f5da137ff;hb=598ae0a0f49e834d5af8825f7eef8044fc95a5ec;hp=efe51e67255cb305c1bb0e72469641375e942dfc;hpb=9106e3bd374198c5457c35181ae1d66b3ec95236;p=lilypond.git diff --git a/lily/accidental-placement.cc b/lily/accidental-placement.cc index efe51e6725..02f0a2a609 100644 --- a/lily/accidental-placement.cc +++ b/lily/accidental-placement.cc @@ -3,38 +3,47 @@ source file of the GNU LilyPond music typesetter - (c) 2002--2005 Han-Wen Nienhuys + (c) 2002--2009 Han-Wen Nienhuys */ - #include "accidental-placement.hh" -#include "skyline.hh" + +#include "item.hh" +#include "rhythmic-head.hh" +#include "accidental-interface.hh" #include "music.hh" -#include "pitch.hh" -#include "warn.hh" +#include "note-collision.hh" #include "note-column.hh" #include "pointer-group-interface.hh" -#include "note-collision.hh" -#include "accidental-interface.hh" - +#include "skyline.hh" +#include "stream-event.hh" +#include "warn.hh" -void -Accidental_placement::add_accidental (Grob *me, Grob *a) +static Pitch* +accidental_pitch (Grob *acc) { - a->set_parent (me, X_AXIS); - a->set_property ("X-offset", Grob::x_parent_positioning_proc); - SCM cause = a->get_parent (Y_AXIS)->get_property ("cause"); + SCM cause = acc->get_parent (Y_AXIS)->get_property ("cause"); - Music *mcause = unsmob_music (cause); + Stream_event *mcause = unsmob_stream_event (cause); if (!mcause) { - programming_error ("note head has no music cause"); - return; + programming_error ("note head has no event cause"); + return 0; } - Pitch *p = unsmob_pitch (mcause->get_property ("pitch")); + return unsmob_pitch (mcause->get_property ("pitch")); +} + +void +Accidental_placement::add_accidental (Grob *me, Grob *a) +{ + Pitch *p = accidental_pitch (a); + if (!p) + return; + a->set_parent (me, X_AXIS); + a->set_property ("X-offset", Grob::x_parent_positioning_proc); int n = p->get_notename (); SCM accs = me->get_object ("accidental-grobs"); @@ -57,8 +66,8 @@ Accidental_placement::add_accidental (Grob *me, Grob *a) */ void Accidental_placement::split_accidentals (Grob *accs, - Link_array *break_reminder, - Link_array *real_acc) + vector *break_reminder, + vector *real_acc) { for (SCM acs = accs->get_object ("accidental-grobs"); scm_is_pair (acs); acs = scm_cdr (acs)) @@ -66,78 +75,87 @@ Accidental_placement::split_accidentals (Grob *accs, { Grob *a = unsmob_grob (scm_car (s)); - if (unsmob_grob (a->get_object ("tie"))) - break_reminder->push (a); + if (unsmob_grob (a->get_object ("tie")) + && !to_boolean (a->get_property ("forced"))) + break_reminder->push_back (a); else - real_acc->push (a); + real_acc->push_back (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) +vector +Accidental_placement::get_relevant_accidentals (vector const &elts, Grob *left) { - Link_array br, ra; - Link_array *which = 0; - - Accidental_placement::split_accidentals (me, &br, &ra); - br.concat (ra); + vector br; + vector ra; + vector ret; + bool right = dynamic_cast (left)->break_status_dir () == RIGHT; - 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 ()) + for (vsize i = 0; i < elts.size (); i++) { - Real p = robust_scm2double (me->get_property ("left-padding"), 0.2); - extent[LEFT] -= p; - } + split_accidentals (elts[i], &br, &ra); + + ret.insert (ret.end (), ra.begin (), ra.end ()); - return extent; + if (right) + ret.insert (ret.end (), br.begin (), br.end ()); + } + return ret; } struct Accidental_placement_entry { - Array left_skyline_; - Array right_skyline_; + Skyline left_skyline_; + Skyline right_skyline_; Interval vertical_extent_; - Array extents_; - Link_array grobs_; - Real offset_; - int notename_; - Accidental_placement_entry () - { - offset_ = 0.0; - notename_ = -1; - } + vector extents_; + vector grobs_; }; -static Interval all_accidental_vertical_extent; Real ape_priority (Accidental_placement_entry const *a) { return a->vertical_extent_[UP]; } -int ape_compare (Accidental_placement_entry *const &a, - Accidental_placement_entry *const &b) +bool ape_less (Accidental_placement_entry *const &a, + Accidental_placement_entry *const &b) { - return sign (ape_priority (a) - ape_priority (b)); + return ape_priority (a) < ape_priority (b); } -int ape_rcompare (Accidental_placement_entry *const &a, - Accidental_placement_entry *const &b) +/* + This function provides a method for sorting accidentals that belong to the + same note. The accidentals that this function considers to be "smallest" + will be placed to the left of the "larger" accidentals. + + Naturals are the largest (so that they don't get confused with cancellation + naturals); apart from that, we order according to the alteration (so + double-flats are the smallest). + + Precondition: the accidentals are attached to NoteHeads of the same note + name -- the octaves, however, may be different. +*/ +static bool +acc_less (Grob *const &a, Grob *const &b) { - return -sign (ape_priority (a) - ape_priority (b)); + Pitch *p = accidental_pitch (a); + Pitch *q = accidental_pitch (b); + + if (!p || !q) + { + programming_error ("these accidentals do not have a pitch"); + return false; + } + + if (p->get_octave () != q->get_octave ()) + return p->get_octave () < q->get_octave (); + + if (p->get_alteration () == Rational (0)) + return false; + if (q->get_alteration () == Rational (0)) + return true; + + return p->get_alteration () < q->get_alteration (); } /* @@ -149,31 +167,231 @@ int ape_rcompare (Accidental_placement_entry *const &a, placement */ void -stagger_apes (Link_array *apes) +stagger_apes (vector *apes) { - Link_array asc = *apes; + vector asc = *apes; - asc.sort (&ape_compare); + vector_sort (asc, &ape_less); apes->clear (); - int i = 0; int parity = 1; - while (i < asc.size ()) + for (vsize i = 0; i < asc.size ();) { Accidental_placement_entry *a = 0; if (parity) - a = asc.pop (); + { + a = asc.back (); + asc.pop_back (); + } else a = asc[i++]; - apes->push (a); + apes->push_back (a); parity = !parity; } - apes->reverse (); + reverse (*apes); } +static vector +build_apes (SCM accs) +{ + vector apes; + for (SCM s = accs; scm_is_pair (s); s = scm_cdr (s)) + { + Accidental_placement_entry *ape = new Accidental_placement_entry; + + for (SCM t = scm_cdar (s); scm_is_pair (t); t = scm_cdr (t)) + ape->grobs_.push_back (unsmob_grob (scm_car (t))); + + apes.push_back (ape); + } + + return apes; +} + +static void +set_ape_skylines (Accidental_placement_entry *ape, + Grob **common) +{ + vector accs (ape->grobs_); + vector_sort (accs, &acc_less); + + /* We know that each accidental has the same note name and we assume that + accidentals in different octaves won't collide. If two or more + accidentals are in the same octave: + 1) if they are the same accidental, print them in overstrike + 2) otherwise, shift one to the left so they don't overlap. */ + int last_octave = 0; + Real offset = 0; + Real last_offset = 0; + Rational last_alteration (0); + for (vsize i = accs.size (); i--;) + { + Grob *a = accs[i]; + Pitch *p = accidental_pitch (a); + + if (!p) + continue; + + if (i == accs.size () - 1 || p->get_octave () != last_octave) + { + last_offset = 0; + offset = a->extent (a, X_AXIS)[LEFT] - 0.2; + } + else if (p->get_alteration () == last_alteration) + a->translate_axis (last_offset, X_AXIS); + else /* Our alteration is different from the last one */ + { + Real this_offset = offset - a->extent (a, X_AXIS)[RIGHT]; + a->translate_axis (this_offset, X_AXIS); + + /* FIXME: read the padding from the AccidentalPlacement grob */ + last_offset = this_offset; + offset -= a->extent (a, X_AXIS).length () + 0.2; + } + + vector boxes = Accidental_interface::accurate_boxes (a, common); + ape->extents_.insert (ape->extents_.end (), boxes.begin (), boxes.end ()); + + for (vsize j = boxes.size (); j--;) + ape->vertical_extent_.unite (boxes[j][Y_AXIS]); + + last_octave = p->get_octave (); + last_alteration = p->get_alteration (); + } + ape->left_skyline_ = Skyline (ape->extents_, 0, Y_AXIS, LEFT); + ape->right_skyline_ = Skyline (ape->extents_, 0, Y_AXIS, RIGHT); +} + +static vector +extract_heads_and_stems (vector const &apes) +{ + vector note_cols; + vector ret; + + for (vsize i = apes.size (); i--;) + { + Accidental_placement_entry *ape = apes[i]; + for (vsize j = ape->grobs_.size (); j--;) + { + Grob *acc = ape->grobs_[j]; + Grob *head = acc->get_parent (Y_AXIS); + Grob *col = head->get_parent (X_AXIS); + + if (Note_column::has_interface (col)) + note_cols.push_back (col); + else + ret.push_back (head); + } + } + + /* + This is a little kludgy: in case there are note columns without + accidentals, we get them from the Note_collision objects. + */ + for (vsize i = note_cols.size (); i--;) + { + Grob *c = note_cols[i]->get_parent (X_AXIS); + if (Note_collision_interface::has_interface (c)) + { + extract_grob_set (c, "elements", columns); + concat (note_cols, columns); + } + } + + /* Now that we have all of the columns, grab all of the note-heads */ + for (vsize i = note_cols.size (); i--;) + concat (ret, extract_grob_array (note_cols[i], "note-heads")); + + /* Now that we have all of the heads, grab all of the stems */ + for (vsize i = ret.size (); i--;) + if (Grob *s = Rhythmic_head::get_stem (ret[i])) + ret.push_back (s); + + + vector_sort (ret, less ()); + uniq (ret); + return ret; +} + +static Grob* +common_refpoint_of_accidentals (vector const &apes, Axis a) +{ + Grob *ret = 0; + + for (vsize i = apes.size (); i--;) + for (vsize j = apes[i]->grobs_.size (); j--;) + { + if (!ret) + ret = apes[i]->grobs_[j]; + else + ret = ret->common_refpoint (apes[i]->grobs_[j], a); + } + + return ret; +} + +static Skyline +build_heads_skyline (vector const &heads_and_stems, + Grob **common) +{ + vector head_extents; + for (vsize i = heads_and_stems.size (); i--;) + head_extents.push_back (Box (heads_and_stems[i]->extent (common[X_AXIS], X_AXIS), + heads_and_stems[i]->pure_height (common[Y_AXIS], 0, INT_MAX))); + + return Skyline (head_extents, 0, Y_AXIS, LEFT); +} + +/* + Position the apes, starting from the right, so that they don't collide. + Return the total width. +*/ +static Interval +position_apes (Grob *me, + vector const &apes, + Skyline const &heads_skyline) +{ + Real padding = robust_scm2double (me->get_property ("padding"), 0.2); + Skyline left_skyline = heads_skyline; + left_skyline.raise (-robust_scm2double (me->get_property ("right-padding"), 0)); + + /* + Add accs entries right-to-left. + */ + Interval width; + Real last_offset = 0.0; + for (vsize i = apes.size (); i-- > 0;) + { + Accidental_placement_entry *ape = apes[i]; + + Real offset = -ape->right_skyline_.distance (left_skyline); + if (isinf (offset)) + offset = last_offset; + else + offset -= padding; + + Skyline new_left_skyline = ape->left_skyline_; + new_left_skyline.raise (offset); + new_left_skyline.merge (left_skyline); + left_skyline = new_left_skyline; + + /* Shift all of the accidentals in this ape */ + for (vsize j = ape->grobs_.size (); j--;) + ape->grobs_[j]->translate_axis (offset, X_AXIS); + + for (vsize j = ape->extents_.size (); j--;) + width.unite (offset + ape->extents_[j][X_AXIS]); + + last_offset = offset; + } + + return width; +} + + /* This routine computes placements of accidentals. During add_accidental (), accidentals are already grouped by note, so that @@ -215,7 +433,7 @@ stagger_apes (Link_array *apes) */ -MAKE_SCHEME_CALLBACK(Accidental_placement, calc_positioning_done, 1); +MAKE_SCHEME_CALLBACK (Accidental_placement, calc_positioning_done, 1); SCM Accidental_placement::calc_positioning_done (SCM smob) { @@ -223,188 +441,46 @@ Accidental_placement::calc_positioning_done (SCM smob) if (!me->is_live ()) return SCM_BOOL_T; + me->set_property ("positioning-done", SCM_BOOL_T); + SCM accs = me->get_object ("accidental-grobs"); if (!scm_is_pair (accs)) return SCM_BOOL_T; - /* - 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; scm_is_pair (s); s = scm_cdr (s)) - { - Accidental_placement_entry *ape = new Accidental_placement_entry; - ape->notename_ = scm_to_int (scm_caar (s)); - - for (SCM t = scm_cdar (s); scm_is_pair (t); t = scm_cdr (t)) - ape->grobs_.push (unsmob_grob (scm_car (t))); - - apes.push (ape); - } + vector apes = build_apes (accs); Grob *common[] = {me, 0}; - /* - First we must extract *all* pointers. We can only determine - extents if we're sure that we've found the right common refpoint - */ - Link_array note_cols, heads; - for (int i = apes.size (); i--;) - { - Accidental_placement_entry *ape = apes[i]; - 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; - - Grob *head = a->get_parent (Y_AXIS); - - Grob *col = head->get_parent (X_AXIS); - if (Note_column::has_interface (col)) - note_cols.push (col); - else - heads.push (head); - } - } - - /* - This is a little kludgy: to get all notes, we look if there are - collisions as well. - */ - for (int i = note_cols.size (); i--;) - { - Grob *c = note_cols[i]->get_parent (X_AXIS); - if (Note_collision_interface::has_interface (c)) - { - extract_grob_set (c, "elements", gs); - - note_cols.concat (gs); - } - } + vector heads_and_stems = extract_heads_and_stems (apes); - for (int i = note_cols.size (); i--;) - heads.concat (extract_grob_array (note_cols[i], "note-heads")); + common[Y_AXIS] = common_refpoint_of_accidentals (apes, Y_AXIS); + common[Y_AXIS] = common_refpoint_of_array (heads_and_stems, common[Y_AXIS], Y_AXIS); + common[X_AXIS] = common_refpoint_of_array (heads_and_stems, me, X_AXIS); - heads.default_sort (); - heads.uniq (); - common[Y_AXIS] = common_refpoint_of_array (heads, common[Y_AXIS], Y_AXIS); + for (vsize i = apes.size (); i--;) + set_ape_skylines (apes[i], common); + Skyline heads_skyline = build_heads_skyline (heads_and_stems, common); - for (int i = apes.size (); i--;) - { - Accidental_placement_entry *ape = apes[i]; - ape->left_skyline_ = empty_skyline (LEFT); - ape->right_skyline_ = empty_skyline (RIGHT); - - for (int j = apes[i]->grobs_.size (); j--;) - { - Grob *a = apes[i]->grobs_[j]; - - Array boxes = Accidental_interface::accurate_boxes (a, common); - - 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); - } - } - } - - Interval total; - for (int i = apes.size (); i--;) - { - Interval y; - - for (int j = apes[i]->extents_.size (); j--;) - y.unite (apes[i]->extents_[j][Y_AXIS]); - apes[i]->vertical_extent_ = y; - total.unite (y); - } - all_accidental_vertical_extent = total; stagger_apes (&apes); + Interval width = position_apes (me, apes, heads_skyline); - Accidental_placement_entry *head_ape = new Accidental_placement_entry; - 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 (common[X_AXIS], X_AXIS), - heads[i]->extent (common[Y_AXIS], Y_AXIS)); - - insert_extent_into_skyline (&head_skyline, b, Y_AXIS, LEFT); - } - - head_ape->left_skyline_ = head_skyline; - head_ape->offset_ = 0.0; - - Real padding = robust_scm2double (me->get_property ("padding"), 0.2); - - Array left_skyline = head_ape->left_skyline_; - heighten_skyline (&left_skyline, - -robust_scm2double (me->get_property ("right-padding"), 0)); - /* - Add accs entries right-to-left. - */ - for (int i = apes.size (); i-- > 0;) - { - 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; - } - - for (int i = apes.size (); i--;) - { - Accidental_placement_entry *ape = apes[i]; - for (int j = ape->grobs_.size (); j--;) - ape->grobs_[j]->translate_axis (ape->offset_, X_AXIS); - } - - Interval left_extent, right_extent; - Accidental_placement_entry *ape = apes[0]; - - for (int i = ape->extents_.size (); i--;) - left_extent.unite (ape->offset_ + ape->extents_[i][X_AXIS]); - - ape = apes.top (); - for (int i = ape->extents_.size (); i--;) - right_extent.unite (ape->offset_ + ape->extents_[i][X_AXIS]); - - left_extent[LEFT] -= robust_scm2double (me->get_property ("left-padding"), 0); - Interval width (left_extent[LEFT], right_extent[RIGHT]); - - SCM scm_width = ly_interval2scm (width); me->flush_extent_cache (X_AXIS); - me->set_property ("X-extent", scm_width); + me->set_property ("X-extent", ly_interval2scm (width)); - for (int i = apes.size (); i--;) - delete apes[i]; + junk_pointers (apes); return SCM_BOOL_T; } ADD_INTERFACE (Accidental_placement, - "accidental-placement-interface", "Resolve accidental collisions.", /* properties */ "accidental-grobs " + "direction " "left-padding " "padding " "positioning-done " - "right-padding ") + "right-padding " + "script-priority " + )