@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@ignore
- Translation of GIT committish: 324ff94afc62c7011b7377f24392f95391ed3b84
+ 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.12"
+@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}}
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
-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
@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
@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 @qq{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.
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?} :
@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)
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.
@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)
\revert NoteHead.font-size
}
-\relative c' {
- c2 \AltOn #0.5 c4 c
+\relative {
+ c'2 \AltOn #0.5 c4 c
\AltOn #1.5 c c \AltOff c2
}
@end lilypond
@lilypond[quote,verbatim,ragged-right]
withAlt =
#(define-music-function
- (parser location mag music)
+ (mag music)
(number? ly:music?)
#{
\override Stem.length = #(* 7.0 mag)
\revert NoteHead.font-size
#})
-\relative c' {
- c2 \withAlt #0.5 { c4 c }
+\relative {
+ c'2 \withAlt #0.5 { c4 c }
\withAlt #1.5 { c c } c2
}
@end lilypond
@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' { c\dyn pfsss }
+\relative { c'\dyn pfsss }
@end lilypond
Vous pourriez obtenir le même résultat avec une fonction musicale, à
@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
(ly:context-pushpop-property context grob 'color new-color)))
(for-each desaturate-grob '(NoteHead Stem Beam)))
-\relative g' {
+\relative {
\time 3/4
- g8[ g] \desaturate g[ g] \desaturate g[ g]
+ g'8[ g] \desaturate g[ g] \desaturate g[ g]
\override NoteHead.color = #darkred
\override Stem.color = #darkred
\override Beam.color = #darkred
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 =
#(define-music-function
- (parser location music) (ly:music?)
+ (music) (ly:music?)
#{
\applyContext
#(lambda (context)
(for-each revert-color '(NoteHead Stem Beam)))
#})
-\relative g' {
+\relative {
\override NoteHead.color = #darkblue
\override Stem.color = #darkblue
\override Beam.color = #darkblue
- g8 a b c
+ g'8 a b c
\desaturate { d c b a }
g b d b g2
}
@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
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éé,
-@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)
- (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 c' {
- a'4 e8 <<\applyOutput #'Voice #blanker a c d>> b2
+\relative {
+ 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
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]
+@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
valeur usuelle de la propriété :
@example
-\relative c'' @{
+\relative @{
\override Flag.X-offset = #(lambda (flag)
(let ((default (ly:flag::calc-x-offset flag)))
(* default 4.0)))
- c4. d8 a4. g8
+ c''4. d8 a4. g8
@}
@end example
@example
F = \tweak font-size #-3 -\flageolet
-\relative c'' @{
- c4^\F c4_\F
+\relative @{
+ c''4^\F c4_\F
@}
@end example
(ly:music-property m 'tweaks)))
m)
-\relative c'' @{
- c4^\F c4_\F
+\relative @{
+ c''4^\F c4_\F
@}
@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)
'())))
(eq? (car (last-pair siblings)) grob))
(ly:grob-set-property! grob 'extra-offset '(-2 . 5)))))
-\relative c'' {
+\relative {
\override Tie.after-line-breaking =
#my-callback
- c1 ~ \break
+ c''1 ~ \break
c2 ~ 2
}
@end lilypond
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
projects / lilypond.git / blobdiff