2 This file is part of LilyPond, the GNU music typesetter.
4 Copyright (C) 1998--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
6 LilyPond is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 LilyPond is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
20 #include "engraver.hh"
22 #include "international.hh"
24 #include "rhythmic-head.hh"
25 #include "script-interface.hh"
26 #include "self-alignment-interface.hh"
27 #include "side-position-interface.hh"
29 #include "stream-event.hh"
32 #include "translator.icc"
38 Stream_event *note_event_;
39 Stream_event *finger_event_;
40 bool follow_into_staff_;
47 note_event_ = finger_event_ = 0;
48 follow_into_staff_ = false;
53 operator < (Finger_tuple const &a, Finger_tuple const &b)
55 return a.position_ < b.position_;
58 class New_fingering_engraver : public Engraver
60 vector<Finger_tuple> fingerings_;
61 vector<Finger_tuple> stroke_fingerings_;
62 vector<Finger_tuple> articulations_;
63 vector<Finger_tuple> string_numbers_;
65 vector<Grob *> heads_;
66 vector<Grob *> accidentals_;
71 TRANSLATOR_DECLARATIONS (New_fingering_engraver);
73 void stop_translation_timestep ();
74 DECLARE_ACKNOWLEDGER (rhythmic_head);
75 DECLARE_ACKNOWLEDGER (inline_accidental);
76 DECLARE_ACKNOWLEDGER (stem);
77 void add_fingering (Grob *, SCM,
78 vector<Finger_tuple> *,
79 Stream_event *, Stream_event *);
80 void add_script (Grob *, Stream_event *, Stream_event *);
81 void add_string (Grob *, Stream_event *, Stream_event *);
82 void position_scripts (SCM orientations, vector<Finger_tuple> *);
86 New_fingering_engraver::acknowledge_inline_accidental (Grob_info inf)
88 accidentals_.push_back (inf.grob ());
92 New_fingering_engraver::acknowledge_rhythmic_head (Grob_info inf)
94 Stream_event *note_ev = inf.event_cause ();
98 SCM arts = note_ev->get_property ("articulations");
100 for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
102 Stream_event *ev = unsmob_stream_event (scm_car (s));
107 if (ev->in_event_class ("fingering-event"))
108 add_fingering (inf.grob (),
109 ly_symbol2scm ("Fingering"),
112 else if (ev->in_event_class ("text-script-event"))
113 ev->origin ()->warning (_ ("cannot add text scripts to individual note heads"));
114 else if (ev->in_event_class ("script-event"))
115 add_script (inf.grob (), ev, note_ev);
116 else if (ev->in_event_class ("string-number-event"))
118 // String numbers are used in calculating harmonics even
119 // when we don't want them displayed. So don't make space
120 // for them if 'stencil is #f
121 Grob *g = make_item ("StringNumber", ev->self_scm ());
122 if (g->get_property ("stencil") != SCM_BOOL_F)
123 add_fingering (inf.grob (),
124 ly_symbol2scm ("StringNumber"), &string_numbers_,
126 g->suicide (); // Kill grob created to check stencil
128 else if (ev->in_event_class ("stroke-finger-event"))
129 add_fingering (inf.grob (),
130 ly_symbol2scm ("StrokeFinger"), &stroke_fingerings_,
132 else if (ev->in_event_class ("harmonic-event"))
134 inf.grob ()->set_property ("style", ly_symbol2scm ("harmonic"));
135 Grob *d = unsmob_grob (inf.grob ()->get_object ("dot"));
136 if (d && !to_boolean (get_property ("harmonicDots")))
141 heads_.push_back (inf.grob ());
145 New_fingering_engraver::acknowledge_stem (Grob_info inf)
151 New_fingering_engraver::add_script (Grob *head,
153 Stream_event * /* note */)
157 Grob *g = make_item ("Script", event->self_scm ());
158 make_script_from_event (g, context (),
159 event->get_property ("articulation-type"), 0);
161 ft.script_->set_parent (head, X_AXIS);
163 SCM forced_dir = event->get_property ("direction");
164 if (to_dir (forced_dir))
165 ft.script_->set_property ("direction", forced_dir);
167 articulations_.push_back (ft);
171 New_fingering_engraver::add_fingering (Grob *head,
173 vector<Finger_tuple> *tuple_vector,
175 Stream_event *hevent)
179 ft.script_ = internal_make_item (grob_sym, event->self_scm (),
180 ly_symbol2string (grob_sym).c_str (),
181 __FILE__, __LINE__, __FUNCTION__);
183 Side_position_interface::add_support (ft.script_, head);
185 ft.finger_event_ = event;
186 ft.note_event_ = hevent;
189 tuple_vector->push_back (ft);
193 New_fingering_engraver::position_scripts (SCM orientations,
194 vector<Finger_tuple> *scripts)
196 for (vsize i = 0; i < scripts->size (); i++)
197 if (stem_ && to_boolean (scripts->at (i).script_->get_property ("add-stem-support")))
198 Side_position_interface::add_support (scripts->at (i).script_, stem_);
201 This is not extremely elegant, but we have to do a little
202 formatting here, because the parent/child relations should be
203 known before we move on to the next time step.
205 A more sophisticated approach would be to set both X and Y parents
206 to the note head, and write a more flexible function for
207 positioning the fingerings, setting both X and Y coordinates.
209 for (vsize i = 0; i < scripts->size (); i++)
210 (*scripts)[i].position_ = scm_to_int ((*scripts)[i].head_->get_property ("staff-position"));
212 for (vsize i = scripts->size (); i--;)
213 for (vsize j = heads_.size (); j--;)
214 Side_position_interface::add_support ((*scripts)[i].script_, heads_[j]);
216 vector<Finger_tuple> up, down, horiz;
217 for (vsize i = scripts->size (); i--;)
219 SCM d = (*scripts)[i].finger_event_->get_property ("direction");
222 ((to_dir (d) == UP) ? up : down).push_back ((*scripts)[i]);
223 scripts->erase (scripts->begin () + i);
227 vector_sort (*scripts, less<Finger_tuple> ());
229 bool up_p = scm_c_memq (ly_symbol2scm ("up"), orientations) != SCM_BOOL_F;
230 bool down_p = scm_c_memq (ly_symbol2scm ("down"), orientations) != SCM_BOOL_F;
231 bool left_p = scm_c_memq (ly_symbol2scm ("left"), orientations) != SCM_BOOL_F;
232 bool right_p = scm_c_memq (ly_symbol2scm ("right"), orientations) != SCM_BOOL_F;
233 Direction hordir = (right_p) ? RIGHT : LEFT;
234 if (left_p || right_p)
236 if (up_p && !up.size () && scripts->size ())
238 up.push_back (scripts->back ());
239 scripts->pop_back ();
242 if (down_p && !down.size () && scripts->size ())
244 down.push_back ((*scripts)[0]);
245 scripts->erase (scripts->begin ());
248 horiz.insert (horiz.end (), scripts->begin (), scripts->end ());
250 else if (up_p && down_p)
252 int center = scripts->size () / 2;
253 down.insert (down.end (), scripts->begin (), scripts->begin () + center);
254 up.insert (up.end (), scripts->begin () + center, scripts->end ());
258 up.insert (up.end (), scripts->begin (), scripts->end ());
265 warning (_ ("no placement found for fingerings"));
266 warning (_ ("placing below"));
268 down.insert (down.end (), scripts->begin (), scripts->end ());
272 for (vsize i = 0; i < horiz.size (); i++)
274 Finger_tuple ft = horiz[i];
275 Grob *f = ft.script_;
276 f->set_parent (ft.head_, X_AXIS);
277 f->set_parent (ft.head_, Y_AXIS);
278 f->set_property ("avoid-slur", ly_symbol2scm ("inside"));
280 && unsmob_grob (ft.head_->get_object ("accidental-grob")))
281 Side_position_interface::add_support (f,
282 unsmob_grob (ft.head_->get_object ("accidental-grob")));
283 else if (unsmob_grob (ft.head_->get_object ("dot")))
284 Side_position_interface::add_support (f,
285 unsmob_grob (ft.head_->get_object ("dot")));
287 Self_alignment_interface::set_align_self (f, Y_AXIS);
288 Self_alignment_interface::set_center_parent (f, Y_AXIS);
289 Side_position_interface::set_axis (f, X_AXIS);
291 f->set_property ("direction", scm_from_int (hordir));
294 Drul_array< vector<Finger_tuple> > vertical (down, up);
295 for (DOWN_and_UP (d))
297 for (vsize i = 0; i < vertical[d].size (); i++)
299 Finger_tuple ft = vertical[d][i];
300 Grob *f = ft.script_;
301 int finger_prio = robust_scm2int (f->get_property ("script-priority"), 200);
302 f->set_parent (ft.head_, X_AXIS);
303 f->set_property ("script-priority",
304 scm_from_int (finger_prio + d * ft.position_));
306 Self_alignment_interface::set_align_self (f, X_AXIS);
307 Self_alignment_interface::set_center_parent (f, X_AXIS);
308 Side_position_interface::set_axis (f, Y_AXIS);
310 f->set_property ("direction", scm_from_int (d));
316 New_fingering_engraver::stop_translation_timestep ()
324 New_fingering_engraver::position_all ()
326 if (fingerings_.size ())
328 position_scripts (get_property ("fingeringOrientations"),
330 fingerings_.clear ();
333 if (string_numbers_.size ())
335 position_scripts (get_property ("stringNumberOrientations"),
337 string_numbers_.clear ();
340 if (stroke_fingerings_.size ())
342 position_scripts (get_property ("strokeFingerOrientations"),
343 &stroke_fingerings_);
344 stroke_fingerings_.clear ();
347 for (vsize i = articulations_.size (); i--;)
349 Grob *script = articulations_[i].script_;
351 for (vsize j = 0; j < accidentals_.size (); j++)
352 Side_position_interface::add_support (script, accidentals_[j]);
354 accidentals_.resize (0);
355 for (vsize j = heads_.size (); j--;)
356 Side_position_interface::add_support (script, heads_[j]);
358 if (stem_ && to_dir (script->get_property ("side-relative-direction")))
359 script->set_object ("direction-source", stem_->self_scm ());
361 if (stem_ && to_boolean (script->get_property ("add-stem-support")))
362 Side_position_interface::add_support (script, stem_);
364 articulations_.clear ();
367 New_fingering_engraver::New_fingering_engraver ()
372 ADD_ACKNOWLEDGER (New_fingering_engraver, rhythmic_head);
373 ADD_ACKNOWLEDGER (New_fingering_engraver, inline_accidental);
374 ADD_ACKNOWLEDGER (New_fingering_engraver, stem);
376 ADD_TRANSLATOR (New_fingering_engraver,
378 "Create fingering scripts for notes in a new chord. This"
379 " engraver is ill-named, since it also takes care of"
380 " articulations and harmonic note heads.",
389 "fingeringOrientations "
391 "strokeFingerOrientations "
392 "stringNumberOrientations ",