@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: ea78e54687b8beb80958e55bcd3ddfbe90ab5967
+ Translation of GIT committish: e8c4826ed3fca952984600bcce60b53e76aff5d2
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.16.0"
+@c \version "2.19.22"
@c Translators: Jean-Charles Malahieude
vous rendre sur @uref{http://@/www@/.schemers@/.org}.
Le Scheme utilisé par LilyPond repose sur l'implémentation GNU
-Guile ; celle-ci se base sur le standard Scheme @qq{R5RS}. Si
+Guile ; celle-ci se base sur le standard Scheme « R5RS ». Si
votre but est d'apprendre Scheme au travers de LilyPond, sachez que
l'utilisation d'une autre implémentation ou d'un autre standard pourrait
être source de désagrément. Vous trouverez plus d'information sur
-GUILE à la page @uref{http://www.gnu.org/software/guile/} ; le
-standard Scheme @qq{R5RS} est quant à lui disponible à la page
+Guile à la page @uref{http://www.gnu.org/software/guile/} ; le
+standard Scheme « R5RS » est quant à lui disponible à la page
@uref{http://www.schemers.org/Documents/Standards/R5RS/}.
@menu
@translationof Introduction to Scheme
Nous commencerons par nous intéresser à Scheme et à son fonctionnement,
-grâce à l'interpréteur GUILE. Une fois plus à l'aise avec Scheme, nous
+grâce à l'interpréteur Guile. Une fois plus à l'aise avec Scheme, nous
verrons comment ce langage peut s'intégrer à un fichier LilyPond.
@menu
@subsection Le bac à sable de Scheme
@translationof Scheme sandbox
-L'installation de LilyPond comprend l'implémentation GUILE de Scheme.
-La plupart des systèmes disposent d'un @qq{bac à sable} Scheme pour
-effectuer des tests ; vous y accéderez en tapant @qq{guile} dans
+L'installation de LilyPond comprend l'implémentation Guile de Scheme.
+La plupart des systèmes disposent d'un « bac à sable » Scheme pour
+effectuer des tests ; vous y accéderez en tapant @code{guile} dans
un terminal. Certains systèmes, notamment Windows, nécessitent d'avoir
auparavant créé la variable d'environnement @code{GUILE_LOAD_PATH} qui
devra pointer vers le répertoire @code{../usr/share/guile/1.8} de
l'installation de LilyPond -- pour connaître le chemin complet d'accès à
ce répertoire, consultez @rlearning{Autres sources de documentation}.
-Les utilisateurs de Windows peuvent aussi prendre l'option @qq{Exécuter}
-à partir du menu @qq{Démarrer} puis taper @qq{guile}.
+Les utilisateurs de Windows peuvent aussi prendre l'option « Exécuter »
+à partir du menu « Démarrer » puis taper @code{guile}.
Néanmoins, tous les paquetages de LilyPond disposent d'un bac à sable
Scheme, accessible par la commande :
Vous aurez remarqué que la valeur @code{2} et l'invite @code{guile}
apparaissent sur une même ligne. On peut améliorer la présentation à
l'aide de la procédure @code{newline} ou bien en affichant un caractère
-@qq{retour chariot}.
+« retour chariot ».
@lisp
guile> (display a)(newline)
@translationof Scheme simple data types
L'un des concepts de base de tout langage est la saisie de données,
-qu'il s'agisse de nombres, de chaînes de caractères, de listes etc.
+qu'il s'agisse de nombres, de chaînes de caractères, de listes, etc.
Voici les différents types de données Scheme simples utilisées
couramment dans LilyPond.
utilise beaucoup les paires, listes, listes associatives et tables de
hachage.
-@subheading Paires
+@menu
+* Paires::
+* Listes::
+* Listes associatives (alists)::
+* Tables de hachage::
+@end menu
+
+
+@node Paires
+@unnumberedsubsubsec Paires
+@translationof Pairs
Le type de donnée composite fondamental est la paire (@code{pair}).
Comme son nom l'indique, il s'agit de lier deux valeurs, à l'aide de
@lisp
guile> (define mypair (cons 123 "hello there")
-... )
+@dots{} )
guile> (car mypair)
123
guile> (cdr mypair)
@noindent
-Note : @code{cdr} se prononce @qq{couldeur}, comme l'indiquent Sussman et
+Note : @code{cdr} se prononce « couldeur », comme l'indiquent Sussman et
Abelson -- voir
@uref{http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-14.html#footnote_Temp_133}.
-@subheading Listes
+@node Listes
+@unnumberedsubsubsec Listes
+@translationof Lists
Autre structure de donnée commune en Scheme : la liste (@emph{list}).
-Une liste se définit comme étant vide (représentée par @code{'()}) ou
-une paire dont le @code{cdr} est une liste.
+Une liste « correcte » se définit comme étant vide (représentée par
+@code{'()} et de longueur 0) ou une paire dont le @code{cdr} est une
+liste.
Il existe plusieurs méthodes pour créer une liste, la plus courante
étant l'utilisation de la procédure @code{list} :
Les listes ont une importance considérable en Scheme. Certains vont
d'ailleurs jusqu'à considérer Scheme comme un dialecte du lisp, où
-@qq{lisp} serait une abréviation de @qq{List Processing}. Il est vrai
+« lisp » serait une abréviation de « List Processing ». Il est vrai
que toute expression Scheme est une liste.
-@subheading Listes associatives (alists)
+@node Listes associatives (alists)
+@unnumberedsubsubsec Listes associatives (alists)
+@translationof Association lists (alists)
Il existe un type particulier de liste : la @emph{liste associative} --
ou @emph{alist}. Une @emph{alist} permet de stocker des données dans le
propriétés ou autres données.
-@subheading Tables de hachage
+@node Tables de hachage
+@unnumberedsubsubsec Tables de hachage
+@translationof Hash tables
Il s'agit d'une structure de données à laquelle LilyPond fait parfois
appel. Une table de hachage (@emph{hash table}) peut se comparer à une
guile>
@end lisp
+
@node Scheme et les calculs
@subsection Scheme et les calculs
@translationof Calculations in Scheme
Vous pouvez constater que l'interpréteur a tenté de considérer @code{1}
comme étant un opérateur ou une procédure, ce qu'il n'a pu réaliser. Il
-a donc renvoyé l'erreur @qq{Wrong type to apply: 1} (@emph{Application
+a donc renvoyé l'erreur « Wrong type to apply: 1 » (@emph{Application
d'un type erroné : 1}).
C'est pourquoi il est impératif, pour créer une liste, soit d'utiliser
issue de son exécution. Les procédures Scheme sont capables de
manipuler des variables qui ne sont pas définies en leur sein.
+@menu
+* Définition de procédures::
+* Prédicats::
+* Valeurs de retour::
+@end menu
+
-@subheading Définition de procédures
+@node Définition de procédures
+@unnumberedsubsubsec Définition de procédures
+@translationof Defining procedures
En Scheme, on définit une procédure à l'aide de l'instruction
@code{define} :
@example
-(define (nom-fonction argument1 argument2 ... argumentn)
+(define (nom-fonction argument1 argument2@dots{} argumentn)
expression-scheme-qui-donnera-une-valeur-en-retour)
@end example
@end lisp
-@subheading Prédicats
+@node Prédicats
+@unnumberedsubsubsec Prédicats
+@translationof Predicates
Une procédure Scheme chargée de retourner une valeur booléenne s'appelle
-un @qq{prédicat} (@emph{predicate}). Par convention, plutôt que par
+un « prédicat » (@emph{predicate}). Par convention, plutôt que par
nécessité, le nom d'un prédicat se termine par un point
d'interrogation :
@end lisp
-@subheading Valeurs de retour
+@node Valeurs de retour
+@unnumberedsubsubsec Valeurs de retour
+@translationof Return values
Une procédure Scheme doit toujours renvoyer une valeur de retour, en
l'occurrence la valeur de la dernière expression exécutée par cette
@lisp
guile> (let ((x 2) (y 3) (z 4)) (display (+ x y)) (display (- z 4))
-... (+ (* x y) (/ z x)))
+@dots{} (+ (* x y) (/ z x)))
508
@end lisp
@subsection Scheme et les conditions
@translationof Scheme conditionals
-@subheading if
+@menu
+* if::
+* cond::
+@end menu
+
+
+@node if
+@unnumberedsubsubsec if
+@translationof if
Scheme dispose d'une procédure @code{if} :
@end example
@var{expression-test} est une expression qui renverra une valeur
-booléenne. Dans le cas où @var{expression-test} retourne @code{#t}, la
+booléenne. Dans le cas où @var{expression-test} retourne @code{#t}, la
procédure @code{if} renvoie la valeur de @var{expression-affirmative},
et celle de @var{expression-négative} dans le cas contraire.
@end lisp
-@subheading cond
+@node cond
+@unnumberedsubsubsec cond
+@translationof cond
Une autre manière d'introduire une condition en Scheme est d'utiliser
l'instruction @code{cond} :
@example
(cond (expression-test-1 expression-résultat-séquence-1)
(expression-test-2 expression-résultat-séquence-2)
- ...
+ @dots{}
(expression-test-n expression-résultat-séquence-n))
@end example
guile> (define a 6)
guile> (define b 8)
guile> (cond ((< a b) "a est plus petit que b")
-... ((= a b) "a égale b")
-... ((> a b) "a est plus grand que b"))
+@dots{} ((= a b) "a égale b")
+@dots{} ((> a b) "a est plus grand que b"))
"a est plus petit que b"
@end lisp
expressions, tout comme le langage humain est structuré en mots et
phrases. LilyPond dispose d'un analyseur lexical (appelé @emph{lexer})
qui sait identifier les jetons -- nombres, chaînes, éléments Scheme,
-hauteurs etc. -- ainsi que d'un analyseur syntaxique (appelé
-@emph{parser}) -- voir l'annexe @ruser{Grammaire de LilyPond}. Dès lors
+hauteurs, etc. -- ainsi que d'un analyseur syntaxique (appelé
+@emph{parser}) -- voir
+@rcontribnamed{LilyPond grammar, Grammaire de LilyPond}. Dès lors
que le programme sait quelle règle grammaticale particulière doit
s'appliquer, il exécute les consignes qui lui sont associées.
Le recours à un @emph{hash} pour mettre en exergue du Scheme est tout à
-fait approprié. Dès qu'il rencontre un @code{#}, l'analyseur lexical
+fait approprié. Dès qu'il rencontre un @code{#}, l'analyseur lexical
passe le relais au lecteur Scheme qui va alors déchiffrer l'intégralité
de l'expression Scheme -- ce peut être un identificateur, une expression
bornée par des parenthèses ou bien d'autres choses encore. Une fois
@funindex #@@
Les opérateurs @code{$@@} et @code{#@@} agissent comme des « colleurs de
-liste » : leur fonction consiste à insérer tous les éléments d'un liste
+liste » : leur fonction consiste à insérer tous les éléments d'une liste
dans le contexte environnant.
Examinons à présent du vrai code Scheme. Nous pouvons définir des
@end example
Pour mémoire, vous noterez que les commentaires LilyPond (@code{%} ou
-@code{%@{ %@}}) ne peuvent s'utiliser dans du code Scheme, même si
+@code{%@{…%@}}) ne peuvent s'utiliser dans du code Scheme, même si
celui-ci se trouve au sein d'un fichier LilyPond. Ceci tient au fait
que l'expression Scheme est lue par l'interpréteur Guile, et en aucune
façon par l'analyseur lexical de LilyPond. Voici comment introduire des
internes de LilyPond y compris les expressions musicales, aura pour
effet d'en recopier la valeur, les fonctions musicales n'ont pas pour
habitude de créer une copie du matériau qu'elles vont modifier. De
-fait, une expression musicale introduite par @code{#} ne devrait pas
+fait, une expression musicale introduite par @code{#} ne devrait pas
contenir de matériau inexistant auparavant ou bien littéralement
recopié, mais plutôt une référence explicite.
est convertie, en interne, en une définition Scheme :
@example
-(define traLaLa @var{valeur Scheme de `@code{... }'})
+(define traLaLa @var{valeur Scheme de `@code{@dots{}}'})
@end example
Cela signifie que variables LilyPond et variables Scheme peuvent tout à
Cet exemple est particulièrement intéressant. L'assignation
n'interviendra qu'une fois que l'analyseur grammatical aura l'assurance
que rien du type de @code{\addlyrics} ne suit ; il doit donc
-vérifier ce qui vient après. Le @emph{parser} lit le @code{#} et
+vérifier ce qui vient après. Le @emph{parser} lit le @code{#} et
l'expression Scheme qui le suit @strong{sans} l'évaluer, de telle sorte
qu'il peut procéder à l'assignation, et @strong{ensuite} exécuter le
code Scheme sans problème.
@funindex $
@funindex #
-L'exemple précédent illustre la manière @qq{d'exporter} une expression
+L'exemple précédent illustre la manière « d'exporter » une expression
musicale à partir des saisies et à destination de l'interpréteur Scheme.
L'inverse est aussi réalisable : en la plaçant derrière un @code{$}, une
valeur Scheme sera interprétée comme si elle avait été saisie en
aussi bien pu écrire
@example
-...
+@dots{}
$(make-sequential-music (list newLa))
@end example
dernière partie de notre fonction pourrait s'écrire ainsi :
@example
-...
+@dots{}
@{ #@@newLa @}
@end example
#(define (nopc)
(ly:set-option 'point-and-click #f))
-...
+@dots{}
#(nopc)
@{ c'4 @}
@end example
La modification d'une valeur pour une propriété donnée requiert
l'assignation d'une valeur de la liste associative, tant pour la clé que
-la valeur associée. Voici comment procéder selon la syntaxe de
+pour la valeur associée. Voici comment procéder selon la syntaxe de
LilyPond :
@example
-\override Stem #'thickness = #2.6
+\override Stem.thickness = #2.6
@end example
Cette instruction ajuste l'apparence des hampes. Une entrée
épaisseur normale. Afin de faire la distinction entre les variables que
vous définissez au fil de vos fichiers -- tel le @code{vingtQuatre} que
nous avons vu plus haut -- et les variables internes des objets, nous
-parlerons de @qq{propriétés} pour ces dernières, et de @qq{variables}
+parlerons de « propriétés » pour ces dernières, et de « variables »
pour les autres. Ainsi, l'objet hampe possède une propriété
@code{thickness}, alors que @code{vingtQuatre} est une variable.
@subsection Variables LilyPond composites
@translationof LilyPond compound variables
-@subheading Décalages (@emph{offsets})
+@menu
+* Décalages (offsets)::
+* Fractions::
+* Étendues (extents)::
+* Propriété en alists::
+* Chaînes d'alist::
+@end menu
+
+
+@node Décalages (offsets)
+@unnumberedsubsubsec Décalages (@emph{offsets})
+@translationof Offsets
Les décalages (@emph{offset}) sur deux axes (coordonnées X et Y) sont
stockés sous forme de @emph{paires}. Le @code{car} de l'offset
(coordonnée Y).
@example
-\override TextScript #'extra-offset = #'(1 . 2)
+\override TextScript.extra-offset = #'(1 . 2)
@end example
Cette clause affecte la paire @code{(1 . 2)} à la propriété
le fichier @file{scm/lily-library.scm}.
-@subheading Fractions
+@node Fractions
+@unnumberedsubsubsec Fractions
+@translationof Fractions
-Les fractions, tel que LilyPond les utilise, sont aussi stockées sous
+Les fractions, telles que LilyPond les utilise, sont aussi stockées sous
forme de @emph{paire}. Alors que Scheme est tout à fait capable de
représenter des nombres rationnels, vous conviendrez que, musicalement
parlant, @samp{2/4} et @samp{1/2} ne se valent pas ; nous devrons
donc pouvoir les distinguer. Dans le même ordre d'idée, LilyPond ne
-connaît pas les @qq{fractions} négatives. Pour ces raisons, @code{2/4}
+connaît pas les « fractions » négatives. Pour ces raisons, @code{2/4}
en LilyPond correspond à @code{(2 . 4)} en Scheme, et @code{#2/4} en
LilyPond correspond à @code{1/2} en Scheme.
-@subheading Étendues (@emph{extents})
+@node Étendues (extents)
+@unnumberedsubsubsec Étendues (@emph{extents})
+@translationof Extents
Les paires permettent aussi de stocker des intervalles qui représentent
un ensemble de nombres compris entre un minimum (le @code{car}) et un
maximum (le @code{cdr}). Ces intervalles stockent l'étendue, tant au
-niveau horizontal (X) que vertical (Y) des objets imprimables. En
+niveau horizontal (X) que vertical (Y) des objets imprimables. En
matière d'étendue sur les X, le @code{car} correspond à la coordonnée de
l'extrémité gauche, et le @code{cdr} à la coordonnée de l'extrémité
droite. En matière d'étendue sur les Y, le @code{car} correspond à la
d'assurer la cohérence du code.
-@subheading Propriété en @emph{alists}
+@node Propriété en alists
+@unnumberedsubsubsec Propriété en @emph{alists}
+@translationof Property alists
Les propriétés en @emph{alists} sont des structures de données
particulières à LilyPond. Il s'agit de listes associatives dont les
@code{'thickness}.
-@subheading Chaînes d'@emph{alist}
+@node Chaînes d'alist
+@unnumberedsubsubsec Chaînes d'@emph{alist}
+@translationof Alist chains
Une chaîne d'@emph{alist} est une liste contenant les listes
associatives d'une propriété.
Un objet musical dispose de trois types :
@itemize
@item
-un nom de musique : Toute expression musicale a un nom. Par exemple,
+un nom de musique : toute expression musicale a un nom. Par exemple,
une note amène à un @rinternals{NoteEvent}, un @code{\simultaneous} à un
@rinternals{SimultaneousMusic}. Une liste exhaustive des différentes
expressions est disponible dans la référence des propriétés internes, à
la rubrique @rinternals{Music expressions}.
@item
-un @qq{type} ou interface : Tout nom de musique dispose de
+un « type » ou interface : tout nom de musique dispose de
plusieurs types ou interfaces. Ainsi, une note est tout à la fois un
@code{event}, un @code{note-event}, un @code{rhythmic-event} et un
@code{melodic-event}. Les différentes classes musicales sont
des propriétés internes.
@item
-un objet C++ : Tout objet musical est représenté par un objet de la
+un objet C++ : tout objet musical est représenté par un objet de la
classe C++ @code{Music}.
@end itemize
Une expression composite est un objet musical dont les propriétés
contiennent d'autres objets musicaux. S'il s'agit d'une liste d'objets,
elle sera stockée dans la propriété @code{elements} d'un objet
-musical ; s'il n'y a qu'un seul objet @qq{enfant}, il sera stocké
+musical ; s'il n'y a qu'un seul objet « enfant », il sera stocké
dans la propriété @code{element}. Ainsi, par exemple, les enfants de
@rinternals{SequentialMusic} iront dans @code{elements}, alors que
l'argument unique de @rinternals{GraceMusic} ira dans @code{element}.
'text
"f"))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))))
@end example
Par défaut, LilyPond affichera ces messages sur la console, parmi toutes
les autres informations. Vous pouvez, afin de les isoler et de garder
-le résultat des commandes @code{\display@{TRUC@}}, rediriger la sortie
-vers un fichier :
+le résultat des commandes @code{\display@{TRUC@}}, spécifier un
+port optionnel à utiliser pour la sortie :
@example
-lilypond file.ly >display.txt
+@{
+ \displayMusic #(open-output-file "display.txt") @{ c'4\f @}
+@}
@end example
-Un peu de Scheme combiné à notre code LilyPond, et les seules
-informations qui nous intéressent se retrouveront directement dans un
-fichier indépendant :
+Ceci aura pour effet d'écraser tout fichier précédemment généré.
+Lorsque plusieurs expressions doivent être retranscrites, il suffit de
+faire appel à une variable pour le port puis de la réutiliser :
@example
@{
- #(with-output-to-file "display.txt"
- (lambda () #@{ \displayMusic @{ c'4\f @} #@}))
+ port = #(open-output-file "display.txt")
+ \displayMusic \port @{ c'4\f @}
+ \displayMusic \port @{ d'4 @}
+ #(close-output-port port)
@}
@end example
+La documentation de Guile fournit une description détaillée des ports.
+Clôturer un port n'est requis que si vous désirez consulter le fichier
+avant que LilyPond n'ait fini, ce dont nous ne nous sommes pas préoccupé
+dans le premier exemple.
+
L'information sera encore plus lisible après un peu de mise en forme :
@example
(make-music 'AbsoluteDynamicEvent
'text
"f"))
- 'duration (ly:make-duration 2 0 1 1)
+ 'duration (ly:make-duration 2 0 1/1)
'pitch (ly:make-pitch 0 0 0))))
@end example
-Une séquence musicale @code{@{ ... @}} se voit attribuer le nom de
+Une séquence musicale @code{@{ @dots{} @}} se voit attribuer le nom de
@code{SequentialMusic}, et les expressions qu'elle contient sont
enregistrées en tant que liste dans sa propriété @code{'elements}. Une
note est représentée par un objet @code{NoteEvent} -- contenant les
Nous abordons ici les propriétés @emph{music}, et non pas les propriétés
@emph{context} ou @emph{layout}.
-Partons de cet exemple simple@tie{}:
+Partons de cet exemple simple :
@example
someNote = c'
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))
@end example
(list (make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))))
@end example
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 0 0))
@end example
@end example
La hauteur de la note se modifie en définissant sa propriété
-@code{'pitch}@tie{}:
+@code{'pitch} :
@funindex \displayLilyMusic
(ly:make-pitch 0 1 0)) ;; set the pitch to d'.
\displayLilyMusic \someNote
===>
-d'
+d'4
@end example
'span-direction
-1))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))
(make-music
'span-direction
1))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))))
@end example
Mauvaise nouvelle ! Les expressions @code{SlurEvent} doivent
-s'ajouter @qq{à l'intérieur} de la note -- dans sa propriété
+s'ajouter « à l'intérieur » de la note -- dans sa propriété
@code{articulations}.
Examinons à présent la saisie :
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch 0 5 0))))
@end example
-- de telle sorte que les deux notes constituent la séquence -- puis
d'ajouter un @code{SlurEvent} à la propriété @code{'articulations} de
chacune d'elles, et enfin réaliser un @code{SequentialMusic} de ces deux
-@code{EventChords}. En tenant compte du fait que, dans le cadre d'un
-ajout, une propriété non définie est lue @code{'()} (une liste vide),
-aucune vérification n'est requise avant d'introduire un nouvel élément
-en tête de la propriété @code{articulations}.
+éléments @code{NoteEvent}. En tenant compte du fait que, dans le cadre
+d'un ajout, une propriété non définie est lue @code{'()} (une liste
+vide), aucune vérification n'est requise avant d'introduire un nouvel
+élément en tête de la propriété @code{articulations}.
@example
-doubleSlur = #(define-music-function (parser location note) (ly:music?)
+doubleSlur = #(define-music-function (note) (ly:music?)
"Renvoie : @{ note ( note ) @}.
`note' est censé être une note unique."
(let ((note2 (ly:music-deep-copy note)))
@translationof Adding articulation to notes (example)
Le moyen d'ajouter une articulation à des notes consiste à fusionner
-deux expressions musicales en un même contexte, comme nous l'avons vu à
-la rubrique @ruser{Création d'un contexte}. L'option de réaliser
+deux expressions musicales en un même contexte. L'option de réaliser
nous-mêmes une fonction musicale à cette fin nous offre l'avantage de
pouvoir alors ajouter une articulation, telle qu'une instruction de
doigté, individuellement à l'une des notes d'un accord, ce qui est
impossible dans le cadre d'une simple fusion de musique indépendante.
-Un @code{$variable} au milieu de la notation @code{#@{...#@}} se
+Un @code{$variable} au milieu de la notation @code{#@{ @dots{} #@}} se
comporte exactement comme un banal @code{\variable} en notation LilyPond
traditionnelle. Nous savons déjà que
(make-music
'NoteEvent
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch -1 0 0))))
=====
'articulation-type
"accent"))
'duration
- (ly:make-duration 2 0 1 1)
+ (ly:make-duration 2 0 1/1)
'pitch
(ly:make-pitch -1 0 0))
@end example
excellente pratique que l'on retrouve dans de nombreux autres langages.
@example
-"Ajoute un accent..."
+"Ajoute un accent@dots{}"
@end example
@noindent
répétitions se devait d'être une copie. Dans le cas contraire,
certaines bizarreries auraient pu survenir. Par exemple, la présence
d'un @code{\relative} ou d'un @code{\transpose}, après plusieurs
-répétitions du même élément, entraînerait des @qq{relativisations} ou
+répétitions du même élément, entraînerait des « relativisations » ou
transpositions en cascade. Si nous les assignons à une variable
musicale, l'enchaînement est rompu puisque la référence à @samp{\nom}
créera une nouvelle copie sans toutefois prendre en considération
lecture des fonctions propres à LilyPond, comme @code{music-map}, que ce
principe est toujours respecté.
-Revenons à nos moutons@dots{} Nous disposons maintenant d'un
-@code{note-event} que nous pouvons modifier, non pas grâce à un
-@code{ly:music-deep-copy}, mais plutôt en raison de notre précédente
-réflexion. Nous ajoutons @notation{l'accent} à la liste de ses
-propriétés @code{'articulations}.
+Revenons à nos moutons… Nous disposons maintenant d'un @code{note-event}
+que nous pouvons modifier, non pas grâce à un @code{ly:music-deep-copy},
+mais plutôt en raison de notre précédente réflexion. Nous ajoutons
+@notation{l'accent} à la liste de ses propriétés @code{'articulations}.
@example
(set! emplacement nouvelle-valeur)
@end example
La fonction @code{ly:music-property} permet d'accéder aux propriétés
-musicales -- les @code{'articulations}, @code{'duration}, @code{'pitch}
+musicales -- les @code{'articulations}, @code{'duration}, @code{'pitch},
etc. que @code{\displayMusic} nous a indiquées. La nouvelle valeur sera
l'ancienne propriété @code{'articulations}, augmentée d'un
élément : l'expression @code{ArticulationEvent}, que nous
Nous pouvons à présent transformer la fonction @code{ajoute-accent} en
fonction musicale, à l'aide d'un peu d'enrobage syntaxique et mention du
-type de son unique argument @qq{réel}.
+type de son unique argument « réel ».
@example
-ajouteAccent = #(define-music-function (parser location note-event)
+ajouteAccent = #(define-music-function (note-event)
(ly:music?)
"Ajoute un accent (ArticulationEvent) aux articulations de `note-event',
qui est censé être une expression NoteEvent."
We have seen how LilyPond output can be heavily modified using
commands like
-@code{\override TextScript #'extra-offset = ( 1 . -1)}. But
+@code{\override TextScript.extra-offset = ( 1 . -1)}. But
we have even more power if we use Scheme. For a full explanation
of this, see the @ref{Scheme tutorial}, and
@ref{Interfaces for programmers}.
@ignore
@lilypond[quote,verbatim,ragged-right]
-padText = #(define-music-function (parser location padding) (number?)
+padText = #(define-music-function (padding) (number?)
#{
- \once \override TextScript #'padding = #padding
+ \once \override TextScript.padding = #padding
#})
-\relative c''' {
- c4^"piu mosso" b a b
+\relative {
+ c'''4^"piu mosso" b a b
\padText #1.8
c4^"piu mosso" d e f
\padText #2.6
@lilypond[quote,verbatim,ragged-right]
-tempoPadded = #(define-music-function (parser location padding tempotext)
+tempoPadded = #(define-music-function (padding tempotext)
(number? markup?)
#{
- \once \override Score.MetronomeMark #'padding = #padding
+ \once \override Score.MetronomeMark.padding = #padding
\tempo \markup { \bold #tempotext }
#})
-\relative c'' {
+\relative {
\tempo \markup { "Low tempo" }
- c4 d e f g1
+ c''4 d e f g1
\tempoPadded #4.0 "High tempo"
g4 f e d c1
}
Even music expressions can be passed in:
@lilypond[quote,verbatim,ragged-right]
-pattern = #(define-music-function (parser location x y) (ly:music? ly:music?)
+pattern = #(define-music-function (x y) (ly:music? ly:music?)
#{
#x e8 a b $y b a e
#})
projects / lilypond.git / blobdiff