X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fspan-bar.cc;h=072b110e7a1ef1b66cb6ad468dcb26050f8cccf1;hb=87eedcd59f4082cb0841528ad5bc82cb1d1191e3;hp=f33f70fdcedb3bb092a7f7c4e6471eb1bdcd2e42;hpb=e4f07a592ebde9621dede5a47430a51b9c232eb3;p=lilypond.git

diff --git a/lily/span-bar.cc b/lily/span-bar.cc
index f33f70fdce..072b110e7a 100644
--- a/lily/span-bar.cc
+++ b/lily/span-bar.cc
@@ -3,120 +3,217 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c)  1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+  (c) 1997--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
 */
-#include "dimension-cache.hh"
+
 #include "span-bar.hh"
-#include "lookup.hh"
+
+#include "font-interface.hh"
 #include "dimensions.hh"
-#include "paper-def.hh"
-#include "molecule.hh"
+#include "output-def.hh"
+#include "stencil.hh"
 #include "warn.hh"
 #include "axis-group-interface.hh"
-#include "group-interface.hh"
+#include "bar-line.hh"
+#include "grob.hh"
+#include "pointer-group-interface.hh"
 
 void
-Span_bar::add_bar (Score_element*b)
+Span_bar::add_bar (Grob *me, Grob *b)
 {
-  Pointer_group_interface gi (this);
-  gi.add_element (b);
-
-  add_dependency (b);
+  Pointer_group_interface::add_grob (me, ly_symbol2scm ("elements"), b);
 }
 
+MAKE_SCHEME_CALLBACK (Span_bar, print, 1);
 
-Interval
-Span_bar::width_callback (Score_element const *se, Axis )
+/* Limitations/Bugs:
+
+(1) Elements from 'me->get_object ("elements")' must be
+ordered according to their y coordinates relative to their common
+axis group parent.  Otherwise, the computation goes mad.
+
+(2) This method depends on bar_engraver not being removed from
+staff context.  If bar_engraver is removed, the size of the staff
+lines is evaluated as 0, which results in a solid span bar line
+with faulty y coordinate. */
+
+/* This routine was originally by Juergen Reuter, but it was a on the
+   bulky side. Rewritten by Han-Wen. */
+SCM
+Span_bar::print (SCM smobbed_me)
 {
-  Span_bar*  s= dynamic_cast<Span_bar*> ((Score_element*)se);
-  String gl = ly_scm2string (s->get_elt_property ("glyph"));
+  Grob *me = unsmob_grob (smobbed_me);
+  extract_grob_set (me, "elements", elements);
+  Grob *refp = common_refpoint_of_array (elements, me, Y_AXIS);
 
-  /*
-    urg.
-   */
-  Molecule m = s->compound_barline (gl, 40 PT);
-  
-  return m.extent (X_AXIS);
+  SCM glyph = me->get_property ("glyph-name");
+
+  /* glyph may not be a string, when ME is killed by Hara Kiri in
+     between. */
+  if (!scm_is_string (glyph))
+    return SCM_EOL;
+
+  string glyph_string = ly_scm2string (glyph);
+
+  /* compose span_bar_mol */
+  vector<Interval> extents;
+  Grob *model_bar = 0;
+  for (vsize i = elements.size (); i--;)
+    {
+      Grob *bar = elements[i];
+      Interval ext = bar->extent (refp, Y_AXIS);
+      if (ext.is_empty ())
+	continue;
+
+      extents.push_back (ext);
+      model_bar = bar;
+    }
+
+  if (!model_bar)
+    model_bar = me;
+
+  vector_sort (extents, Interval::left_less);
+
+  Stencil span_bar;
+  for (vsize i = 1; i < extents.size (); i++)
+    {
+      Interval prev_extent = extents[i - 1];
+      Interval ext = extents[i];
+      if (!prev_extent.is_empty ())
+	{
+	  Interval l (prev_extent [UP],
+		      ext[DOWN]);
+
+	  if (l.is_empty ())
+	    {
+	      /* There is overlap between the bar lines.  Do nothing. */
+	    }
+	  else
+	    {
+	      Stencil interbar = Bar_line::compound_barline (model_bar,
+							     glyph_string,
+							     l.length (),
+							     false);
+	      interbar.translate_axis (l.center (), Y_AXIS);
+	      span_bar.add_stencil (interbar);
+	    }
+	}
+      prev_extent = ext;
+    }
+
+  span_bar.translate_axis (- me->relative_coordinate (refp, Y_AXIS),
+			   Y_AXIS);
+
+  return span_bar.smobbed_copy ();
 }
 
-void
-Span_bar::before_line_breaking ()
+MAKE_SCHEME_CALLBACK (Span_bar, width, 1);
+SCM
+Span_bar::width (SCM smob)
 {
-  Bar::before_line_breaking ();
+  Grob *me = unsmob_grob (smob);
+  SCM gn = me->get_property ("glyph-name");
+  if (!me->is_live ())
+    return ly_interval2scm (Interval ());
   
-  evaluate_empty ();
+  string gl = ly_scm2string (gn);
+
+  /*
+    urg.
+  */
+  Stencil m = Bar_line::compound_barline (me, gl, 40 PT, false);
+
+  return ly_interval2scm (m.extent (X_AXIS));
 }
 
