Adds glissando stems to Lilypond.

lily/stem.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 1996--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
   Jan Nieuwenhuizen <janneke@gnu.org>
 
   TODO: This is way too hairy
 
   TODO: fix naming.
 
@@ skipping 19 matching lines @@
 #include <cmath>                // rint
 using namespace std;
 
 #include "beam.hh"
 #include "directional-element-interface.hh"
 #include "dot-column.hh"
 #include "font-interface.hh"
 #include "international.hh"
 #include "lookup.hh"
 #include "misc.hh"
+#include "note-column.hh"
 #include "note-head.hh"
 #include "output-def.hh"
 #include "paper-column.hh"
 #include "pointer-group-interface.hh"
 #include "rest.hh"
 #include "rhythmic-head.hh"
+#include "script-interface.hh"
 #include "side-position-interface.hh"
+#include "simple-closure.hh"
 #include "staff-symbol-referencer.hh"
 #include "stem-tremolo.hh"
 #include "warn.hh"
 
 void
 Stem::set_beaming (Grob *me, int beam_count, Direction d)
 {
   SCM pair = me->get_property ("beaming");
 
   if (!scm_is_pair (pair))
@@ skipping 183 matching lines @@
 
 MAKE_SCHEME_CALLBACK (Stem, pure_height, 3)
 SCM
 Stem::pure_height (SCM smob,
                    SCM /* start */,
                    SCM /* end */)
 {
   Grob *me = unsmob_grob (smob);
   Interval iv;
 
-  if (!is_normal_stem (me) || ly_is_procedure (me->get_property_data ("glissando-stem")))
+  if (!is_normal_stem (me))
     return ly_interval2scm (iv);
 
   Real ss = Staff_symbol_referencer::staff_space (me);
   Real rad = Staff_symbol_referencer::staff_radius (me);
 
   if (!to_boolean (me->get_property ("cross-staff")))
     {
       Real len_in_halfspaces;
       SCM user_set_len_scm = me->get_property_data ("length");
       if (scm_is_number (user_set_len_scm))
@@ skipping 152 matching lines @@
 }
 
 MAKE_SCHEME_CALLBACK (Stem, calc_positioning_done, 1);
 SCM
 Stem::calc_positioning_done (SCM smob)
 {
   Grob *me = unsmob_grob (smob);··
   if (!head_count (me))
     return SCM_BOOL_T;
 
-  if (ly_is_procedure (me->get_property_data ("glissando-stem")))
-    return SCM_BOOL_T;
-
   me->set_property ("positioning-done", SCM_BOOL_T);
 ··
   extract_grob_set (me, "note-heads", ro_heads);
   vector<Grob*> heads (ro_heads);
   vector_sort (heads, position_less);
   Direction dir = get_grob_direction (me);
 
   if (dir < 0)
     reverse (heads);
 
@@ skipping 84 matching lines @@
 
   return SCM_BOOL_T;
 }
 
 MAKE_SCHEME_CALLBACK (Stem, calc_direction, 1);
 SCM
 Stem::calc_direction (SCM smob)
 {
   Grob *me = unsmob_grob (smob);
   Direction dir = CENTER;
-
-  // Trigger glissando stem positioning.
-  (void) me->get_property ("glissando-stem");
 
   if (Grob *beam = unsmob_grob (me->get_object ("beam")))
     {
       SCM ignore_me = beam->get_property ("direction");
       (void) ignore_me;
       dir = get_grob_direction (me);
     }
   else
     {
       SCM dd = me->get_property ("default-direction");
@@ skipping 190 matching lines @@
   return ly_interval2scm (r);
 }
 
 Real
 Stem::thickness (Grob *me)
 {
   return scm_to_double (me->get_property ("thickness"))
     * Staff_symbol_referencer::line_thickness (me);
 }
 
+MAKE_SCHEME_CALLBACK (Stem, calc_stem_begin_position, 1);
+SCM
+Stem::calc_stem_begin_position (SCM smob)
+{
+  Grob *me = unsmob_grob (smob);
+  Direction d = get_grob_direction (me);
+  Real half_space = Staff_symbol_referencer::staff_space (me) * 0.5;
+  Grob *lh
+    = to_boolean (me->get_property ("avoid-note-head"))
+    ? last_head (me)
+    : first_head (me);
+
+  Real pos = Staff_symbol_referencer::get_position (lh);
+
+  if (Grob *head = support_head (me))
+    {
+      Interval head_height = head->extent (head, Y_AXIS);
+      Real y_attach = Note_head::stem_attachment_coordinate (head, Y_AXIS);
+
+      y_attach = head_height.linear_combination (y_attach);
+      pos += d * y_attach / half_space;
+    }
+
+  return scm_from_double (pos);
+}
+
 MAKE_SCHEME_CALLBACK (Stem, print, 1);
 SCM
 Stem::print (SCM smob)
 {
   Grob *me = unsmob_grob (smob);
   Grob *beam = get_beam (me);
 
   Stencil mol;
   Direction d = get_grob_direction (me);
 
@@ skipping 18 matching lines @@
     return SCM_EOL;
 
   if (is_invisible (me))
     return SCM_EOL;
 
   Real y2 = robust_scm2double (me->get_property ("stem-end-position"), 0.0);
   Real y1 = y2;
   Real half_space = Staff_symbol_referencer::staff_space (me) * 0.5;
 
   if (lh)
-    y2 = Staff_symbol_referencer::get_position (lh);
+    y2 = robust_scm2double (me->get_property ("stem-begin-position"), 0.0);
   else if (stemlet)
     {
       Real beam_translation = Beam::get_beam_translation (beam);
       Real beam_thickness = Beam::get_beam_thickness (beam);
       int beam_count = beam_multiplicity (me).length () + 1;
 
       y2 -= d
         * (0.5 * beam_thickness
            + beam_translation * max (0, (beam_count - 1))
            + stemlet_length) / half_space;
     }
 
   Interval stem_y (min (y1, y2), max (y2, y1));
-
-  if (Grob *head = support_head (me))
-    {
-      /*
-        must not take ledgers into account.
-      */
-      Interval head_height = head->extent (head, Y_AXIS);
-      Real y_attach = Note_head::stem_attachment_coordinate (head, Y_AXIS);
-
-      y_attach = head_height.linear_combination (y_attach);
-      stem_y[Direction (-d)] += d * y_attach / half_space;
-    }
 
   // URG
   Real stem_width = thickness (me);
   Real blot
     = me->layout ()->get_dimension (ly_symbol2scm ("blot-diameter"));
 
   Box b = Box (Interval (-stem_width / 2, stem_width / 2),
                Interval (stem_y[DOWN] * half_space, stem_y[UP] * half_space));
 
   Stencil ss = Lookup::round_filled_box (b, blot);
@@ skipping 24 matching lines @@
 
 
 /*
   move the stem to right of the notehead if it is up.
 */
 MAKE_SCHEME_CALLBACK (Stem, offset_callback, 1);
 SCM
 Stem::offset_callback (SCM smob)
 {
   Grob *me = unsmob_grob (smob);
-  if (ly_is_procedure (me->get_property_data ("glissando-stem")))
-    return scm_from_double (0.0);
 
   extract_grob_set (me, "rests", rests);
   if (rests.size ())
     {
       Grob *rest = rests.back ();
       Real r = rest->extent (rest, X_AXIS).center ();
       return scm_from_double (r);
     }
 
 ··
@@ skipping 201 matching lines @@
   return beam && Beam::is_cross_staff (beam);
 }
 
 MAKE_SCHEME_CALLBACK (Stem, calc_cross_staff, 1)
 SCM
 Stem::calc_cross_staff (SCM smob)
 {
   return scm_from_bool (is_cross_staff (unsmob_grob (smob)));
 }
 
-MAKE_SCHEME_CALLBACK (Stem, glissando_stem_positioning, 1);
-SCM
-Stem::glissando_stem_positioning (SCM smob)
-{
+MAKE_SCHEME_CALLBACK (Glissando_stem, after_line_breaking, 1);
+SCM
+Glissando_stem::after_line_breaking (SCM smob)
+{message ("ALB");
   Grob *me = unsmob_grob (smob);
 
   extract_grob_set (me, "glissandi", glissandi);
 
   if (!glissandi.size ())
     {
       me->programming_error ("This glissando stem does not have any glissandi to which it can attach.  Killing stem.");
       me->suicide ();
       return SCM_BOOL_F;
     }
 
   // first, every note column must have two and only two notes.
   extract_grob_set (me, "note-heads", note_heads);
   if (note_heads.size () != 2)
     {
-      programming_error ("Glissandi stem must have two and only two noteheads.");
+      programming_error ("Glissandi stem does not have exactly two noteheads.");
       return SCM_BOOL_F;
     }
 
   // now, position the note heads
 
   Grob *common[NO_AXES];
 
   Drul_array<Grob *> extremals = Stem::extremal_heads (me);
 
   for (Axis a = X_AXIS; a < NO_AXES; incr (a))
@@ skipping 27 matching lines @@
         }
       while (flip (&d) != LEFT);
 
       Interval normalized_endpoints = robust_scm2interval (gls->get_property ("normalized-endpoints"), Interval (0, 1));
       Real y_length = span_points[RIGHT][Y_AXIS] - span_points[LEFT][Y_AXIS];
 
       span_points[LEFT][Y_AXIS] += normalized_endpoints[LEFT] * y_length;
       span_points[RIGHT][Y_AXIS] -= (1 - normalized_endpoints[RIGHT]) * y_length;
       // end code dup :)
 
-      SCM placement_function = gls->get_property ("stem-placement-function");
+      SCM placement_function = gls->get_property_data ("stem-placement-function");
       Real pos = 0.0;
 
       if (placement_function != SCM_EOL)
         {
           pos = robust_scm2double (scm_call_4 (placement_function,
                                                scm_from_double (stem_pos),
                                                ly_offset2scm (span_points[LEFT]),
                                                ly_offset2scm (span_points[RIGHT]),
                                                ly_interval2scm (normalized_endpoints)),
                                    0.0);
         }
       else
         {
           Real slope = (span_points[RIGHT][Y_AXIS] - span_points[LEFT][Y_AXIS]) / (span_points[RIGHT][X_AXIS] - span_points[LEFT][X_AXIS]);
           Real offset = span_points[RIGHT][Y_AXIS] - (span_points[RIGHT][X_AXIS] * slope);
           pos = slope * stem_pos + offset;
         }
-      
+
       d = DOWN;
       do
         ypos[d] = minmax (d, ypos[d], pos);
       while (flip (&d) != DOWN);
     }
 
   // Note that staff symbol positions are in half space : must multiply by 0.5
   Direction d = DOWN;
   do
     extremals[d]->translate_axis (ypos[d] - (0.5 * Staff_symbol_referencer::get_position (extremals[d])), Y_AXIS);
   while (flip (&d) != DOWN);
-··
+
+  me->set_property ("direction", Stem::calc_direction_proc);
+  me->set_property ("flag", Stem::calc_flag_proc);
+··
+  if (Grob *beam = Stem::get_beam (me))
+    beam->set_property ("direction", Beam::calc_direction_proc);
+
+  if (Note_column::has_interface (me->get_parent (X_AXIS)))
+    {
+      extract_grob_set (me->get_parent (X_AXIS), "scripts", elts);
+      for (vsize i = 0; i < elts.size(); i++)
+        elts[i]->set_property ("direction", Script_interface::calc_opposite_direction_proc);
+    }
+
+  if (Grob *tremolo = unsmob_grob (me->get_object ("tremolo-flag")))
+    {
+      tremolo->set_property ("style", Stem_tremolo::calc_style_proc);
+      tremolo->set_property ("beam-width", Stem_tremolo::calc_width_proc);
+    }
+
   return SCM_BOOL_T;
 }
 
 /* FIXME:  Too many properties  */
 ADD_INTERFACE (Stem,
                "The stem represents the graphical stem.  In addition, it"
                " internally connects note heads, beams, and tremolos.  Rests"
                " and whole notes have invisible stems.\n"
                "\n"
                "The following properties may be set in the @code{details}"
@@ skipping 23 matching lines @@
                "beaming "
                "beamlet-default-length "
                "beamlet-max-length-proportion "
                "default-direction "
                "details "
                "direction "
                "duration-log "
                "flag "
                "flag-style "
                "french-beaming "
-               "glissando-stem "
+               "length "
+               "length-fraction "
+               "max-beam-connect "
+               "neutral-direction "
+               "no-stem-extend "
+               "note-heads "
+               "positioning-done "
+               "rests "
+               "stem-begin-position "
+               "stem-end-position "
+               "stem-placement-function "
+               "stem-info "
+               "stemlet-length "
+               "stroke-style "
+               "thickness "
+               "tremolo-flag "
+               );
+
+/* Fix me. Code dup. */
+ADD_INTERFACE (Glissando_stem,
+               "Like stems, but for glissandi",
+
+               /* properties */
+               "avoid-note-head "
+               "beam "
+               "beaming "
+               "beamlet-default-length "
+               "beamlet-max-length-proportion "
+               "default-direction "
+               "details "
+               "direction "
+               "duration-log "
+               "flag "
+               "flag-style "
+               "french-beaming "
+               "glissandi "
                "length "
                "length-fraction "
                "max-beam-connect "
                "neutral-direction "
                "no-stem-extend "
                "note-heads "
                "positioning-done "
                "rests "
                "stem-end-position "
+               "stem-placement-function "
                "stem-info "
                "stemlet-length "
                "stroke-style "
                "thickness "
                "tremolo-flag "
                );
 
 /****************************************************************/
 
 Stem_info::Stem_info ()
 {
   ideal_y_ = shortest_y_ = 0;
   dir_ = CENTER;
 }
 
 void
 Stem_info::scale (Real x)
 {
   ideal_y_ *= x;
   shortest_y_ *= x;
 }