Merge branch 'master' of git://git.sv.gnu.org/lilypond

[lilypond.git] / lily / item.cc

diff --git a/lily/item.cc b/lily/item.cc
index 33066086c3f4d02a4983d505ed6a2d406ed2a86d..fdf9b00ce9d36c1498076dc221e6ab01f992be61 100644 (file)
--- a/lily/item.cc
+++ b/lily/item.cc
@@ -3,11 +3,12 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c) 1997--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+  (c) 1997--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
 */
 
 #include "item.hh"
 
+#include "axis-group-interface.hh"
 #include "paper-score.hh"
 #include "warn.hh"
 #include "paper-column.hh"
@@ -15,38 +16,40 @@
 #include "system.hh"
 #include "pointer-group-interface.hh"
 
+#include "moment.hh"
+
+
 Grob *
-Item::clone (int count) const
+Item::clone () const
 {
-  return new Item (*this, count);
+  return new Item (*this);
 }
 
-Item::Item (SCM s, Object_key const *key)
-  : Grob (s, key)
+Item::Item (SCM s)
+  : Grob (s)
 {
   broken_to_drul_[LEFT] = broken_to_drul_[RIGHT] = 0;
+  cached_pure_height_valid_ = false;
 }
 
 /**
    Item copy ctor.  Copy nothing: everything should be a elt property
    or a special purpose pointer (such as broken_to_drul_[]) */
-Item::Item (Item const &s, int copy_count)
-  : Grob (s, copy_count)
+Item::Item (Item const &s)
+  : Grob (s)
 {
   broken_to_drul_[LEFT] = broken_to_drul_[RIGHT] = 0;
+  cached_pure_height_valid_ = false;
 }
 
 bool
-Item::is_breakable (Grob *me)
+Item::is_non_musical (Grob *me)
 {
   if (me->original ())
     return false;
 
-  if (!dynamic_cast<Item *> (me))
-    me->programming_error ("only items can be breakable.");
-
   Item *i = dynamic_cast<Item *> (me->get_parent (X_AXIS));
-  return (i) ? Item::is_breakable (i) : to_boolean (me->get_property ("breakable"));
+  return i ? Item::is_non_musical (i) : to_boolean (me->get_property ("non-musical"));
 }
 
 Paper_column *
@@ -68,10 +71,9 @@ Item::copy_breakable_items ()
 {
   Drul_array<Item *> new_copies;
   Direction i = LEFT;
-  int count = 0;
   do
     {
-      Grob *dolly = clone (count++);
+      Grob *dolly = clone ();
       Item *item = dynamic_cast<Item *> (dolly);
       get_root_system (this)->typeset_grob (item);
       new_copies[i] = item;
@@ -96,7 +98,7 @@ Item::discretionary_processing ()
   if (is_broken ())
     return;
 
-  if (Item::is_breakable (this))
+  if (Item::is_non_musical (this))
     copy_breakable_items ();
 }
 
@@ -149,16 +151,71 @@ Item::handle_prebroken_dependencies ()
     Can't do this earlier, because try_visibility_lambda () might set
     the elt property transparent, which would then be copied.
   */
+  if (!Item::break_visible (this))
+    suicide ();
+}
+
+bool
+Item::break_visible (Grob *g)
+{
+  Item *it = dynamic_cast<Item*> (g);
+  SCM vis = g->get_property ("break-visibility");
+  if (scm_is_vector (vis))
+    return to_boolean (scm_c_vector_ref (vis, it->break_status_dir () + 1));
+  return true;
+}
+
+bool
+Item::pure_is_visible (int start, int end) const
+{
   SCM vis = get_property ("break-visibility");
   if (scm_is_vector (vis))
     {
-      bool visible = to_boolean (scm_vector_ref (vis, scm_from_int (break_status_dir () + 1)));
+      int pos = 1;
+      int pc_rank = Paper_column::get_rank (get_column ());
+      if (pc_rank == start)
+       pos = 2;
+      else if (pc_rank == end)
+       pos = 0;
+      return to_boolean (scm_vector_ref (vis, scm_from_int (pos)));
+    }
+  return true;
+}
+
+Interval_t<int>
+Item::spanned_rank_interval () const
+{
+  int c = get_column ()->get_rank ();
+  return Interval_t<int> (c, c);
+}
+
+Interval_t<Moment>
+spanned_time_interval (Item *l, Item *r) 
+{
+  Drul_array<Item*> bounds (l, r);
+  Interval_t<Moment> iv;
 
-      if (!visible)
-       suicide ();
+  Direction d = LEFT;
+  do
+    {
+      if (bounds[d] && bounds[d]->get_column ())
+       iv[d] = robust_scm2moment (bounds[d]->get_column ()->get_property ("when"),
+                                 iv[d]);
+    }
+  while (flip (&d) != LEFT);
+
+  do
+    {
+      if (!bounds[d] || !bounds[d]->get_column ())
+       iv[d] = iv[-d];
     }
+  while (flip (&d) != LEFT);
+  
+  
+  return iv;
 }
 
+
 void
 Item::derived_mark () const
 {
@@ -174,10 +231,25 @@ unsmob_item (SCM s)
   return dynamic_cast<Item *> (unsmob_grob (s));
 }
 
+Interval
+Item::pure_height (Grob *g, int start, int end)
+{
+  if (cached_pure_height_valid_)
+    return cached_pure_height_ + pure_relative_y_coordinate (g, start, end);
+
+  cached_pure_height_ = Grob::pure_height (this, start, end);
+  cached_pure_height_valid_ = true;
+  return cached_pure_height_ + pure_relative_y_coordinate (g, start, end);
+}
+
+bool
+Item::less (Grob * const &g1, Grob * const &g2)
+{
+  return dynamic_cast<Item*> (g1)->get_column ()->get_rank () < dynamic_cast<Item*> (g2)->get_column ()->get_rank ();
+}
+
 ADD_INTERFACE (Item,
-              "item-interface",
-              "\n"
-              "\n"
+
               "Grobs can be distinguished in their role in the horizontal spacing.\n"
               "Many grobs define constraints on the spacing by their sizes. For\n"
               "example, note heads, clefs, stems, and all other symbols with a fixed\n"
@@ -210,4 +282,9 @@ ADD_INTERFACE (Item,
               "  end-of-line-invisible      no      yes    yes\n"
               "  center-invisible           yes      no    yes\n"
               "@end example\n",
-              "no-spacing-rods break-visibility breakable")
+
+              /* properties */
+              "break-visibility "
+              "extra-spacing-width "
+              "infinite-spacing-height "
+              "non-musical")