X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-placement.cc;h=0f14cc9a83e94e021e173075c6b1dfa4ddc9b7ff;hb=988d5288bd7999a92dd137fb57d8272153a14aa8;hp=c706ff4a6915ccf9d0549fcbeaa6da33f52abf4c;hpb=076b6e8c0da5ce9251bfef7ed1e85b74d52521ef;p=lilypond.git diff --git a/lily/accidental-placement.cc b/lily/accidental-placement.cc index c706ff4a69..0f14cc9a83 100644 --- a/lily/accidental-placement.cc +++ b/lily/accidental-placement.cc @@ -3,7 +3,7 @@ source file of the GNU LilyPond music typesetter - (c) 2002--2006 Han-Wen Nienhuys + (c) 2002--2009 Han-Wen Nienhuys */ @@ -68,44 +68,32 @@ Accidental_placement::split_accidentals (Grob *accs, { Grob *a = unsmob_grob (scm_car (s)); - if (unsmob_grob (a->get_object ("tie"))) + if (unsmob_grob (a->get_object ("tie")) + && !to_boolean (a->get_property ("forced"))) break_reminder->push_back (a); else 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) { - vector br, ra; - vector *which = 0; - - Accidental_placement::split_accidentals (me, &br, &ra); - concat (br, ra); - - if (dynamic_cast (left_object)->break_status_dir () == RIGHT) - which = &br; - else - which = &ra; - - Interval extent; - for (vsize i = 0; i < which->size (); i++) - extent.unite (which->at (i)->extent (item_col, X_AXIS)); + vector br; + vector ra; + vector ret; + bool right = dynamic_cast (left)->break_status_dir () == RIGHT; - 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 @@ -115,16 +103,8 @@ struct Accidental_placement_entry Interval vertical_extent_; vector extents_; vector grobs_; - Real offset_; - int notename_; - Accidental_placement_entry () - { - offset_ = 0.0; - notename_ = -1; - } }; -static Interval all_accidental_vertical_extent; Real ape_priority (Accidental_placement_entry const *a) { return a->vertical_extent_[UP]; @@ -184,68 +164,13 @@ stagger_apes (vector *apes) reverse (*apes); } -/* - This routine computes placements of accidentals. During - add_accidental (), accidentals are already grouped by note, so that - octaves are placed above each other; they form columns. Then the - columns are sorted: the biggest columns go closest to the note. - Then the columns are spaced as closely as possible (using skyline - spacing). - - - TODO: more advanced placement. Typically, the accs should be placed - to form a C shape, like this - - - ## - b b - # # - b - b b - - The naturals should be left of the C as well; they should - be separate accs. - - Note that this placement problem looks 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 - * |_| | - * | | - * - -*/ - -MAKE_SCHEME_CALLBACK(Accidental_placement, calc_positioning_done, 1); -SCM -Accidental_placement::calc_positioning_done (SCM smob) +static vector +build_apes (SCM accs) { - Grob *me = unsmob_grob (smob); - if (!me->is_live ()) - return 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. - */ vector 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_back (unsmob_grob (scm_car (t))); @@ -253,180 +178,229 @@ Accidental_placement::calc_positioning_done (SCM smob) apes.push_back (ape); } - Grob *common[] = {me, 0}; + return apes; +} + +static void +set_ape_skylines (Accidental_placement_entry *ape, + Grob **common) +{ + for (vsize i = ape->grobs_.size (); i--;) + { + Grob *a = ape->grobs_[i]; + 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]); + } + 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; - /* - First we must extract *all* pointers. We can only determine - extents if we're sure that we've found the right common refpoint - */ - vector note_cols, heads; for (vsize i = apes.size (); i--;) { Accidental_placement_entry *ape = apes[i]; for (vsize 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 *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 - heads.push_back (head); + ret.push_back (head); } } /* - This is a little kludgy: to get all notes, we look if there are - collisions as well. + 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", gs); - - concat (note_cols, gs); + 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 (heads, extract_grob_array (note_cols[i], "note-heads")); - - vector_sort (heads, less ()); - uniq (heads); + concat (ret, extract_grob_array (note_cols[i], "note-heads")); - vector stems; - for (vsize i = 0; i < heads.size (); i++) - { - if (Grob *s = Rhythmic_head::get_stem (heads[i])) - stems.push_back (s); - } - - vector_sort (stems, less ()); - uniq (stems); + /* 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); - common[Y_AXIS] = common_refpoint_of_array (heads, common[Y_AXIS], Y_AXIS); - common[Y_AXIS] = common_refpoint_of_array (stems, common[Y_AXIS], Y_AXIS); - - vector stems; - for (vsize i = 0; i < heads.size (); i++) - { - if (Grob *s = Rhythmic_head::get_stem (heads[i])) - { - stems.push_back (s); - common[Y_AXIS] = s->common_refpoint (common[Y_AXIS], Y_AXIS); - } - } - - vector_sort (stems, less ()); - uniq (stems); - - - for (vsize i = apes.size (); i--;) - { - Accidental_placement_entry *ape = apes[i]; - for (vsize j = apes[i]->grobs_.size (); j--;) - { - Grob *a = apes[i]->grobs_[j]; - vector boxes = Accidental_interface::accurate_boxes (a, common); + vector_sort (ret, less ()); + uniq (ret); + return ret; +} - ape->extents_.insert (ape->extents_.end (), boxes.begin (), boxes.end ()); - } - ape->left_skyline_ = Skyline (ape->extents_, Y_AXIS, LEFT); - ape->right_skyline_ = Skyline (ape->extents_, Y_AXIS, RIGHT); - } +static Grob* +common_refpoint_of_accidentals (vector const &apes, Axis a) +{ + Grob *ret = 0; - Interval total; for (vsize i = apes.size (); i--;) - { - Interval y; + 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); + } - for (vsize 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); + return ret; +} - Accidental_placement_entry *head_ape = new Accidental_placement_entry; - common[X_AXIS] = common_refpoint_of_array (heads, common[X_AXIS], X_AXIS); - +static Skyline +build_heads_skyline (vector const &heads_and_stems, + Grob **common) +{ vector head_extents; - for (vsize i = heads.size (); i--;) - head_extents.push_back (Box (heads[i]->extent (common[X_AXIS], X_AXIS), - heads[i]->extent (common[Y_AXIS], Y_AXIS))); - - for (vsize i = 0; i < stems.size (); i ++) - { - int very_large = INT_MAX; - - head_extents.push_back (Box (stems[i]->extent (common[X_AXIS], X_AXIS), - stems[i]->pure_height (common[Y_AXIS], 0, very_large))); - } + 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))); - head_ape->left_skyline_ = Skyline (head_extents, Y_AXIS, LEFT); - head_ape->offset_ = 0.0; + 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 = head_ape->left_skyline_; - left_skyline.raise (-robust_scm2double (me->get_property ("right-padding"), 0)) -; + 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;) { - Real offset = -apes[i]->right_skyline_.distance (left_skyline); + Accidental_placement_entry *ape = apes[i]; + + Real offset = -ape->right_skyline_.distance (left_skyline); if (isinf (offset)) - offset = (i < apes.size () - 1) ? apes[i + 1]->offset_ : 0.0; + offset = last_offset; else offset -= padding; - apes[i]->offset_ = offset; - - Skyline new_left_skyline = apes[i]->left_skyline_; - new_left_skyline.raise (apes[i]->offset_); + Skyline new_left_skyline = ape->left_skyline_; + new_left_skyline.raise (offset); new_left_skyline.merge (left_skyline); left_skyline = new_left_skyline; - } - for (vsize i = apes.size (); i--;) - { - Accidental_placement_entry *ape = apes[i]; + /* Shift all of the accidentals in this ape */ for (vsize j = ape->grobs_.size (); j--;) - ape->grobs_[j]->translate_axis (ape->offset_, X_AXIS); + 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; } - Interval left_extent, right_extent; - Accidental_placement_entry *ape = apes[0]; + return width; +} + - for (vsize i = ape->extents_.size (); i--;) - left_extent.unite (ape->offset_ + ape->extents_[i][X_AXIS]); +/* + This routine computes placements of accidentals. During + add_accidental (), accidentals are already grouped by note, so that + octaves are placed above each other; they form columns. Then the + columns are sorted: the biggest columns go closest to the note. + Then the columns are spaced as closely as possible (using skyline + spacing). - ape = apes.back (); - for (vsize 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]); + TODO: more advanced placement. Typically, the accs should be placed + to form a C shape, like this - SCM scm_width = ly_interval2scm (width); - me->flush_extent_cache (X_AXIS); - me->set_property ("X-extent", scm_width); + + ## + b b + # # + b + b b + + The naturals should be left of the C as well; they should + be separate accs. + + Note that this placement problem looks 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 + * |_| | + * | | + * + +*/ + +MAKE_SCHEME_CALLBACK (Accidental_placement, calc_positioning_done, 1); +SCM +Accidental_placement::calc_positioning_done (SCM smob) +{ + Grob *me = unsmob_grob (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; + + vector apes = build_apes (accs); + + Grob *common[] = {me, 0}; + + vector heads_and_stems = extract_heads_and_stems (apes); + + 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); for (vsize i = apes.size (); i--;) - delete apes[i]; + set_ape_skylines (apes[i], common); + Skyline heads_skyline = build_heads_skyline (heads_and_stems, common); + + stagger_apes (&apes); + Interval width = position_apes (me, apes, heads_skyline); + + me->flush_extent_cache (X_AXIS); + me->set_property ("X-extent", ly_interval2scm (width)); + + junk_pointers (apes); return SCM_BOOL_T; } @@ -436,6 +410,7 @@ ADD_INTERFACE (Accidental_placement, /* properties */ "accidental-grobs " + "direction " "left-padding " "padding " "positioning-done "