]> git.donarmstrong.com Git - lilypond.git/blobdiff - lily/rest-collision.cc
* lily/rest.cc (polyphonic_offset_callback): new function. Do
[lilypond.git] / lily / rest-collision.cc
index 42f7bbbfe33912f0d8e694c0256a470f221df1d9..a0f7e744913840dc110440a3fc7fb3f762361c01 100644 (file)
 /*
   rest-collision.cc -- implement Rest_collision
 
-  source file of the LilyPond music typesetter
+  source file of the GNU LilyPond music typesetter
 
-  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+  (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
 */
 
+#include <math.h>              // ceil.
+
+#include "warn.hh"
 #include "rest-collision.hh"
-#include "rest-column.hh"
-#include "collision.hh"
+#include "note-column.hh"
+#include "stem.hh"
+#include "rhythmic-head.hh"
+#include "paper-def.hh"
+#include "rest.hh"
+#include "group-interface.hh"
+#include "staff-symbol-referencer.hh"
+#include "duration.hh"
+#include "directional-element-interface.hh"
 
-void
-Rest_collision::add(Rest_column *rc_l)
+MAKE_SCHEME_CALLBACK (Rest_collision,force_shift_callback,2);
+SCM
+Rest_collision::force_shift_callback (SCM element_smob, SCM axis)
 {
-    rest_l_arr_.push(rc_l);
-    add_dependency(rc_l);
+  Grob *them = unsmob_grob (element_smob);
+  Axis a = (Axis) gh_scm2int (axis);
+  assert (a == Y_AXIS);
+
+  Grob * rc = unsmob_grob (them->get_grob_property ("rest-collision"));
+
+  if (rc && !to_boolean (rc->get_grob_property ("positioning-done")))
+    {
+      rc->set_grob_property ("positioning-done", SCM_BOOL_T);
+
+      do_shift (rc);
+    }
+  
+  return gh_double2scm (0.0);
 }
+
+
+
 void
-Rest_collision::add(Collision * c_l)
+Rest_collision::add_column (Grob*me,Grob *p)
 {
-    add_dependency(c_l);
-    for (int i=0; i < c_l->clash_l_arr_.size(); i ++)
-       ncol_l_arr_.push(c_l->clash_l_arr_[i]);
+  me->add_dependency (p);
+  Pointer_group_interface::add_grob (me, ly_symbol2scm ("elements"), p);
+
+  /*
+    only add callback for the rests, since we don't move anything
+    else.
+
+    (not?)
+  */
+  p->add_offset_callback (Rest_collision::force_shift_callback_proc, Y_AXIS);
+  p->set_grob_property ("rest-collision", me->self_scm ());
 }
 
 
