Approximates cross-staff slurs in VerticalAxisGroup vertical-skylines.

lily/slur-scoring.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 1996--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
   Jan Nieuwenhuizen <janneke@gnu.org>
 
   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 10 matching lines @@
 #include "slur-scoring.hh"
 
 #include <queue>
 
 #include "axis-group-interface.hh"
 #include "accidental-interface.hh"
 #include "beam.hh"
 #include "clef.hh"
 #include "directional-element-interface.hh"
 #include "dots.hh"
+#include "international.hh"
 #include "libc-extension.hh"
 #include "main.hh"
 #include "misc.hh"
 #include "note-column.hh"
 #include "output-def.hh"
 #include "paper-column.hh"
 #include "pitch.hh"
 #include "pointer-group-interface.hh"
 #include "slur-configuration.hh"
 #include "slur.hh"
@@ skipping 68 matching lines @@
 Slur_score_state::get_encompass_info (Grob *col) const
 {
   Grob *stem = unsmob_grob (col->get_object ("stem"));
   Encompass_info ei;
 
   if (!stem)
     {
       programming_error ("no stem for note column");
       ei.x_ = col->relative_coordinate (common_[X_AXIS], X_AXIS);
       ei.head_ = ei.stem_ = col->maybe_pure_extent (common_[Y_AXIS],
-                                         Y_AXIS, stub_, 0, INT_MAX)[dir_];
+                                         Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])[dir_];
       return ei;
     }
   Direction stem_dir = get_grob_direction (stem);
 
   if (Grob *head = Note_column::first_head (col))
     ei.x_ = head->extent (common_[X_AXIS], X_AXIS).center ();
   else
     ei.x_ = col->extent (common_[X_AXIS], X_AXIS).center ();
 
   Grob *h = Stem::extremal_heads (stem)[Direction (dir_)];
   if (!h)
     {
-      ei.head_ = ei.stem_ = col->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX)[dir_];
+      ei.head_ = ei.stem_ = col->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])[dir_];
       return ei;
     }
 
-  ei.head_ = h->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX)[dir_];
+  ei.head_ = h->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])[dir_];
 
   if ((stem_dir == dir_)
-      && !stem->maybe_pure_extent (stem, Y_AXIS, stub_, 0, INT_MAX).is_empty ())
-    {
-      ei.stem_ = stem->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX)[dir_];
+      && !stem->maybe_pure_extent (stem, Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT]).is_empty ())
+    {
+      ei.stem_ = stem->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])[dir_];
       if (Grob *b = Stem::get_beam (stem))
         ei.stem_ += stem_dir * 0.5 * Beam::get_beam_thickness (b);
 
       Interval x = stem->extent (common_[X_AXIS], X_AXIS);
       ei.x_ = x.is_empty ()
               ? stem->relative_coordinate (common_[X_AXIS], X_AXIS)
               : x.center ();
     }
   else
     ei.stem_ = ei.head_;
