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