X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Faccidental-placement.cc;h=a96f0e2542afdde9c4ad0cb894e99fb12d35675a;hb=44ad1d66c072e4d6545e75c769c86a460cb1df13;hp=79cb293ac16c09c8026a3e9a790420d06ea60550;hpb=947454c5cc430a9627262de4f25274a64789d3c2;p=lilypond.git diff --git a/lily/accidental-placement.cc b/lily/accidental-placement.cc index 79cb293ac1..a96f0e2542 100644 --- a/lily/accidental-placement.cc +++ b/lily/accidental-placement.cc @@ -1,96 +1,78 @@ -/* -accidental-placement.cc -- implement Accidental_placement +/* + accidental-placement.cc -- implement Accidental_placement -source file of the GNU LilyPond music typesetter + source file of the GNU LilyPond music typesetter -(c) 2002--2004 Han-Wen Nienhuys + (c) 2002--2006 Han-Wen Nienhuys +*/ - */ -#include -#include +#include "accidental-placement.hh" #include "item.hh" -#include "skyline.hh" +#include "rhythmic-head.hh" +#include "accidental-interface.hh" #include "music.hh" +#include "note-collision.hh" +#include "note-column.hh" #include "pitch.hh" +#include "pointer-group-interface.hh" +#include "skyline.hh" +#include "stream-event.hh" #include "warn.hh" -#include "accidental-placement.hh" -#include "note-column.hh" -#include "group-interface.hh" -#include "note-collision.hh" -#include "accidental-interface.hh" - -MAKE_SCHEME_CALLBACK (Accidental_placement,alignment_callback, 2); -SCM -Accidental_placement::alignment_callback (SCM s, SCM ) -{ - Grob * me =unsmob_grob (s); - - Grob * par = me->get_parent (X_AXIS); - if (!to_boolean (par->get_property ("positioning-done"))) - { - par->set_property ("positioning-done", SCM_BOOL_T); - position_accidentals (par); - } - - return scm_int2num (0); -} void -Accidental_placement::add_accidental (Grob* me, Grob* a) +Accidental_placement::add_accidental (Grob *me, Grob *a) { a->set_parent (me, X_AXIS); - a->add_offset_callback (alignment_callback_proc, X_AXIS); + a->set_property ("X-offset", Grob::x_parent_positioning_proc); SCM cause = a->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; } - Pitch *p= unsmob_pitch (mcause->get_property ("pitch")); + Pitch *p = unsmob_pitch (mcause->get_property ("pitch")); int n = p->get_notename (); - SCM accs = me->get_property ("accidental-grobs"); - SCM key = scm_int2num (n); + SCM accs = me->get_object ("accidental-grobs"); + SCM key = scm_from_int (n); SCM entry = scm_assq (key, accs); if (entry == SCM_BOOL_F) - { - entry = SCM_EOL; - } + entry = SCM_EOL; else - entry = gh_cdr (entry); + entry = scm_cdr (entry); - entry = gh_cons (a->self_scm (), entry); + entry = scm_cons (a->self_scm (), entry); - accs = scm_assq_set_x (accs, key, entry); + accs = scm_assq_set_x (accs, key, entry); - me->set_property ("accidental-grobs", accs); + me->set_object ("accidental-grobs", accs); } /* Split into break reminders. - */ +*/ void -Accidental_placement::split_accidentals (Grob * accs, - Link_array *break_reminder, - Link_array *real_acc) +Accidental_placement::split_accidentals (Grob *accs, + vector *break_reminder, + vector *real_acc) { - for (SCM acs =accs->get_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)) + for (SCM acs = accs->get_object ("accidental-grobs"); scm_is_pair (acs); + acs = scm_cdr (acs)) + for (SCM s = scm_cdar (acs); scm_is_pair (s); s = scm_cdr (s)) { - Grob *a = unsmob_grob (gh_car (s)); + Grob *a = unsmob_grob (scm_car (s)); - if (unsmob_grob (a->get_property ("tie"))) - break_reminder->push (a); + if (unsmob_grob (a->get_object ("tie"))) + break_reminder->push_back (a); else - real_acc->push (a); + real_acc->push_back (a); } } @@ -103,346 +85,344 @@ Accidental_placement::get_relevant_accidental_extent (Grob *me, Item *item_col, Grob *left_object) { - Link_array br, ra; - Link_array *which = 0; + vector br, ra; + vector *which = 0; Accidental_placement::split_accidentals (me, &br, &ra); - br.concat (ra); - - if (dynamic_cast(left_object)->break_status_dir () == RIGHT) - which = & br; + concat (br, ra); + + if (dynamic_cast (left_object)->break_status_dir () == RIGHT) + which = &br; else - which = & ra; - + which = &ra; + Interval extent; - for (int i = 0; i < which->size (); i++) - { - extent.unite (which->elem (i)->extent (item_col, X_AXIS)); - } + for (vsize i = 0; i < which->size (); i++) + extent.unite (which->at (i)->extent (item_col, X_AXIS)); if (!extent.is_empty ()) { Real p = robust_scm2double (me->get_property ("left-padding"), 0.2); extent[LEFT] -= p; } - + return extent; } - - 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_; + vector extents_; + vector grobs_; + Real offset_; int notename_; Accidental_placement_entry () { - offset_ =0.0; + offset_ = 0.0; notename_ = -1; } }; static Interval all_accidental_vertical_extent; -Real ape_priority (Accidental_placement_entry const * a) +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) { return sign (ape_priority (a) - ape_priority (b)); } +bool ape_less (Accidental_placement_entry *const &a, + Accidental_placement_entry *const &b) +{ + return ape_priority (a) < ape_priority (b); +} + int ape_rcompare (Accidental_placement_entry *const &a, - Accidental_placement_entry *const &b) + Accidental_placement_entry *const &b) { return -sign (ape_priority (a) - ape_priority (b)); } - /* - -TODO: should favor + TODO: should favor b - b + b -placement - + 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; + 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); } - - /* - 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. + ## + b b + # # + b + b b - Note that this placement problem looks NP hard, so we just use a - simple strategy, not an optimal choice. + 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 + Natural + downstem - |_ - | | X - |_| | - | | - - */ + * + * |_ + * | | X + * |_| | + * | | + * + +*/ + +MAKE_SCHEME_CALLBACK(Accidental_placement, calc_positioning_done, 1); SCM -Accidental_placement::position_accidentals (Grob * me) +Accidental_placement::calc_positioning_done (SCM smob) { - if (!me->live ()) - return SCM_UNSPECIFIED; - - SCM accs = me->get_property ("accidental-grobs"); + 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. - */ - Link_array apes; - for (SCM s = accs; gh_pair_p (s); s =gh_cdr (s)) + */ + vector apes; + for (SCM s = accs; scm_is_pair (s); s = scm_cdr (s)) { Accidental_placement_entry *ape = new Accidental_placement_entry; - ape->notename_ = gh_scm2int (gh_caar (s)); - - for (SCM t = gh_cdar (s); gh_pair_p (t); t =gh_cdr (t)) - ape->grobs_.push (unsmob_grob (gh_car (t))); + ape->notename_ = scm_to_int (scm_caar (s)); - apes.push (ape); - } + 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); + } 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--;) + */ + 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]; + 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); + Grob *col = head->get_parent (X_AXIS); if (Note_column::has_interface (col)) - note_cols.push (col); + note_cols.push_back (col); else - heads.push (head); + heads.push_back (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--;) + */ + for (vsize i = note_cols.size (); i--;) { Grob *c = note_cols[i]->get_parent (X_AXIS); if (Note_collision_interface::has_interface (c)) { - Link_array gs = - Pointer_group_interface__extract_grobs (c, (Grob*)0, "elements"); - - note_cols.concat (gs); + extract_grob_set (c, "elements", gs); + + concat (note_cols, gs); } } - - for (int i = note_cols.size () ; i--;) - { - heads.concat (Pointer_group_interface__extract_grobs (note_cols[i], - (Grob*)0, - "note-heads")); - - } - heads.default_sort (); - heads.uniq (); + + for (vsize i = note_cols.size (); i--;) + concat (heads, extract_grob_array (note_cols[i], "note-heads")); + + vector_sort (heads, less ()); + uniq (heads); common[Y_AXIS] = common_refpoint_of_array (heads, common[Y_AXIS], Y_AXIS); - - for (int i= apes.size (); i--;) + for (vsize 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--;) + Accidental_placement_entry *ape = apes[i]; + + for (vsize 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); - } + Grob *a = apes[i]->grobs_[j]; + vector boxes = Accidental_interface::accurate_boxes (a, common); + + 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); } - Interval total; - for (int i = apes.size (); i--;) + for (vsize i = apes.size (); i--;) { - Interval y ; - - for (int j = apes[i]->extents_.size (); j--;) - { - y.unite (apes[i]->extents_[j][Y_AXIS]); - } + Interval y; + + 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); - 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)); + Accidental_placement_entry *head_ape = new Accidental_placement_entry; + common[X_AXIS] = common_refpoint_of_array (heads, common[X_AXIS], X_AXIS); + + 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))); - insert_extent_into_skyline (&head_skyline, b , Y_AXIS, LEFT); + 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); + for (vsize i = 0; i < stems.size (); i ++) + { + int very_large = INT_MAX; + + head_extents.push_back (Box (heads[i]->extent (common[X_AXIS], X_AXIS), + heads[i]->pure_height (common[Y_AXIS], 0, very_large))); } - head_ape-> left_skyline_ = head_skyline; + head_ape->left_skyline_ = Skyline (head_extents, Y_AXIS, LEFT); head_ape->offset_ = 0.0; - head_ape->offset_ -= robust_scm2double ( me->get_property ("right-padding"), 0); - - - Real padding = robust_scm2double (me->get_property ("padding"),0.2); + Real padding = robust_scm2double (me->get_property ("padding"), 0.2); - Array left_skyline = head_ape->left_skyline_; + Skyline left_skyline = head_ape->left_skyline_; + left_skyline.raise (-robust_scm2double (me->get_property ("right-padding"), 0)) +; /* Add accs entries right-to-left. - */ - for (int i= apes.size (); i-- > 0;) + */ + for (vsize i = apes.size (); i-- > 0;) { - Real offset = - -skyline_meshing_distance (apes[i]->right_skyline_, left_skyline); + Real offset = -apes[i]->right_skyline_.distance (left_skyline); if (isinf (offset)) - offset = (i < apes.size () - 1) ? apes[i+1]->offset_ : 0.0; + 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); + Skyline new_left_skyline = apes[i]->left_skyline_; + new_left_skyline.raise (apes[i]->offset_); + new_left_skyline.merge (left_skyline); left_skyline = new_left_skyline; - } + } - for (int i = apes.size (); i--;) + for (vsize 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); - } + Accidental_placement_entry *ape = apes[i]; + for (vsize 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]); + for (vsize 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]); + 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]); SCM scm_width = ly_interval2scm (width); - me->set_extent (scm_width, X_AXIS); - - for (int i = apes.size (); i--;) + me->flush_extent_cache (X_AXIS); + me->set_property ("X-extent", scm_width); + + for (vsize i = apes.size (); i--;) delete apes[i]; - return SCM_UNSPECIFIED; + return SCM_BOOL_T; } ADD_INTERFACE (Accidental_placement, - "accidental-placement-interface", - "Resolve accidental collisions.", - "left-padding padding right-padding accidental-grobs positioning-done") + "Resolve accidental collisions.", + + /* properties */ + "accidental-grobs " + "left-padding " + "padding " + "positioning-done " + "right-padding " + "script-priority " + )