@@ skipping 17 matching lines @@
           extremes[d].stem_ = Note_column::get_stem (extremes[d].note_column_);
           extremes[d].flag_ = Note_column::get_flag (extremes[d].note_column_);
 
           if (extremes[d].stem_)
             {
               extremes[d].stem_dir_ = get_grob_direction (extremes[d].stem_);
 
               for (int a = X_AXIS; a < NO_AXES; a++)
                 {
                   Axis ax = Axis (a);
-                  Interval s = extremes[d].stem_->maybe_pure_extent (common_[ax], ax, stub_, 0, INT_MAX);
+                  Interval s = ax == Y_AXIS
+                               ? extremes[d].stem_->maybe_pure_extent (common_[ax], ax, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])
+                               : extremes[d].stem_->extent (common_[ax], ax);
                   if (extremes[d].flag_)
-                    s.unite (extremes[d].flag_->maybe_pure_extent (common_[ax], ax, stub_, 0, INT_MAX));
+                    s.unite (ax == Y_AXIS
+                             ? extremes[d].flag_->maybe_pure_extent (common_[ax], ax, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])
+                             : extremes[d].flag_->extent (common_[ax], ax));
                   if (s.is_empty ())
                     {
                       /*
                         do not issue warning. This happens for rests and
                         whole notes.
                       */
                       s = Interval (0, 0)
-                          + extremes[d].stem_->maybe_pure_coordinate (common_[ax], ax, stub_, 0, INT_MAX);
+                          + (ax == Y_AXIS
+                             ? extremes[d].stem_->maybe_pure_coordinate (common_[ax], ax, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])
+                             : extremes[d].stem_->relative_coordinate (common_[ax], ax));
                     }
                   extremes[d].stem_extent_[ax] = s;
                 }
 
               extremes[d].slur_head_
                 = Stem::extremal_heads (extremes[d].stem_)[dir];
               if (!extremes[d].slur_head_
                   && Note_column::has_rests (extremes[d].bound_))
                 extremes[d].slur_head_ = Note_column::get_rest (extremes[d].bound_);
               extremes[d].staff_ = Staff_symbol_referencer
                                    ::get_staff_symbol (extremes[d].stem_);
               extremes[d].staff_space_ = Staff_symbol_referencer
                                          ::staff_space (extremes[d].stem_);
             }
 
           if (extremes[d].slur_head_)
             extremes[d].slur_head_x_extent_
               = extremes[d].slur_head_->extent (common_[X_AXIS], X_AXIS);
 
         }
     }
 
   return extremes;
 }
 
 void
 Slur_score_state::fill (Grob *me)
 {
   slur_ = dynamic_cast<Spanner *> (me);
-  stub_ = slur_->internal_has_interface (ly_symbol2scm ("slur-stub-interface"));
+  stub_ = slur_->internal_has_interface (ly_symbol2scm ("cross-staff-stub-interface"));
+  spanned_rank_interval_ = slur_->spanned_rank_interval ();
 
   columns_
     = internal_extract_grob_array (me, ly_symbol2scm ("note-columns"));
 
   if (columns_.empty ())
     {
       me->suicide ();
       return;
     }
 
@@ skipping 82 matching lines @@
     encompass_infos_.push_back (get_encompass_info (columns_[i]));
 
   valid_ = true;
 
   musical_dy_ = 0.0;
   for (LEFT_and_RIGHT (d))
     {
       if (!is_broken_
           && extremes_[d].slur_head_)
         musical_dy_ += d
-                       * extremes_[d].slur_head_->maybe_pure_coordinate (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX);
+                       * extremes_[d].slur_head_->maybe_pure_coordinate (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT]);
     }
 
   edge_has_beams_
     = (extremes_[LEFT].stem_ && Stem::get_beam (extremes_[LEFT].stem_))
       || (extremes_[RIGHT].stem_ && Stem::get_beam (extremes_[RIGHT].stem_));
 
   if (is_broken_)
     musical_dy_ = 0.0;
 }
 
 MAKE_SCHEME_CALLBACK (Slur, calc_control_points, 1)
 SCM
 Slur::calc_control_points (SCM smob)
 {
   Spanner *me = unsmob_spanner (smob);
+
+  if (!to_boolean (me->get_property ("cross-staff"))
+      && me->internal_has_interface (ly_symbol2scm ("cross-staff-stub-interface")))
+    {
+      me->suicide ();
+      return SCM_EOL;
+    }
 
   Slur_score_state state;
   state.fill (me);
 
   if (!state.valid_)
     return SCM_EOL;
 
   state.generate_curves ();
 
   SCM end_ys = me->get_property ("positions");
@@ skipping 21 matching lines @@
       me->set_property ("annotation", ly_string2scm (total));
     }
 #endif
 
   SCM controls = SCM_EOL;
   for (int i = 4; i--;)
     {
       Offset o = best->curve_.control_[i]
                  - Offset (me->relative_coordinate (state.common_[X_AXIS], X_AXIS),
                            me->maybe_pure_coordinate (state.common_[Y_AXIS], Y_AXIS,
-                               me->internal_has_interface (ly_symbol2scm ("slur-stub-interface")), 0, INT_MAX));
+                               state.stub_, state.spanned_rank_interval_[LEFT], state.spanned_rank_interval_[RIGHT]));
 
       controls = scm_cons (ly_offset2scm (o), controls);
     }
 
   return controls;
 }
 
 Slur_configuration *
 Slur_score_state::get_forced_configuration (Interval ys) const
 {
@@ skipping 71 matching lines @@
 {
   Drul_array<Real> end_ys;
   for (LEFT_and_RIGHT (d))
     {
       if (extremes_[d].note_column_)
         {
           end_ys[d] = dir_
                       * max (max (dir_ * (base_attachments_[d][Y_AXIS]
                                           + parameters_.region_size_ * dir_),
                                   dir_ * (dir_ + extremes_[d].note_column_->maybe_pure_extent
-                                                   (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX)[dir_])),
+                                                   (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])[dir_])),
                              dir_ * base_attachments_[-d][Y_AXIS]);
         }
       else
         end_ys[d] = base_attachments_[d][Y_AXIS] + parameters_.region_size_ * dir_;
     }
 
   return end_ys;
 }
 
 bool
@@ skipping 29 matching lines @@
           */
           if (stem
               && !Stem::is_invisible (stem)
               && extremes_[d].stem_dir_ == dir_
               && Stem::get_beaming (stem, -d)
               && Stem::get_beam (stem)
               && (!spanner_less (slur_, Stem::get_beam (stem))
                   || has_same_beam_))
             y = extremes_[d].stem_extent_[Y_AXIS][dir_];
           else if (head)
-            y = head->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX)[dir_];
+            y = head->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])[dir_];
           y += dir_ * 0.5 * staff_space_;
 
           y = move_away_from_staffline (y, head);
 
           Grob *fh = Note_column::first_head (extremes_[d].note_column_);
           x
             = (fh ? fh->extent (common_[X_AXIS], X_AXIS)
                : extremes_[d].bound_->extent (common_[X_AXIS], X_AXIS))
               .linear_combination (CENTER);
         }
