Fix some bugs in the dynamic engraver and PostScript backend

[lilypond.git] / lily / engraver-group.cc

diff --git a/lily/engraver-group.cc b/lily/engraver-group.cc
index 8ac916b54737a96f862efc9e849ff12e2ecfdb8a..71533cd116cd8e353d853285578ed287fc3344c6 100644 (file)
--- a/lily/engraver-group.cc
+++ b/lily/engraver-group.cc
@@ -1,95 +1,152 @@
 /*
-  engravergroup.cc -- implement Engraver_group_engraver
+  engraver-group.cc -- implement Engraver_group
 
   source file of the GNU LilyPond music typesetter
 
-  (c)  1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+  (c) 1997--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
 */
 
-#include "proto.hh"
-#include "plist.hh"
 #include "engraver-group.hh"
-#include "engraver.hh"
-#include "debug.hh"
-#include "p-score.hh"
-#include "score-element.hh"
 
-IMPLEMENT_IS_TYPE_B2(Engraver_group_engraver,Engraver, Translator_group);
-ADD_THIS_TRANSLATOR(Engraver_group_engraver);
+#include "warn.hh"
+#include "paper-score.hh"
+#include "grob.hh"
+#include "context.hh"
+#include "translator-dispatch-list.hh"
 
 void
-Engraver_group_engraver::announce_element (Score_element_info info)
+Engraver_group::announce_grob (Grob_info info)
 {
-  announce_info_arr_.push (info);
-  Engraver::announce_element (info);
+  announce_infos_.push_back (info);
+
+  Engraver_group *dad_eng
+    = context_->get_parent_context ()
+    ? dynamic_cast<Engraver_group *> (context_->get_parent_context ()->implementation ())
+    : 0;
+
+  if (dad_eng)
+    dad_eng->announce_grob (info);
 }
 
 void
-Engraver_group_engraver::do_announces()
+Engraver_group::acknowledge_grobs ()
 {
-  Link_array<Translator_group> groups = group_l_arr ();
-  for (int i=0; i < groups.size(); i++) 
-    {
-      Engraver * eng = groups[i]->engraver_l ();
-      if (eng)
-       {
-         Engraver_group_engraver * group =
-           (Engraver_group_engraver*) eng;
-         group->do_announces();
-       }
-    }
-  
-  Request dummy_req;
+  if (!announce_infos_.size ())
+    return;
 
-  Link_array<Translator> nongroups = nongroup_l_arr ();
-  while (announce_info_arr_.size ())
+  SCM name_sym = ly_symbol2scm ("name");
+  SCM meta_sym = ly_symbol2scm ("meta");
+
+  for (vsize j = 0; j < announce_infos_.size (); j++)
     {
-      for (int j =0; j < announce_info_arr_.size(); j++)
-       {
-         Score_element_info info = announce_info_arr_[j];
-         
-         if (!info.req_l_)
-           info.req_l_ = &dummy_req;
-         for (int i=0; i < nongroups.size(); i++) 
-           {   // Is this good enough?
-             Engraver * eng = nongroups[i]->engraver_l ();
-             if (eng && eng!= info.origin_grav_l_arr_[0])
-               eng->acknowledge_element (info);
-           }
-       }
-      announce_info_arr_.clear ();
-      for (int i=0; i < nongroups.size(); i++)
+      Grob_info info = announce_infos_[j];
+      
+      SCM meta = info.grob ()->internal_get_property (meta_sym);
+      SCM nm = scm_assoc (name_sym, meta);
+      if (scm_is_pair (nm))
+       nm = scm_cdr (nm);
+      else
+       continue;
+
+      SCM acklist = scm_hashq_ref (acknowledge_hash_table_drul_[info.start_end()],
+                                  nm, SCM_BOOL_F);
+      
+      Engraver_dispatch_list *dispatch
+       = Engraver_dispatch_list::unsmob (acklist);
+
+      if (acklist == SCM_BOOL_F)
        {
-         Engraver * eng = nongroups[i]->engraver_l ();
-         if (eng)
-           eng->process_acknowledged ();
+         SCM ifaces
+           = scm_cdr (scm_assoc (ly_symbol2scm ("interfaces"), meta));
+         acklist = Engraver_dispatch_list::create (get_simple_trans_list (),
+                                                   ifaces, info.start_end ());
+
+         dispatch
+           = Engraver_dispatch_list::unsmob (acklist);
+
+         scm_hashq_set_x (acknowledge_hash_table_drul_[info.start_end ()], nm, acklist);
        }
 
+      if (dispatch)
+       dispatch->apply (info);
     }
 }
 
-
-Staff_info
-Engraver_group_engraver::get_staff_info() const
+/*
+  Ugh. This is slightly expensive. We could/should cache the value of
+  the group count?
+*/
+int
+Engraver_group::pending_grob_count () const
 {
-  Staff_info inf = Engraver::get_staff_info();
-
-  Link_array<Translator> simple_translators = nongroup_l_arr (); 
-  for (int i=0; i < simple_translators.size(); i++)
+  int count = announce_infos_.size ();
+  for (SCM s = context_->children_contexts ();
+       scm_is_pair (s); s = scm_cdr (s))
     {
-    Engraver * eng = simple_translators[i]->engraver_l ();
-    if (eng)
-      eng->fill_staff_info (inf);
+      Context *c = unsmob_context (scm_car (s));
+      Engraver_group *group
+       = dynamic_cast<Engraver_group *> (c->implementation ());
+
+      if (group)
+       count += group->pending_grob_count ();
     }
-  return inf;
+  return count;
 }
 
+void
+Engraver_group::do_announces ()
+{
+  do
+    {
+      /*
+       DOCME: why is this inside the loop? 
+       */
+      for (SCM s = context ()->children_contexts ();
+          scm_is_pair (s); s = scm_cdr (s))
+       {
+         Context *c = unsmob_context (scm_car (s));
+         Engraver_group *group
+           = dynamic_cast<Engraver_group *> (c->implementation ());
+         if (group)
+           group->do_announces ();
+       }
+
+      
+      while (1)
+       {
+         precomputed_translator_foreach (PROCESS_ACKNOWLEDGED);
+         if (announce_infos_.size () == 0)
+           break;
 
+         acknowledge_grobs ();
+         announce_infos_.clear ();
+       }
+    }
+  while (pending_grob_count () > 0);
+}
 
-Engraver_group_engraver::~Engraver_group_engraver ()
+Engraver_group::Engraver_group ()
 {
+  acknowledge_hash_table_drul_[LEFT] 
+    = acknowledge_hash_table_drul_[RIGHT] 
+    = SCM_EOL;
+  
+  acknowledge_hash_table_drul_[LEFT] = scm_c_make_hash_table (61);
+  acknowledge_hash_table_drul_[RIGHT] = scm_c_make_hash_table (61);
 }
 
-Engraver_group_engraver::Engraver_group_engraver ()
+#include "translator.icc"
+
+ADD_TRANSLATOR_GROUP (Engraver_group,
+                     /* doc */ "A group of engravers taken together",
+                     /* create */ "",
+                     /* accept */ "",
+                     /* read */ "",
+                     /* write */ "");
+
+void
+Engraver_group::derived_mark () const
 {
+  scm_gc_mark (acknowledge_hash_table_drul_[LEFT]);
+  scm_gc_mark (acknowledge_hash_table_drul_[RIGHT]);
 }