release: 1.3.39

[lilypond.git] / lily / item.cc

diff --git a/lily/item.cc b/lily/item.cc
index 7919a3ec35ce8baca840bd02f1c04a83b6c5eb13..0458144c3513ced1cc671d0b7526889ae7eccf20 100644 (file)
--- a/lily/item.cc
+++ b/lily/item.cc
@@ -3,107 +3,180 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
+  (c)  1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
 */
-#include "p-score.hh"
+
+#include "dimension-cache.hh"
+#include "paper-score.hh"
 #include "debug.hh"
 #include "item.hh"
-#include "p-col.hh"
+#include "paper-column.hh"
+#include "spanner.hh"
+#include "lily-guile.hh"
 
-Item::Item()
+Item::Item ()
 {
-    pcol_l_ = 0;
+  broken_to_drul_[LEFT] = broken_to_drul_[RIGHT]=0;
+}
 
-    broken_to_a_[0]
-       = broken_to_a_[1]=0;
+/**
+   Item copy ctor.  Copy nothing: everything should be a elt property
+   or a special purpose poitner (such as broken_to_drul_[]) */
+Item::Item (Item const &s)
+  : Score_element (s)
+{
+  broken_to_drul_[LEFT] = broken_to_drul_[RIGHT] =0;
 }
 
 
-IMPLEMENT_IS_TYPE_B1(Item, Score_elem);
 
-void
-Item::do_print() const
+bool
+Item::breakable_b () const
 {
-#ifndef NPRINT
-    mtor << "(unknown)";
-#endif
+  if (original_l_ )
+    return false;
+  
+  Item * i  =dynamic_cast<Item*> (parent_l (X_AXIS));
+  return (i) ?  i->breakable_b () : to_boolean (get_elt_property( "breakable"));
 }
 
-
-Real 
-Item::hpos_f()const
+Line_of_score *
+Item::line_l() const
 {
-    return pcol_l_->hpos_f_ + offset().x;
+  Score_element *g = parent_l (X_AXIS);
+  return g ?  g->line_l () : 0;
 }
 
 
+void
+Item::copy_breakable_items()
+{
+  Drul_array<Item *> new_copies;
+  Direction  i=LEFT;
+  do 
+    {
+      Score_element * dolly = clone();
+      Item * item_p = dynamic_cast<Item*>(dolly);
+      pscore_l_->typeset_element (item_p);
+      new_copies[i] =item_p;
+    }
+  while (flip(&i) != LEFT);
+  broken_to_drul_= new_copies;
 
-Line_of_score *
-Item::line_l()const
+  do 
+    {
+       broken_to_drul_[i]->handle_prebroken_dependencies();
+       broken_to_drul_[i]->try_visibility_lambda();
+    }
+  while (flip(&i) != LEFT);
+}
+
+void
+Item::try_visibility_lambda ()
 {
-    return pcol_l_->line_l_;
+  SCM vis = remove_elt_property ("visibility-lambda");
+  if (gh_procedure_p (vis))
+    {
+      SCM args = scm_listify (gh_int2scm (break_status_dir ()), SCM_UNDEFINED);
+      SCM result = gh_apply (vis, args);
+      bool trans = gh_scm2bool (gh_car (result));
+      bool empty = gh_scm2bool (gh_cdr (result));
+
+      if (empty)
+       {
+         set_empty (X_AXIS);
+         set_empty ( Y_AXIS);
+       }
+      if (trans)
+       set_elt_property ("transparent", SCM_BOOL_T);
+    }
 }
 
-int
-Item::break_status_i() const
+bool
+Item::broken_b () const
 {
-    PCol * c = pcol_l_;
-    if (c->breakable_b())
-       return 0;
-    else if (!c->daddy_l_) 
-       return 0; 
-    else if (c == c->daddy_l_->prebreak_p_)
-       return -1;
-    else 
-       return 1;
+  return broken_to_drul_[LEFT] || broken_to_drul_[RIGHT];
 }
 
 void
-Item::do_breakable_col_processing()
+Item::do_break ()
 {
-    PCol * c = pcol_l_;
-    if (!c->breakable_b())
-       return;
-    
-    for (int i=0; i < 2; i++) {
-       broken_to_a_[i] = clone()->item();
-       pscore_l_->typeset_item(broken_to_a_[i], c, -1+ 2*i);
-       broken_to_a_[i]->handle_prebroken_dependencies();
+  if (broken_b ())
+    return;
+
+  if (breakable_b ())
+    {
+      copy_breakable_items();
+      handle_prebroken_dependencies();
+  
+      /*
+    Otherwise the broken items won't be pre_process()'ed.
+  */
+  
+      if (broken_to_drul_[LEFT])
+       {
+         add_dependency (broken_to_drul_[LEFT]);
+         add_dependency (broken_to_drul_[RIGHT]);
+       }
     }
-
-    handle_prebroken_dependencies();
+  try_visibility_lambda ();    // ugh.
 }
 
-Item*
-Item::find_prebroken_piece(Line_of_score*l) const
+void
+Item::do_breakable_col_processing()
 {
-    if (line_l() == l) 
-       return this;
-    else if (broken_to_a_[0] && broken_to_a_[0]->line_l() == l)
-       return broken_to_a_[0];
-    else if (broken_to_a_[1] && broken_to_a_[1]->line_l() == l)
-       return broken_to_a_[1];
+  do_break ();
+}
 
-    return 0;
+Score_element*
+Item::find_broken_piece (Line_of_score*l) const
+{
+  if (line_l() == l) 
+    return (Item*)(this);
+
+  Direction d = LEFT;
+  do {
+    Score_element *s = find_broken_piece (d);
+    if (s && s->line_l () == l)
+      return s;
+  }
+  while (flip (&d) != LEFT);
+
+  return 0;
 }
 
 Item*
-Item::find_prebroken_piece(PCol*c)const
+Item::find_broken_piece (Direction d) const
 {
-    if (c == pcol_l_ )
-       return (Item *) this;   // ugh
-
-    if (c == pcol_l_->prebreak_p_)
-       return (Item *) broken_to_a_[0];
-    else if (c==pcol_l_->postbreak_p_)
-       return  (Item *)broken_to_a_[1];
+  Item * me = (Item *) (this); 
+  if (!d)
+    return me;
+  else if (breakable_b ())
+    {
+      me->do_break ();
+      return dynamic_cast<Item*> (broken_to_drul_[d]);
+    }
+  else
+    return 0;
+}
 
-    assert(false);
+Paper_column *
+Item::column_l () const
+{
+  return dynamic_cast<Item*> (parent_l (X_AXIS))->column_l ();
 }
 
-void
-Item::handle_prebroken_dependencies()
+Direction
+Item::break_status_dir () const
 {
-    if ( pcol_l_->breakable_b() || pcol_l_->daddy_l_ )
-       Score_elem::handle_prebroken_dependencies();
+  if (original_l_)
+    {
+      Item * i = dynamic_cast<Item*> (original_l_);
+
+      return (i->broken_to_drul_[LEFT] == this) ? LEFT : RIGHT;
+    }
+  else
+    return CENTER;
 }
+
+