Approximates cross-staff slurs in VerticalAxisGroup vertical-skylines.

lily/phrasing-slur-engraver.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 1997--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
   LilyPond is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
@@ skipping 12 matching lines @@
 #include "directional-element-interface.hh"
 #include "international.hh"
 #include "note-column.hh"
 #include "slur.hh"
 #include "spanner.hh"
 #include "stream-event.hh"
 #include "warn.hh"
 
 #include "translator.icc"
 
+#include <map>
+
 /*
   NOTE NOTE NOTE
 
   This is largely similar to Slur_engraver. Check if fixes
   apply there too.
 
   (on principle, engravers don't use inheritance for code sharing)
 
  */
 
 /*
   It is possible that a slur starts and ends on the same note.  At
   least, it is for phrasing slurs: a note can be both beginning and
   ending of a phrase.
 */
 class Phrasing_slur_engraver : public Engraver
 {
   vector<Stream_event *> start_events_;
   vector<Stream_event *> stop_events_;
   vector<Grob *> slurs_;
   vector<Grob *> end_slurs_;
+  map<Grob *, vector<Grob *> > slur_stubs_;
   vector<Grob_info> objects_to_acknowledge_;
 
 protected:
   DECLARE_TRANSLATOR_LISTENER (phrasing_slur);
   DECLARE_ACKNOWLEDGER (inline_accidental);
   DECLARE_ACKNOWLEDGER (fingering);
   DECLARE_ACKNOWLEDGER (note_column);
   DECLARE_ACKNOWLEDGER (slur);
   DECLARE_ACKNOWLEDGER (script);
   DECLARE_ACKNOWLEDGER (dots);
@@ skipping 39 matching lines @@
 }
 
 void
 Phrasing_slur_engraver::acknowledge_note_column (Grob_info info)
 {
   Grob *e = info.grob ();
   for (vsize i = slurs_.size (); i--;)
     Slur::add_column (slurs_[i], e);
   for (vsize i = end_slurs_.size (); i--;)
     Slur::add_column (end_slurs_[i], e);
+
+  for (vsize j = 0; j < slurs_.size (); j++)
+    {
+      if (slur_stubs_.find (slurs_[j]) == slur_stubs_.end ())

[dak, 2012/09/02 15:59:00]

It is quite nonsensical to have slur_stubs be a map indexed via slurs_[j] rather
than just an array indexed through j.

That is inefficient use of time, memory, and complexity.

[MikeSol, 2012/09/02 16:45:14]

It is sensical because:
--) It avoids having two vectors (slur_stubs_ and end_slur_stubs_ would be
needed), thus making the code easier to read and maintain.
--) It has a "find" method built into it.

Unless people are crunching scores with thousands of slurs on Strong Bad's
original Tandy 400, I'm not too worried about the tradeoff.

[dak, 2012/09/02 17:02:12]

I don't see that a "find" method is advantageous over just indexing.  And
typical scores _have_ thousands of slurs.

Since you don't bother writing even a single comment, it is rather hard to
figure out what you are doing, and you are doing it in complicated way.

+        slur_stubs_[slurs_[j]] = vector<Grob *> ();
+
+      Grob *stub = make_spanner ("SlurStub", info.grob ()->self_scm ());
+      slur_stubs_[slurs_[j]].push_back (stub);
+    }
+
+  for (vsize j = 0; j < end_slurs_.size (); j++)
+    {
+      if (slur_stubs_.find (end_slurs_[j]) == slur_stubs_.end ())
+        slur_stubs_[end_slurs_[j]] = vector<Grob *> ();
+
+      Grob *stub = make_spanner ("SlurStub", info.grob ()->self_scm ());
+      slur_stubs_[end_slurs_[j]].push_back (stub);
+    }
 }
 
 void
 Phrasing_slur_engraver::acknowledge_extra_object (Grob_info info)
 {
   objects_to_acknowledge_.push_back (info);
 }
 
 void
 Phrasing_slur_engraver::acknowledge_inline_accidental (Grob_info info)