-void
-Rest_collision::do_post_processing()
+/*
+  Combination of dot-count and duration-log.
+ */
+static SCM
+head_characteristic (Grob * col)
 {
-#if 0
-        bool rest_b_a[4];
-       rest_b_a[j] = (col_l_a[j]) ? col_l_a[j]->rest_b_ : false;       
-    do {
-       int i1 = idx(d, false);
-       int i2 = idx(d,true);
-       if (!intersection(y_extent[i1] , 
-                         y_extent[i2]).empty_b()) {
-           if (rest_b_a[i1]) {
-               y_off[i1] = -y_extent[i1][-d] + y_extent[1][d] + d*4; // ugh
-               y_extent[i1] += y_off[i1];
+  Grob * s = unsmob_grob (col->get_grob_property ("rest"));
+
+  if (!s)
+    return SCM_BOOL_F;
+  else
+    return gh_cons (s->get_grob_property ("duration-log"),
+                   gh_int2scm (Rhythmic_head::dot_count (s)));
+}
+
+/*
+  TODO: fixme, fucks up if called twice on the same set of rests.
+
+  TODO: look at horizontal-shift to determine ordering between rests
+  for more than two voices.
+
+  
+ */
+SCM
+Rest_collision::do_shift (Grob *me)
+{
+  SCM elts = me->get_grob_property ("elements");
+
+  Link_array<Grob> rests;
+  Link_array<Grob> notes;
+
+  for (SCM s = elts; gh_pair_p (s); s = ly_cdr (s))
+    {
+      Grob * e = unsmob_grob (ly_car (s));
+      if (unsmob_grob (e->get_grob_property ("rest")))
+       {
+         /*
+           Ignore rests under beam.
+          */
+         Grob* st = unsmob_grob (e->get_grob_property ("stem"));
+         if (st && unsmob_grob (st->get_grob_property ("beam")))
+           continue;
+         
+         rests.push (e);
+       }
+      else
+       notes.push (e);
+    }
+
+  
+  /* 
+     handle rest-rest and rest-note collisions
+
+     [todo]
+     * decide not to print rest if too crowded?
+   */
+
+  /*
+    no partners to collide with
+   */
+  if (rests.size () + notes.size () < 2)
+    return SCM_UNSPECIFIED;
+
+
+  Real staff_space = Staff_symbol_referencer::staff_space (me);
+  /*
+    only rests
+  */
+  if (!notes.size ()) 
+    {
+
+      /*
+       This is incomplete: in case of an uneven number of rests, the
+       center one should be centered on the staff.
+       */
+      Drul_array< Link_array <Grob > > ordered_rests;
+      for (int i= 0; i < rests.size (); i++)
+       {
+         Grob * r = Note_column::get_rest (rests[i]);
+         
+         Direction d = get_grob_direction (r);
+         if (d)
+           {
+             ordered_rests[d].push (rests[i]);
            }
+         else
+           rests[d]->warning (_("rest direction not set.  Cannot resolve collision."));
+       }
+
+      Direction d =  LEFT;
+      do {
+       ordered_rests[d].sort (Note_column::shift_compare);
+      } while (flip (&d) != LEFT);
+      
+      if (ordered_rests[UP].size () + ordered_rests[DOWN].size () < 2)
+       return SCM_UNSPECIFIED;
+
+      Grob *common = common_refpoint_of_array (ordered_rests[DOWN], me, Y_AXIS);
+      common =  common_refpoint_of_array (ordered_rests[UP], common, Y_AXIS);
+
+      Real diff = 
+       (ordered_rests[DOWN].top ()->extent (common, Y_AXIS)[UP]
+        - ordered_rests[UP].top ()->extent (common, Y_AXIS)[DOWN]) /staff_space;
+
+      if (diff > 0)
+       {
+         int amount_down = (int) ceil (diff / 2); 
+         diff -= amount_down;
+         Note_column::translate_rests (ordered_rests[DOWN].top (),
+                                       -2 * amount_down);
+         if (diff > 0)
+           Note_column::translate_rests (ordered_rests[UP].top (),
+                                         2 * int (ceil (diff)));
+       }
+
+      do {
+       for (int i = ordered_rests[d].size () -1; i-- > 0;)
+         {
+           Real last_y = ordered_rests[d][i+1]->extent (common, Y_AXIS)[d];
+           Real y = ordered_rests[d][i]->extent (common, Y_AXIS)[-d];
+
+           Real diff = d * ((last_y - y) /staff_space);
+           if (diff > 0)
+             Note_column::translate_rests (ordered_rests[d][i],d * (int) ceil (diff) * 2);
+         }
+      } while (flip (&d) != LEFT);
+    }
+  else 
+    {
+      /*
+       Rests and notes.
+       */
+      if (rests.size () > 1)
+       {
+         warning (_ ("too many colliding rests"));
+       }
+      Grob * rcol = rests[0];
+      Grob *common = common_refpoint_of_array (notes, rcol, Y_AXIS);
+      
+      Direction dir = Note_column::dir (rests[0]);
+      
+      Interval restdim = rcol->extent (common, Y_AXIS);
+      if (restdim.is_empty ())
+       return SCM_UNSPECIFIED;
+      
+      Real staff_space = Staff_symbol_referencer::staff_space (rcol);
+      Real minimum_dist = robust_scm2double (me->get_grob_property ("minimum-distance"), 1.0) * staff_space;
+
+      Interval notedim;
+      for (int i = 0; i < notes.size (); i++) 
+       {
+         notedim.unite (notes[i]->extent (common, Y_AXIS));
        }
-    } while ((d *= -1) != 1);
-
-    do {
-       int i1 = idx(d, false);
-       int i2 = idx(-d,false);
-       
-       if (d*(y_extent[i1][-d] - y_extent[i2][d] )< 0&& rest_b_a[i1]) {
-           y_off[i1] = -y_extent[i1][-d] + y_extent[i2][d] +d* 4; // ugh
-           y_extent[i1] += y_off[i1];
+
+      Real dist =
+       minimum_dist +  dir * (notedim[dir] - restdim[-dir]) >? 0;
+
+      int stafflines = Staff_symbol_referencer::line_count (me);
+      if (!stafflines)
+       {
+         programming_error ("No staff line count ? ");
+         stafflines =5;
        }
-    } while ((d *= -1) != 1);
-    
-#endif
+      
+      // move discretely by half spaces.
+      int discrete_dist = int (ceil (dist / (0.5 *staff_space)));
+
+      // move by whole spaces inside the staff.
+      if (discrete_dist < stafflines+1)
+       discrete_dist = int (ceil (discrete_dist / 2.0)* 2.0);
+
+      Note_column::translate_rests (rcol,dir * discrete_dist);
+    }
+  return SCM_UNSPECIFIED;
 }
-IMPLEMENT_STATIC_NAME(Rest_collision);
+
+
+ADD_INTERFACE (Rest_collision,"rest-collision-interface",
+  "Move around ordinary rests (not multi-measure-rests) to avoid "
+"conflicts.",
+  "maximum-rest-count minimum-distance positioning-done elements");
+