]> git.donarmstrong.com Git - lilypond.git/blob - lily/mensural-ligature.cc
* lily/mensural-ligature-engraver.cc:
[lilypond.git] / lily / mensural-ligature.cc
1 /*
2   mensural-ligature.cc -- implement Mensural_ligature
3   
4   source file of the GNU LilyPond music typesetter
5   
6   (c) 2002 Juergen Reuter <reuter@ipd.uka.de>
7 */
8
9 #include <math.h>
10 #include "item.hh"
11 #include "mensural-ligature.hh"
12 #include "font-interface.hh"
13 #include "molecule.hh"
14 #include "lookup.hh"
15 #include "staff-symbol-referencer.hh"
16 #include "note-head.hh"
17 #include "paper-def.hh"
18 #include "warn.hh"
19
20 /*
21  * TODO: divide this function into mensural and neo-mensural style.
22  *
23  * TODO: move this function to class Lookup?
24  */
25 Molecule
26 brew_flexa (Grob *me,
27             Real interval,
28             bool solid,
29             Real width,
30             Real thickness,
31             bool add_stem,
32             Direction stem_direction)
33 {
34   Real staff_space = Staff_symbol_referencer::staff_space (me);
35   Real height = 0.6 * staff_space;
36   Molecule molecule = Molecule ();
37
38   if (add_stem)
39     {
40       bool consider_interval =
41         stem_direction * interval > 0.0;
42
43       Interval stem_box_x (0, thickness);
44       Interval stem_box_y;
45
46       if (consider_interval)
47         {
48           Real y_length = max (interval/2.0*staff_space, 1.2*staff_space);
49           stem_box_y = Interval (0, y_length);
50         }
51       else
52         stem_box_y = Interval (0, staff_space);
53
54       Real y_correction =
55         (stem_direction == UP) ?
56         +0.5*height :
57         -0.5*height - stem_box_y.length();
58
59       Box stem_box (stem_box_x, stem_box_y);
60       Molecule stem = Lookup::filledbox (stem_box);
61       stem.translate_axis (y_correction, Y_AXIS);
62       molecule.add_molecule(stem);
63     }
64
65   Real slope = (interval / 2.0 * staff_space) / width;
66
67   // Compensate optical illusion regarding vertical position of left
68   // and right endings due to slope.
69   Real ypos_correction = -0.1*staff_space * sign(slope);
70   Real slope_correction = 0.2*staff_space * sign(slope);
71   Real corrected_slope = slope + slope_correction/width;
72
73   if (solid)
74     {
75       Molecule solid_head =
76         Lookup::horizontal_slope (width, corrected_slope, height);
77       molecule.add_molecule (solid_head);
78     }
79   else // outline
80     {
81       Molecule left_edge =
82         Lookup::horizontal_slope (thickness, corrected_slope, height);
83       molecule.add_molecule(left_edge);
84
85       Molecule right_edge =
86         Lookup::horizontal_slope (thickness, corrected_slope, height);
87       right_edge.translate_axis (width-thickness, X_AXIS);
88       right_edge.translate_axis (corrected_slope * (width-thickness), Y_AXIS);
89       molecule.add_molecule(right_edge);
90
91       Molecule bottom_edge =
92         Lookup::horizontal_slope (width, corrected_slope, thickness);
93       bottom_edge.translate_axis (-0.5*height, Y_AXIS);
94       molecule.add_molecule (bottom_edge);
95
96       Molecule top_edge =
97         Lookup::horizontal_slope (width, corrected_slope, thickness);
98       top_edge.translate_axis (+0.5*height, Y_AXIS);
99       molecule.add_molecule (top_edge);
100     }
101   molecule.translate_axis (ypos_correction, Y_AXIS);
102   return molecule;
103 }
104
105 void
106 add_ledger_lines (Grob *me, Molecule *out, int pos, Real offs,
107                   bool ledger_take_space)
108 {
109   int interspaces = Staff_symbol_referencer::line_count (me)-1;
110   if (abs (pos) - interspaces > 1)
111     {
112       Interval hd = out->extent (X_AXIS);
113       Real left_ledger_protusion = hd.length ()/4;
114       Real right_ledger_protusion = left_ledger_protusion;
115
116       Interval l_extents = Interval (hd[LEFT] - left_ledger_protusion,
117                                      hd[RIGHT] + right_ledger_protusion);
118       Molecule ledger_lines =
119         Note_head::brew_ledger_lines (me, pos, interspaces,
120                                       l_extents,
121                                       ledger_take_space);
122       ledger_lines.translate_axis (offs, Y_AXIS);
123       out->add_molecule (ledger_lines);
124     }
125 }
126
127 Molecule
128 internal_brew_primitive (Grob *me, bool ledger_take_space)
129 {
130   SCM primitive_scm = me->get_grob_property ("primitive");
131   if (primitive_scm == SCM_EOL)
132     {
133       programming_error ("Mensural_ligature: undefined primitive -> ignoring grob");
134       return Molecule ();
135     }
136
137   Molecule out;
138   int primitive = gh_scm2int (primitive_scm);
139   int delta_pitch = 0;
140   Real thickness = 0.0;
141   Real flexa_width = 0.0;
142   Real staff_space = Staff_symbol_referencer::staff_space (me);
143   if (primitive & MLP_ANY)
144     {
145       SCM thickness_scm = me->get_grob_property ("thickness");
146       if (thickness_scm != SCM_EOL)
147         {
148           thickness = gh_scm2double (thickness_scm);
149         }
150       else
151         {
152           programming_error (_f ("Mensural_ligature: thickness undefined on flexa %d; assuming 1.4", primitive));
153           thickness = 1.4 * me->get_paper ()->get_var ("linethickness");
154         }
155     }
156
157   if (primitive & MLP_FLEXA)
158     {
159       SCM delta_pitch_scm = me->get_grob_property ("delta-pitch");
160       if (delta_pitch_scm != SCM_EOL)
161         {
162           delta_pitch = gh_scm2int (delta_pitch_scm);
163         }
164       else
165         {
166           programming_error (_f ("Mensural_ligature: delta-pitch undefined on flexa %d; assuming 0", primitive));
167           delta_pitch = 0;
168         }
169
170       SCM flexa_width_scm = me->get_grob_property ("flexa-width");
171       if (flexa_width_scm != SCM_EOL)
172         {
173           flexa_width = gh_scm2double (flexa_width_scm);
174         }
175       else
176         {
177           programming_error (_f ("Mensural_ligature: flexa-width undefined on flexa %d; assuming 2.0", primitive));
178           flexa_width = 2.0 * staff_space;
179         }
180     }
181
182   switch (primitive)
183     {
184       case MLP_NONE:
185         return Molecule();
186       case MLP_BB:
187         out = brew_flexa (me, delta_pitch, false,
188                           flexa_width, thickness, true, DOWN);
189         break;
190       case MLP_sc:
191         out = Font_interface::get_default_font (me)->find_by_name ("noteheads--2mensural");
192         break;
193       case MLP_ss:
194         out = Font_interface::get_default_font (me)->find_by_name ("noteheads--1mensural");
195         break;
196       case MLP_cs:
197         out = Font_interface::get_default_font (me)->find_by_name ("noteheads-lmensural");
198         break;
199       case MLP_SS:
200         out = brew_flexa (me, delta_pitch, false,
201                           flexa_width, thickness, true, UP);
202         break;
203       case MLP_LB:
204         out = brew_flexa (me, delta_pitch, false,
205                           flexa_width, thickness, false, CENTER);
206         break;
207       default:
208         programming_error (_f ("Mensural_ligature: unexpected case fall-through"));
209         return Molecule ();
210     }
211
212   SCM join_left_scm = me->get_grob_property ("join-left");
213   if (join_left_scm != SCM_EOL)
214     {
215       int join_left = gh_scm2int (join_left_scm);
216       if (!join_left)
217         programming_error (_f ("Menusral_ligature: (join_left == 0)"));
218       Real blotdiameter = (me->get_paper ()->get_var ("blotdiameter"));
219       Interval x_extent = Interval (0, thickness);
220       Interval y_extent = (join_left > 0) ?
221         Interval (-join_left * 0.5 * staff_space, 0) :
222         Interval (0, -join_left * 0.5 * staff_space);
223       Box stem_box (x_extent, y_extent);
224
225       Molecule stem =
226         Lookup::roundfilledbox (stem_box, blotdiameter);
227       out.add_molecule (stem);
228     }
229
230   int pos = (int)rint (Staff_symbol_referencer::get_position (me));
231   add_ledger_lines(me, &out, pos, 0, ledger_take_space);
232   if (primitive & MLP_FLEXA)
233     {
234       pos += delta_pitch;
235       add_ledger_lines(me, &out, pos, 0.5*delta_pitch, ledger_take_space);
236     }
237
238   return out;
239 }
240
241 MAKE_SCHEME_CALLBACK (Mensural_ligature, brew_ligature_primitive, 1);
242 SCM
243 Mensural_ligature::brew_ligature_primitive (SCM smob)
244 {
245   Grob *me = unsmob_grob (smob);
246   return internal_brew_primitive (me, false).smobbed_copy ();
247 }
248
249 MAKE_SCHEME_CALLBACK (Mensural_ligature, brew_molecule, 1);
250 SCM
251 Mensural_ligature::brew_molecule (SCM)
252 {
253   return SCM_EOL;
254 }
255
256 ADD_INTERFACE(Mensural_ligature, "mensural-ligature-interface",
257               "A mensural ligature",
258               "thickness flexa-width ligature-primitive-callback");