]> git.donarmstrong.com Git - lilypond.git/blob - lily/molecule.cc
6bb59a58a1b3239e0cf01332e45b74d75e1880bc
[lilypond.git] / lily / molecule.cc
1 /*
2   molecule.cc -- implement Molecule
3
4   source file of the GNU LilyPond music typesetter
5
6   (c)  1997--2002 Han-Wen Nienhuys <hanwen@cs.uu.nl>
7 */
8
9 #include <math.h>
10 #include <libc-extension.hh>    // isinf
11
12 #include "font-metric.hh" 
13 #include "dimensions.hh"
14 #include "interval.hh"
15 #include "string.hh"
16 #include "molecule.hh"
17 #include "debug.hh"
18
19
20 #include "ly-smobs.icc"
21
22
23 SCM
24 Molecule::smobbed_copy () const
25 {
26   Molecule * m = new Molecule (*this);
27
28   return m->smobbed_self ();
29 }
30
31 Interval
32 Molecule::extent (Axis a) const
33 {
34   return dim_[a];
35 }
36
37 Molecule::Molecule (Box b, SCM func)
38 {
39   expr_ = func;
40   dim_ = b;
41 }
42
43 Molecule::Molecule ()
44 {
45   expr_ = SCM_EOL;
46   set_empty (true);
47 }
48
49 void
50 Molecule::translate (Offset o)
51 {
52   Axis a = X_AXIS;
53   while (a < NO_AXES)
54     {
55       if (abs (o[a]) > 30 CM
56           || isinf (o[a]) || isnan (o[a]))
57         {
58           programming_error ("Improbable offset for translation: setting to zero");
59           o[a] =  0.0;
60         }
61       incr (a);
62     }
63
64   expr_ = scm_list_n (ly_symbol2scm ("translate-molecule"),
65                    ly_offset2scm (o),
66                    expr_, SCM_UNDEFINED);
67   if (!empty_b ())
68     dim_.translate (o);
69 }
70   
71
72 void
73 Molecule::translate_axis (Real x,Axis a)
74 {
75   Offset o (0,0);
76   o[a] = x;
77   translate (o);
78 }  
79
80
81
82 void
83 Molecule::add_molecule (Molecule const &m)
84 {
85   expr_ = scm_list_n (ly_symbol2scm ("combine-molecule"),
86                    m.expr_,
87                    expr_, SCM_UNDEFINED);
88   dim_.unite (m.dim_);
89 }
90
91 void
92 Molecule::set_empty (bool e)
93 {
94   if (e)
95     {
96       dim_[X_AXIS].set_empty ();
97       dim_[Y_AXIS].set_empty ();
98     }
99   else
100     {
101       dim_[X_AXIS] = Interval (0,0);
102       dim_[Y_AXIS] = Interval (0,0);
103     }
104 }
105
106
107 void
108 Molecule::align_to (Axis a, Direction d)
109 {
110   Interval i (extent (a));
111   Real r = (d == CENTER) ? i.center () : i[d];
112   translate_axis (-r, a);
113 }
114
115 void
116 Molecule::add_at_edge (Axis a, Direction d, Molecule const &m, Real padding)
117 {
118   Real my_extent= empty_b () ? 0.0 : dim_[a][d];
119   Interval i (m.extent (a));
120   Real his_extent;
121   if (i.empty_b ())
122     {
123       programming_error ("Molecule::add_at_edge: adding empty molecule.");
124       his_extent = 0.0;
125     }
126   else
127     his_extent = i[-d];      
128
129   Real offset = my_extent -  his_extent;
130   Molecule toadd (m);
131   toadd.translate_axis (offset + d * padding, a);
132   add_molecule (toadd);
133 }
134
135 /* ly_?  Thought we had the ly_ prefix for wrapping/adding to gh_ */
136 SCM
137 Molecule::ly_set_molecule_extent_x (SCM mol, SCM axis, SCM np)
138 {
139   Molecule* m = unsmob_molecule (mol);
140   SCM_ASSERT_TYPE (m, mol, SCM_ARG1, __FUNCTION__, "molecule");
141   SCM_ASSERT_TYPE (ly_axis_p(axis), axis, SCM_ARG2, __FUNCTION__, "axis");
142   SCM_ASSERT_TYPE (ly_number_pair_p (np), np, SCM_ARG3, __FUNCTION__, "number pair");
143
144   Interval iv = ly_scm2interval (np);
145   m->dim_[Axis (gh_scm2int (axis))] = iv;
146
147   return SCM_UNDEFINED;
148 }
149
150 SCM
151 Molecule::ly_get_molecule_extent (SCM mol, SCM axis)
152 {
153   Molecule *m = unsmob_molecule (mol);
154   SCM_ASSERT_TYPE (m, mol, SCM_ARG1, __FUNCTION__, "molecule");
155   SCM_ASSERT_TYPE (ly_axis_p(axis), axis, SCM_ARG2, __FUNCTION__, "axis");
156  
157   return ly_interval2scm (m->extent (Axis (gh_scm2int (axis))));
158 }
159
160
161 SCM
162 Molecule::ly_molecule_combined_at_edge (SCM first, SCM axis, SCM direction,
163                                         SCM second, SCM padding)
164
165 {
166   Molecule * m1 = unsmob_molecule (first);
167   Molecule * m2 = unsmob_molecule (second);
168   Molecule result;
169
170
171   SCM_ASSERT_TYPE(ly_axis_p(axis), axis, SCM_ARG2, __FUNCTION__, "axis");
172   SCM_ASSERT_TYPE(ly_dir_p (direction), direction, SCM_ARG3, __FUNCTION__, "dir");
173   SCM_ASSERT_TYPE(gh_number_p(padding), padding, SCM_ARG4, __FUNCTION__, "number");
174
175   if (m1)
176     result = *m1;
177   if (m2)
178     result.add_at_edge (Axis (gh_scm2int (axis)), Direction (gh_scm2int (direction)),
179                         *m2, gh_scm2double (padding));
180
181   return result.smobbed_copy ();
182 }
183
184
185 SCM
186 make_molecule (SCM expr, SCM xext, SCM yext)
187 {
188   /*
189     TODO: typechecking. 
190    */
191   Box b (ly_scm2interval (xext), ly_scm2interval(yext));
192   Molecule m (b, expr);
193   return m.smobbed_copy ();
194 }
195
196 SCM
197 fontify_atom (Font_metric * met, SCM f)
198 {
199   if (f == SCM_EOL)
200     return f;
201   else
202     return  scm_list_n (ly_symbol2scm ("fontify"),
203                         ly_quote_scm (met->description_), f, SCM_UNDEFINED);
204 }
205
206 SCM
207 ly_fontify_atom (SCM met, SCM f)
208 {
209   SCM_ASSERT_TYPE(unsmob_metrics (met), met, SCM_ARG1, __FUNCTION__, "font metric");
210
211   return fontify_atom (unsmob_metrics (met), f);
212 }
213
214 SCM
215 ly_align_to_x (SCM mol, SCM axis, SCM dir)
216 {
217   SCM_ASSERT_TYPE(unsmob_molecule (mol), mol, SCM_ARG1, __FUNCTION__, "molecule");
218   SCM_ASSERT_TYPE(ly_axis_p(axis), axis, SCM_ARG2, __FUNCTION__, "axis");
219   SCM_ASSERT_TYPE(ly_dir_p (dir), dir, SCM_ARG3, __FUNCTION__, "dir");
220
221   unsmob_molecule (mol)->align_to ((Axis)gh_scm2int (axis), Direction (gh_scm2int (dir)));
222
223   return SCM_UNDEFINED;
224 }
225
226
227 static void
228 molecule_init ()
229 {
230   scm_c_define_gsubr ("ly-make-molecule", 3, 0, 0, (Scheme_function_unknown) make_molecule);
231   scm_c_define_gsubr ("ly-fontify-atom", 2, 0, 0, (Scheme_function_unknown) ly_fontify_atom);
232   scm_c_define_gsubr ("ly-align-to!", 3, 0, 0, (Scheme_function_unknown) ly_align_to_x);    
233   scm_c_define_gsubr ("ly-combine-molecule-at-edge", 5 , 0, 0, (Scheme_function_unknown) Molecule::ly_molecule_combined_at_edge);
234   scm_c_define_gsubr ("ly-set-molecule-extent!", 3 , 0, 0, (Scheme_function_unknown) Molecule::ly_set_molecule_extent_x);
235   scm_c_define_gsubr ("ly-get-molecule-extent", 2 , 0, 0, (Scheme_function_unknown) Molecule::ly_get_molecule_extent);
236 }
237 ADD_SCM_INIT_FUNC (molecule,molecule_init);
238
239
240 bool
241 Molecule::empty_b () const
242 {
243   return expr_ == SCM_EOL;
244 }
245
246 SCM
247 Molecule::get_expr () const
248 {
249   return expr_;
250 }
251
252
253
254 Box
255 Molecule::extent_box () const
256 {
257   return dim_;
258 }
259 IMPLEMENT_SIMPLE_SMOBS (Molecule);
260
261
262 int
263 Molecule::print_smob (SCM s, SCM port, scm_print_state *)
264 {
265      
266   scm_puts ("#<Molecule ", port);
267 #if 0
268   Molecule  *r = (Molecule *) ly_cdr (s);
269   String str (r->str ());
270   scm_puts ((char *)str.ch_C (), port);
271 #endif
272   scm_puts (" >", port);
273   
274   return 1;
275 }
276
277   
278 SCM
279 Molecule::mark_smob (SCM s)
280 {
281   Molecule  *r = (Molecule *) ly_cdr (s);
282   
283   return r->expr_;
284 }
285
286 IMPLEMENT_TYPE_P (Molecule, "molecule?");
287 IMPLEMENT_DEFAULT_EQUAL_P (Molecule);
288