@@ skipping 16 matching lines @@
 void
 Phrasing_slur_engraver::acknowledge_tuplet_number (Grob_info info)
 {
   acknowledge_extra_object (info);
 }
 
 void
 Phrasing_slur_engraver::acknowledge_script (Grob_info info)
 {
   if (!info.grob ()->internal_has_interface (ly_symbol2scm ("dynamic-interface")))
+··
     acknowledge_extra_object (info);
 }
 
 void
 Phrasing_slur_engraver::acknowledge_text_script (Grob_info info)
 {
   acknowledge_extra_object (info);
 }
 
 void
 Phrasing_slur_engraver::acknowledge_tie (Grob_info info)
 {
   acknowledge_extra_object (info);
 }
 
 void
 Phrasing_slur_engraver::acknowledge_slur (Grob_info info)
 {
-  acknowledge_extra_object (info);
+  if (!info.grob ()->internal_has_interface (ly_symbol2scm ("slur-stub-interface")))
+    acknowledge_extra_object (info);
 }
 
 void
 Phrasing_slur_engraver::finalize ()
 {
   for (vsize i = 0; i < slurs_.size (); i++)
     {
       slurs_[i]->warning (_ ("unterminated phrasing slur"));
       slurs_[i]->suicide ();
     }
   slurs_.clear ();
+  slur_stubs_.clear ();
 }
 
 void
 Phrasing_slur_engraver::process_music ()
 {
   for (vsize i = 0; i < stop_events_.size (); i++)
     {
       Stream_event *ev = stop_events_[i];
       string id = robust_scm2string (ev->get_property ("spanner-id"), "");
 
@@ skipping 105 matching lines @@
     {
       Spanner *s = dynamic_cast<Spanner *> (end_slurs_[i]);
       if (!s->get_bound (RIGHT))
         s->set_bound (RIGHT, unsmob_grob (get_property ("currentMusicalColumn")));
       announce_end_grob (s, SCM_EOL);
     }
 
   for (vsize i = 0; i < objects_to_acknowledge_.size (); i++)
     Slur::auxiliary_acknowledge_extra_object (objects_to_acknowledge_[i], slurs_, end_slurs_);
 
+  for (vsize i = 0; i < end_slurs_.size (); i++)
+    if (slur_stubs_.find (end_slurs_[i]) != slur_stubs_.end ())
+      {
+        // We likely SlurStubs we don't need.  Get rid of them.
+        map<Grob *, Grob *> vag_to_slur;

[dak, 2012/09/02 15:59:00]

Again: why a map here?

[MikeSol, 2012/09/02 16:45:14]

find method, see above.
I know that find exists for vectors in algorithm, but I think this is easier to
read and more consistent.

[dak, 2012/09/02 17:02:12]

You are apparently going to a lot of effort of getting your map entries out
again when you could just keep arrays with an identical structure to the slurs_
and end_slurs_ arrays.  Again, since you don't bother writing any comment
regarding what you are trying to do, it is hard to figure out what the purpose
is.

+        for (vsize j = 0; j < slur_stubs_[end_slurs_[i]].size (); j++)
+          {
+            Grob *vag = Grob::get_vertical_axis_group (slur_stubs_[end_slurs_[i]][j]);
+            if (vag)
+              {
+                if (vag_to_slur.find (vag) != vag_to_slur.end ())
+                  slur_stubs_[end_slurs_[i]][j]->suicide ();
+                else
+                  vag_to_slur[vag] = slur_stubs_[end_slurs_[i]][j];
+              }
+            else
+              {
+                end_slurs_[i]->programming_error ("Cannot find vertical axis group for NoteColumn.");
+                slur_stubs_[end_slurs_[i]][j]->suicide ();
+              }
+          }
+        map<Grob *, Grob *>::const_iterator it;
+        for (it = vag_to_slur.begin ();
+             it != vag_to_slur.end ();
+             it++)
+          Slur::main_to_stub (end_slurs_[i], it->second);
+
+        slur_stubs_.erase (end_slurs_[i]);
+      }
+
   objects_to_acknowledge_.clear ();
   end_slurs_.clear ();
   start_events_.clear ();
   stop_events_.clear ();
 }
 
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, inline_accidental);
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, fingering)
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, note_column);
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, slur);
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, script);
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, dots);
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, text_script);
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, tie);
 ADD_ACKNOWLEDGER (Phrasing_slur_engraver, tuplet_number);
 
 ADD_TRANSLATOR (Phrasing_slur_engraver,
                 /* doc */
                 "Print phrasing slurs.  Similar to @ref{Slur_engraver}.",
 
                 /* create */
                 "PhrasingSlur ",
 
                 /* read */
                 "",
 
                 /* write */
                 ""
                );