]> git.donarmstrong.com Git - lilypond.git/blob - lily/line-interface.cc
Docs: Fix fixed IR compilation (copy @q and @qq from macros.itely)
[lilypond.git] / lily / line-interface.cc
1 /*
2   line-interface.cc -- implement Line_interface
3
4   source file of the GNU LilyPond music typesetter
5
6   (c) 2004--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
7 */
8
9 #include "line-interface.hh"
10
11 #include "staff-symbol-referencer.hh"
12 #include "lookup.hh"
13 #include "output-def.hh"
14 #include "grob.hh"
15 #include "font-interface.hh"
16
17 Stencil
18 Line_interface::make_arrow (Offset begin, Offset end,
19                             Real thick,
20                             Real length, Real width)
21 {
22   Real angle = (end - begin).arg ();
23   vector<Offset> points;
24
25   points.push_back (Offset (0, 0));
26   points.push_back (Offset (-length, width));
27   points.push_back (Offset (-length, -width));
28
29   for (vsize i = 0; i < points.size (); i++)
30     points[i] = points[i] * complex_exp (Offset (0, angle)) + end;
31
32   return Lookup::round_filled_polygon (points, thick);
33 }
34
35 Stencil
36 Line_interface::make_trill_line (Grob *me,
37                                  Offset from,
38                                  Offset to)
39 {
40   Offset dz = (to-from);
41   SCM alist_chain = Font_interface::text_font_alist_chain (me);
42   SCM style_alist = scm_list_n (scm_cons (ly_symbol2scm ("font-encoding"),
43                                           ly_symbol2scm ("fetaMusic")),
44                                 SCM_UNDEFINED);
45
46   Font_metric *fm = select_font (me->layout (),
47                                  scm_cons (style_alist,
48                                            alist_chain));
49
50   Stencil elt = fm->find_by_name ("scripts.trill_element");
51   elt.align_to (Y_AXIS, CENTER);
52   Real elt_len = elt.extent (X_AXIS).length ();
53   if (elt_len <= 0.0)
54     {
55       programming_error ("can't find scripts.trill_element");
56       return Stencil ();
57     }
58       
59   Stencil line;
60   Real len = 0.0;
61   do
62     {
63       line.add_at_edge (X_AXIS, RIGHT, elt, 0);
64       len = line.extent (X_AXIS).length ();
65     }
66   while (len + elt_len < dz.length ());
67
68   line.rotate (dz.arg (), Offset (LEFT, CENTER));
69   line.translate (from);
70
71   return line; 
72 }
73
74
75 Stencil
76 Line_interface::make_zigzag_line (Grob *me,
77                                   Offset from,
78                                   Offset to)
79 {
80   Offset dz = to -from;
81
82   Real thick = Staff_symbol_referencer::line_thickness (me);
83   thick *= robust_scm2double (me->get_property ("thickness"), 1.0); // todo: staff sym referencer? 
84
85   Real staff_space = Staff_symbol_referencer::staff_space (me);
86
87   Real w = robust_scm2double (me->get_property ("zigzag-width"), 1) * staff_space;
88   int count = (int) ceil (dz.length () / w);
89   w = dz.length () / count;
90
91   Real l = robust_scm2double (me->get_property ("zigzag-length"), 1) * w;
92   Real h = l > w / 2 ? sqrt (l * l - w * w / 4) : 0;
93
94   Offset rotation_factor = complex_exp (Offset (0, dz.arg ()));
95
96   Offset points[3];
97   points[0] = Offset (0, -h / 2);
98   points[1] = Offset (w / 2, h / 2);
99   points[2] = Offset (w, -h / 2);
100   for (int i = 0; i < 3; i++)
101     points[i] = complex_multiply (points[i], rotation_factor);
102
103   Stencil squiggle (Line_interface::make_line (thick, points[0], points[1]));
104   squiggle.add_stencil (Line_interface::make_line (thick, points[1], points[2]));
105
106   Stencil total;
107   for (int i = 0; i < count; i++)
108     {
109       Stencil moved_squiggle (squiggle);
110       moved_squiggle.translate (from + Offset (i * w, 0) * rotation_factor);
111       total.add_stencil (moved_squiggle);
112     }
113
114   Box b;
115   b.add_point (Offset (0, 0));
116   b.add_point (dz);
117   b[X_AXIS].widen (thick / 2);
118   b[Y_AXIS].widen (thick / 2);
119
120   return Stencil (b, total.expr ());
121 }
122
123
124 Stencil
125 Line_interface::make_dashed_line (Real thick, Offset from, Offset to,
126                                   Real dash_period, Real dash_fraction)
127 {
128   dash_fraction = min (max (dash_fraction, 0.0), 1.0);
129   Real on = dash_fraction * dash_period + thick;
130   Real off = max (0.0, dash_period - on);
131
132   SCM at = scm_list_n (ly_symbol2scm ("dashed-line"),
133                        scm_from_double (thick),
134                        scm_from_double (on),
135                        scm_from_double (off),
136                        scm_from_double (to[X_AXIS] - from[X_AXIS]),
137                        scm_from_double (to[Y_AXIS] - from[Y_AXIS]),
138                        scm_from_double (0.0),
139                        SCM_UNDEFINED);
140
141   Box box;
142   box.add_point (Offset (0, 0));
143   box.add_point (to - from);
144
145   box[X_AXIS].widen (thick / 2);
146   box[Y_AXIS].widen (thick / 2);
147
148   Stencil m = Stencil (box, at);
149   m.translate (from);
150   return m;
151 }
152
153 Stencil
154 Line_interface::make_line (Real th, Offset from, Offset to)
155 {
156   SCM at = scm_list_n (ly_symbol2scm ("draw-line"),
157                        scm_from_double (th),
158                        scm_from_double (from[X_AXIS]),
159                        scm_from_double (from[Y_AXIS]),
160                        scm_from_double (to[X_AXIS]),
161                        scm_from_double (to[Y_AXIS]),
162                        SCM_UNDEFINED);
163
164   Box box;
165   box.add_point (from);
166   box.add_point (to);
167
168   box[X_AXIS].widen (th / 2);
169   box[Y_AXIS].widen (th / 2);
170
171   return Stencil (box, at);
172 }
173
174 Stencil
175 Line_interface::arrows (Grob *me, Offset from, Offset to,
176                         bool from_arrow,
177                         bool to_arrow)
178 {
179   Stencil a;
180   if (from_arrow || to_arrow)
181     {
182       Real thick = Staff_symbol_referencer::line_thickness (me)
183         * robust_scm2double (me->get_property ("thickness"), 1);
184       Real ss = Staff_symbol_referencer::staff_space (me);
185
186       Real len = robust_scm2double (me->get_property ("arrow-length"), 1.3 * ss);
187       Real wid = robust_scm2double (me->get_property ("arrow-width"), 0.5 * ss);
188
189       if (to_arrow)
190         a.add_stencil (make_arrow (from, to, thick, len, wid));
191
192       if (from_arrow)
193         a.add_stencil (make_arrow (to, from, thick, len, wid));
194     }
195
196   return a;
197 }
198
199 Stencil
200 Line_interface::line (Grob *me, Offset from, Offset to)
201 {
202   Real thick = Staff_symbol_referencer::line_thickness (me)
203     * robust_scm2double (me->get_property ("thickness"), 1);
204
205   SCM type = me->get_property ("style");
206   if (type == ly_symbol2scm ("zigzag"))
207     {
208       return make_zigzag_line (me, from, to);
209     }
210   else if (type == ly_symbol2scm ("trill"))
211     return make_trill_line (me, from, to);
212   
213   Stencil stencil;
214
215   if (type == ly_symbol2scm ("dashed-line") || type == ly_symbol2scm ("dotted-line"))
216     {
217
218       Real fraction
219         = type == ly_symbol2scm ("dotted-line")
220         ? 0.0
221         : robust_scm2double (me->get_property ("dash-fraction"), 0.4);
222
223       fraction = min (max (fraction, 0.0), 1.0);
224       Real period = Staff_symbol_referencer::staff_space (me)
225         * robust_scm2double (me->get_property ("dash-period"), 1.0);
226
227       if (period <= 0)
228         return Stencil ();
229
230       Real len = (to-from).length ();
231       
232       int n = (int) rint ((len - period * fraction) / period);
233       n = max (0, n);
234       if (n > 0)
235         {
236           /*
237             TODO: figure out something intelligent for really short
238             sections.
239            */
240           period = ((to-from).length () - period * fraction) / n;
241         }
242       stencil = make_dashed_line (thick, from, to, period, fraction);
243     }
244   else
245     stencil = make_line (thick, from, to);
246
247   return stencil;
248 }
249
250 ADD_INTERFACE (Line_interface,
251                "Generic line objects.  Any object using lines supports this."
252                "  The property @code{style} can be @code{line},"
253                " @code{dashed-line}, @code{trill}, @code{dotted-line} or"
254                " @code{zigzag}.\n"
255                "\n"
256                "For @code{dashed-line}, the length of the dashes is tuned"
257                " with @code{dash-fraction}.  If the latter is set to@tie{}0, a"
258                " dotted line is produced.  If @code{dash-period} is negative,"
259                " the line is made transparent.",
260
261                /* properties */
262                "dash-period "
263                "dash-fraction "
264                "thickness "
265                "style "
266                "zigzag-length "
267                "zigzag-width "
268                "arrow-length "
269                "arrow-width ")
270