lily/system-start-delimiter-engraver.cc

   1 /*
   2   System-start-delimiter-engraver.cc -- implement
   3   System_start_delimiter_engraver
   4
   5   source file of the GNU LilyPond music typesetter
   6
   7   (c) 2005--2009 Han-Wen Nienhuys <hanwen@xs4all.nl>
   8
   9 */
  10
  11 #include "engraver.hh"
  12
  13 #include "side-position-interface.hh"
  14 #include "system-start-delimiter.hh"
  15 #include "staff-symbol.hh"
  16 #include "pointer-group-interface.hh"
  17 #include "paper-column.hh"
  18 #include "output-def.hh"
  19 #include "spanner.hh"
  20
  21 struct Bracket_nesting_node
  22 {
  23 public:
  24   virtual ~Bracket_nesting_node (){}
  25   virtual bool add_staff (Grob *) { return false; }
  26   virtual void add_support (Grob *) { }
  27   virtual void set_bound (Direction, Grob *){}
  28   virtual void set_nesting_support (Grob*) {}
  29   virtual void create_grobs (Engraver*, SCM) {}
  30 };
  31
  32 struct Bracket_nesting_group : public Bracket_nesting_node
  33 {
  34   Spanner *delimiter_;
  35   vector<Bracket_nesting_node*> children_;
  36   SCM symbol_;
  37
  38   void from_list (SCM );
  39   virtual void add_support (Grob *grob);
  40   virtual bool add_staff (Grob *grob);
  41   virtual void set_nesting_support (Grob*);
  42   virtual void set_bound (Direction, Grob *grob);
  43   virtual void create_grobs (Engraver*, SCM);
  44   ~Bracket_nesting_group ();
  45   Bracket_nesting_group ();
  46 };
  47
  48
  49 struct Bracket_nesting_staff : public Bracket_nesting_node
  50 {
  51   Grob *staff_;
  52
  53   Bracket_nesting_staff (Grob *s) { staff_ = s; }
  54   virtual bool add_staff (Grob *);
  55 };
  56
  57
  58 Bracket_nesting_group::Bracket_nesting_group ()
  59 {
  60   symbol_ = SCM_EOL;
  61   delimiter_ = 0;
  62 }
  63
  64 bool
  65 Bracket_nesting_staff::add_staff (Grob *g)
  66 {
  67   if (!staff_)
  68     {
  69       staff_ = g;
  70       return true;
  71     }
  72   return false;
  73 }
  74
  75 void
  76 Bracket_nesting_group::create_grobs (Engraver *engraver, SCM default_type)
  77 {
  78   SCM type = scm_is_symbol (symbol_) ? symbol_ : default_type;
  79   delimiter_ = engraver->make_spanner (ly_symbol2string (type).c_str (), SCM_EOL);
  80
  81   for (vsize i = 0 ; i < children_.size (); i++)
  82     {
  83       children_[i]->create_grobs (engraver, default_type);
  84     }
  85 }
  86
  87 void
  88 Bracket_nesting_group::add_support (Grob *g)
  89 {
  90   Side_position_interface::add_support (g, delimiter_);
  91   for (vsize i = 0 ; i < children_.size (); i++)
  92     {
  93       children_[i]->add_support (g);
  94     }
  95 }
  96
  97 Bracket_nesting_group::~Bracket_nesting_group ()
  98 {
  99   junk_pointers (children_);
 100 }
 101
 102 void
 103 Bracket_nesting_group::set_bound (Direction d, Grob *g)
 104 {
 105   delimiter_->set_bound (d, g);
 106   for (vsize i = 0 ; i < children_.size (); i++)
 107     {
 108       children_[i]->set_bound (d, g);
 109     }
 110 }
 111
 112 void
 113 Bracket_nesting_group::set_nesting_support (Grob *parent)
 114 {
 115   if (parent)
 116     Side_position_interface::add_support (delimiter_, parent);
 117
 118   for (vsize i = 0 ; i < children_.size (); i++)
 119     {
 120       children_[i]->set_nesting_support (delimiter_);
 121     }
 122 }
 123
 124
 125 void
 126 Bracket_nesting_group::from_list (SCM x)
 127 {
 128   for (SCM s = x; scm_is_pair (s); s = scm_cdr (s))
 129     {
 130       SCM entry = scm_car (s);
 131       if (scm_is_pair (entry))
 132         {
 133           Bracket_nesting_group *node = new Bracket_nesting_group;
 134           node->from_list (entry);
 135           children_.push_back (node);
 136         }
 137       else if (entry == ly_symbol2scm ("SystemStartBrace")
 138                || entry == ly_symbol2scm ("SystemStartBracket")
 139                || entry == ly_symbol2scm ("SystemStartBar")
 140                || entry == ly_symbol2scm ("SystemStartSquare")
 141                )
 142         symbol_ = entry;
 143       else
 144         {
 145           children_.push_back (new Bracket_nesting_staff (0));
 146         }
 147     }
 148 }
 149
 150 bool
 151 Bracket_nesting_group::add_staff (Grob *grob)
 152 {
 153   for (vsize i = 0; i < children_.size (); i++)
 154     {
 155       if (children_[i]->add_staff (grob))
 156         {
 157           Pointer_group_interface::add_grob (delimiter_, ly_symbol2scm ("elements"), grob);
 158           return true;
 159         }
 160     }
 161
 162   return false;
 163 }
 164
 165
 166
 167
 168 /****************/
 169
 170 class System_start_delimiter_engraver : public Engraver
 171 {
 172 public:
 173   TRANSLATOR_DECLARATIONS (System_start_delimiter_engraver);
 174
 175 protected:
 176   Bracket_nesting_group *nesting_;
 177
 178   DECLARE_ACKNOWLEDGER (system_start_delimiter);
 179   DECLARE_ACKNOWLEDGER (system_start_text);
 180   DECLARE_ACKNOWLEDGER (staff_symbol);
 181
 182   void process_music ();
 183   virtual void finalize ();
 184 };
 185
 186 System_start_delimiter_engraver::System_start_delimiter_engraver ()
 187 {
 188   nesting_ = 0;
 189 }
 190
 191 void
 192 System_start_delimiter_engraver::process_music ()
 193 {
 194   if (!nesting_)
 195     {
 196       nesting_ = new Bracket_nesting_group ();
 197       SCM hierarchy = get_property ("systemStartDelimiterHierarchy");
 198       SCM delimiter_name = get_property ("systemStartDelimiter");
 199
 200       nesting_->from_list (hierarchy);
 201       nesting_->create_grobs (this, delimiter_name);
 202       nesting_->set_bound (LEFT, unsmob_grob (get_property ("currentCommandColumn")));
 203     }
 204 }
 205
 206 void
 207 System_start_delimiter_engraver::finalize ()
 208 {
 209   if (nesting_)
 210     {
 211       nesting_->set_bound (RIGHT,
 212                            unsmob_grob (get_property ("currentCommandColumn")));
 213       nesting_->set_nesting_support (0);
 214
 215       delete nesting_;
 216     }
 217 }
 218
 219 void
 220 System_start_delimiter_engraver::acknowledge_staff_symbol (Grob_info inf)
 221 {
 222   Grob *staff = inf.grob ();
 223   bool succ = nesting_->add_staff (staff);
 224
 225   if (!succ)
 226     {
 227       nesting_->children_.push_back (new Bracket_nesting_staff (0));
 228       nesting_->add_staff (staff);
 229     }
 230 }
 231
 232
 233
 234 void
 235 System_start_delimiter_engraver::acknowledge_system_start_text (Grob_info inf)
 236 {
 237   nesting_->add_support (inf.grob ());
 238 }
 239
 240 void
 241 System_start_delimiter_engraver::acknowledge_system_start_delimiter (Grob_info inf)
 242 {
 243   nesting_->add_support (inf.grob ());
 244 }
 245
 246 #include "translator.icc"
 247
 248 ADD_ACKNOWLEDGER (System_start_delimiter_engraver, staff_symbol);
 249 ADD_ACKNOWLEDGER (System_start_delimiter_engraver, system_start_delimiter);
 250 ADD_ACKNOWLEDGER (System_start_delimiter_engraver, system_start_text);
 251
 252 ADD_TRANSLATOR (System_start_delimiter_engraver,
 253                 /* doc */
 254                 "Create a system start delimiter (i.e., a"
 255                 " @code{SystemStartBar}, @code{SystemStartBrace},"
 256                 " @code{SystemStartBracket} or @code{SystemStartSquare}"
 257                 " spanner).",
 258
 259                 /* create */
 260                 "SystemStartSquare "
 261                 "SystemStartBrace "
 262                 "SystemStartBracket "
 263                 "SystemStartBar ",
 264
 265                 /* read */
 266                 "systemStartDelimiter "
 267                 "systemStartDelimiterHierarchy "
 268                 "currentCommandColumn ",
 269
 270                 /* write */
 271                 ""
 272                 );