-void
-Span_bar::after_line_breaking ()
+MAKE_SCHEME_CALLBACK (Span_bar, before_line_breaking, 1);
+SCM
+Span_bar::before_line_breaking (SCM smob)
 {
-  Bar::after_line_breaking ();
-  Interval i (get_spanned_interval ());
-  translate_axis (i.center (), Y_AXIS);
+  Grob *me = unsmob_grob (smob);
+  extract_grob_set (me, "elements", elements);
+  if (elements.empty ())
+    me->suicide ();
+
+  return SCM_UNSPECIFIED;
 }
 
-void
-Span_bar::evaluate_empty ()
-{ 
-  if (!gh_pair_p (get_elt_property ("elements")))
+MAKE_SCHEME_CALLBACK (Span_bar, center_on_spanned_callback, 1);
+
+SCM
+Span_bar::center_on_spanned_callback (SCM smob)
+{
+  Grob *me = unsmob_grob (smob);
+  Interval i (get_spanned_interval (me));
+
+  /* Bar_line::print delivers a barline of y-extent (-h/2, h/2), so
+     we have to translate ourselves to be in the center of the
+     interval that we span. */
+  if (i.is_empty ())
     {
-      set_elt_property ("transparent", SCM_BOOL_T);
-      set_extent_callback (0, X_AXIS);
-      set_extent_callback (0, Y_AXIS);   
+      me->suicide ();
+      return scm_from_double (0.0);
     }
-  
-  SCM gl = get_elt_property ("glyph");
-  if (!gh_string_p (gl))
+
+  return scm_from_double (i.center ());
+}
+
+
+
+MAKE_SCHEME_CALLBACK(Span_bar, calc_glyph_name, 1);
+SCM
+Span_bar::calc_glyph_name (SCM smob)
+{
+  Grob *me = unsmob_grob (smob);
+  extract_grob_set (me, "elements", elements);
+  SCM gl = SCM_EOL;
+  for (vsize i = elements.size ();
+       i-- && !scm_is_string (gl);)
+    gl = elements[i]->get_property ("glyph-name");
+
+  if (!scm_is_string (gl))
     {
-      set_elt_property ("transparent", SCM_BOOL_T);
-      set_extent_callback (0, X_AXIS);
-      set_extent_callback (0, Y_AXIS);   
+      me->suicide ();
+      return SCM_UNSPECIFIED;
     }
-  else {
-    String type_str = ly_scm2string (gl);
-    if (type_str == "|:") 
-      {
-	type_str= ".|";
-      }
-    else if (type_str== ":|")
-      {
-	type_str= "|.";
-      }
-    else if (type_str== ":|:")
-      {
-	type_str= ".|.";
-      }
-
-    set_elt_property ("glyph", ly_str02scm (type_str.ch_C()));
-  }
+
+  string type = ly_scm2string (gl);
+  if (type == "|:")
+    type = ".|";
+  else if (type == ":|")
+    type = "|.";
+  else if (type == ":|:")
+    type = ".|.";
+
+  return ly_string2scm (type);
 }
 
 Interval
-Span_bar::get_spanned_interval () const
+Span_bar::get_spanned_interval (Grob *me)
 {
-  return Axis_group_interface::group_extent_callback (this, Y_AXIS);  
+  return ly_scm2interval (Axis_group_interface::generic_group_extent (me, Y_AXIS));
 }
 
-
-Real
-Span_bar::get_bar_size () const
+MAKE_SCHEME_CALLBACK (Span_bar, calc_bar_size, 1);
+SCM
+Span_bar::calc_bar_size (SCM smob)
 {
-  Interval iv (get_spanned_interval ());
-  if (iv.empty_b ())
+  Grob *me = unsmob_grob (smob);
+  Interval iv (get_spanned_interval (me));
+  if (iv.is_empty ())
     {
-      programming_error("Huh? My children deflated (FIXME)");
-      iv = Interval (0,0);
+      /* This happens if the bars are hara-kiried from under us. */
+      me->suicide ();
+      return scm_from_double (-1);
     }
-  return iv.length ();
+  return scm_from_double (iv.length ());
 }
 
-Span_bar::Span_bar ()
-{
-  Pointer_group_interface(this).set_interface ();
-  set_extent_callback (width_callback, X_AXIS);
-  
-  // dim_cache_[Y_AXIS]->set_extent_callback (Axis_group_interface::group_extent_callback);
+ADD_INTERFACE (Span_bar,
+	       "A bar line that spanned between other barlines. This interface is "
+	       " used for  bar lines that connect different staves.",
 
-  set_extent_callback (0, Y_AXIS);
-}
+	       /* properties */
+	       "glyph-name "
+	       "elements");