2 This file is part of LilyPond, the GNU music typesetter.
4 Copyright (C) 2002--2011 Juergen Reuter <reuter@ipd.uka.de>,
5 Pal Benko <benkop@freestart.hu>
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.
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.
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/>.
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"
30 #include "rhythmic-head.hh"
32 #include "staff-symbol-referencer.hh"
33 #include "stream-event.hh"
36 #include "translator.icc"
39 * TODO: accidentals are aligned with the first note;
40 * they must appear ahead.
42 * TODO: prohibit ligatures having notes differing only in accidentals
43 * (like \[ a\breve g as \])
45 * TODO: do something with multiple voices within a ligature. See
47 * Ockeghem: Missa Ecce ancilla domini, bassus part, end of Christe.
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
55 class Mensural_ligature_engraver
: public Coherent_ligature_engraver
59 virtual Spanner
*create_ligature_spanner ();
60 virtual void build_ligature (Spanner
*ligature
, vector
<Grob_info
> primitives
);
61 DECLARE_TRANSLATOR_LISTENER (ligature
);
64 TRANSLATOR_DECLARATIONS (Mensural_ligature_engraver
);
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
);
72 IMPLEMENT_TRANSLATOR_LISTENER (Mensural_ligature_engraver
, ligature
);
74 Mensural_ligature_engraver::listen_ligature (Stream_event
*ev
)
76 Ligature_engraver::listen_ligature (ev
);
79 Mensural_ligature_engraver::Mensural_ligature_engraver ()
81 brew_ligature_primitive_proc
=
82 Mensural_ligature::brew_ligature_primitive_proc
;
86 Mensural_ligature_engraver::create_ligature_spanner ()
88 return make_spanner ("MensuralLigature", SCM_EOL
);
92 Mensural_ligature_engraver::transform_heads (vector
<Grob_info
> primitives
)
94 if (primitives
.size () < 2)
96 warning (_ ("ligature with less than 2 heads -> skipping"));
100 bool at_beginning
= true;
102 // needed so that we can check whether
103 // the previous note can be turned into a flexa
104 bool prev_brevis_shape
= false;
106 bool prev_semibrevis
= false;
107 Item
*prev_primitive
= NULL
;
109 for (vsize i
= 0, s
= primitives
.size (); i
< s
; i
++)
111 Grob_info info
= primitives
[i
];
112 Item
*primitive
= dynamic_cast<Item
*> (info
.grob ());
113 int duration_log
= Rhythmic_head::duration_log (primitive
);
115 Stream_event
*nr
= info
.event_cause ();
118 ugh. why not simply check for pitch?
120 if (!nr
->in_event_class ("note-event"))
122 nr
->origin ()->warning
123 (_ ("cannot determine pitch of ligature primitive -> skipping"));
128 int pitch
= unsmob_pitch (nr
->get_property ("pitch"))->steps ();
135 // we can get here after invalid input
136 nr
->origin ()->warning
137 (_ ("single note ligature - skipping"));
140 prev_semibrevis
= prev_brevis_shape
= false;
141 prev_primitive
= NULL
;
145 if (pitch
== prev_pitch
)
147 nr
->origin ()->warning
148 (_ ("prime interval within ligature -> skipping"));
155 if (duration_log
< -3 // is this possible at all???
158 nr
->origin ()->warning
159 (_ ("mensural ligature: duration none of Mx, L, B, S -> skipping"));
165 bool general_case
= true;
166 bool make_flexa
= false;
167 bool allow_flexa
= true;
169 // first check special cases
174 if (duration_log
== 0)
176 prim
= MLP_UP
| MLP_BREVIS
;
177 general_case
= false;
179 // b. descendens longa or brevis
181 && (unsmob_pitch (primitives
[i
+ 1].event_cause ()
182 ->get_property ("pitch"))->steps () < pitch
)
183 && duration_log
> -3)
185 int left_stem
= duration_log
== -1 ? MLP_DOWN
: 0;
186 prim
= left_stem
| MLP_BREVIS
;
187 general_case
= false;
190 // 2. initial semibrevis must be followed by another one
191 else if (prev_semibrevis
)
193 prev_semibrevis
= false;
194 if (duration_log
== 0)
197 general_case
= false;
201 nr
->origin ()->warning
202 (_ ("semibrevis must be followed by another one -> skipping"));
208 // 3. semibreves are otherwise not allowed
209 else if (duration_log
== 0)
211 nr
->origin ()->warning
212 (_ ("semibreves can only appear at the beginning of a ligature,\n"
213 "and there may be only zero or two of them"));
218 // 4. end, descendens
219 else if (i
== s
- 1 && pitch
< prev_pitch
)
221 // brevis; previous note must be turned into flexa
222 if (duration_log
== -1)
224 if (prev_brevis_shape
)
227 general_case
= false;
231 nr
->origin ()->warning
232 (_ ("invalid ligatura ending:\n"
233 "when the last note is a descending brevis,\n"
234 "the penultimate note must be another one,\n"
235 "or the ligatura must be LB or SSB"));
241 else if (duration_log
== -2)
244 general_case
= allow_flexa
= false;
246 // else maxima; fall through to regular case below
250 && to_boolean (primitive
->get_property ("ligature-flexa")))
253 flexa requested, check whether allowed:
254 - there should be a previous note
255 - both of the notes must be of brevis shape
256 (i.e. can't be maxima or flexa;
257 longa is forbidden as well - it's nonexistent anyway)
258 - no compulsory flexa for the next note,
259 i.e. it's not an ultimate descending breve
261 make_flexa
= !at_beginning
&& prev_brevis_shape
&& duration_log
> -2;
262 if (make_flexa
&& i
== s
- 2)
265 check last condition: look ahead to next note
267 Grob_info next_info
= primitives
[i
+ 1];
268 Item
*next_primitive
= dynamic_cast<Item
*> (next_info
.grob ());
269 if (Rhythmic_head::duration_log (next_primitive
) == -1)
272 breve: check whether descending
274 int const next_pitch
= unsmob_pitch
275 (next_info
.event_cause ()->get_property ("pitch"))->steps ();
276 if (next_pitch
< pitch
)
287 static int const shape
[3] = {MLP_MAXIMA
, MLP_LONGA
, MLP_BREVIS
};
289 prim
= shape
[duration_log
+ 3];
295 turn the note with the previous one into a flexa
297 prev_primitive
->set_property
301 | (scm_to_int (prev_primitive
->get_property ("primitive"))
303 prev_primitive
->set_property
304 ("flexa-interval", scm_from_int (pitch
- prev_pitch
));
305 prim
= MLP_FLEXA_END
;
306 primitive
->set_property
307 ("flexa-interval", scm_from_int (pitch
- prev_pitch
));
310 // join_primitives replacement
311 if (!(at_beginning
|| make_flexa
))
312 prev_primitive
->set_property ("add-join", ly_bool2scm (true));
314 at_beginning
= false;
315 prev_primitive
= primitive
;
317 primitive
->set_property ("primitive", scm_from_int (prim
));
318 prev_brevis_shape
= (prim
& MLP_BREVIS
) != 0;
319 prev_semibrevis
= (prim
& MLP_UP
) != 0;
324 * A MensuralLigature grob consists of a bunch of NoteHead grobs that
325 * are glued together. It (a) does not make sense to change
326 * properties like thickness or flexa-width from one head to the next
327 * within a ligature (this would totally screw up alignment), and (b)
328 * some of these properties (like flexa-width) are specific to
329 * e.g. the MensuralLigature (as in contrast to e.g. LigatureBracket),
330 * and therefore should not be handled in the NoteHead code (which is
331 * also used by LigatureBracket). Therefore, we let the user control
332 * these properties via the concrete Ligature grob (like
333 * MensuralLigature) and then copy these properties as necessary to
334 * each of the NoteHead grobs. This is what
335 * propagate_properties () does.
338 Mensural_ligature_engraver::propagate_properties (Spanner
*ligature
,
339 vector
<Grob_info
> primitives
)
342 = robust_scm2double (ligature
->get_property ("thickness"), 1.4);
344 *= ligature
->layout ()->get_dimension (ly_symbol2scm ("line-thickness"));
347 = Font_interface::get_default_font (ligature
)->
348 find_by_name ("noteheads.sM1mensural").extent (X_AXIS
).length ();
349 Real maxima_head_width
350 = Font_interface::get_default_font (ligature
)->
351 find_by_name ("noteheads.sM3ligmensural").extent (X_AXIS
).length ();
353 Item
*prev_primitive
= NULL
;
354 for (vsize i
= 0; i
< primitives
.size (); i
++)
356 Item
*primitive
= dynamic_cast<Item
*> (primitives
[i
].grob ());
357 int output
= scm_to_int (primitive
->get_property ("primitive"));
358 primitive
->set_property ("thickness",
359 scm_from_double (thickness
));
361 switch (output
& MLP_ANY
) {
364 primitive
->set_property ("head-width", scm_from_double (head_width
));
367 primitive
->set_property ("head-width",
368 scm_from_double (maxima_head_width
));
370 case MLP_FLEXA_BEGIN
:
372 the next note (should be MLP_FLEXA_END) will handle this one
377 SCM flexa_scm
= primitive
->get_property ("flexa-width");
378 Real
const flexa_width
= robust_scm2double (flexa_scm
, 2.0);
379 SCM head_width
= scm_from_double (0.5 * (flexa_width
+ thickness
));
380 primitive
->set_property ("head-width", head_width
);
381 prev_primitive
->set_property ("head-width", head_width
);
382 prev_primitive
->set_property ("flexa-width", flexa_scm
);
386 programming_error (_ ("unexpected case fall-through"));
390 prev_primitive
= primitive
;
395 Mensural_ligature_engraver::fold_up_primitives (vector
<Grob_info
> primitives
)
399 Real staff_space
= 0.0;
400 Real thickness
= 0.0;
402 for (vsize i
= 0; i
< primitives
.size (); i
++)
404 Item
*current
= dynamic_cast<Item
*> (primitives
[i
].grob ());
408 staff_space
= Staff_symbol_referencer::staff_space (first
);
409 thickness
= scm_to_double (current
->get_property ("thickness"));
412 move_related_items_to_column (current
, first
->get_column (),
415 Real head_width
= scm_to_double (current
->get_property ("head-width"));
416 distance
+= head_width
- thickness
;
418 if (Rhythmic_head::dot_count (current
) > 0)
420 Move dots above/behind the ligature.
421 dots should also avoid staff lines.
424 Grob
*dot_gr
= Rhythmic_head::get_dots (current
);
426 bool const on_line
= Staff_symbol_referencer::on_line
428 robust_scm2int (current
->get_property ("staff-position"), 0));
429 Real vert_shift
= on_line
? staff_space
* 0.5 : 0.0;
430 bool const flexa_begin
=
431 scm_to_int (current
->get_property ("primitive"))
434 if (i
+ 1 < primitives
.size ())
436 dot in the midst => avoid next note;
437 what to avoid and where depends on
438 being on a line or between lines
442 scm_to_int (current
->get_property ("delta-position"));
444 vert_shift
+= delta
< 0
445 ? staff_space
: (on_line
? -2.0 : -1.0) * staff_space
;
448 if (0 < delta
&& delta
< 3)
449 vert_shift
-= staff_space
;
451 else if (delta
== 1 || delta
== -1)
452 vert_shift
-= delta
* staff_space
;
455 dot_gr
->translate_axis (vert_shift
, Y_AXIS
);
458 move all dots behind head
460 dot_gr
->translate_axis
461 ((flexa_begin
? staff_space
* 0.6 : head_width
) - 2.0*thickness
, X_AXIS
);
467 Mensural_ligature_engraver::build_ligature (Spanner
*ligature
,
468 vector
<Grob_info
> primitives
)
470 transform_heads (primitives
);
471 propagate_properties (ligature
, primitives
);
472 fold_up_primitives (primitives
);
475 ADD_ACKNOWLEDGER (Mensural_ligature_engraver
, rest
);
476 ADD_ACKNOWLEDGER (Mensural_ligature_engraver
, note_head
);
478 ADD_TRANSLATOR (Mensural_ligature_engraver
,
480 "Handle @code{Mensural_ligature_events} by glueing special"
481 " ligature heads together.",