@@ skipping 11 matching lines @@
           if (ext.is_empty ())
             ext = Axis_group_interface::
                   generic_bound_extent (extremes_[d].bound_,
                                         common_[X_AXIS], X_AXIS);
           x = ext[-d];
 
           Grob *col = (d == LEFT) ? columns_[0] : columns_.back ();
 
           if (extremes_[-d].bound_ != col)
             {
-              y = maybe_pure_robust_relative_extent (col, common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX)[dir_];
+              y = maybe_pure_robust_relative_extent (col, common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT])[dir_];
               y += dir_ * 0.5 * staff_space_;
 
               if (get_grob_direction (col) == dir_
                   && Note_column::get_stem (col)
                   && !Stem::is_invisible (Note_column::get_stem (col)))
                 y -= dir_ * 1.5 * staff_space_;
             }
           else
             y = base_attachment[-d][Y_AXIS];
 
@@ skipping 26 matching lines @@
 {
   if (!on_staff)
     return y;
 
   Grob *staff_symbol = Staff_symbol_referencer::get_staff_symbol (on_staff);
   if (!staff_symbol)
     return y;
 
   Real pos
     = (y - staff_symbol->maybe_pure_coordinate (common_[Y_AXIS],
-                                              Y_AXIS, stub_, 0, INT_MAX))
+                                              Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT]))
       * 2.0 / staff_space_;
 
   if (fabs (pos - my_round (pos)) < 0.2
       && Staff_symbol_referencer::on_staff_line (on_staff, (int) rint (pos)))
     y += 1.5 * staff_space_ * dir_ / 10;
 
   return y;
 }
 
 vector<Offset>
@@ skipping 17 matching lines @@
   extract_grob_set (slur_, "encompass-objects", extra_encompasses);
   for (vsize i = 0; i < extra_encompasses.size (); i++)
     {
       if (Slur::has_interface (extra_encompasses[i]))
         {
           Grob *small_slur = extra_encompasses[i];
           Bezier b = Slur::get_curve (small_slur);
 
           Offset z = b.curve_point (0.5);
           z += Offset (small_slur->relative_coordinate (common_[X_AXIS], X_AXIS),
-                       small_slur->maybe_pure_coordinate (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX));
+                       small_slur->maybe_pure_coordinate (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT]));
 
           z[Y_AXIS] += dir_ * parameters_.free_slur_distance_;
           avoid.push_back (z);
         }
       else if (extra_encompasses[i]->get_property ("avoid-slur") == ly_symbol2scm ("inside"))
         {
           Grob *g = extra_encompasses [i];
           Interval xe = g->extent (common_[X_AXIS], X_AXIS);
-          Interval ye = g->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX);
+          Interval ye = g->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT]);
 
           if (!xe.is_empty ()
               && !ye.is_empty ())
             avoid.push_back (Offset (xe.center (), ye[dir_]));
         }
     }
   return avoid;
 }
 
 void
@@ skipping 97 matching lines @@
   extract_grob_set (slur_, "encompass-objects", encompasses);
   vector<Extra_collision_info> collision_infos;
   for (vsize i = encompasses.size (); i--;)
     {
       if (Slur::has_interface (encompasses[i]))
         {
           Spanner *small_slur = dynamic_cast<Spanner *> (encompasses[i]);
           Bezier b = Slur::get_curve (small_slur);
 
           Offset relative (small_slur->relative_coordinate (common_[X_AXIS], X_AXIS),
-                           small_slur->maybe_pure_coordinate (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX));
+                           small_slur->maybe_pure_coordinate (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT]));
 
           for (int k = 0; k < 3; k++)
             {
               Direction hdir = Direction (k - 1);
 
               /*
                 Only take bound into account if small slur starts
                 together with big slur.
               */
               if (hdir && small_slur->get_bound (hdir) != slur_->get_bound (hdir))
@@ skipping 13 matching lines @@
                                          xext,
                                          yext,
                                          parameters_.extra_object_collision_penalty_);
               collision_infos.push_back (info);
             }
         }
       else
         {
           Grob *g = encompasses [i];
           Interval xe = g->extent (common_[X_AXIS], X_AXIS);
-          Interval ye = g->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, 0, INT_MAX);
+          Interval ye = g->maybe_pure_extent (common_[Y_AXIS], Y_AXIS, stub_, spanned_rank_interval_[LEFT], spanned_rank_interval_[RIGHT]);
           if (Dots::has_interface (g))
             ye.widen (0.2);
 
           Real xp = 0.0;
           Real penalty = parameters_.extra_object_collision_penalty_;
           if (Accidental_interface::has_interface (g))
             {
               penalty = parameters_.accidental_collision_;
 
               Rational alt = ly_scm2rational (g->get_property ("alteration"));
@@ skipping 33 matching lines @@
   type_ = g->get_property ("avoid-slur");
 }
 
 Extra_collision_info::Extra_collision_info ()
 {
   idx_ = 0.0;
   penalty_ = 0.;
   grob_ = 0;
   type_ = SCM_EOL;
 }