]> git.donarmstrong.com Git - lilypond.git/blob - lily/mensural-ligature-engraver.cc
Doc-es: Update of Input.
[lilypond.git] / lily / mensural-ligature-engraver.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 2002--2009 Juergen Reuter <reuter@ipd.uka.de>,
5   Pal Benko <benkop@freestart.hu>
6
7   LilyPond is free software: you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation, either version 3 of the License, or
10   (at your option) any later version.
11
12   LilyPond is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "coherent-ligature-engraver.hh"
22 #include "font-interface.hh"
23 #include "international.hh"
24 #include "mensural-ligature.hh"
25 #include "note-column.hh"
26 #include "note-head.hh"
27 #include "output-def.hh"
28 #include "paper-column.hh"
29 #include "pitch.hh"
30 #include "rhythmic-head.hh"
31 #include "spanner.hh"
32 #include "staff-symbol-referencer.hh"
33 #include "stream-event.hh"
34 #include "warn.hh"
35
36 #include "translator.icc"
37
38 /*
39  * TODO: accidentals are aligned with the first note;
40  * they must appear ahead.
41  *
42  * TODO: prohibit ligatures having notes differing only in accidentals
43  * (like \[ a\breve g as \])
44  *
45  * TODO: do something with multiple voices within a ligature.  See
46  * for example:
47  * Ockeghem: Missa Ecce ancilla domini, bassus part, end of Christe.
48  *
49  * TODO: enhance robustness: in case of an invalid ligature (e.g. the
50  * input specifies a ligature that contains a minima), automatically
51  * break the ligature into smaller, valid pieces.  Such a piece may be
52  * a single note.
53  */
54
55 class Mensural_ligature_engraver : public Coherent_ligature_engraver
56 {
57
58 protected:
59   virtual Spanner *create_ligature_spanner ();
60   virtual void build_ligature (Spanner *ligature, vector<Grob_info> primitives);
61   DECLARE_TRANSLATOR_LISTENER (ligature);
62   
63 public:
64   TRANSLATOR_DECLARATIONS (Mensural_ligature_engraver);
65
66 private:
67   void transform_heads (vector<Grob_info> primitives);
68   void propagate_properties (Spanner *ligature, vector<Grob_info> primitives);
69   void fold_up_primitives (vector<Grob_info> primitives);
70 };
71
72 IMPLEMENT_TRANSLATOR_LISTENER (Mensural_ligature_engraver, ligature);
73 void
74 Mensural_ligature_engraver::listen_ligature (Stream_event *ev)
75 {
76   Ligature_engraver::listen_ligature (ev);
77 }
78
79 Mensural_ligature_engraver::Mensural_ligature_engraver ()
80 {
81   brew_ligature_primitive_proc = 
82     Mensural_ligature::brew_ligature_primitive_proc;
83 }
84
85 Spanner *
86 Mensural_ligature_engraver::create_ligature_spanner ()
87 {
88   return make_spanner ("MensuralLigature", SCM_EOL);
89 }
90
91 void
92 Mensural_ligature_engraver::transform_heads (vector<Grob_info> primitives)
93 {
94   if (primitives.size () < 2)
95     {
96       warning (_ ("ligature with less than 2 heads -> skipping"));
97       return;
98     }
99   int prev_pitch = 0;
100   bool at_beginning = true;
101
102   // needed so that we can check whether
103   // the previous note can be turned into a flexa
104   bool prev_brevis_shape = false;
105
106   bool prev_semibrevis = false;
107   Item *prev_primitive = NULL;
108
109   for (vsize i = 0, s = primitives.size (); i < s; i++)
110     {
111       Grob_info info = primitives[i];
112       Item *primitive = dynamic_cast<Item *> (info.grob ());
113       int duration_log = Rhythmic_head::duration_log (primitive);
114
115       Stream_event *nr = info.event_cause ();
116
117       /*
118         ugh. why not simply check for pitch?
119       */
120       if (!nr->in_event_class ("note-event"))
121         {
122           nr->origin ()->warning
123             (_ ("cannot determine pitch of ligature primitive -> skipping"));
124           at_beginning = true;
125           continue;
126         }
127
128       int pitch = unsmob_pitch (nr->get_property ("pitch"))->steps ();
129       int delta_pitch = 0;
130
131       if (at_beginning)
132         {
133           if (i == s - 1)
134             {
135               // we can get here after invalid input
136               nr->origin ()->warning
137                 (_ ("single note ligature - skipping"));
138               break;
139             }
140           prev_semibrevis = prev_brevis_shape = false;
141           prev_primitive = NULL;
142         }
143       else
144         {
145           delta_pitch = pitch - prev_pitch;
146           if (delta_pitch == 0)
147             {
148               nr->origin ()->warning
149                 (_ ("prime interval within ligature -> skipping"));
150               at_beginning = true;
151               primitive->set_property ("primitive",
152                                        scm_from_int (MLP_NONE));
153               continue;
154             }
155         }
156
157       if (duration_log < -3 // is this possible at all???
158           || duration_log > 0)
159         {
160           nr->origin ()->warning
161             (_ ("mensural ligature: duration none of Mx, L, B, S -> skipping"));
162           primitive->set_property ("primitive",
163                                    scm_from_int (MLP_NONE));
164           at_beginning = true;
165           continue;
166         }
167
168       // apply_transition replacement begins
169       bool general_case = true;
170
171       // first check special cases
172       // 1. beginning
173       if (at_beginning)
174         {
175           // a. semibreves
176           if (duration_log == 0)
177             {
178               primitive->set_property ("primitive",
179                                        scm_from_int (MLP_UP | MLP_BREVIS));
180               prev_semibrevis = prev_brevis_shape = true;
181               general_case = false;
182             }
183           // b. descendens longa or brevis
184           else if (i < s - 1
185                    && (unsmob_pitch (primitives[i + 1].event_cause ()
186                                      ->get_property ("pitch"))->steps () < pitch)
187                    && duration_log > -3)
188             {
189               int left_stem = duration_log == -1 ? MLP_DOWN : 0;
190
191               primitive->set_property ("primitive",
192                                        scm_from_int (left_stem | MLP_BREVIS));
193               prev_brevis_shape = true;
194               prev_semibrevis = general_case = false;
195             }
196         }
197       // 2. initial semibrevis must be followed by another one
198       else if (prev_semibrevis)
199         {
200           prev_semibrevis = false;
201           if (duration_log == 0)
202             {
203               primitive->set_property ("primitive", scm_from_int (MLP_BREVIS));
204               general_case = false;
205             }
206           else
207             {
208               nr->origin ()->warning
209                 (_ ("semibrevis must be followed by another one -> skipping"));
210               primitive->set_property ("primitive",
211                                        scm_from_int (MLP_NONE));
212               at_beginning = true;
213               continue;
214             }
215         }
216       // 3. semibreves are otherwise not allowed
217       else if (duration_log == 0)
218         {
219           nr->origin ()->warning
220             (_ ("semibreves can only appear at the beginning of a ligature,\n"
221                 "and there may be only zero or two of them"));
222           primitive->set_property ("primitive",
223                                    scm_from_int (MLP_NONE));
224           at_beginning = true;
225           continue;
226         }
227       // 4. end, descendens
228       else if (i == s - 1 && delta_pitch < 0)
229         {
230           // brevis; previous note must be turned into flexa
231           if (duration_log == -1)
232             {
233               if (prev_brevis_shape)
234                 {
235                   prev_primitive->set_property
236                     ("primitive",
237                      scm_from_int
238                      (MLP_FLEXA
239                       | (scm_to_int (prev_primitive->get_property ("primitive"))
240                          & MLP_DOWN)));
241                   primitive->set_property ("primitive", scm_from_int (MLP_NONE));
242                   break; // no more notes, no join
243                 }
244               else
245                 {
246                   nr->origin ()->warning
247                     (_ ("invalid ligatura ending:\n"
248                         "when the last note is a descending brevis,\n"
249                         "the penultimate note must be another one,\n"
250                         "or the ligatura must be LB or SSB"));
251                   primitive->set_property ("primitive", scm_from_int (MLP_NONE));
252                   break;
253                 }
254             }
255           // longa
256           else if (duration_log == -2)
257             {
258               primitive->set_property ("primitive", scm_from_int (MLP_BREVIS));
259               general_case = false;
260             }
261           // else maxima; fall through regular case below
262         }
263
264       if (general_case)
265         {
266           static int const shape[3] = {MLP_MAXIMA, MLP_LONGA, MLP_BREVIS};
267
268           primitive->set_property ("primitive",
269                                    scm_from_int (shape[duration_log + 3]));
270           prev_brevis_shape = duration_log == -1;
271         }
272
273       // join_primitives replacement
274       if (!at_beginning)
275         {
276           /*
277             if the previous note is longa-shaped and this note is lower,
278             then the joining line may hide the stem, so it is made longer
279             to serve as stem as well
280           */
281           if (delta_pitch < 0
282               && (scm_to_int (prev_primitive->get_property ("primitive"))
283                   & MLP_LONGA))
284             {
285               delta_pitch -= 6;
286               // instead of number 6
287               // the legth of the longa stem should be queried something like
288               // Font_interface::get_default_font (ligature)->find_by_name
289               //  ("noteheads.sM2mensural").extent (Y_AXIS).length ()
290             }
291           prev_primitive->set_property ("join-right-amount",
292                                         scm_from_int (delta_pitch));
293           // perhaps set add-join as well
294         }
295       at_beginning = false;
296       prev_primitive = primitive;
297       prev_pitch = pitch;
298       // apply_transition replacement ends
299     }
300 }
301
302 /*
303  * A MensuralLigature grob consists of a bunch of NoteHead grobs that
304  * are glued together.  It (a) does not make sense to change
305  * properties like thickness or flexa-width from one head to the next
306  * within a ligature (this would totally screw up alignment), and (b)
307  * some of these properties (like flexa-width) are specific to
308  * e.g. the MensuralLigature (as in contrast to e.g. LigatureBracket),
309  * and therefore should not be handled in the NoteHead code (which is
310  * also used by LigatureBracket).  Therefore, we let the user control
311  * these properties via the concrete Ligature grob (like
312  * MensuralLigature) and then copy these properties as necessary to
313  * each of the NoteHead grobs.  This is what
314  * propagate_properties () does.
315  */
316 void
317 Mensural_ligature_engraver::propagate_properties (Spanner *ligature,
318                                                   vector<Grob_info> primitives)
319 {
320   Real thickness
321     = robust_scm2double (ligature->get_property ("thickness"), 1.4);
322   thickness
323     *= ligature->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
324
325   Real head_width
326     = Font_interface::get_default_font (ligature)->
327     find_by_name ("noteheads.sM1mensural").extent (X_AXIS).length ();
328   Real flexa_width
329     = robust_scm2double (ligature->get_property ("flexa-width"), 2);
330   Real maxima_head_width
331     = Font_interface::get_default_font (ligature)->
332     find_by_name ("noteheads.sM1neomensural").extent (X_AXIS).length ();
333
334   flexa_width *= Staff_symbol_referencer::staff_space (ligature);
335
336   Real half_flexa_width = 0.5 * (flexa_width + thickness);
337
338   for (vsize i = 0; i < primitives.size (); i++)
339     {
340       Item *primitive = dynamic_cast<Item *> (primitives[i].grob ());
341       int output = scm_to_int (primitive->get_property ("primitive"));
342       primitive->set_property ("thickness",
343                                scm_from_double (thickness));
344
345       switch (output & MLP_ANY)
346         {
347         case MLP_NONE:
348           primitive->set_property ("head-width",
349                                    scm_from_double (half_flexa_width));
350           break;
351         case MLP_BREVIS:
352         case MLP_LONGA:
353           primitive->set_property ("head-width",
354                                    scm_from_double (head_width));
355           break;
356         case MLP_MAXIMA:
357           primitive->set_property ("head-width",
358                                    scm_from_double (maxima_head_width));
359           break;
360         case MLP_FLEXA:
361           primitive->set_property ("head-width",
362                                    scm_from_double (half_flexa_width));
363           primitive->set_property ("flexa-width",
364                                    scm_from_double (flexa_width));
365           break;
366         default:
367           programming_error (_ ("unexpected case fall-through"));
368           break;
369         }
370     }
371 }
372
373 void
374 Mensural_ligature_engraver::fold_up_primitives (vector<Grob_info> primitives)
375 {
376   Item *first = 0;
377   Real distance = 0.0;
378   Real dot_shift = 0.0;
379   for (vsize i = 0; i < primitives.size (); i++)
380     {
381       Item *current = dynamic_cast<Item *> (primitives[i].grob ());
382       if (i == 0)
383         {
384           first = current;
385           dot_shift = 1.5 * Staff_symbol_referencer::staff_space (first);
386         }
387
388       move_related_items_to_column (current, first->get_column (),
389                                     distance);
390
391       distance
392         += scm_to_double (current->get_property ("head-width"))
393         - scm_to_double (current->get_property ("thickness"));
394
395       if (Rhythmic_head::dot_count (current) > 0)
396         // Move dots above/behind the ligature.
397         {
398           if (i + 1 < primitives.size ())
399             // dot in the midst => move above head
400             {
401               // FIXME: Amount of vertical dot-shift should depend on
402               // pitch.
403               //
404               // FIXME: dot placement is horizontally slightly off.
405               Rhythmic_head::get_dots (current)->translate_axis (dot_shift, Y_AXIS);
406             }
407           else
408             // trailing dot => move behind head
409             {
410               double head_width =
411                 scm_to_double (current->get_property ("head-width"));
412               Rhythmic_head::get_dots (current)->
413                 translate_axis (head_width, X_AXIS);
414             }
415         }
416     }
417 }
418
419 void
420 Mensural_ligature_engraver::build_ligature (Spanner *ligature,
421                                             vector<Grob_info> primitives)
422 {
423   transform_heads (primitives);
424   propagate_properties (ligature, primitives);
425   fold_up_primitives (primitives);
426 }
427
428 ADD_ACKNOWLEDGER (Mensural_ligature_engraver, rest);
429 ADD_ACKNOWLEDGER (Mensural_ligature_engraver, note_head);
430
431 ADD_TRANSLATOR (Mensural_ligature_engraver,
432                 /* doc */
433                 "Handle @code{Mensural_ligature_events} by glueing special"
434                 " ligature heads together.",
435
436                 /* create */
437                 "MensuralLigature ",
438
439                 /* read */
440                 "",
441
442                 /* write */
443                 ""
444                 );