@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: 324ff94afc62c7011b7377f24392f95391ed3b84
+ Translation of GIT committish: 5a6340b7f319802a7313c0e6b82eef96909cde42
When revising a translation, copy the HEAD committish of the
version that you are working on. For details, see the Contributors'
si ces valeurs par défaut ne peuvent être déterminées que plus tard,
mentionner une valeur spéciale que vous reconnaîtrez facilement.
Lorsque vous mentionnez un prédicat entre parenthèses sans toutefois
-fournir sa valeur par défaut, celle-ci sera considérée comme étant
-@code{#f}. Les valeurs par défaut d'un @code{prédicat?} ne sont
+fournir sa valeur par défaut, celle-ci sera considérée comme
+étant @code{#f}. Les valeurs par défaut d'un @code{prédicat?} ne sont
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
@noindent
La recevabilité des arguments est déterminée par un appel effectif au
-prédicat après que LilyPond les a déjà converti en expression Scheme.
+prédicat après que LilyPond les a déjà convertis en expression Scheme.
Par voie de conséquence, l'argument peut tout à fait se libeller en
syntaxe Scheme -- introduite par un @code{#} ou en tant que résultat
d'un appel à une fonction Scheme. Par ailleurs, LilyPond convertira en
Il existe certaines situations pour lesquelles LilyPond lèvera toute
ambiguïté grâce aux fonctions de prédicat : un @samp{-3} est-il un
-@emph{postévénement} de type doigté ou un nombre négatif@tie{}? Un
+@emph{postévénement} de type doigté ou un nombre négatif ? Un
@code{"a" 4} en mode paroles est-il une chaîne suivie d'un nombre ou
bien un événement syllabe de durée @code{4} ? LilyPond répondra à ces
questions par des interprétations successives du prédicat de l'argument,
permissifs tel que @code{Scheme?} lorsque l'application fait plutôt
appel à des type d'argument plus spécifiques.
-Les différents types des prédicat propres à LilyPond sont recensés à
+Les différents types de prédicat propres à LilyPond sont recensés à
l'annexe @ruser{Types de prédicats prédéfinis}.
@seealso
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
+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 @qq{sauvegarde} en tant que prochain argument
+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
Certaines commandes @code{\override} nécessitent un argument
supplémentaire constitué d'une paire de nombres, appelée @emph{cons
-cell} en Scheme -- que l'on pourrait traduire par @qq{construction de
-cellule}.
+cell} en Scheme -- que l'on pourrait traduire par « construction de
+cellule ».
Cette paire peut se mentionner directement dans la fonction musicale à
l'aide d'une variable @code{pair?} :
L'entretien des propriétés peut se voir comme un empilement par
propriété par objet par contexte. Les fonctions musicales peuvent
-nécessiter des dérogatoins pour une ou plusieurs propriétés pour la
+nécessiter des dérogations pour une ou plusieurs propriétés pour la
durée de la fonction, puis de revenir aux valeurs précédentes avant de
quitter. Néanmoins, une dérogation normale va retirer de la pile -- ou
dépiler -- et supprimer le sommet de la pile de la propriété avant
En d'autres termes, un @code{\revert} qui suit un @code{\temporary
\override} pour la même propriété n'apporte rien. Ce principe est aussi
-valable pour une couple @code{\temporary} et @code{\undo} sur la même
+valable pour un couple @code{\temporary} et @code{\undo} sur la même
musique contenant des dérogations.
Voici un exemple de fonction musicale utilisant cette fonctionnalité.
La présence du @code{\temporary} permet de s'assurer qu'en sortant de la
fonction, les propriétés @code{cross-staff} et @code{style} retrouveront
-les valeurs qu'elles avaient que ne soit appelée la fonction
+les valeurs qu'elles avaient avant que ne soit appelée la fonction
@code{crossStaff}. En l'absence de @code{\temporary}, ces propriétés
auraient retrouvé leurs valeurs par défaut à la sortie de la fonction.
@item @var{nom-commande}
le nom que vous attribuez à votre commande de @emph{markup}.
@item layout
-la définition du @qq{layout} -- son formatage.
+la définition du « layout » -- son formatage.
@item props
une liste de listes associatives, comprenant toutes les propriétés actives.
@item @var{argi}
Les arguments se distinguent selon leur type :
@itemize
@item un @emph{markup}, correspondant au type de prédicat
-@code{markup?}@tie{};
+@code{markup?} ;
@item une liste de @emph{markups}, correspondant au type de prédicat
-@code{markup-list?}@tie{};
+@code{markup-list?} ;
@item tout autre objet Scheme, correspondant au types de prédicat tels
que @code{list?}, @code{number?}, @code{boolean?}, etc.
@end itemize
@var{layout} et @var{props}. Ces arguments ne seront en principe connus
que bien plus tardivement dans le processus typographique. Lors de
l'expansion d'une expression LilyPond @code{\markup} ou d'une macro
-Scheme @code{macro}, les expressions @emph{markup} auront déjà vu leurs
+Scheme @code{markup}, les expressions @emph{markup} auront déjà vu leurs
composants assemblés en expressions @emph{markup}. L'évaluation et le
contrôle du type des arguments à une commande de @emph{markup}
n'interviennent qu'au moment de l'interprétation de @code{\markup} ou
Les arguments @code{layout} et @code{props} d'une commande de
@emph{markup} fournissent un contexte à l'interprétation du
-@emph{markup} : taille de fonte, longueur de ligne etc.
+@emph{markup} : taille de fonte, longueur de ligne, etc.
L'argument @code{layout} permet d'accéder aux propriétés définies dans
les blocs @code{\paper}, grâce à la fonction
d'un @emph{markup} de titre d'ouvrage : toutes les variables
définies dans le bloc @code{\header} sont automatiquement ajoutées aux
@code{props}, de telle sorte que le @emph{markup} de titrage de
-l'ouvrage pourra accéder aux différents champs titre, compositeur etc.
+l'ouvrage pourra accéder aux différents champs titre, compositeur, etc.
Ceci permet aussi de configurer le comportement d'une commande de
@emph{markup} : la taille des fontes, par exemple, est lue à
partir de @code{props} plutôt que grâce à un argument @code{font-size}.
@end example
Il serait intéressant de rendre cette commande @code{double-box} plus
-souple@tie{}: les valeurs de @code{box-padding} sont figées et ne
+souple : les valeurs de @code{box-padding} sont figées et ne
peuvent être modifiées à l'envie. Pareillement, il serait bien de
distinguer l'espacement entre les encadrements de l'espacement entre le
texte et ses encadrements. Nous allons donc introduire une propriété
C'est ici le mot-clé @code{#:properties} qui permet de lire les
propriétés @code{inter-box-padding} et @code{box-padding} à partir de
-l'argumenet @code{props}@tie{}; on leur a d'ailleurs fourni des valeurs
+l'argumenet @code{props} ; on leur a d'ailleurs fourni des valeurs
par défaut au cas où elles ne seraient pas définies.
Ces valeurs permettront alors d'adapter les propriétés de
@subsection Définition d'une nouvelle commande de liste de @emph{markups}
@translationof New markup list command definition
+@cindex liste de markup, définition de commande
@funindex define-markup-list-command
@funindex interpret-markup-list
Une commande traitant une liste de @emph{markups} se définit à l'aide de
la macro Scheme @code{define-markup-list-command}, de manière analogue à
la macro @code{define-markup-command} abordée à la rubrique
-@ref{Définition d'une nouvelle commande de markup} à ceci près que cette
-dernière renvoie un seul stencil, non une liste de stencils.
+@ref{Définition d'une nouvelle commande de markup}, à ceci près que
+cette dernière renvoie un seul stencil, non une liste de stencils.
La fonction @code{interpret-markup-list}, à l'instar de la fonction
@code{interpret-markup}, permet de convertir une liste de @emph{markups}
En dehors des habituels arguments @code{layout} et @code{props}, la
commande de liste de @emph{markups} @code{paragraph} prend en argument
-une liste de @emph{markups} appelé @code{args}. Le prédicat des listes
+une liste de @emph{markups} appelée @code{args}. Le prédicat des listes
de @emph{markups} est @code{markup-list?}.
Pour commencer, la fonction récupère la taille de l'alinéa, propriété
Voici comment utiliser cette nouvelle commande de liste de
@emph{markups} :
+
@example
\markuplist @{
\paragraph @{
recherche la valeur d'une propriété de @emph{grob},
@item ly:context-pushpop-property
-réalise un @code{\temporary@tie{}\override} ou un @code{\revert} sur une
+réalise un @code{\temporary \override} ou un @code{\revert} sur une
propriété de @emph{grob}.
@end table
Ceci pourrait tout à fait s'implémenter sous la forme d'une fonction
musicale, afin d'en réduire les effets à un seul bloc de musique. Notez
comment @code{ly:context-pushpop-property} est utilisé à la fois pour un
-@code{\temporary@tie{}\override} et pour un @code{\revert} :
+@code{\temporary \override} et pour un @code{\revert} :
@lilypond[quote,verbatim]
desaturate =
@translationof Running a function on all layout objects
@cindex appel de code sur des objets de mise en forme
+@cindex objets de mise en forme, appel de code
@funindex \applyOutput
La manière la plus souple d'affiner un objet consiste à utiliser la
@itemize
@item l'objet de rendu en lui-même,
@item le contexte au sein duquel cet objet est créé,
-@item et le contexte dans lequel @code{\applyOutput} est effectué.
+@item le contexte dans lequel @code{\applyOutput} est effectué.
@end itemize
De plus, ce qui est à l'origine de l'objet de rendu -- l'expression
@rinternals{NoteHead}, et d'un objet @rinternals{Stem} pour une hampe.
Voici une fonction utilisable avec la commande
-@code{\applyOutput} : elle @qq{blanchit} la tête des notes se
-trouvant sur la ligne médiane ou bien directement à son contact.
+@code{\applyOutput} : elle « blanchit » la tête des notes se trouvant
+sur la ligne médiane ou bien directement à son contact.
@lilypond[quote,verbatim,ragged-right]
#(define (blanker grob grob-origin context)
Certaines propriétés, entre autres @code{thickness} ou @code{direction},
peuvent voir leur valeur figée à l'aide d'un @code{\override} comme
-ici@tie{}:
+ici :
@example
\override Stem.thickness = #2.0
@end example
-Une procédure Scheme peut aussi se charger de modifier des
-propriétés@tie{}:
+Une procédure Scheme peut aussi se charger de modifier des propriétés :
@lilypond[fragment,verbatim,quote,relative=2]
\override Stem.thickness = #(lambda (grob)
@end example
@noindent
-Ici les propriétés @code{tweak} de l'objet flageolet nommé
-@samp{m} (créé au moyen de @code{make-music}) sont extraites par
+Ici les propriétés @code{tweak} de l'objet flageolet nommé @samp{m}
+(créé au moyen de @code{make-music}) sont extraites par
@code{ly:music-property}, une nouvelle valeur de la taille de fonte
est ajoutée à la liste de ses propriétés (grâce à la fonction Scheme
@code{acons}), et le résultat de cette opération est renvoyé par
@itemize
@item
-L'un d'entre eux est l'apparence des objets dits @qq{extenseurs}
+L'un d'entre eux est l'apparence des objets dits « extenseurs »
(@emph{spanner}), qui s'étendent horizontalement, tels que les liaisons.
Si, en principe, un seul de ces objets est créé à la fois et peut donc
être modifié de façon habituelle, lorsque ces objets doivent enjamber un
@item
détermine si l'objet a été divisé à l'occasion d'un changement de ligne
@item
-dans l'affirmative, recherche les différents morceaux de l'objet
+dans l'affirmative, recherche les différents tronçons de l'objet
@item
vérifie si l'objet considéré est bien la deuxième moitié d'un objet
divisé
@end itemize
On ajoute cette procédure à l'objet @rinternals{Tie} (liaison de tenue),
-de façon à ce que le deuxième morceau d'une liaison divisée soit
+de façon à ce que le deuxième tronçon d'une liaison divisée soit
rehaussé.
@c KEEP LY
;; l'objet a-t-il été divisé ?
(orig (ly:grob-original grob))
- ;; si oui, rechercher les morceaux frères (siblings)
+ ;; si oui, rechercher les tronçons frères (siblings)
(siblings (if (ly:grob? orig)
(ly:spanner-broken-into orig)
'())))
modifiés par @code{\override}. Parmi ceux-là, les objets
@code{NonMusicalPaperColumn} et @code{PaperColumn}. La commande
@code{\overrideProperty} sert à les modifier, de façon similaire à
-@code{\once \override} mais avec une syntaxe différente :
+@code{\once \override}, mais avec une syntaxe différente :
@example
\overrideProperty
@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: ec074a41f03cf4cd3b914daa1359dd6e0fb2012d
+ Translation of GIT committish: 5a6340b7f319802a7313c0e6b82eef96909cde42
When revising a translation, copy the HEAD committish of the
version that you are working on. For details, see the Contributors'
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.
@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}.
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.
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
@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 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.
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é
+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.
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
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
é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.
@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.
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
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}.
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'
@end example
La hauteur de la note se modifie en définissant sa propriété
-@code{'pitch}@tie{}:
+@code{'pitch} :
@funindex \displayLilyMusic
@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 :
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)
projects / lilypond.git / commitdiff