X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fspan-bar.cc;h=e806a0dd2ddc122a499b25bdbdef3a75b94c5f55;hb=ac93c7dd01e0b6661c360acf89721ce9d32e4e4c;hp=62c2c66fac81b964a309b5edd1bcc40d6c48a2d6;hpb=5f42fe18c41237a73d99fd76b34e434a33598704;p=lilypond.git

diff --git a/lily/span-bar.cc b/lily/span-bar.cc
index 62c2c66fac..e806a0dd2d 100644
--- a/lily/span-bar.cc
+++ b/lily/span-bar.cc
@@ -3,138 +3,246 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+  (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
 */
 
 #include "span-bar.hh"
-#include "lookup.hh"
+#include "font-interface.hh"
 #include "dimensions.hh"
-#include "paper-def.hh"
-#include "molecule.hh"
-#include "align-element.hh"
+#include "output-def.hh"
+#include "stencil.hh"
 #include "warn.hh"
+#include "axis-group-interface.hh"
+#include "group-interface.hh"
+#include "grob.hh"
+#include "bar-line.hh"
 
 void
-Span_bar::add_bar (Score_element*b)
+Span_bar::add_bar (Grob*me, Grob*b)
 {
-  spanning_l_arr_.push (b);
-  add_dependency (b);
-}
+  Pointer_group_interface::add_grob (me, ly_symbol2scm ("elements"),  b);
 
-void
-Span_bar::do_substitute_element_pointer (Score_element*o, Score_element*n)
-{
-  spanning_l_arr_.unordered_substitute (o, n);
+  me->add_dependency (b);
 }
 
-void
-Span_bar::set_align (Align_element *a)
-{
-  add_dependency (a);
-}
+MAKE_SCHEME_CALLBACK (Span_bar,print,1);
 
-Interval
-Span_bar::do_width () const
+/* Limitations/Bugs:
+
+   (1) Elements from 'me->get_property ("elements")' must be
+   ordered according to their y coordinates relative to their common
+   axis group parent.  Otherwise, the computation goes mad.
+
+   (TODO:
+   apply a sort algorithm that ensures this precondition.)  However,
+   until now, I have seen no case where lily has not fulfilled this
+   precondition.
+
+   (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) 
 {
-  if (no_width_b_)
+  Grob *me = unsmob_grob (smobbed_me);
+  SCM first_elt = me->get_property ("elements");
+
+  /* compute common refpoint of elements */
+  Grob *refp = me;
+  for (SCM elts = first_elt; scm_is_pair (elts); elts = scm_cdr (elts))
     {
-      return Interval (0,0);
+      SCM smobbed_staff_bar = scm_car (elts);
+      Grob *staff_bar = unsmob_grob (smobbed_staff_bar);
+      refp = staff_bar->common_refpoint (refp, Y_AXIS);
     }
+
+  Span_bar::evaluate_glyph (me);
+  SCM glyph = me->get_property ("glyph");
+
+  /* glyph may not be a string, when ME is killed by Hara Kiri in
+    between. */
+  if (!scm_is_string (glyph))
+    return SCM_EOL;
   
-  Molecule m = lookup_l ()->bar (type_str_, 40 PT);
+  String glyph_string = ly_scm2string (glyph);
+
+  /* compose span_bar_mol */
+  Stencil span_bar_mol;
+
+  Interval prev_extent;
+  for (SCM elts = first_elt; scm_is_pair (elts); elts = scm_cdr (elts))
+    {
+      SCM smobbed_staff_bar = scm_car (elts);
+      Grob *staff_bar = unsmob_grob (smobbed_staff_bar);
+      Interval ext = staff_bar->extent (refp, Y_AXIS);
+      if (ext.is_empty ())
+	continue; 
+      
+      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 (staff_bar,
+							      glyph_string,
+							      l.length ());
+	      interbar.translate_axis (l.center (), Y_AXIS);
+	      span_bar_mol.add_stencil (interbar);
+	    }
+	}
+      prev_extent = ext;
+    }
+
+  span_bar_mol.translate_axis (- me->relative_coordinate (refp, Y_AXIS),
+			       Y_AXIS);
   
-  return m.extent (X_AXIS);
+  return span_bar_mol.smobbed_copy ();
 }
 
-void
-Span_bar::do_pre_processing ()
+MAKE_SCHEME_CALLBACK (Span_bar,width_callback,2);
+SCM
+Span_bar::width_callback (SCM element_smob, SCM scm_axis)
 {
-  Bar::do_pre_processing ();
+  Grob *se = unsmob_grob (element_smob);
+  Axis a = (Axis) scm_to_int (scm_axis);
+  assert (a == X_AXIS);
+  String gl = ly_scm2string (se->get_property ("glyph"));
+
+  /*
+    urg.
+  */
+  Stencil m = Bar_line::compound_barline (se, gl, 40 PT);
   
-  evaluate_empty ();
-  translate_axis (extra_x_off_, X_AXIS);
+  return ly_interval2scm (m.extent (X_AXIS));
+}
+
+MAKE_SCHEME_CALLBACK (Span_bar,before_line_breaking,1);
+SCM
+Span_bar::before_line_breaking (SCM smob)
+{
+  Grob * g = unsmob_grob (smob);
+  evaluate_empty (g);
+  evaluate_glyph (g);
+
+  /* No need to call Bar_line::before_line_breaking (), because the info
+     in ELEMENTS already has been procced by
+     Bar_line::before_line_breaking (). */
+  return SCM_UNSPECIFIED;
+}
+
+MAKE_SCHEME_CALLBACK (Span_bar,center_on_spanned_callback,2);
+
+SCM
+Span_bar::center_on_spanned_callback (SCM element_smob, SCM axis)
+{
+  Grob *me = unsmob_grob (element_smob);
+  Axis a = (Axis) scm_to_int (axis);
+  assert (a == Y_AXIS);
+  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 ())
+    {
+      me->suicide ();
+      return scm_make_real (0.0);
+    }
   
