@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: 5a6340b7f319802a7313c0e6b82eef96909cde42
+ Translation of GIT committish: 8c1840ca28a05b3dad8d595e04d03779ba0a286a
- When revising a translation, copy the HEAD committish of the
- version that you are working on. For details, see the Contributors'
- Guide, node Updating translation committishes..
+ When revising a translation, copy the HEAD committish of the
+ version that you are working on. For details, see the Contributors'
+ Guide, node Updating translation committishes..
@end ignore
-@c \version "2.19.21"
+@c \version "2.19.24"
@c Translators: Valentin Villenave, Jean-Charles Malahieude
@c Translation checkers: Gilles Thibault
En voici un exemple basique :
@lilypond[verbatim,quote]
-ritpp = #(define-event-function (parser location) ()
+ritpp = #(define-event-function () ()
#{ ^"rit." \pp #}
)
pour accepter des blocs de code LilyPond ; il est capable de traiter des
expressions Scheme intégrées débutant par @code{$} ou @code{#}.
-@cindex parser (fonction argument)
-@cindex location
-
Le lecteur Scheme extrait le bloc de code LilyPond et déclenche un appel
-à l'analyseur grammatical de LilyPond (le @code{parser}) qui réalise en
+à l'analyseur grammatical de LilyPond (le @emph{parser}) qui réalise en
temps réel l'interprétation de ce bloc de code LilyPond. Toute
expression Scheme imbriquée est exécutée dans l'environnement lexical du
bloc de code LilyPond, de telle sorte que vous avez accès aux variables
un @code{#}) mais en tant que variables LilyPond (préfixées par
un @code{\}).
-Lorsque l'emplacement (@code{location} -- voir @ref{Fonctions Scheme})
-fait référence à un endroit valide dans la source -- ce qui est en
-général le cas au sein de fonctions musicales ou Scheme --, toute la
-musique générée au sein de ce bloc de code voit son @code{origine}
-établie à cet @emph{emplacement}.
+Toute la musique générée au sein de ce bloc de code voit son
+@code{origine} établie à cet @emph{emplacement}.
Un bloc de code LilyPond peut contenir tout ce que vous pourriez mettre
à droite de l'assignation. Par ailleurs, un bloc LilyPond vide
Les @emph{fonctions Scheme} sont des procédures Scheme chargées de créer
des expressions Scheme à partir de code rédigé selon la syntaxe de
LilyPond. Elles peuvent être appelées en de nombreux endroits, à l'aide
-d'un @code{#}, où spécifier une valeur en syntaxe Scheme est autorisé.
+d'un @code{#}, où spécifier une valeur en syntaxe Scheme est autorisé.
Bien que Scheme dispose de fonctions en propre, nous nous intéresserons,
au fil des paragraphes qui suivent, aux fonctions @emph{syntaxiques},
autrement dit des fonctions qui reçoivent des arguments libellés dans la
@example
fonction =
#(define-scheme-function
- (parser location @var{arg1} @var{arg2}@dots{})
+ (@var{arg1} @var{arg2}@dots{})
(@var{type1?} @var{type2?}@dots{})
@var{corps})
@end example
où
@multitable @columnfractions .33 .66
-@item @code{parser}
-@tab doit être littéralement @code{parser}, de telle sorte que
-l'analyseur grammatical puisse accéder aux blocs de code LilyPond
-(@code{#@{}@dots{}@code{#@}}).
-
-@item @code{location}
-@tab doit être littéralement @code{location}, de telle sorte que soit
-accessible l'emplacement de l'objet dans la source, aux fins de
-transmettre aux messages d'erreur les fichier et numéro de ligne.
-
@item @code{@var{argN}}
-@tab @var{n}ième argument
+@tab @var{n}-ième argument.
@item @code{@var{typeN?}}
@tab un @emph{type de prédicat} Scheme pour lequel @code{@var{argN}}
vérifiées ni au moment de la définition, ni à l'exécution ; il est
de votre ressort de gérer les valeurs que vous spécifiez. Une valeur
par défaut constituée d'une expression musicale est recopiée dès la
-définition de @code{origin} vers le paramètre @code{location}.
+définition de @code{origin} à l'emplacement courant du code.
@item @code{@var{corps}}
@tab une séquence de formules Scheme évaluées dans l'ordre, la dernière
arguments de la fonction -- par exemple @w{@samp{#(cons arg1 arg2)}}.
Dans le cas où une expression Scheme introduite par @code{#} ne vous
permet pas de parvenir à vos fins, vous pourriez devoir revenir à une
-expression Scheme « immédiate » à l'aide d'un @code{$}, comme
+expression Scheme « immédiate » à l'aide d'un @code{$}, comme
@samp{$music}.
Lorsque votre fonction retourne une expression musicale, lui est
@translationof Scheme function usage
Vous pouvez appeler une fonction Scheme pratiquement partout où une
-expression Scheme derrière un @code{#} peut prendre place. Vous appelez
-une fonction Scheme en faisant précéder son nom d'un @code{\}, et en le
-faisant suivre de ses arguments. Lorsqu'un prédicat d'argument
-optionnel ne correspond pas à un argument, LilyPond l'ignore ainsi que
-tous les arguments optionnels qui suivent, les remplaçant par leur
-valeur par défaut, et « sauvegarde » en tant que prochain argument
-obligatoire l'argument qui ne correspondait pas. Dans la mesure où
-l'argument sauvegardé doit servir, les argument optionnels ne sont en
-fait pas considérés comme optionnels, sauf à être suivis d'un argument
-obligatoire.
+expression Scheme derrière un @code{#} peut prendre place. Vous appelez
+une fonction Scheme à partir de LilyPond en faisant précéder son nom
+d'un @code{\}, et en le faisant suivre de ses arguments. Lorsqu'un
+prédicat d'argument optionnel ne correspond pas à un argument, LilyPond
+l'ignore ainsi que tous les arguments optionnels qui suivent, les
+remplaçant par leur valeur par défaut, et « sauvegarde » en tant que
+prochain argument obligatoire l'argument qui ne correspondait pas. Dans
+la mesure où l'argument sauvegardé doit servir, les argument optionnels
+ne sont en fait pas considérés comme optionnels, sauf à être suivis d'un
+argument obligatoire.
Une exception cependant à cette règle : le fait de donner un
@code{\default} en tant qu'argument optionnel aura pour résultat que cet
renvoyez toujours une valeur utile, et une fonction fantôme -- voir
@ref{Fonctions Scheme fantômes} -- dans le cas contraire.
+Pour des raisons de commodité, il est possible de faire appel à des
+fonctions Scheme directement en Scheme, courcircuitant ainsi l'analyseur
+de LilyPond. Leur nom s'utilise comme n'importe quel nom de fonction.
+Le contrôle de typologie des arguments et l'omission des arguments
+optionnels seront traîtés de la même manière que lorsque l'appel est
+fait à partir de LilyPond, la valeur Scheme @code{*unspecified*} ayant
+le rôle du mot réservé @code{\default} pour omettre explicitement les
+arguments optionnels.
+
@node Fonctions Scheme fantômes
@subsection Fonctions Scheme fantômes
@example
noPointAndClick =
#(define-void-function
- (parser location)
+ ()
()
(ly:set-option 'point-and-click #f))
@dots{}
@example
fonction =
#(define-music-function
- (parser location @var{arg1} @var{arg2}@dots{})
+ (@var{arg1} @var{arg2}@dots{})
(@var{type1?} @var{type2?}@dots{})
@var{corps})
@end example
@noindent
de manière similaire aux @ref{Définition de fonctions Scheme, fonctions
-Scheme}. La plupart du temps, le @code{corps} sera constitué d'un
-@ref{Blocs de code LilyPond, bloc de code Lilypond}.
+Scheme}. La plupart du temps, le @var{corps} sera constitué d'un
+@ref{Blocs de code LilyPond, bloc de code LilyPond}.
Les différents types des prédicat sont recensés à l'annexe
@ruser{Types de prédicats prédéfinis}.
Lorsqu'une fonction musicale -- contrairement à une fonction
événementielle -- renvoie une expression de type postévénement, LilyPond
requiert son introduction par un indicateur de positionnement -- à
-savoir @code{-}, @code{^} ou @code{_} -- de telle sorte que le
+savoir @code{-}, @code{^} ou @code{_} -- de telle sorte que le
postévénement produit par l'appel à cette fonction s'intègre
correctement dans l'expression environnante.
@example
manualBeam =
#(define-music-function
- (parser location beg-end)
+ (beg-end)
(pair?)
#@{
\once \override Beam.positions = #beg-end
@lilypond[quote,verbatim,ragged-right]
manualBeam =
#(define-music-function
- (parser location beg end)
+ (beg end)
(number? number?)
#{
\once \override Beam.positions = #(cons beg end)
@example
crossStaff =
-#(define-music-function (parser location notes) (ly:music?)
+#(define-music-function (notes) (ly:music?)
(_i "Create cross-staff stems")
#@{
\temporary \override Stem.cross-staff = #cross-staff-connect
@lilypond[quote,verbatim,ragged-right]
AltOn =
#(define-music-function
- (parser location mag)
+ (mag)
(number?)
#{
\override Stem.length = #(* 7.0 mag)
@lilypond[quote,verbatim,ragged-right]
withAlt =
#(define-music-function
- (parser location mag music)
+ (mag music)
(number? ly:music?)
#{
\override Stem.length = #(* 7.0 mag)
@example
displayBarNum =
#(define-music-function
- (parser location)
+ ()
()
(if (eq? #t (ly:get-option 'display-bar-numbers))
#@{ \once \override Score.BarNumber.break-visibility = ##f #@}
quelle nuance :
@lilypond[quote,verbatim,ragged-right]
-dyn=#(define-event-function (parser location arg) (markup?)
+dyn=#(define-event-function (arg) (markup?)
(make-dynamic-script arg))
\relative { c'\dyn pfsss }
@end lilypond
@lilypond[quote,verbatim]
desaturate =
#(define-music-function
- (parser location music) (ly:music?)
+ (music) (ly:music?)
#{
\applyContext
#(lambda (context)
La manière la plus souple d'affiner un objet consiste à utiliser la
commande @code{\applyOutput}. Celle-ci va insérer un événement
(@rinternals{ApplyOutputEvent}) dans le contexte spécifié. Elle répond
-à la syntaxe
+aussi bien à la syntaxe
@example
\applyOutput @var{Contexte} @var{procédure}
@end example
+que
+@example
+\applyOutput @var{Contexte}.@var{Grob} @var{procédure}
+@end example
@noindent
où @code{@var{procédure}} est une fonction Scheme à trois arguments.
Lors de l'interprétation de cette commande, la fonction
-@code{@var{procédure}} est appelée pout tout objet de rendu appartenant
-au contexte @code{@var{Contexte}} à cet instant précis, avec les
-arguments suivants :
+@code{@var{procédure}} est appelée pout tout objet de rendu (nommé
+@var{Grob} si celui-ci est spécifié) appartenant au contexte
+@code{@var{Contexte}} à cet instant précis, avec les arguments
+suivants :
@itemize
@item l'objet de rendu en lui-même,
@item le contexte au sein duquel cet objet est créé,
@lilypond[quote,verbatim,ragged-right]
#(define (blanker grob grob-origin context)
- (if (and (memq 'note-head-interface (ly:grob-interfaces grob))
- (< (abs (ly:grob-property grob 'staff-position)) 2))
+ (if (< (abs (ly:grob-property grob 'staff-position)) 2)
(set! (ly:grob-property grob 'transparent) #t)))
\relative {
- a'4 e8 <<\applyOutput #'Voice #blanker a c d>> b2
+ a'4 e8 <<\applyOutput Voice.NoteHead #blanker a c d>> b2
}
@end lilypond
-La @var{procédure} sera interprétée au niveau @code{Score}
-(partition) ou @code{Staff} (portée) dès lors que vous utiliserez l'une
-des syntaxes
+La @var{procédure} sera interprétée au niveau @code{Score} (partition)
+ou @code{Staff} (portée) dès lors que vous utiliserez l'une des syntaxes
@example
-\applyOutput #'Score #@var{procédure}
-\applyOutput #'Staff #@var{procédure}
+\applyOutput Score@dots{}
+\applyOutput Staff@dots{}
@end example
Une procédure Scheme peut aussi se charger de modifier des propriétés :
-@lilypond[fragment,verbatim,quote,relative=2]
+@lilypond[fragment,verbatim,quote]
\override Stem.thickness = #(lambda (grob)
(if (= UP (ly:grob-property grob 'direction))
2.0
7.0))
-c b a g b a g b
+\relative { c'' b a g b a g b }
@end lilypond
@noindent
projects / lilypond.git / blobdiff