]> git.donarmstrong.com Git - lilypond.git/blob - lily/key-engraver.cc
Doc-es: update Vocal.
[lilypond.git] / lily / key-engraver.cc
1 /*
2   This file is part of LilyPond, the GNU music typesetter.
3
4   Copyright (C) 1997--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
5
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.
10
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.
15
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/>.
18 */
19
20 #include "bar-line.hh"
21 #include "clef.hh"
22 #include "context.hh"
23 #include "engraver.hh"
24 #include "item.hh"
25 #include "pitch.hh"
26 #include "protected-scm.hh"
27 #include "staff-symbol-referencer.hh"
28 #include "stream-event.hh"
29
30 #include "translator.icc"
31
32 class Key_engraver : public Engraver
33 {
34   void create_key (bool);
35   void read_event (Stream_event const *r);
36
37   Stream_event *key_event_;
38   Item *item_;
39   Item *cancellation_;
40 public:
41   TRANSLATOR_DECLARATIONS (Key_engraver);
42
43 protected:
44   virtual void initialize ();
45   virtual void finalize ();
46   void stop_translation_timestep ();
47   void process_music ();
48
49   DECLARE_TRANSLATOR_LISTENER (key_change);
50   DECLARE_ACKNOWLEDGER (clef);
51   DECLARE_ACKNOWLEDGER (bar_line);
52 };
53
54 void
55 Key_engraver::finalize ()
56 {
57 }
58
59 Key_engraver::Key_engraver ()
60 {
61   key_event_ = 0;
62   item_ = 0;
63   cancellation_ = 0;
64 }
65
66 void
67 Key_engraver::create_key (bool is_default)
68 {
69   if (!item_)
70     {
71       item_ = make_item ("KeySignature",
72                          key_event_ ? key_event_->self_scm () : SCM_EOL);
73
74       /* Use middleCClefPosition rather than middleCPosition, because cue
75        * notes with a different clef will modify middleCPosition. The
76        * Key signature, however, should still be printed at the original
77        * position. */
78       item_->set_property ("c0-position",
79                            get_property ("middleCClefPosition"));
80
81       SCM last = get_property ("lastKeySignature");
82       SCM key = get_property ("keySignature");
83
84       if ((to_boolean (get_property ("printKeyCancellation"))
85            || key == SCM_EOL)
86           && !scm_is_eq (last, key))
87         {
88           SCM restore = SCM_EOL;
89           for (SCM s = last; scm_is_pair (s); s = scm_cdr (s))
90             {
91               SCM new_alter_pair = scm_assoc (scm_caar (s), key);
92               Rational old_alter = robust_scm2rational (scm_cdar (s), 0);
93               if (new_alter_pair == SCM_BOOL_F
94                   || ((ly_scm2rational (scm_cdr (new_alter_pair)) - old_alter) * old_alter
95                       < Rational (0)))
96                 {
97                   restore = scm_cons (scm_car (s), restore);
98                 }
99             }
100
101           if (scm_is_pair (restore))
102             {
103               cancellation_ = make_item ("KeyCancellation",
104                                          key_event_
105                                          ? key_event_->self_scm () : SCM_EOL);
106
107               cancellation_->set_property ("alteration-alist", restore);
108               cancellation_->set_property ("c0-position",
109                                            get_property ("middleCPosition"));
110             }
111         }
112
113       item_->set_property ("alteration-alist", scm_reverse (key));
114     }
115
116   if (!is_default)
117     {
118       SCM visibility = get_property ("explicitKeySignatureVisibility");
119       item_->set_property ("break-visibility", visibility);
120     }
121 }
122
123 IMPLEMENT_TRANSLATOR_LISTENER (Key_engraver, key_change);
124 void
125 Key_engraver::listen_key_change (Stream_event *ev)
126 {
127   /* do this only once, just to be on the safe side.  */
128   if (ASSIGN_EVENT_ONCE (key_event_, ev))
129     read_event (key_event_);
130 }
131
132 void
133 Key_engraver::acknowledge_clef (Grob_info /* info */)
134 {
135   SCM c = get_property ("createKeyOnClefChange");
136   if (to_boolean (c))
137     create_key (false);
138 }
139
140 void
141 Key_engraver::acknowledge_bar_line (Grob_info /* info */)
142 {
143   if (scm_is_pair (get_property ("keySignature")))
144     create_key (true);
145 }
146
147 void
148 Key_engraver::process_music ()
149 {
150   if (key_event_
151       || get_property ("lastKeySignature") != get_property ("keySignature"))
152     create_key (false);
153 }
154
155 void
156 Key_engraver::stop_translation_timestep ()
157 {
158   item_ = 0;
159   context ()->set_property ("lastKeySignature", get_property ("keySignature"));
160   cancellation_ = 0;
161   key_event_ = 0;
162 }
163
164 void
165 Key_engraver::read_event (Stream_event const *r)
166 {
167   SCM p = r->get_property ("pitch-alist");
168   if (!scm_is_pair (p))
169     return;
170
171   SCM accs = SCM_EOL;
172
173   SCM alist = scm_list_copy (p);
174   SCM order = get_property ("keyAlterationOrder");
175   for (SCM s = order;
176        scm_is_pair (s) && scm_is_pair (alist); s = scm_cdr (s))
177     {
178       SCM head = scm_member (scm_car (s), alist);
179
180       if (scm_is_pair (head))
181         {
182           accs = scm_cons (scm_car (head), accs);
183           alist = scm_delete_x (scm_car (head), alist);
184         }
185     }
186
187   if (scm_is_pair (alist))
188     {
189       bool warn = false;
190       for (SCM s = alist; scm_is_pair (s); s = scm_cdr (s))
191         if (ly_scm2rational (scm_cdar (s)))
192           {
193             warn = true;
194             accs = scm_cons (scm_car (s), accs);
195           }
196
197       if (warn)
198         r->origin ()->warning ("Incomplete keyAlterationOrder for key signature");
199     }
200
201   context ()->set_property ("keySignature", scm_reverse (accs));
202   context ()->set_property ("tonic",
203                             r->get_property ("tonic"));
204 }
205
206 void
207 Key_engraver::initialize ()
208 {
209   context ()->set_property ("keySignature", SCM_EOL);
210   context ()->set_property ("lastKeySignature", SCM_EOL);
211
212   Pitch p (0, 0, 0);
213   context ()->set_property ("tonic", p.smobbed_copy ());
214 }
215
216 ADD_ACKNOWLEDGER (Key_engraver, clef);
217 ADD_ACKNOWLEDGER (Key_engraver, bar_line);
218
219 ADD_TRANSLATOR (Key_engraver,
220                 /* doc */
221                 "Engrave a key signature.",
222
223                 /* create */
224                 "KeyCancellation "
225                 "KeySignature ",
226
227                 /* read */
228                 "createKeyOnClefChange "
229                 "explicitKeySignatureVisibility "
230                 "extraNatural "
231                 "keyAlterationOrder "
232                 "keySignature "
233                 "lastKeySignature "
234                 "printKeyCancellation "
235                 "middleCClefPosition ",
236
237                 /* write */
238                 "keySignature "
239                 "lastKeySignature "
240                 "tonic "
241                );