-  dim_cache_[Y_AXIS].set_empty (false); // a hack to make mark scripts work.
+  return scm_make_real (i.center ());
 }
 
 void
-Span_bar::do_post_processing ()
+Span_bar::evaluate_empty (Grob*me)
 {
-  Bar::do_post_processing ();
+  /* TODO: filter all hara-kiried out of ELEMENS list, and then
+     optionally do suicide. Call this cleanage function from
+     center_on_spanned_callback () as well. */
+  if (!scm_is_pair (me->get_property ("elements")))
+    {
+      me->suicide ();
+    }
 }
 
 void
-Span_bar::evaluate_empty ()
-{ 
-  if (spanning_l_arr_.size () < 1) 
+Span_bar::evaluate_glyph (Grob*me)
+{
+  SCM gl = me->get_property ("glyph");
+
+  if (scm_is_string (gl))
+    return ;
+  
+  for (SCM s = me->get_property ("elements");
+       !scm_is_string (gl) && scm_is_pair (s); s = scm_cdr (s))
     {
-      transparent_b_ = true;
-      set_empty (true);   
+      gl = unsmob_grob (scm_car (s))
+	->get_property ("glyph");
     }
-  if (type_str_.empty_b ()) 
+
+  if (!scm_is_string (gl))
     {
-      transparent_b_=true;
-      set_empty (true);
+      me->suicide ();
+      return;
     }
-  else if (type_str_ == "|:") 
+  
+  String type = ly_scm2string (gl);
+  if (type == "|:") 
     {
-      type_str_ = ".|";
+      type = ".|";
     }
-  else if (type_str_ == ":|")
+  else if (type== ":|")
     {
-      type_str_ = "|.";
+      type = "|.";
     }
-  else if (type_str_ == ":|:")
+  else if (type== ":|:")
     {
-      type_str_ = ".|.";
+      type = ".|.";
     }
-}
 
-Interval
-Span_bar::get_spanned_interval () const
-{
-  Interval y_int;
-  for (int i=0; i < spanning_l_arr_.size (); i++) 
-    {
-      Dimension_cache*common = 
-	common_group (spanning_l_arr_[i], Y_AXIS);
-	
-      Real y = spanning_l_arr_[i]->dim_cache_[Y_AXIS].relative_coordinate (common)  
-	-dim_cache_[Y_AXIS].relative_coordinate (common);
-
-      y_int.unite (y + spanning_l_arr_[i]->extent(Y_AXIS));
-    }
-  return y_int;
+  gl = scm_makfrom0str (type.to_str0 ());
+  if (scm_equal_p (me->get_property ("glyph"), gl)
+      != SCM_BOOL_T)
+    me->set_property ("glyph", gl);
 }
 
 Interval
-Span_bar::do_height () const
+Span_bar::get_spanned_interval (Grob*me) 
 {
-  return get_spanned_interval ();
+  return ly_scm2interval (Axis_group_interface::group_extent_callback
+			  (me->self_scm (), scm_int2num (Y_AXIS))); 
 }
 
-Molecule*
-Span_bar::do_brew_molecule_p () const
+
+MAKE_SCHEME_CALLBACK (Span_bar,get_bar_size,1);
+SCM
+Span_bar::get_bar_size (SCM smob)
 {
-  Interval iv (get_spanned_interval ());
-  Molecule*output = new Molecule;
-  if (!iv.empty_b())
+  Grob* me =  unsmob_grob (smob);
+  Interval iv (get_spanned_interval (me));
+  if (iv.is_empty ())
     {
-      output->add_molecule (lookup_l ()->bar (type_str_, iv.length ()));
-      output->translate_axis (iv.center (), Y_AXIS);
+      /* This happens if the bars are hara-kiried from under us. */
+      me->suicide ();
+      return scm_make_real (-1);
     }
-  else
-    {
-      warning("Huh? My children deflated (FIXME)");
-    }
-  return output;
+  return scm_make_real (iv.length ());
 }
 
 
 
-Span_bar::Span_bar ()
-{
-  type_str_ = "";
-  extra_x_off_ = 0.0;
-  no_width_b_ = false;
-}
+ADD_INTERFACE (Span_bar,"span-bar-interface",
+  "A bar line that spanned between other barlines. This interface is "
+	       " used for  bar lines that connect different staves.",
+  "elements");
+
+