dev/johngourlay/issue-4751 to bring the development branch up to date.
Melodické ozdoby se zadávají příkazem @code{\grace}, ačkoli se také dají
vytvářet uvozením hudebního výrazu příkazem @code{\appoggiatura} (dlouhý
-příraz, prodleva) a @code{\acciaccatura} (příraz, krátká appogiatura).
+příraz, prodleva) a @code{\acciaccatura} (příraz, krátká appoggiatura).
@lilypond[verbatim,quote]
\relative {
@funindex \grace
@funindex \slashedGrace
@funindex \acciaccatura
-@funindex \appoggiature
+@funindex \appoggiatura
@cindex Verzierungen
@cindex Ziernoten
Es gibt drei Arten von Verzierungen:
den Vorschlag (engl. acciaccatura), eine angebundene Verzierungsnote
-mit einem Schrägstrich durch den Hals, und den Vorhalt (engl. appogiatura),
+mit einem Schrägstrich durch den Hals, und den Vorhalt (engl. appoggiatura),
welcher den Wert der Hauptnote um seinen eigenen Wert verkürzt und
ohne Schrägstrich notiert wird. Man kann einen Vorschlag auch mit
Schrägstrich durch den Hals, aber ohne Legatobogen notieren. Diese
Glossaire musicologique :
@rglosnamed{grace notes,ornements},
@rglosnamed{acciaccatura,acciaccature},
-@rglosnamed{appoggiatura,appogiature}.
+@rglosnamed{appoggiatura,appoggiature}.
Des @notation{notes d'ornement} s'obtiennent en appliquant la commande
@code{\grace}, @code{\appoggiatura} ou @code{\acciaccatura} à une
@item @code{\grace}
-@tab appogiatures
+@tab appoggiatures
@tab
@lilypond[relative=2]
\set Staff.initialTimeSignatureVisibility = #all-invisible
seront aussi reportés en MIDI :
@itemize
-@item les appogiatures -- celles-ci prendront la moitié de la valeur,
+@item les appoggiatures -- celles-ci prendront la moitié de la valeur,
dépourvue de point, de la note qui les suit -- par exemple,
@example
@seealso
Glossaire musicologique :
@rglosnamed{grace notes,ornements},
-@rglosnamed{acciaccatura,acciacature},
-@rglosnamed{appoggiatura,appogiature}.
+@rglosnamed{acciaccatura,acciaccature},
+@rglosnamed{appoggiatura,appoggiature}.
Manuel de notation :
@ref{Barres de ligature manuelles},
\acciaccatura g8 f4
</pre>
- <p>Both reflect the traditional meanings of acciaccatura and appogiatura,
+ <p>Both reflect the traditional meanings of acciaccatura and appoggiatura,
and both insert insert a slur from the first grace note to the main
note.
NL: dubbele voorslag,
DK: dobbelt forslag,
S: dubbelslag,
-FI: kaksoisappogiatura, kaksoisetuhele.
+FI: kaksoisappoggiatura, kaksoisetuhele.
@seealso
@ref{appoggiatura}.
return generic_get_acknowledger (sym, interface_end_acknowledger_hash_);
}
- void init_acknowledgers (SCM alist, SCM *hash);
+ SCM init_acknowledgers (SCM alist);
// For now no description. In future, something derived from the
// definition might make sense.
SCM translator_description () const { return SCM_EOL; }
vector<Method_instance>
precomputed_method_bindings_[TRANSLATOR_METHOD_PRECOMPUTE_COUNT];
- SCM
- precomputed_self_method_bindings_[TRANSLATOR_METHOD_PRECOMPUTE_COUNT];
-
SCM protected_events_;
void create_child_translator (SCM);
void stop_translation_timestep ();
void start_translation_timestep ();
- virtual void fetch_precomputable_methods (SCM []);
-
Translator_group ();
void precomputed_translator_foreach (Translator_precompute_index);
- void call_precomputed_self_method (Translator_precompute_index);
Context *context () const { return context_; }
protected:
initialize_function_ = callable (ly_symbol2scm ("initialize"), definition);
finalize_function_ = callable (ly_symbol2scm ("finalize"), definition);
- SCM listeners = ly_assoc_get (ly_symbol2scm ("listeners"), definition, SCM_EOL);
-
- per_instance_listeners_ = SCM_EOL;
+ SCM p = ly_assoc_get (ly_symbol2scm ("listeners"), definition, SCM_EOL);
+ SCM listeners = SCM_EOL;
must_be_last_ = to_boolean (ly_assoc_get (ly_symbol2scm ("must-be-last"),
definition,
SCM_BOOL_F));
- for (SCM p = listeners; scm_is_pair (p); p = scm_cdr (p))
+ for (; scm_is_pair (p); p = scm_cdr (p))
{
SCM event_class = scm_caar (p);
SCM proc = scm_cdar (p);
// We should check the arity of the function?
// Record for later lookup.
- per_instance_listeners_ = scm_acons (event_class, proc, per_instance_listeners_);
+ listeners = scm_acons (event_class, proc, listeners);
}
- init_acknowledgers (ly_assoc_get (ly_symbol2scm ("acknowledgers"),
- definition, SCM_EOL),
- &interface_acknowledger_hash_);
+ SCM hash1 =
+ init_acknowledgers (ly_assoc_get (ly_symbol2scm ("acknowledgers"),
+ definition, SCM_EOL));
+ SCM hash2 =
+ init_acknowledgers (ly_assoc_get (ly_symbol2scm ("end-acknowledgers"),
+ definition, SCM_EOL));
+
+ per_instance_listeners_ = listeners;
+ interface_acknowledger_hash_ = hash1;
+ interface_end_acknowledger_hash_ = hash2;
- init_acknowledgers (ly_assoc_get (ly_symbol2scm ("end-acknowledgers"),
- definition, SCM_EOL),
- &interface_end_acknowledger_hash_);
+ // It's not defined whether Scheme_engraver::derived_mark is already
+ // active while the construction is underway, so we make sure we
+ // keep a version of everything on the stack that is not still
+ // covered by `definition'.
+
+ scm_remember_upto_here_2 (definition, listeners);
+ scm_remember_upto_here_2 (hash1, hash2);
// TODO: hook up description, props read/written, grobs created
// etc. to provide automatic documentation.
}
-void
-Scheme_engraver::init_acknowledgers (SCM alist,
- SCM *hash)
+SCM
+Scheme_engraver::init_acknowledgers (SCM alist)
{
- *hash = Scheme_hash_table::make_smob ();
+ SCM hash = Scheme_hash_table::make_smob ();
for (SCM p = alist; scm_is_pair (p); p = scm_cdr (p))
{
SCM iface = scm_caar (p);
if (!(ly_is_procedure (proc) && ly_is_symbol (iface)))
continue;
- unsmob<Scheme_hash_table>(*hash)->set (iface, proc);
+ unsmob<Scheme_hash_table>(hash)->set (iface, proc);
}
+ return hash;
}
SCM
if (tg && dir == DOWN)
{
tg->precomputed_translator_foreach (idx);
- tg->call_precomputed_self_method (idx);
}
for (SCM s = c->children_contexts (); scm_is_pair (s);
if (tg && dir == UP)
{
tg->precomputed_translator_foreach (idx);
- tg->call_precomputed_self_method (idx);
}
}
}
}
- fetch_precomputable_methods (precomputed_self_method_bindings_);
}
void
bindings[i]();
}
-void
-Translator_group::fetch_precomputable_methods (SCM ptrs[])
-{
- for (int i = 0; i < TRANSLATOR_METHOD_PRECOMPUTE_COUNT; i++)
- ptrs[i] = SCM_UNDEFINED;
-}
-
-void
-Translator_group::call_precomputed_self_method (Translator_precompute_index idx)
-{
- if (!SCM_UNBNDP (precomputed_self_method_bindings_[idx]))
- scm_call_1 (precomputed_self_method_bindings_[idx], self_scm ());
-}
-
Translator_group::~Translator_group ()
{
}
% portato ac:portatoFactor (default 3/4)
% tenuto ac:tenutoFactor (default 1/1 - by default, notes marked
% tenuto are not shortened)
-% * Appogiaturas are made to take half the value of the note following,
+% * Appoggiaturas are made to take half the value of the note following,
% without taking dots into account (so in \appoggiatura c8 d2. the c
% will take the time of a crotchet).
% * Trills and turns are expanded. The algorithm tries to choose notes
%%%%%%%%
%
-% Single Stroke for Short Appogiatura
+% Single Stroke for Short Appoggiatura
%
fet_beginchar ("grace dash (up)", "ugrace");
" some handy key mappings
"
" <F4> save & make and play midi with timidity
-map <buffer> <F4> :w<Return>:se makeprg=lilypond\ \"%<\"<Return>:make<Return>:!timidity "%<.midi"<Return>
+map <buffer> <F4> :w<Return>:setl makeprg=lilypond\ \"%<\"<Return>:make<Return>:!timidity "%<.midi"<Return>
"
" <F5> save & make
-map <buffer> <F5> :w<Return>:se makeprg=lilypond\ \"%<\"<Return>:make<Return>
+map <buffer> <F5> :w<Return>:setl makeprg=lilypond\ \"%<\"<Return>:make<Return>
"
" <F6> view pdf with ghostview
map <buffer> <F6> :!gv --watch "%<.pdf" &<Return>
map <buffer> <F8> :cn<Return>
"
" <F9> make
-map <buffer> <F9> :w<Return>:se makeprg=make\ -k<Return>:make<Return>
+map <buffer> <F9> :w<Return>:setl makeprg=make\ -k<Return>:make<Return>
"
" <F10> menu
source $VIMRUNTIME/menu.vim