Doc-fr: Learning Manual full update

[lilypond.git] / Documentation / fr / user / tweaks.itely

@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@c This file is part of lilypond-learning.tely
@ignore
        Translation of GIT committish: 7eee2a7382029cc29cc069f93a431758ae8a13b7

    When revising a translation, copy the HEAD committish of the
    version that you are working on.  See TRANSLATION for details.
@end ignore

@c \version "2.12.0"

@c Translators: Valentin Villenave, Nicolas Klutchnikoff, Damien Heurtebise
@c Translation checkers: Jean-Charles Malahieude, John Mandereau
@c Translation status: post-GDP

@node Tweaking output
@chapter Tweaking output

Ce chapitre indique comment modifier le résultat obtenu.
LilyPond offre de nombreuses possibilités de réglages, permettant
théoriquement de modifier chaque élément de votre partition.

@menu
* Tweaking basics::             
* The Internals Reference manual::  
* Appearance of objects::       
* Placement of objects::        
* Collisions of objects::       
* Further tweaking::            
@end menu

@node Tweaking basics
@section Tweaking basics

@menu
* Introduction to tweaks::      
* Objects and interfaces::      
* Naming conventions of objects and properties::  
* Tweaking methods::            
@end menu

@node Introduction to tweaks
@subsection Introduction to tweaks

LilyPond regroupe sous le terme de @qq{retouches} (@emph{tweaks} en
anglais) les différents moyens dont dispose l'utilisateur pour 
intervenir sur l'interprétation du fichier d'entrée et pour modifier 
l'apparence du fichier de sortie.  Certaines retouches sont très 
simples à mettre en œuvre ; d'autres sont plus complexes.  Mais 
à elles toutes, elles permettent d'obtenir tout ce qu'on veut en matière
de musique imprimée.

Dans ce chapitre, nous traitons des concepts de base nécessaires
pour comprendre l'art de la retouche.  Puis nous présentons de 
nombreuses commandes déjà prêtes, qu'il suffit de recopier pour 
obtenir un résultat identique dans vos partitions ; nous en profitons
pour expliquer comment ces commandes ont été construites, si bien 
que vous pouvez apprendre par la même occasion à développer 
vos propres retouches.

Avant de vous lancer dans ce chapitre, il peut être utile de revoir la
section @ref{Contexts and engravers}, dans la mesure où les contextes,
graveurs et autres propriétés qui y sont décrits, sont indispensables 
pour comprendre et construire les retouches.

@node Objects and interfaces
@subsection Objects and interfaces

@cindex objet
@cindex grob
@cindex spanner
@cindex extenseur
@cindex interface
@cindex propriétés des objets
@cindex objet, propriétés
@cindex objet de rendu
@cindex rendu, objets de

Toute retouche implique que l'on modifie les opérations internes 
et les structures du programme LilyPond.  Nous allons donc, pour
commencer, présenter certains termes qui servent à décrire ces
opérations internes et ces structures.

Le terme d'@qq{Objet} est un terme générique qui fait référence à 
une multitude de structures internes mises en place par LilyPond 
durant la compilation d'un fichier d'entrée.  Ainsi, quand une 
commande du type @code{\new Staff} apparaît, un nouvel objet 
du type @code{Staff} est créé.  Cet objet @code{Staff} contient 
alors toutes les propriétés associées à cette portée, par exemple son
nom et son armure, ainsi que le détail des graveurs qui ont été 
désignés pour fonctionner dans ce contexte de portée.  
Certains objets peuvent contenir les propriétés de tous les autres 
contextes, comme les objets @code{Voice}, les objets @code{Score},
les objets @code{Lyrics} ; d'autres se rapportent à tous les éléments de
notation, comme les barres de mesure, les liaisons, les nuances, etc. 
Chaque objet dispose de son propre échantillon de valeurs pour le 
réglage des propriétés.

Certains types d'objet portent des noms spécifiques.  Les objets qui se 
rapportent à des éléments de notation sur le fichier de sortie, comme les 
notes, les hampes, les liaisons de phrasé ou de prolongation, les doigtés, 
les clefs, etc. sont appelés @qq{Objets de rendu} ; ils sont aussi connus 
sous le nom d'@qq{Objets graphiques} (en anglais : @emph{Graphical
objects} ou @emph{Grobs} pour faire court).  Ce sont bien des objets au
sens générique ci-dessus, et, en tant que tels, ils reçoivent des
propriétés qui leur sont associées, comme leur position, leur taille,
leur couleur, etc. 

Certains objets de rendu, comme les liaisons de phrasé, les soufflets 
de crescendo, les marques d'octaviation et beaucoup d'autres @emph{grobs}, 
ont pour particularité de ne pas se situer à un seul et unique endroit
--- ils ont un point de départ, un point d'arrivée, et éventuellement
d'autres propriétés relatives à leur forme.  Ces objets avec une forme
étendue sont appelés des bandeaux (@emph{Spanners} en anglais).

Il reste à expliquer ce que sont les @qq{interfaces}.  De nombreux objets, 
qui peuvent être très différents les uns des autres, ont pour point commun
de devoir être compilés simultanément.  Par exemple, tous les
@emph{grobs} ont une couleur, une taille, une position, etc., et toutes
ces propriétés sont compilées simultanément durant l'interprétation du
fichier d'entrée par LilyPond.  Pour alléger ces opérations internes,
ces actions et propriétés communes sont regroupées en un objet appelé
@code{grob-interface}.  Il existe beaucoup d'autres regroupements de
propriétés communes dans le genre de celui-ci, chacun portant un nom qui
se termine par @code{interface}.  En tout, on en compte plus d'une
centaine.  Nous verrons plus loin en quoi c'est intéressant et utile
pour l'utilisateur. 

Ainsi s'achève le tour des principaux termes relatifs aux objets et 
que nous serons amenés à utiliser dans ce chapitre. 

@node Naming conventions of objects and properties
@subsection Naming conventions of objects and properties

@cindex conventions de nommage des objets
@cindex conventions de nommage des propriétés
@cindex objets, conventions de nommage des
@cindex propriétés, conventions de nommage des

Nous avons eu un aperçu, dans @ref{Contexts and engravers}, de 
la façon de nommer les objets.  Voici maintenant une liste de 
référence des types d'objets et de propriétés les plus courants, 
avec leur convention de nommage et quelques exemples 
de cas concrets.  La lettre @code{A} représente n'importe quel 
caractère alphabétique majuscule, et les lettres @code{aaa} 
un nombre indéterminé de caractères alphabétiques minuscules.  
Les autres caractères sont à prendre comme ils se présentent.

@multitable @columnfractions .33 .33 .33
@headitem Type d'objet/propriété           
        @tab Convention de nommage
        @tab Exemples
@item Contextes
        @tab Aaaa ou AaaaAaaaAaaa
        @tab Staff, GrandStaff
@item Objets de rendu
        @tab Aaaa ou AaaaAaaaAaaa
        @tab Slur, NoteHead
@item Graveurs
        @tab Aaaa_aaa_engraver
        @tab Clef_engraver, Note_heads_engraver
@item Interfaces
        @tab aaa-aaa-interface
        @tab grob-interface, break-aligned-interface 
@item Propriétés de contexte
        @tab aaa ou aaaAaaaAaaa
        @tab alignAboveContext, skipBars
@item Propriétés d'objet de rendu
        @tab aaa ou aaa-aaa-aaa
        @tab direction, beam-thickness
@end multitable

Comme nous le verrons bientôt, les propriétés des différents 
types d'objets sont modifiées par des commandes différentes, si bien 
qu'il est bon de savoir reconnaître le type d'objet en fonction du nom
de ses propriétés. 

@node Tweaking methods
@subsection Tweaking methods

@cindex retouches, méthodologie
@cindex méthodes de retouche

@strong{La commande \override}

@cindex override, commande
@cindex override, syntaxe

@funindex \override
@funindex override

Dans @ref{Modifying context properties} et dans 
@ref{Adding and removing engravers}, nous avons déjà rencontré les
commandes @code{\set} et @code{\with}, qui servent à changer les
propriétés des @strong{contextes} et à supprimer ou ajouter des
@strong{graveurs}.  Voici maintenant d'autres commandes plus
importantes. 

La commande pour changer les propriétés des @strong{objets de rendu} 
est @code{\override}.  Du fait que cette commande modifie en profondeur 
les propriétés internes de LilyPond, sa syntaxe n'est pas aussi simple que 
pour les commandes vues précédemment.  Elle a besoin de savoir avec 
précision quelle est la propriété à modifier, pour quel objet et dans
quel  contexte, et quelle doit être sa nouvelle valeur.  Voyons de quoi
il retourne.

La syntaxe générale de cette commande est : 

@example
\override @var{Contexte}.@var{ObjetDeRendu} #'@var{propriété-rendu} = #@var{valeur}
@end example

@noindent
Elle attribue à la propriété appelée @var{propriété-rendu}, associée à
l'objet @var{ObjetDeRendu}, appartenant lui-même au contexte 
@var{Contexte}, une valeur @var{valeur}.

Le contexte @var{Contexte} peut être omis (c'est généralement 
le cas) quand il n'y a pas d'ambiguïté et qu'il s'agit d'un contexte 
de très bas niveau, comme @code{Voice}, @code{ChordNames} 
ou @code{Lyrics}.  Dans les exemples qui suivent, le contexte sera 
très souvent omis.  Nous verrons plus tard dans quelles
circonstances il doit impérativement être indiqué.

Les sections ci-dessous traitent largement des propriétés et de leurs 
valeurs mais, pour illustrer la mise en forme et l'utilisation de ces 
commandes, nous nous limiterons à n'employer que quelques propriétés et
valeurs simples, facilement compréhensibles.

Nous ne parlerons dans l'immédiat ni du @code{#'}, qui précède 
toujours la propriété, ni du @code{#}, qui précède toujours la 
valeur.  Ces deux éléments doivent obligatoirement être 
présents sous cette forme.  Voici la commande la plus fréquente 
pour faire des retouches, et pratiquement tout le reste de ce 
chapitre aura pour but montrer, à travers des exemples, comment 
l'utiliser.  L'exemple ci-dessous change la couleur des têtes de 
notes :

@cindex couleur,exemple d'utilisation de la propriété
@cindex NoteHead, exemple de dérogation

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
c d
\override NoteHead #'color = #red
e f g
\override NoteHead #'color = #green
a b c
@end lilypond

@strong{La commande \revert}

@cindex revert, commande

@funindex \revert
@funindex revert

Une fois qu'elle a été modifiée, la propriété conserve sa nouvelle valeur 
jusqu'à ce qu'elle soit à nouveau modifiée ou qu'elle rencontre la 
commande @code{\revert}.  La commande @code{\revert} obéit à 
la syntaxe ci-dessous et ramène la valeur de la propriété à sa valeur 
d'origine.  Attention : dans le cas où plusieurs @code{\override} ont 
été employés, il ne s'agit pas de la valeur précédente mais bien de la 
valeur par défaut. 

@example
\revert @var{Contexte}.@var{ObjetDeRendu} #'@var{propriété-de-rendu}
@end example

Tout comme pour la commande @code{\override}, la mention du 
@var{Contexte} est souvent facultative.  Elle sera omise dans de 
nombreux exemples ci-dessous.  Voici un exemple qui ramène la 
couleur des deux dernières notes à leur valeur par défaut :

@cindex couleur,exemple d'utilisation de la propriété
@cindex NoteHead, exemple de dérogation

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
c d
\override NoteHead #'color = #red
e f g
\override NoteHead #'color = #green
a
\revert NoteHead #'color
b c
@end lilypond

@strong{Le préfixe \once}

@funindex \once
@funindex once

Les commandes @code{\override} et @code{\set} peuvent supporter  
toutes les deux le préfixe @code{\once}.  Celui-ci a pour fonction de 
n'appliquer la commande @code{\override} ou @code{\set} qu'à
l'instant musical en cours, avant que la propriété ne reprenne 
sa valeur par défaut.  Toujours à partir du même exemple, il est
possible de ne changer la couleur que d'une seule note :

@cindex couleur,exemple d'utilisation de la propriété
@cindex NoteHead, exemple de dérogation

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
c d
\once \override NoteHead #'color = #red
e f g
\once \override NoteHead #'color = #green
a b c
@end lilypond

@strong{La commande \overrideProperty}

@cindex overrideProperty, commande

@funindex \overrideProperty
@funindex overrideProperty

Il existe une autre forme de commande @code{\override}, 
@code{\overrideProperty}, qui est parfois utile.  Nous la mentionnons
ici par souci d'exhaustivité ; pour le détail, voir 
@ruser{Difficult tweaks}. 

@c Maybe explain in a later iteration  -td

@strong{La commande \tweak}

@cindex tweak, commande

@funindex \tweak
@funindex tweak

La dernière commande disponible pour les retouches est 
@code{\tweak}.  Elle sert à changer les propriétés d'objets qui
surviennent simultanément dans la musique, comme par exemple les 
notes d'un accord.  La commande @code{\override} modifierait toutes
les notes de l'accord, tandis que @code{\tweak} permet de ne modifier
que  l'élément suivant dans la chaîne de saisie.

Voici un exemple.  Supposons que nous voulions changer la taille de 
la tête de note du milieu (le mi) dans un accord de do majeur.  Voyons 
d'abord ce que donnerait @code{\once \override} :

@cindex font-size, exemple d'utilisation de la propriété
@cindex NoteHead, exemple de dérogation

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
<c e g>4
\once \override NoteHead #'font-size = #-3
<c e g>
<c e g>
@end lilypond

Nous voyons que @code{\override} modifie @emph{toutes} les têtes 
de notes de l'accord, car toutes les notes de l'accord surviennent au 
même @emph{instant musical} et que la fonction de @code{\once} 
est de faire porter la modification sur tous les objets du type spécifié 
qui surviennent au même instant musical, comme le fait la commande 
@code{\override} elle-même. 

La commande @code{\tweak} opère différemment.  Elle agit 
sur l'élément immédiatement suivant dans la chaîne de saisie.  Elle ne
fonctionne toutefois que sur des objets créés directement à partir de 
la chaîne de saisie, c'est-à-dire essentiellement des têtes de notes et
des articulations ; des objets comme les hampes ou les 
altérations accidentelles sont créés ultérieurement et ne peuvent 
être retouchés de cette manière.  En outre, quand la retouche porte 
sur une tête de note, celle-ci @emph{doit} appartenir à un accord, 
c'est-à-dire être comprise à l'intérieur de chevrons gauche/droite.  Pour 
retoucher une note isolée, il faut donc placer la commande 
@code{\tweak} avec la note à l'intérieur des chevrons gauche/droite.

Pour reprendre notre exemple, la taille de la note du milieu d'un 
accord peut être modifiée de cette manière : 

@cindex font-size, exemple d'utilisation de la propriété
@cindex @code{\tweak}, exemple

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
<c e g>4
<c \tweak #'font-size #-3 e g>4
@end lilypond

Vous noterez que la syntaxe de @code{\tweak} est différente de 
celle de la commande @code{\override}.  Ni le contexte, 
ni l'objet n'ont besoin d'être spécifiés ; au contraire, cela 
produirait une erreur si on le faisait.  Tous deux sont sous-entendus
par l'élément suivant dans la chaîne de saisie.  La syntaxe générale 
de la commande @code{\tweak} est donc, tout simplement :

@example
\tweak #'@var{propriété-de-rendu} = #@var{valeur}
@end example

La commande @code{\tweak} est aussi utilisée quand on veut, dans 
une série d'articulations, n'en modifier qu'une seule.  Ainsi :

@cindex couleur, exemple d'utilisation de la propriété
@cindex @code{\tweak}, exemple

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
a ^Black
        -\tweak #'color #red ^Red
        -\tweak #'color #green _Green
@end lilypond

@noindent
Attention : la commande @code{\tweak} doit être précédée d'une 
marque d'articulation, comme si elle-même était une articulation.

@cindex nolets imbriqués
@cindex triolets imbriqués
@cindex crochet de nolet
@cindex nolet, crochet
@cindex triolet, crochet

@funindex TupletBracket

Quand plusieurs nolets sont imbriqués et commencent au même instant 
musical, c'est encore la commande @code{\tweak} qui est utilisée pour 
changer l'apparence de l'un d'entre eux.  Dans l'exemple suivant, le
long crochet de nolet et le premier des trois crochets courts commencent
au même instant musical ; une commande @code{\override} s'appliquerait 
donc à la fois aux deux.  En revanche, @code{\tweak} permet  
de les dissocier.  La première commande @code{\tweak} indique que 
le long crochet doit être placé au-dessus des notes, et la seconde 
indique que le coefficient de nolet doit être imprimé en rouge sur le 
premier crochet de triolet court. 

@cindex @code{\tweak}, exemple
@cindex direction, exemple d'utilisation de la propriété
@cindex couleur, exemple d'utilisation de la propriété

@lilypond[quote,ragged-right,verbatim,fragment,relative=2]
\tweak #'direction #up
\times 4/3 {
        \tweak #'color #red
        \times 2/3 { c8[ c8 c8] }
        \times 2/3 { c8[ c8 c8] }
        \times 2/3 { c8[ c8 c8] }
}
@end lilypond

Si les nolets imbriqués ne commencent pas au même moment, 
leur apparence peut alors être modifiée de la façon habituelle, 
avec la commande @code{\override} :

@cindex texte, exemple d'utilisation de la propriété
@cindex tuplet-number, exemple de fonction
@cindex transparence, exemple d'utilisation de la propriété
@cindex TupletNumber, exemple de dérogation

@c NOTE Tuplet brackets collide if notes are high on staff
@c See issue 509
@lilypond[quote,ragged-right,verbatim,fragment,relative=1]
\times 2/3 { c8[ c c]}
\once \override TupletNumber
        #'text = #tuplet-number::calc-fraction-text
\times 2/3 {
        c[ c]
        c[ c]
        \once \override TupletNumber #'transparent = ##t
        \times 2/3 { c8[ c c] }
\times 2/3 { c8[ c c]}
}
@end lilypond

@seealso
Manuel de notation :
@ruser{The tweak command}.


@node The Internals Reference manual
@section The Internals Reference manual

@cindex Références internes

@menu
* Properties of layout objects::  
* Properties found in interfaces::  
* Types of properties::         
@end menu

@node Properties of layout objects
@subsection Properties of layout objects

@cindex propriétés des objets de rendu
@cindex propriétés des objets graphiques (grobs)
@cindex grobs, propriétés
@cindex objets de rendu, propriétés
@cindex Manuel des références internes

Imaginons que votre partition contienne une liaison trop fine à votre 
goût et que vous vouliez la rendre plus épaisse.  Comment vous y 
prendre ?  Vous êtes convaincu, avec tout ce qui a été dit sur la 
souplesse de LilyPond, qu'une telle retouche est réalisable et 
vous vous dites qu'elle fera sans doute intervenir la commande 
@code{\override}.  Mais existe-t-il une propriété lourde qui s'applique 
à une liaison et, dans l'affirmative, comment faire pour la modifier ? 
C'est là qu'intervient la Référence des propriétés internes. 
Elle contient toutes les informations dont vous avez besoin pour 
construire n'importe quelle commande @code{\override}.

Avant de nous plonger dans la Référence des propriétés 
internes, un mot d'avertissement.  Il s'agit d'un document de 
@strong{références}, de sorte qu'il ne contient pas ou peu 
d'explications : son but est de présenter les informations de 
façon précise et concise.  Cela peut paraître décourageant 
à première vue.  Pas d'inquiétude !  Les conseils et les explications 
fournis ici vous permettent de retrouver par vous-même les 
informations dans la Référence des propriétés internes.  Il 
suffit d'un peu de pratique. 

@cindex override, exemple
@cindex dérogation, exemple
@cindex Références internes, exemple d'utilisation
@cindex @code{\addlyrics} -- exemple

Prenons un exemple concret tiré d'un morceau de musique connu :

@lilypond[quote,verbatim,relative=2]
{
  \time 6/8
  {
    r4 b8 b[( g]) g |
    g[( e]) e d[( f]) a |
    a g
  }
  \addlyrics {
    The man who feels love's sweet e -- mo -- tion
  }
}
@end lilypond

Admettons que nous voulions rendre les traits de liaison plus épais. 
Est-ce possible ?  Une liaison est assurément un objet de rendu, si bien 
que la question est @qq{Existe-t-il une propriété attachée aux liaisons 
et qui en contrôle l'épaisseur ? } Pour y répondre, nous consultons la 
Référence des propriétés internes (ou RPI pour faire court).

Vous trouverez sur le site de LilyPond @uref{http://lilypond.org} la
RPI correspondant à votre version du programme.  Allez sur la page 
Documentation et cliquez sur Référence des propriétés internes. 
Pour l'apprentissage, mieux vaut utiliser la version HTML standard, 
et non la @q{page unique en anglais} ou le PDF.  Durant la lecture 
des prochains paragraphes, il vous est conseillé de vous y reporter 
réellement afin que les explications prennent tout leur sens.

En dessous du bandeau d'en-tête figurent cinq liens.  Cliquez sur le lien 
vers le @emph{Backend}, où se trouvent les informations sur les 
objets de rendu.  En dessous du titre @strong{Backend}, choisissez 
alors le lien vers @emph{Tous les objets de rendu}.  La page qui s'ouvre 
énumère, dans l'ordre alphabétique, tous les objets utilisés dans votre 
version de LilyPond.  Cliquez sur Liaisons (@emph{Slurs} en anglais), 
et les propriétés des liaisons apparaîtront. 

Il existe un autre moyen de trouver cette page, à partir du Manuel de 
notation.  Une des pages qui traitent des liaisons contient un lien vers 
la Référence des propriétés internes, qui mène directement à cette 
page.  Mais lorsque vous connaissez le nom de l'objet à retoucher, le 
plus simple est de consulter la RPI. 

La page de la RPI sur les liaisons commence par préciser que les objets 
Liaison sont créés par le graveur Slur_engraver.  Vient ensuite la liste 
des réglages standard.  Attention : ceux-ci @strong{ne suivent pas} l'ordre 
alphabétique.  Il faut donc les parcourir en entier pour trouver la propriété 
susceptible de contrôler l'épaisseur des traits de liaison.

@example
@code{thickness} (number)
     @code{1.2}
     Épaisseur de ligne, généralement mesurée en @code{line-thickness}
@end example

Voilà qui semble approprié pour changer l'épaisseur (@emph{thickness} en
anglais).  On apprend que la valeur de @code{thickness} 
est un simple nombre (@emph{number}), qu'elle est par défaut 
à 1,2 et que l'unité de mesure est fixée par une autre propriété 
appelée @code{line-thickness}.

Comme il a été indiqué, on ne trouve que peu, voire pas du tout 
d'explication dans la RPI, mais nous en savons assez pour essayer 
de changer l'épaisseur de la liaison.  Comme nous l'avons vu, le 
nom de l'objet est @code{Slur}, le nom de la propriété à changer 
est @code{thickness} et la nouvelle valeur sera un nombre supérieur 
à @code{1.2} si l'on veut augmenter l'épaisseur du trait.

Pour construire la commande @code{\override}, il suffit donc de 
remplacer les valeurs que nous avons trouvées en guise de noms, en 
laissant de côté le contexte.  Commençons par une valeur très élevée
dans un premier temps, pour nous assurer que la commande fonctionne. 
Nous obtenons :

@example
\override Slur #'thickness = #5.0
@end example

N'oublions pas le @code{#'} qui doit précéder le nom de la propriété et 
le @code{#} qui doit précéder la nouvelle valeur.

La dernière question est : @qq{Où placer cette commande ?}  
Tant qu'on n'est pas sûr de soi, la meilleure réponse est @qq{À
l'intérieur de l'expression musicale, avant la première liaison et
proche d'elle.}  Essayons :

@cindex Slur, exemple de dérogation
@cindex thickness, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,relative=2]
{
  \time 6/8
  {
    % Increase thickness of all following slurs from 1.2 to 5.0
    \override Slur #'thickness = #5.0
    r4 b8 b[( g]) g |
    g[( e]) e d[( f]) a |
    a g
  }
  \addlyrics {
    The man who feels love's sweet e -- mo -- tion
  }
}
@end lilypond 

@noindent
et nous constatons que le trait de liaison est beaucoup plus épais.

Telle est la façon normale de construire les commandes 
@code{\override}.  Comme nous aurons l'occasion de le voir 
par la suite, le problème est parfois plus complexe.  Dans 
l'immédiat, nous en savons assez pour construire nos propres 
commandes --- mais il faut encore s'exercer.  Les exemples 
suivants sont là dans cette intention.

@subheading Finding the context

@cindex contexte, détermination du
@cindex contexte, identification correcte du

Tout d'abord, de quoi avions-nous besoin pour préciser le 
contexte ?  À quoi devait-il ressembler ?  Gageons que les 
liaisons appartiennent au contexte Voix, dans la mesure où 
elles sont étroitement liées à une ligne mélodique, mais 
comment en être sûr ?  Pour répondre à cette question, 
revenons en haut de la page de la RPI consacrée aux liaisons ; 
il est écrit : @q{Les objets Liaison sont créés par le graveur 
Slur_engraver}.  Ainsi les liaisons seront créées dans n'importe 
quel contexte où se trouve le @code{Slur_engraver}.  Suivons 
le lien vers la page @code{Slur_engraver}.  Tout en bas, on 
lit que le @code{Slur_engraver} est un élément appartenant 
à cinq contextes Voix, dont le contexte de voix 
standard, @code{Voice}.  Notre hypothèse était donc juste. 
Et parce que @code{Voice} est un contexte de très bas 
niveau, qu'il est activé sans ambiguïté par le fait que l'on est 
en train de saisir des notes, on peut ici ne pas le mentionner.

@subheading Overriding once only

@cindex dérogation pour une seule fois
@cindex usage unique, dérogation à

@funindex \once
@funindex once

Dans le dernier exemple ci-dessus, @emph{toutes} les liaisons étaient plus 
épaisses.  Et si on veut épaissir uniquement la première liaison ?  On
recourt alors à la commande @code{\once}.  Placée juste avant la commande 
@code{\override}, elle lui indique de ne changer que la liaison commençant 
avec la note @strong{juste après}.  Si la note juste après n'ouvre pas une 
liaison, la commande sera sans aucun effet --- elle ne reste pas en mémoire 
jusqu'à la prochaine liaison, elle est purement et simplement ignorée.
Il faut donc que la commande introduite par @code{\once} soit insérée
comme suit : 


@cindex Slur, exemple de dérogation
@cindex thickness, exemple d'utilisation de la propriété
@cindex Liaison, exemple de dérogation
@cindex Épaisseur, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,relative=2]
{
  \time 6/8
  {
    r4 b8
    % Increase thickness of immediately following slur only
    \once \override Slur #'thickness = #5.0
    b[( g]) g |
    g[( e]) e d[( f]) a |
    a g
  }
  \addlyrics {
    The man who feels love's sweet e -- mo -- tion
  }
}
@end lilypond 

@noindent
Alors seule la première liaison est rendue plus épaisse.

La commande @code{\once} peut aussi être utilisée devant la commande 
@code{\set}.
 

@subheading Reverting

@cindex revert
@cindex retour
@cindex défaut, retour aux propriétés par

@funindex \revert
@funindex revert

Et si l'on voulait que les deux premières liaisons soient plus épaisses ? 
On pourrait bien sûr utiliser deux commandes, chacune précédée de 
@code{\once}, et placées juste avant la note par laquelle débute la 
liaison :


@cindex Slur, exemple de dérogation
@cindex thickness, exemple d'utilisation de la propriété
@cindex Liaison, exemple de dérogation
@cindex Épaisseur, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,relative=2]
{
  \time 6/8
  {
    r4 b8
    % Increase thickness of immediately following slur only
    \once \override Slur #'thickness = #5.0
    b[( g]) g |
    % Increase thickness of immediately following slur only
    \once \override Slur #'thickness = #5.0
    g[( e]) e d[( f]) a |
    a g
  }
  \addlyrics {
    The man who feels love's sweet e -- mo -- tion
  }
}
@end lilypond 

@noindent
mais on peut aussi, au lieu de la commande @code{\once}, utiliser après 
la seconde liaison la commande @code{\revert}, qui ramène la propriété 
@code{thickness} à sa valeur par défaut .

@cindex Slur, exemple de dérogation
@cindex thickness, exemple d'utilisation de la propriété
@cindex Liaison, exemple de dérogation
@cindex Épaisseur, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,relative=2]
{
  \time 6/8
  {
    r4 b8
    % Increase thickness of all following slurs from 1.2 to 5.0
    \override Slur #'thickness = #5.0
    b[( g]) g |
    g[( e])
    % Revert thickness of all following slurs to default of 1.2
    \revert Slur #'thickness
    e d[( f]) a |
    a g
  }
  \addlyrics {
  The man who feels love's sweet e -- mo -- tion
  }
}
@end lilypond

@noindent
N'importe quelle propriété modifiée par @code{\override} peut ainsi 
être ramenée, grâce à la commande @code{\revert}, à sa valeur par 
défaut. 

Ici s'achève notre introduction à la RPI et aux retouches 
simples.  Vous trouverez d'autres exemples dans les prochaines 
sections de ce chapitre ; ils vous permettront, d'une part, 
d'apprendre à connaître un peu mieux la RPI et, d'autre part, de 
vous entraîner un peu plus à y chercher les informations.  Ces 
exemples seront progressivement accompagnés d'explications et 
introduiront des termes nouveaux.
 
@node Properties found in interfaces
@subsection Properties found in interfaces

@cindex interface
@cindex interfaces, propriétés des
@cindex propriétés des interfaces

Supposons maintenant que nous voulions imprimer des paroles en italique.  
Quelle formulation de la commande @code{\override} allons-nous utiliser ? 
Nous consultons en premier lieu, comme précédemment, la page de la RPI 
qui contient la liste @qq{Tous les objets de rendu}, et recherchons 
un objet qui contrôle les paroles.  Nous trouvons @code{LyricText}, qui 
semble approprié.  Nous cliquons dessus et nous voyons apparaître les 
différentes propriétés des paroles, parmi lesquelles @code{font-series} 
et @code{font-size}.  Mais aucune ne propose l'italique.  Car la mise 
en forme des caractères est une propriété commune à tous les objets 
d'écriture, si bien que, au lieu de figurer dans tous les objets de rendu, 
elle est regroupée avec d'autres propriétés semblables et placée dans une 
@strong{Interface}, la @code{font-interface}.

Il nous faut donc apprendre à trouver les propriétés des interfaces 
et découvrir les objets qui utilisent les propriétés de ces interfaces.

Retournons à la page de la RPI qui traite des paroles
(@emph{LyricText}).  En bas de la page est dressée sous forme de liens
la liste des interfaces qui concernent LyricText.  Cette liste comporte
plusieurs entrées, dont @code{font-interface}.  En cliquant dessus, nous
voyons apparaître les différentes propriétés associées à cette
interface, qui sont en même temps les propriétés de tous les objets qui
s'y rapportent, parmi lesquels  LyricText.

Nous avons alors sous les yeux tous les réglages de propriétés qui 
contrôlent les polices de caractères, et notamment 
@code{font-shape(symbole)}, où @code{symbole} peut prendre la valeur 
@code{upright}, @code{italics} ou @code{caps}.

Vous remarquerez que @code{font-series} et @code{font-size} figurent 
aussi dans la liste.  La question qui ne manque pas de se poser est : 
@qq{Comment se fait-il que les propriétés @code{font-series} et 
@code{font-size} se retrouvent à la fois dans @code{LyricText} et dans 
l'interface @code{font-interface} alors que ce n'est pas le cas pour 
@code{font-shape} ?}  La réponse est que lorsqu'un objet @code{LyricText} 
est créé, les valeurs globales par défaut de @code{font-series} et 
@code{font-size} sont modifiées, mais pas celles de @code{font-shape}. 
Les possibilités de modification dans @code{LyricText} ne concernent 
donc que les valeurs à appliquer à @code{LyricText}.  Les autres objets qui 
dépendent de @code{font-interface} fixeront leurs propriétés différemment 
lorsqu'ils seront créés.

Voyons maintenant si nous sommes en mesure de formuler la commande 
@code{\override} pour mettre les paroles en italique.  L'objet est 
@code{LyricText}, la propriété est @code{font-shape} et la valeur est 
@code{italic}.  Comme auparavant, nous laissons de côté le contexte. 

Signalons rapidement --- même si cette remarque est importante --- que,
puisque les valeurs de @code{font-shape} se présentent sous forme de
symboles, elles doivent être précédées d'une simple apostrophe,
@code{'}.  C'est pour cette raison qu'il fallait une apostrophe devant
@code{thickness} dans l'exemple précédent, et qu'il en faut une devant
@code{font-shape}. Ce sont à chaque fois des symboles, qui sont
interprétés comme tels par LilyPond.  Certains symboles peuvent être des
noms de propriété, comme @code{thickness} ou @code{font-shape},
d'autres sont des valeurs à attribuer aux propriétés, comme
@code{italic}. À ne pas confondre avec les chaînes de caractères libres,
qui se présentent comme @code{"un texte libre"} ; pour plus de détails
sur les symboles et les chaînes de caractères, voir @ref{Scheme
tutorial}. 

Ainsi, la commande @code{\override} pour mettre les paroles en italique 
est : 

@example
\override LyricText #'font-shape = #'italic
@end example

@noindent
et elle doit être placée juste devant et tout près des paroles à modifier, 
comme ceci :

@cindex font-shape, exemple d'utilisation de la propriété
@cindex italic, exemple
@cindex LyricText, exemple de dérogation
@cindex @code{\addlyrics}, exemple

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 6/8
  {
    r4 b8 b[( g]) g |
    g[( e]) e d[( f]) a |
    a g
  }
  \addlyrics {
    \override LyricText #'font-shape = #'italic
    The man who feels love's sweet e -- mo -- tion
  }
}
@end lilypond

@noindent
et voilà les paroles en italiques.

@subheading Specifying the context in lyric mode

@cindex contexte, spécification en mode lyrique
@cindex mode lyrique, spécification de contexte en

Lorsqu'il s'agit de paroles et qu'on cherche à préciser le contexte 
sur le modèle de ce qui a été fait précédemment, la commande échoue. 
Car une syllabe saisie en mode Paroles (lyricmode) se termine 
obligatoirement par une espace, un saut de ligne ou un nombre. Tout 
autre caractère compte comme un élément de la syllabe. C'est pourquoi 
il faut une espace ou un saut de ligne avant le @code{@}} final, pour 
éviter qu'il ne soit assimilé à la dernière syllabe. De même, il faut insérer 
des espaces avant et après le point, @qq{.}, qui sépare le nom de 
contexte du nom de l'objet, faute de quoi les deux noms seront joints et 
l'interpréteur ne pourra pas les reconnaître. La formulation correcte est 
donc : 

@example
\override Lyrics . LyricText #'font-shape = #'italic
@end example

@warning{Dans la saisie des paroles, pensez à toujours laisser une
espace entre la dernière syllabe et l'accolade fermante.}

@warning{Lorsqu'on retouche des paroles, toujours placer des espaces 
autour du point qui sépare le nom de contexte du nom d'objet.}

@seealso
Manuel d'initiation : @ref{Scheme tutorial}.


@node Types of properties
@subsection Types of properties


@cindex propriété, types de

Nous avons vu jusqu'à maintenant deux types de propriétés :
@code{nombre} et @code{symbole}.  Pour pouvoir fonctionner, la valeur
associée à une propriété doit correspondre au type attendu et suivre les
règles liées à ce type.  Le type de propriété est toujours donné entre
parenthèses après le nom de propriété dans la RPI.  Voici une liste des
différents types de propriétés, avec les règles qui les régissent et
quelques exemples d'utilisation.  Il faut, bien sûr, toujours ajouter un
symbole hash, @code{#}, devant ces valeurs lors de la saisie de la
commande @code{\override}. 

@multitable @columnfractions .2 .45 .35
@headitem Type de propriété 
  @tab Règles
  @tab Exemples
@item Booléenne (anglais @emph{Boolean})
  @tab Vrai (@emph{true} en anglais) ou Faux (@emph{false} en anglais),
       sous la forme #t  ou #f
  @tab @code{#t}, @code{#f}
@item Dimension (en lignes de portée)
  @tab Un nombre positif décimal (en unités de lignes de portée)
  @tab @code{2.5}, @code{0.34}
@item Direction
  @tab Une direction valide ou son équivalent numérique (valeur décimale
       comprise entre -1 et 1 seulement)
  @tab @code{LEFT}, @code{CENTER}, @code{UP}, @code{1}, @code{-1}
@item Entier (@emph{Integer} en anglais)
  @tab Un nombre entier positif
  @tab @code{3}, @code{1}
@item Liste
  @tab Plusieurs valeurs séparées par une espace, encadrées par des
parenthèses et prédédées par une apostrophe 
  @tab @code{'(left-edge staff-bar)}, @code{'(1)}, @code{'(1.0 0.25 0.5)}
@item Markup (ou étiquette)
  @tab Toute commande @code{\markup} valide
  @tab @code{\markup @{ \italic "cresc." @}}
@item Durée (@emph{Moment} en anglais)
  @tab Une durée de note construite avec la fonction make-moment
  @tab @code{(ly:make-moment 1 4)}, @code{(ly:make-moment 3 8)}
@item Nombre
  @tab Une valeur décimale positive ou négative
  @tab @code{3.5}, @code{-2.45}
@item Paire (de nombres)
  @tab Deux nombres séparées par @q{espace . espace}, encadrés 
par des parenthèses et précédés par une apostrophe
  @tab @code{'(2 . 3.5)}, @code{'(0.1 . -3.2)}
@item Symbole
  @tab L'un des symboles autorisés pour cette propriété, précédé par une
apostrophe
  @tab @code{'italic}, @code{'inside}
@item Inconnu (@emph{Unknown} en anglais)
  @tab Un processus, ou @code{#f} pour empêcher toute action 
  @tab @code{bend::print}, @code{ly:text-interface::print}, @code{#f}
@item Vecteur
  @tab Une liste de trois éléments encadrés par des parenthèses et
précédés par apostrophe-hash, @code{'#}
  @tab @code{'#(#t #t #f)}
@end multitable


@seealso
Manuel d'initiation : @ref{Scheme tutorial}.


@node Appearance of objects
@section Appearance of objects

Il est temps de mettre en pratique les notions apprises précédemment
pour modifier l'allure de la partition ; les exemples qui suivent
montrent l'utilisation des différentes méthodes de retouche.  

@menu
* Visibility and color of objects::  
* Size of objects::             
* Length and thickness of objects::  
@end menu


@node Visibility and color of objects
@subsection Visibility and color of objects

Dans un but pédagogique, on peut être amené à masquer certains éléments
d'une partition, que les élèves doivent ensuite compléter.  Imaginons,
par exemple, un exercice dans lequel il faudrait rétablir les barres de
mesure dans un morceau de musique. En temps normal, les barres de mesure
s'insèrent automatiquement.  Comment faire pour les effacer de la
partition ?  

Avant de nous y attaquer, souvenons-nous que les propriétés d'objets
sont parfois groupées dans ce qu'on appelle des @emph{interfaces} ---
voir @ref{Properties found in interfaces}.  Cela permet de rapprocher
toutes les propriétés susceptibles d'être utilisées ensemble pour
modifier un objet graphique --- si l'une d'elles est choisie pour un
objet, elle s'appliquera à tous les autres.  Certains objets tirent
alors leurs propriétés de telle ou telle interface, d'autres objets de
telle ou telle autre interface.  La liste des interfaces qui contiennent
les propriétés liées à un objet graphique (@emph{grob}) figure dans la
RPI, en bas de la page de description du @emph{grob} ; pour voir ces
propriétés, il faut aller voir ces interfaces.  

Nous avons vu, dans @ref{Properties of layout objects}, comment trouver 
les informations sur les @emph{grobs}.  Nous procédons de la même manière
et consultons la RPI pour connaître l'objet chargé d'imprimer les barres
de mesure.  En cliquant sur @emph{Backend} puis sur @emph{Tous les
objets de rendu}, nous trouvons un objet appelé @code{BarLine}.  Parmi 
ses propriétés, deux d'entre elles déterminent son aspect visuel : 
@code{break-visibility} et @code{stencil}.  L'objet @code{BarLine} 
est également lié à plusieurs interfaces, dont la @code{grob-interface} 
où figurent les propriétés @code{transparent} et @code{color}.  Toutes
peuvent modifier l'aspect visuel des barres de mesure --- et de beaucoup
d'autres objets, bien sûr.  Examinons chacune d'elles tour à tour.

@subheading stencil

@cindex stencil, propriété

Cette propriété contrôle l'apparence des barres de mesure en précisant 
le type de symbole (glyphe) à imprimer.  Comme pour de nombreuses 
autres propriétés, on peut lui indiquer de ne rien imprimer en lui
attribuant la valeur @code{#f}.  Essayons en laissant de côté, une fois
encore, le contexte concerné (@code{Voice} en l'occurrence) : 

@cindex BarLine, exemple de dérogation
@cindex stencil, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override BarLine #'stencil = ##f
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

Les barres de mesure sont encore là !  Pourquoi ?  Retournons à la RPI
et regardons de nouveau la page qui traite des propriétés de BarLine.
En haut de la page, il est précisé que @qq{Les objets BarLine sont créés
par le graveur Bar_engraver}.  Allons à la page de @code{Bar_engraver}. 
Tout en bas se trouve la liste des contextes dans lesquels fonctionne ce 
graveur.  Tous sont du type @code{Staff}, de sorte que, si la commande 
@code{\override} n'a pas fonctionné comme prévu, c'est parce que 
@code{Barline} n'appartient pas au contexte par défaut, @code{Voice}. 
Si le contexte spécifié est erroné, la commande ne fonctionne pas.  Cela 
n'entraîne pas de message d'erreur, et rien n'apparaît sur le fichier log. 
Essayons de corriger en mentionnant le bon contexte : 

@cindex BarLine, exemple de dérogation
@cindex stencil, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override Staff.BarLine #'stencil = ##f
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

Cette fois, les barres de mesure ont disparu.

@subheading break-visibility

@cindex break-visibility, propriété

La RPI mentionne, à la page sur @code{BarLine}, que la propriété
@code{break-visibility} attend comme argument un vecteur de trois
boléens.  Ceux-ci indiquent respectivement si les barres de mesure
doivent être imprimées ou non à la fin de la ligne, à l'intérieur de la
ligne et au début de la ligne.  Dans notre cas, nous voulons que toutes
les barres soient supprimées, si bien que la valeur dont nous avons
besoin est @code{'#(#f@tie{}#f@tie{}#f)}. Essayons, sans oublier
d'ajouter le contexte @code{Staff}.  Vous remarquerez que, en plus de
cette valeur, nous ajoutons @code{#'#} devant la parenthèse ouvrante.
Le @code{'#} est nécessaire car il fait partie intégrante de la valeur
contenant un vecteur, et le premier @code{#} est là, comme toujours avec
la commande @code{\override}, pour introduire la valeur elle-même. 

@cindex BarLine, exemple de dérogation
@cindex break-visibility exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override Staff.BarLine #'break-visibility = #'#(#f #f #f)
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

Comme on peut le constater, cette solution-là aussi supprime les barres 
de mesure.

@subheading transparent

@cindex transparent, propriété
@cindex transparence

La RPI mentionne, à la page sur @code{grob-interface}, que la propriété
@code{transparent} attend comme argument un boléen.  Il faudrait donc
mettre @code{#t} pour rendre l'objet transparent.  Dans cet exemple,
essayons de rendre transparente la métrique (@emph{time signature} en
anglais) plutôt que les barres de mesure.  Pour cela, il nous faut
trouver le nom du @emph{grob} chargé de l'indication de mesure.  De
retour sur la page @qq{Tous les objets de rendu} de la RPI, nous
cherchons les propriétés de l'objet @code{TimeSignature}.  Celui-ci est
géré par le graveur @code{Time_signature_engraver} qui, comme vous
pouvez le constater, appartient au contexte @code{Staff} et peut se
rattacher à la @code{grob-interface}.  Dans ces conditions, la commande
pour rendre la métrique transparente est : 

@cindex TimeSignature, exemple de dérogation
@cindex transparent, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override Staff.TimeSignature #'transparent = ##t
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

@noindent
La métrique a bien disparu mais la commande a laissé un blanc en lieu et
place du chiffrage.  Ce peut être souhaitable dans le cadre d'un
exercice, afin que les élèves aient la place à compléter, mais dans
d'autres circonstances, ce peut être gênant.  Pour y remédier,
attribuons plutôt au stencil des métriques la valeur @code{#f} : 

@cindex TimeSignature, exemple de dérogation
@cindex stencil, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override Staff.TimeSignature #'stencil = ##f
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

@noindent
La différence est flagrante : le fait d'attribuer au stencil la valeur
@code{#f} supprime totalement l'objet, tandis que le fait de le rendre
@code{transparent} le laisse en place, mais de façon invisible. 

@subheading color

@cindex color, propriété

Essayons enfin de rendre les barres de mesure invisibles en les colorant
en blanc.  La difficulté est de savoir si les barres blanches vont
couper ou non les lignes de la portée aux endroits où elles se
croisent.  Vous verrez dans les exemples ci-dessous que cela peut se
produire, sans qu'on le sache à l'avance.  Les explications de ce
phénomène et les solutions pour y remédier sont exposées dans
@ruser{Painting objects white}.  Pour le moment, acceptons cet
inconvénient et concentrons-nous sur l'apprentissage de la gestion des
couleurs. 

La @code{grob-interface} indique que la valeur de la propriété
@code{color} est une liste, sans plus d'explication.  En fait, cette
liste est une liste de valeurs en unités internes ; pour éviter d'avoir
à chercher ce qu'il faut y mettre, il existe différents moyens
d'indiquer la couleur.  Le premier moyen consiste à utiliser l'une des
couleurs @emph{normales} de la première @ruser{List of colors}.  Pour
mettre les barres de mesure en blanc, on écrit :  

@cindex BarLine, exemple de dérogation
@cindex color, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override Staff.BarLine #'color = #white
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

@noindent
et nous constatons que les barres de mesure sont une fois de plus
invisibles.  Attention : aucune apostrophe ne précède @code{white} -- il
ne s'agit pas d'un symbole mais d'une @strong{fonction}.  Quand on
l'invoque, elle fournit une liste de valeurs internes requises pour
changer la couleur en blanc.  Les autres couleurs aussi, dans la
@qq{liste normale}, sont des fonctions.  Pour en être certain, vous
pouvez faire l'essai en choisissant une autre fonction de la liste en
guise de couleur. 

@cindex couleur X11
@cindex X11, couleurs

@funindex x11-color

Le deuxième moyen de changer la couleur consiste à utiliser la deuxième
@ruser{List of colors}, dite noms de couleurs X11.  Ceux-ci doivent
obligatoirement être précédés d'une autre fonction, qui convertit les
noms de couleurs X11 en une liste de valeurs internes, @code{x11-color},
comme ceci : 

@cindex BarLine, exemple de dérogation
@cindex color, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override Staff.BarLine #'color = #(x11-color 'white)
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

@noindent
Vous noterez que, dans ce cas, la fonction @code{x11-color} admet un
symbole comme argument ; il faut donc placer une apostrophe devant le
symbole et insérer les deux à l'intérieur de parenthèses.  

@cindex rgb, couleur
@cindex couleurs rgb

@funindex rgb-color

Il existe une troisième fonction, écrite pour convertir les valeurs RGB
en couleurs internes --- la fonction @code{rgb-color}.  Elle comporte
trois arguments, donnant respectivement l'intensité du rouge, du vert et
du bleu.  Ces arguments prennent des valeurs comprises entre 0 et 1.
Ainsi, pour choisir la couleur rouge, la valeur serait 
@code{(rgb-color 1 0 0)} ; pour le blanc, ce serait 
@code{(rgb-color 1 1 1)} : 

@cindex BarLine, exemple de dérogation
@cindex color, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override Staff.BarLine #'color = #(rgb-color 1 1 1)
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

Enfin, il existe une échelle de gris parmi les possibilités de couleurs
X11.  Elle va du noir, @code{'grey0}, au blanc, @code{'grey100}, avec
un pas de 1.  Essayons de l'utiliser en attribuant à tous les objets de
notre exemple différentes nuances de gris : 

@cindex StaffSymbol, exemple de dérogation
@cindex TimeSignature, exemple de dérogation
@cindex Clef, exemple de dérogation
@cindex NoteHead, exemple de dérogation
@cindex Stem, exemple de dérogation
@cindex BarLine, exemple de dérogation
@cindex color, exemple d'utilisation de la propriété
@cindex x11-color, exemple d'utilisation

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
{
  \time 12/16
  \override Staff.StaffSymbol   #'color = #(x11-color 'grey30)
  \override Staff.TimeSignature #'color = #(x11-color 'grey60)
  \override Staff.Clef          #'color = #(x11-color 'grey60)
  \override Voice.NoteHead      #'color = #(x11-color 'grey85)
  \override Voice.Stem          #'color = #(x11-color 'grey85)
  \override Staff.BarLine       #'color = #(x11-color 'grey10)
  c4 b8 c d16 c d8 |
  g, a16 b8 c d4 e16 |
  e8
}
@end lilypond

@noindent
Vous remarquerez le contexte associé à chacun des objets.  Une erreur
sur ce point empêcherait la commande de fonctionner.  Souvenez-vous que
le contexte est celui dans lequel est placé le graveur approprié.  Pour
chaque graveur, on peut trouver son contexte par défaut en partant de
l'objet lui-même, puis en cherchant le graveur qui le produit ; la page
du graveur dans la RPI nous indique alors le contexte dans lequel le
graveur se trouve normalement. 


@node Size of objects
@subsection Size of objects

@cindex modification de la taille des objets
@cindex taille d'objets
@cindex objets, taille
@cindex objets, modification de taille

Pour commencer, reprenons l'exemple qui se trouvait dans 
@ref{Nesting music expressions}, qui montrait comment créer une nouvelle
portée temporaire, du type @rglos{ossia}. 

@cindex alignAboveContext, exemple d'utilisation de la propriété
@cindex @code{\with}, exemple

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\new Staff ="main" {
       \relative g' {
         r4 g8 g c4 c8 d |
         e4 r8
         <<
           { f c c }
           \new Staff \with {
             alignAboveContext = #"main" }
           { f8 f c }
         >>
         r4 |
  }
}
@end lilypond

Normalement, les ossia ne comportent ni clef ni indication de mesure, et
elles sont imprimées légèrement plus petit que la portée principale.
Nous avons déjà appris à enlever la clef et la métrique --- il suffit de
régler le stencil de chacun sur @code{#f}, comme ceci : 

@cindex alignAboveContext, exemple d'utilisation de la propriété
@cindex @code{\with}, exemple
@cindex stencil, exemple d'utilisation de la propriété
@cindex Clef, exemple de dérogation
@cindex TimeSignature, exemple de dérogation

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\new Staff ="main" {
  \relative g' {
    r4 g8 g c4 c8 d |
    e4 r8
    <<
      { f c c }
      \new Staff \with {
        alignAboveContext = #"main"
      }
      {
        \override Staff.Clef #'stencil = ##f
        \override Staff.TimeSignature #'stencil = ##f
        { f8 f c }
      }
    >>
    r4 |
  }
}
@end lilypond

@noindent
La paire d'accolades ajoutée après la clause @code{\with} est nécessaire
pour être sûr que les retouches (@code{\override}) ainsi que la musique
qui se trouvent à l'intérieur soient bien appliquées à la portée
d'ossia. 

Mais alors, quelle différence y a-t-il à modifier le contexte de portée
au moyen de @code{\with} ou à modifier les stencils de la clef et de la
métrique  avec @code{\override} ?  La principale différence est que les
changements opérés dans une clause @code{\with} sont réalisés au moment
où le contexte est créé et restent par la suite les valeurs @strong{par
défaut} aussi longtemps que ce contexte existe, tandis que les commandes
@code{\set} ou @code{\override} insérées dans la musique sont dynamiques
-- elles provoquent des changements synchronisés avec un point
particulier de la musique.  Si les changements sont annulés ou
désactivés par @code{\unset} ou @code{\revert}, les réglages reprennent
les valeurs par défaut, c'est-à-dire celles qui ont été fixées dans la
clause @code{\with}, ou, en l'absence de celle-ci, les valeurs par
défaut normales. 

Certaines propriétés de contexte ne peuvent être modifiées que dans une
clause @code{\with}.  Il s'agit des propriétés qu'on ne peut évidemment
plus changer après que le contexte a été créé.  C'est le cas de 
@code{alignAboveContext} et de son pendant, @code{alignBelowContext} 
-- une fois que la portée a été créée, son alignement est décidé et cela
n'aurait aucun sens de vouloir le modifier par la suite. 

Dans une clause @code{\with}, on peut aussi régler les valeurs par
défaut des propriétés d'un objet.  Il suffit d'utiliser la commande 
@code{\override} normale, sans s'occuper du nom de contexte 
puisqu'il ne fait pas de doute qu'il s'agit du contexte en cours de 
modification par la clause @code{\with}.  Il se produirait même une 
erreur si le contexte était précisé.

Remplaçons donc l'exemple ci-dessus par celui-ci :

@cindex alignAboveContext, exemple d'utilisation de la propriété
@cindex @code{\with}, exemple
@cindex Clef, exemple de dérogation
@cindex TimeSignature, exemple de dérogation

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\new Staff ="main" {
  \relative g' {
    r4 g8 g c4 c8 d |
    e4 r8
    <<
      { f c c }
      \new Staff \with {
        alignAboveContext = #"main"
        % Don't print clefs in this staff
        \override Clef #'stencil = ##f
        % Don't print time signatures in this staff
        \override TimeSignature #'stencil = ##f
      }
        { f8 f c }
    >>
    r4 |
  }
}
@end lilypond

Venons-en finalement au changement de taille des objets.

Certains objets sont créés comme des glyphes choisis dans une police de
caractères.  C'est le cas des têtes de notes, des altérations, des
@emph{markup}, des clefs, des métriques, des nuances et des paroles.
Pour changer leur taille, on modifie la propriété @code{font-size},
comme nous le verrons rapidement.  D'autres objets, comme les liaisons
de phrasé ou de prolongation --- en général les objets étendus --- sont
dessinés à la demande, si bien qu'aucune @code{font-size} ne leur est
associée.  Ces objets tirent généralement leur dimension des objets
auxquels ils sont rattachés, de sorte qu'on ne doit pas avoir à les
redimensionner à la main.  D'autres propriétés, comme la hauteur des
hampes et des barres de mesure, l'épaisseur des ligatures et d'autres
lignes, et l'écartement des lignes de portée, doivent encore être
modifiées de façon particulière. 

Si l'on revient à l'exemple d'ossia, commençons par changer la taille de
police.  Nous pouvons employer deux méthodes.  Soit nous changeons la
taille de police de chaque type d'objet avec des commandes comme 
celle-ci pour les têtes de notes (@code{NoteHead}) :

@example
\override NoteHead #'font-size = #-2
@end example

soit nous changeons la taille de toutes les polices à la fois grâce à la 
propriété @code{fontSize}, en utilisant @code{\set} ou en l'insérant 
dans une clause @code{\with} (mais alors sans le @code{\set}).

@example
\set fontSize = #-2
@end example

Chacune de ces méthodes réduira la taille de police de deux points par 
rapport à sa valeur précédente, sachant que chaque point réduit ou 
augmente la taille d'environ 12 %.

Essayons sur l'exemple d'ossia :

@cindex alignAboveContext, exemple d'utilisation de la propriété
@cindex @code{\with}, exemple
@cindex Clef, exemple de dérogation
@cindex TimeSignature, exemple de dérogation
@cindex fontSize, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\new Staff ="main" {
  \relative g' {
    r4 g8 g c4 c8 d |
    e4 r8
    <<
      { f c c }
      \new Staff \with {
        alignAboveContext = #"main"
        \override Clef #'stencil = ##f
        \override TimeSignature #'stencil = ##f
        % Reduce all font sizes by ~24%
        fontSize = #-2
      }
        { f8 f c }
    >>
    r4 |
  }
}
@end lilypond

Ce n'est pas encore parfait.  Les têtes de notes et les crochets sont
plus petits mais, proportionnellement, les hampes sont trop longues et
les lignes de portée trop espacées.  Il faut donc les réduire dans les
mêmes proportions que les polices de caractères.  La prochaine
sous-section montrera comment faire. 

@node Length and thickness of objects
@subsection Length and thickness of objects

@cindex distance
@cindex épaisseur
@cindex longueur
@cindex magstep
@cindex taille, modification
@cindex hampe, modification de longueur
@cindex écartement des lignes, modification

Dans LilyPond, les écartements et longueurs sont généralement mesurés en
@qq{intervalles de lignes} (@emph{staff-spaces} en anglais),
c'est-à-dire l'écartement qui sépare deux lignes adjacentes dans la
portée --- plus rarement, il est question de demi-intervalles de lignes.  
Les propriétés d'épaisseur (@code{thickness}), quant à elles, sont
généralement mesurées en unités d'une propriété interne appelée
@qq{épaisseur de ligne} (@code{line-thickness}).  Par exemple, les
lignes de crescendo/decrescendo présentent par défaut une épaisseur de 1
unité de @code{line-thickness}, alors que l'épaisseur d'une hampe est de
1,3.  Toutefois, certaines propriétés d'épaisseur sont différentes : par
exemple, l'épaisseur des ligature se mesure en espaces de portée. 

Dans ces conditions, comment ajuster les longueurs à la taille des 
polices de caractères ?  La solution consiste à utiliser une fonction 
spéciale appelée @code{magstep} --- pseudo facteur de zoom ---, créée
précisément dans ce but.  Elle comporte un argument, le changement de
taille de police (#-2 dans l'exemple précédent), à partir duquel elle
applique un facteur de mise à l'échelle qui réduit, ou augmente, les
objets en proportion.  Voici comment elle s'utilise : 

@cindex alignAboveContext, exemple d'utilisation de la propriété
@cindex @code{\with}, exemple
@cindex Clef, exemple de dérogation
@cindex TimeSignature, exemple de dérogation
@cindex fontSize , exemple d'utilisation de la propriété
@cindex StaffSymbol, exemple de dérogation
@cindex magstep, exemple d'utilisation de la fonction
@cindex staff-space, exemple d'utilisation de la propriété
@cindex stencil, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\new Staff ="main" {
  \relative g' {
    r4 g8 g c4 c8 d |
    e4 r8
    <<
      { f c c }
      \new Staff \with {
        alignAboveContext = #"main"
        \override Clef #'stencil = ##f
        \override TimeSignature #'stencil = ##f
        fontSize = #-2
        % Reduce stem length and line spacing to match
        \override StaffSymbol #'staff-space = #(magstep -2)
      }
        { f8 f c }
    >>
    r4 |
  }
}
@end lilypond

@noindent
Puisque la longueur des hampes et plusieurs autres propriétés de
longueur sont calculées par rapport à la valeur de la propriété
@code{staff-space}, elles sont automatiquement mises à l'échelle.  Vous 
remarquerez que cela n'affecte que la dimension verticale de l'ossia ---
la dimension horizontale étant déterminée par les objets de la portée
principale de façon à rester synchronisée vis-à-vis d'elle, elle n'est
pas affectée par tous ces changements de taille.  Bien sûr, si l'échelle
de toute la portée principale était modifiée, tout le placement
horizontal s'en trouverait affecté.  Il en sera question plus bas dans
cette section. 

Voilà qui complète la création d'une ossia. Les tailles et longueurs de tous 
les objets peuvent être modifiées de manière analogue.

Pour de petits changements d'échelle, comme dans l'exemple ci-dessus, il
n'est généralement pas utile d'ajuster l'épaisseur des différentes
lignes telles que les barres de mesure, les ligatures, les soufflets de
crescendo/decrescendo, les liaisons, etc.  Si l'épaisseur d'un objet en
particulier doit être ajustée, le mieux est de modifier sa propriété
@code{thickness}.  Nous avons vu plus haut, dans 
@ref{Properties of layout objects}, un exemple de modification de
l'épaisseur des liaisons.  L'épaisseur de tous les objets tracés
(c'est-à-dire ceux qui ne proviennent pas d'une police de caractère)
peut être changée de la même manière. 

@node Placement of objects
@section Placement of objects

 @menu
* Automatic behavior::          
* Within-staff objects::        
* Outside staff objects::       
@end menu

@node Automatic behavior
@subsection Automatic behavior

@cindex objets de la portée
@cindex objets extérieurs à la portée
@cindex portée, objets de la
@cindex portée, objets extérieurs à la

Dans la notation musicale, il y a des objets qui appartiennent à la 
portée et d'autres qui sont placés à l'extérieur de la portée. On les 
appelle respectivement les @qq{objets de la portée} (@emph{within-staff
objects} en anglais) et les @qq{objets extérieurs à la portée}
(@emph{outside-staff objects}en anglais). 

Les objets de la portée sont ceux qui sont placés sur la portée 
--- les têtes de notes et les hampes, les altérations, etc.  Leur
position est généralement déterminée par la musique elle-même --- ils
sont placés verticalement sur des lignes spécifiques ou sont liés à
d'autres objets placés de cette manière.  Normalement, les collisions
entre les têtes et queues de notes et les altérations dans des accords
proches sont évitées automatiquement.  Comme nous le verrons rapidement,
il existe des commandes et des possibilités de retouches qui permettent
de modifier ce comportement automatique. 

Parmi les objets extérieurs à la portée, on compte des éléments comme
les marques de reprise, les indications de texte ou de nuances.  Dans
LilyPond, la règle est de placer verticalement ces objets extérieurs à
la portée le plus près possible de la portée, tout en évitant la
collision avec d'autres objets.  LilyPond utilise la propriété
@code{outside-staff-priority} pour déterminer l'ordre selon lequel
placer ces objets, de la manière suivante : 

D'abord, LilyPond dresse la liste de tous les objets extérieurs à la
portée.  Puis ceux-ci sont classés suivant leur
@code{outside-staff-priority}.  Enfin, ils sont pris un par un, en 
commençant par les objets avec la @code{outside-staff-priority} la plus
basse, et placés de façon à ne pas entrer en collision avec d'autres
objets déjà placés.  Cela signifie que, si deux @emph{grobs} extérieurs
à la portée doivent occuper la même place, c'est celui qui a la
@code{outside-staff-priority} la plus basse qui est placé le plus près
de la portée.  Et si deux objets ont la même
@code{outside-staff-priority}, le premier rencontré sera placé le plus
près de la portée.  

Dans l'exemple suivant, tous les @emph{markup} ont la même priorité, 
dans la mesure où rien n'est indiqué explicitement.  Vous remarquerez
que @code{Text3} est également positionné près de la portée, juste
en-dessous de @code{Text2}. 

@cindex markup, exemple

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
c2^"Text1"
c^"Text2"
c^"Text3"
c^"Text4"
@end lilypond

Les portées aussi sont positionnées, par défaut, le plus près possible 
les unes des autres, en ménageant tout de même une certaine séparation.
Si des notes se rapprochent nettement d'une portée adjacente, elles ne
forceront les portées à s'écarter que s'il y a un risque de
chevauchement.  

@lilypond[quote,ragged-right,verbatim]
<<
  \new Staff {
    \relative c' { c a, }
  }
  \new Staff {
    \relative c'''' { c a, }
  }
>>
@end lilypond 


@node Within-staff objects
@subsection Within-staff objects

Nous avons vu que les commandes @code{\voiceXXX} jouent sur la 
direction des liaisons, des doigtés et sur toute autre chose liée à 
l'orientation des queues de notes. Ces commandes sont essentielles dans 
la musique polyphonique pour distinguer des lignes mélodiques 
entremêlées.  Mais il arrive qu'on ait besoin de modifier ce comportement 
automatique.  On peut le faire pour toutes les parties de la musique ou 
juste pour une note.  La propriété qui contrôle ce comportement est la 
propriété @code{direction} de chaque objet.  Expliquons d'abord ce 
qu'elle fait, puis nous présenterons un certain nombre de commandes 
déjà prêtes qui évitent, pour les modifications les plus courantes, 
d'avoir à encoder les retouches. 

Certains objets comme les traits des liaisons se recourbent tantôt 
vers le haut, tantôt vers le bas ; d'autres encore, comme les hampes 
et les crochets, peuvent se décaler vers la gauche ou vers la droite 
selon qu'ils pointent vers le haut ou vers le bas.  Ce comportement est 
géré automatiquement dès lors que @code{direction} est activé. 

@cindex down
@cindex up
@cindex center
@cindex neutral

L'exemple ci-dessous montre dans la première mesure le comportement par 
défaut des hampes --- celles des notes les plus hautes pointant vers le
bas et celles des notes les plus basses pointant vers le haut ; viennent
ensuite quatre notes avec les hampes forcées vers le bas, puis quatre
autres avec les hampes forcées vers le haut, et pour finir quatre notes
de nouveau avec le comportement par défaut. 

@cindex Stem, exemple de dérogation
@cindex direction, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
a4 g c a
\override Stem #'direction = #DOWN
a g c a
\override Stem #'direction = #UP
a g c a
\revert Stem #'direction
a g c a
@end lilypond

Nous utilisons ici les directions @code{DOWN} et @code{UP}.  Elles 
correspondent respectivement aux valeurs @code{-1} et @code{+1}, 
que l'on peut utiliser à la place.  La valeur @code{0} peut aussi être 
utilisée dans certains cas.  Elle est interprétée comme un @code{UP} 
pour les hampes, et comme un @qq{centré} pour d'autres objets.  Il
existe une direction, @code{CENTER}, qui correspond à la valeur
@code{0}. 

Quoi qu'il en soit, ces retouches manuelles sont rarement utilisées car
il existe des équivalents sous forme de commandes prédéfinies.  Voici un
tableau des plus courantes.  Lorsque ce n'est pas évident, leur
signification est précisée. 

@multitable @columnfractions .2 .2 .25 .35
@headitem Bas/Gauche
  @tab Haut/Droite
  @tab Annulation
  @tab Effet
@item @code{\arpeggioArrowDown}
  @tab @code{\arpeggioArrowUp}
  @tab @code{\arpeggioNormal}
  @tab Flèche en bas, en haut, ou pas de flèche
@item @code{\dotsDown}
  @tab @code{\dotsUp}
  @tab @code{\dotsNeutral}
  @tab Déplacement des points pour éviter les lignes de portée
@item @code{\dynamicDown}
  @tab @code{\dynamicUp}
  @tab @code{\dynamicNeutral}
  @tab
@item @code{\phrasingSlurDown}
  @tab @code{\phrasingSlurUp}
  @tab @code{\phrasingSlurNeutral}
  @tab Attention : à distinguer des commandes de liaison ci-dessous
@item @code{\slurDown}
  @tab @code{\slurUp}
  @tab @code{\slurNeutral}
  @tab
@item @code{\stemDown}
  @tab @code{\stemUp}
  @tab @code{\stemNeutral}
  @tab
@item @code{\textSpannerDown}
  @tab @code{\textSpannerUp}
  @tab @code{\textSpannerNeutral}
  @tab Le texte saisi en tant qu'extension est au-dessous/au-dessus de la portée
@item @code{\tieDown}
  @tab @code{\tieUp}
  @tab @code{\tieNeutral}
  @tab
@item @code{\tupletDown}
  @tab @code{\tupletUp}
  @tab @code{\tupletNeutral}
  @tab Les nolets sont au-dessous/au-dessus des notes
@end multitable

Attention : ces commandes prédéfinies @strong{ne doivent pas} être
précédées de @code{\once}.  Pour limiter l'effet à une seule note, il
faut soit utiliser la commande équivalente @code{\once \override}, soit
utiliser la commande prédéfinie, suivie, après la note à modifier, de la
commande @code{\xxxNeutral} correspondante. 

@subheading Fingering

@cindex doigtés, positionnement
@cindex doigtés, accords

Le placement des doigtés sur des notes simples peut aussi être contrôlé
par la propriété @code{direction}, mais le changement de
@code{direction} n'a pas d'effet sur les accords.  Comme nous le
verrons, il existe des commandes qui permettent de contrôler le doigté
sur chaque note d'un accord, en plaçant l'indication de doigté
au-dessus, en dessous, à gauche ou à droite de chaque note. 

Tout d'abord, voici l'effet de @code{direction} sur le doigté lié à une
note simple.  La première mesure montre le comportement par défaut, et
les deux suivantes montrent l'effet lorsqu'on indique @code{DOWN} et
@code{UP} : 

@cindex doigtés, exemple de dérogation
@cindex direction, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,relative=2]
c-5 a-3 f-1 c'-5
\override Fingering #'direction = #DOWN
c-5 a-3 f-1 c'-5
\override Fingering #'direction = #UP
c-5 a-3 f-1 c'-5
@end lilypond

Le fait d'intervenir sur la propriété @code{direction} n'est sûrement
pas la façon la plus simple de placer manuellement les doigtés au-dessus
ou en dessous des notes ; mieux vaut utiliser @code{_} ou @code{^}
devant le chiffre de doigté plutôt que @code{-}.  Voici ce que donne
l'exemple précédent avec cette méthode : 

@cindex doigtés, exemple

@lilypond[quote,verbatim,relative=2]
c-5 a-3 f-1 c'-5
c_5 a_3 f_1 c'_5
c^5 a^3 f^1 c'^5
@end lilypond

La propriété @code{direction} ne fonctionne pas pour les accords alors
que les préfixes de direction, @code{_} et @code{^}, fonctionnent.  Par
défaut, le doigté est placé automatiquement à la fois au-dessus et
au-dessous des notes d'un accord, comme ceci : 

@cindex doigtés, exemple

@lilypond[quote,verbatim,relative=2]
<c-5 g-3>
<c-5 g-3 e-2>
<c-5 g-3 e-2 c-1>
@end lilypond

@noindent
mais il est possible de forcer manuellement vers le haut ou vers le bas le 
placement de tous ou certains chiffres de doigté, comme ceci :

@cindex doigtés, exemple

@lilypond[quote,verbatim,relative=2]
<c-5 g-3 e-2 c-1>
<c^5 g_3 e_2 c_1>
<c^5 g^3 e^2 c_1>
@end lilypond

On peut aller encore plus loin dans le positionnement des doigtés pour
chacune des notes d'un accord grâce à la commande
@code{\set@tie{}fingeringOrientations}.  La syntaxe de cette commande
est : 

@example
@code{\set fingeringOrientations = #'([up] [left/right] [down])}
@end example

@noindent
On utilise @code{\set} car @code{fingeringOrientations} est une propriété 
du contexte @code{Voice}, créée et utilisée par le graveur 
@code{New_fingering_engraver}.

On peut attribuer à cette propriété une liste composée de une à trois 
valeurs.  Celles-ci déterminent si l'indication de doigté doit être
placée au-dessus (lorsque @code{up} apparaît dans la liste), au-dessous
(lorsque @code{down} apparaît), à gauche (lorsque @code{left} apparaît)
ou à droite (lorsque @code{right} apparaît).  En revanche, si une valeur
n'est pas sur la liste, aucun doigté n'ira à cet emplacement.  LilyPond
garde ces contraintes en mémoire et recherche le meilleur emplacement
pour le doigté des notes des accords suivants.  Vous remarquerez que
@code{left} et @code{right} s'excluent l'un l'autre --- l'indication de
doigté ne peut être placée que d'un côté ou de l'autre, pas des deux. 

@warning{Pour contrôler à l'aide de cette commande le placement du
doigté sur une note simple, il faut la saisir comme un accord composé
d'une note unique, en l'encadrant de chevrons.}

Voici quelques exemples : 

@cindex doigtés, exemple
@cindex @code{\set}, exemple d'utilisation
@cindex fingeringOrientations, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
\set fingeringOrientations = #'(left)
<f-2>
< c-1  e-2 g-3 b-5 > 4
\set fingeringOrientations = #'(left)
<f-2>
< c-1  e-2 g-3 b-5 > 4
\set fingeringOrientations = #'(up left down)
<f-2>
< c-1  e-2 g-3 b-5 > 4
\set fingeringOrientations = #'(up left)
<f-2>
< c-1  e-2 g-3 b-5 > 4
\set fingeringOrientations = #'(right)
<f-2>
< c-1  e-2 g-3 b-5 > 4
@end lilypond

@noindent
Si les indications de doigtés paraissent un peu serrées, on peut 
toujours réduire la taille de police (@code{font-size}).  La valeur 
par défaut donnée dans la RPI à la page de l'objet 
@code{Fingering} étant @code{-5}, essayons @code{-7} :

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
\override Fingering #'font-size = #-7
\set fingeringOrientations = #'(left)
<f-2>
< c-1  e-2 g-3 b-5 > 4
\set fingeringOrientations = #'(left)
<f-2>
< c-1  e-2 g-3 b-5 > 4
\set fingeringOrientations = #'(up left down)
<f-2>
< c-1  e-2 g-3 b-5 > 4
\set fingeringOrientations = #'(up left)
<f-2>
< c-1  e-2 g-3 b-5 > 4
\set fingeringOrientations = #'(right)
<f-2>
< c-1  e-2 g-3 b-5 > 4
@end lilypond


@node Outside staff objects
@subsection Outside staff objects

Les objets extérieurs à la portée sont placés automatiquement de façon à
éviter les collisions.  Les objets avec la plus petite valeur de la
propriété @code{outside-staff-priority} sont placés au plus près de la
portée, tandis que les autres sont écartés autant qu'il faut pour éviter
les collisions.  La @code{outside-staff-priority} est définie dans la
@code{grob-interface} ; elle est donc une propriété commune à tous les
objets de rendu.  Par défaut, elle est réglée sur @code{#f} pour tous
les objets de la portée, et porte une valeur numérique appropriée à
chacun des objets extérieurs à la portée, à mesure qu'ils sont créés.
Le tableau suivant montre la valeur numérique par défaut pour
quelques-uns des objets extérieurs à la portée les plus courants qui
sont placés, par défaut, dans les contextes @code{Staff} ou
@code{Voice}. 

@multitable @columnfractions .3 .3 .3
@headitem Objet de rendu
  @tab Priorité 
  @tab Contrôle la position de :
@item @code{MultiMeasureRestText}
  @tab @code{450}
  @tab Texte sur les silences qui couvrent des mesures entières 
@item @code{TextScript}
  @tab @code{450}
  @tab Texte des @emph{markup} (ou étiquettes)
@item @code{OttavaBracket}
  @tab @code{400}
  @tab Indication d'octaviation
@item @code{TextSpanner}
  @tab @code{350}
  @tab Bandeau ou extension de texte
@item @code{DynamicLineSpanner}
  @tab @code{250}
  @tab Toutes les marques de nuances
@item @code{VoltaBracketSpanner}
  @tab @code{100}
  @tab Bandeau de répétition
@item @code{TrillSpanner}
  @tab @code{50}
  @tab Bandeau de trille
@end multitable

Voici un exemple qui montre le placement par défaut de certains 
d'entre eux.

@cindex extension de texte
@cindex indication d'octaviation

@funindex \startTextSpan
@funindex startTextSpan
@funindex \stopTextSpan
@funindex stopTextSpan

@cindex TextSpanner, exemple de dérogation
@cindex bound-details, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
% Set details for later Text Spanner
\override TextSpanner #'bound-details #'left #'text
    = \markup { \small \bold Slower }
% Place dynamics above staff
\dynamicUp
% Start Ottava Bracket
\ottava #1
c' \startTextSpan
% Add Dynamic Text
c\pp
% Add Dynamic Line Spanner
c\<
% Add Text Script
c^Text
c c
% Add Dynamic Text
c\ff c \stopTextSpan
% Stop Ottava Bracket
\ottava #0
c, c c c
@end lilypond

Cet exemple montre comment créer des extensions de texte (@emph{Text
Spanners} en anglais ) -- texte avec des longues lignes au-dessus d'un
passage musical.  L'extension s'étend depuis la commande
@code{\startTextSpan} jusqu'à la commande @code{\stopTextSpan} et le
format de texte est défini par la commande @code{\override TextSpanner}.
Pour de plus amples détails, voir @ruser{Text spanners}.

Il montre aussi comment créer des marques d'octaviation.

@cindex modification du positionnement des numéros de mesure
@cindex numéros de mesure, modification du positionnement
@cindex modification du positionnement des indications métronomiques
@cindex indications métronomiques, modification du positionnement
@cindex modification du positionnement des marques de repère
@cindex marques de repère, modification du positionnement

Vous aurez remarqué que les numéros de mesure, l'indication métronomique
et les marques de répétition n'apparaissent pas.  Par défaut, ils sont
créés dans le contexte @code{Score} et leur
@code{outside-staff-priority} est ignorée face aux objets qui sont créés
dans le contexte @code{Staff}.  Si vous voulez faire apparaître les
numéros de mesure, l'indication métronomique ou les marques de
répétition conformément à la valeur de leur
@code{outside-staff-priority}, il vous faudra retirer respectivement le
@code{Bar_number_engraver}, le @code{Metronome_mark_engraver} ou le
@code{Mark_engraver} du contexte @code{Score} et les placer en tête du
contexte @code{Staff}.  Après quoi ces marques porteront les valeurs de 
@code{outside-staff-priority} par défaut suivantes : 

@multitable @columnfractions .3 .3
@headitem Objet de rendu          @tab Priorité
@item @code{RehearsalMark}        @tab @code{1500}
@item @code{MetronomeMark}        @tab @code{1000}
@item @code{BarNumber}            @tab @code{ 100}
@end multitable

Si les valeurs de @code{outside-staff-priority} par défaut ne donnent
pas les résultats que vous attendez, il suffit de modifier la priorité
de l'un de ces objets.  Supposons que vous vouliez placer l'indication
d'octaviation sous le bandeau de texte, dans l'exemple précédent.  Tout
ce que nous devons faire, c'est regarder la priorité de
@code{OttavaBracket} dans la RPI ou dans le tableau plus haut, et la
ramener à une valeur plus basse que celle de @code{TextSpanner}, en
gardant à l'esprit que @code{OttavaBracket} est créé dans le contexte
@code{Staff} : 

@cindex TextSpanner, exemple de dérogation
@cindex bound-details, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
% Set details for later Text Spanner
\override TextSpanner #'bound-details #'left #'text
    = \markup { \small \bold Slower }
% Place dynamics above staff
\dynamicUp
%Place following Ottava Bracket below Text Spanners
\once \override Staff.OttavaBracket #'outside-staff-priority = #340
% Start Ottava Bracket
\ottava #1
c' \startTextSpan
% Add Dynamic Text
c\pp
% Add Dynamic Line Spanner
c\<
% Add Text Script
c^Text
c c
% Add Dynamic Text
c\ff c \stopTextSpan
% Stop Ottava Bracket
\ottava #0
c, c c c
@end lilypond

@cindex liaisons et outside-staff-priority
@cindex liaisons et articulations
@cindex articulations et liaisons

Les liaisons sont intrinsèquement des objets membres de la portée
(@emph{within-staff objects}) bien qu'elles la surplombent lorsque les
notes auxquelles elles se rattachent sont relativement hautes.  Ceci
peut avoir pour conséquence de remonter d'autant les objets externes
(@emph{outside-staff objects}) tels les articulations.  La propriété
@code{avoid-slur} de l'articulation en question peut se voir déterminée
à @code{'inside} dans le but de @qq{ramener} cette articulation à
l'intérieur de la liaison.  Cette propriété @code{avoid-slur} ne sera
toutefois effective que dans la mesure où la
@code{outside-staff-priority} est désactivée (valeur @code{#f}).  Dans
le même esprit, il est possible d'affecter un valeur numérique
particulière à la propriété @code{outside-staff-priority} d'une
liaison dans le but de regrouper la liaison avec les objets externes.
L'exemple suivant illustre ces deux différentes méthodes.

@lilypond[quote,verbatim,relative=2]
c4( c^\markup\tiny\sharp d4.) c8
c4(
\once \override TextScript #'avoid-slur = #'inside
\once \override TextScript #'outside-staff-priority = ##f
c^\markup\tiny\sharp d4.) c8
\once \override Slur #'outside-staff-priority = #500
c4( c^\markup\tiny\sharp d4.) c8
@end lilypond

Le fait de changer la @code{outside-staff-priority} peut aussi servir à
contrôler le positionnement vertical des objets individuels, quoique le
résultat ne soit pas toujours formidable.  Imaginons que nous voulions
placer @qq{Text3} au-dessus de @qq{Text4} dans l'exemple de la section
Comportement automatique, plus haut (voir @ref{Automatic behavior}).  Il
nous suffit pour cela de regarder dans la RPI ou dans le tableau plus
haut la priorité de @code{TextScript}, et d'augmenter la priorité de
@qq{Text3} jusqu'à une valeur très haute : 

@cindex TextScript, exemple de dérogation
@cindex outside-staff-priority, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
c2^"Text1"
c^"Text2"
\once \override TextScript #'outside-staff-priority = #500
c^"Text3"
c^"Text4"
@end lilypond

S'il est vrai que cela place @qq{Text3} au-dessus de @qq{Text4}, ça le
place aussi plus haut que @qq{Text2} tandis que @qq{Text4} dégringole.
Ce n'est peut-être pas si bien que ça.  En fait, ce que nous aimerions
faire, c'est placer toutes les annotations à égale distance de la
portée.  Pour cela, nous avons besoin d'espacer horizontalement les
notes pour laisser plus de place au texte.  C'est possible grâce à la
commande @code{textLengthOn}. 

@subheading \textLengthOn

@cindex notes, répartition selon le texte

@funindex \textLengthOn
@funindex textLengthOn
@funindex \textLengthOff
@funindex textLengthOff

Par défaut, l'espacement horizontal d'un texte produit sous forme de
@emph{markup} (ou d'étiquette) n'est pas pris en compte, dans la mesure
où ce qui est concerné n'entre pas dans la musique.  La commande
@code{\textLengthOn} inverse ce comportement, faisant en sorte que les
notes soient espacées autant qu'il faut pour s'adapter au texte :  

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\textLengthOn  % Cause notes to space out to accommodate text
c2^"Text1"
c^"Text2"
c^"Text3"
c^"Text4"
@end lilypond  

La commande qui permet de revenir au comportement par défaut est 
@code{\textLengthOff}.  Rappelez-vous que @code{\once} ne 
fonctionne qu'avec @code{\override}, @code{\set}, @code{\revert} ou 
@code{\unset}, et donc ne peut pas être utilisé avec 
@code{\textLengthOn}.

@cindex étiquette de texte et collision

Les textes des @emph{markup} éviteront également les notes qui
s'échappent au-dessus de la portée.  Si ce n'est pas notre souhait, il
est possible de supprimer ce déplacement automatique vers le haut en
attribuant à la priorité la valeur @code{#f}.  Voici un exemple qui
montre comment les textes des @emph{markup} interagissent avec ces types
de notes. 

@cindex TextScript, exemple de dérogation
@cindex outside-staff-priority, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
% This markup is short enough to fit without collision
c2^"Tex"
c''2
R1
% This is too long to fit, so it is displaced upwards
c,,2^"Text"
c''2
R1
% Turn off collision avoidance
\once \override TextScript #'outside-staff-priority = ##f
c,,2^"Long Text   "
c''2
R1
% Turn off collision avoidance
\once \override TextScript #'outside-staff-priority = ##f
\textLengthOn  % and turn on textLengthOn
c,,2^"Long Text   "  % Spaces at end are honored
c''2
@end lilypond


@subheading Dynamics

@cindex modifier le positionnement des nuances
@cindex nuances, modifier le positionnement

Les indications de nuances se placent normalement sous la portée mais on
peut les placer au-dessus avec la commande @code{dynamicUp}.  Elles se
positionnent verticalement par rapport à la note à laquelle elles sont
liées et se décalent vers le bas (ou le haut) en fonction des objets de
la portée comme les liaisons de phrasé ou les numéros de mesure.  Cela
peut donner d'assez bons résultats, comme le montre cet exemple : 

@lilypond[quote,fragment,ragged-right,verbatim,relative=1]
\clef "bass"
\key aes \major
\time 9/8
\dynamicUp
bes4.~\f\< \( bes4 bes8 des4\ff\> c16 bes\! |
ees,2.~\)\mf ees4 r8 |
@end lilypond

De toute façon, si les notes et les nuances qui leur sont liées sont 
trop proches, le positionnement automatique évitera les collisions en  
déplaçant davantage les nuances suivantes, mais le résultat peut ne 
pas être très satisfaisant, comme le montre cet exemple artificiel : 

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\dynamicUp
a4\f b\mf c\mp b\p
@end lilypond

@noindent
Si une telle situation devait survenir dans de la musique @qq{réelle},
il serait préférable d'espacer un peu plus les notes, de façon que les
indications de nuance puissent toutes se situer à la même distance de la
portée.  Il était possible de faire cela pour les textes de
@emph{markup} grâce à la commande @code{\textLengthOn} mais il n'existe
pas d'équivalent pour les indications de nuance.  Il nous faut donc
chercher à faire cela avec la commande @code{\override}. 

@subheading Grob sizing

@cindex grob, dimensionnement
@cindex dimensionnement des grobs

Tout d'abord, nous devons apprendre ce qui détermine la dimension des 
grobs. Tous les grobs portent en eux un point de référence qui est 
utilisé pour les positionner par rapport à leur objet parent. Ce point du 
grob est placé à une distance horizontale, @code{X-offset}, 
et à une distance verticale, @code{Y-offset}, de son parent. 
L'étendue horizontale de l'objet est fixée par une paire de 
nombres, @code{X-extent}, qui donnent la position du coin 
gauche et du coin droit par rapport au point de référence.  De 
même, l'étendue verticale est fixée par une paire de nombre, 
@code{Y-extent}. Ce sont des propriétés communes à tous les 
grobs et que gère la @code{grob-interface}.

@cindex @code{extra-spacing-width}

Par défaut, la largeur des objets extérieurs à la portée est donnée 
comme étant nulle, si bien qu'ils peuvent se chevaucher 
horizontalement. Pour arriver à cela, on a ajouté l'infini à 
l'extension gauche et moins l'infini à l'extension droite, en 
attribuant à @code{extra-spacing-width} la valeur
 @code{'(+inf.0 . -inf.0)}. Pour être sûr que les objets ne se 
chevaucheront pas horizontalement, nous devons donc corriger 
cette valeur de @code{extra-spacing-width} en @code{'(0 . 0)}, 
afin que leur vraie largeur se manifeste. La commande pour y 
parvenir avec des indications de nuances est : 

@example
\override DynamicText #'extra-spacing-width = #'(0 . 0)
@end example

@noindent
Voyons si ça marche sur notre exemple précédent :

@cindex DynamicText, exemple de dérogation
@cindex extra-spacing-width, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\dynamicUp
\override DynamicText #'extra-spacing-width = #'(0 . 0)
a4\f b\mf c\mp b\p
@end lilypond

@noindent
Bon, cela a mis un terme aux déplacements verticaux des 
nuances mais il reste deux problèmes. Il faudrait que les 
nuances soient un peu plus écartées et ce serait mieux si 
elles étaient toutes à la même distance de la portée. Le 
premier problème est simple à résoudre. Au lieu d'attribuer 
à @code{extra-spacing-width} la valeur zéro, nous pourrions 
mettre un peu plus. L'unité est la distance entre deux lignes 
de portée, donc en écartant le bord gauche d'une demi-unité 
et le bord droit d'une demi-unité, on obtient : 

@cindex DynamicText, exemple de dérogation
@cindex extra-spacing-width, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\dynamicUp
% Extend width by 1 staff space
\override DynamicText #'extra-spacing-width = #'(-0.5 . 0.5)
a4\f b\mf c\mp b\p
@end lilypond

@noindent
C'est mieux mais nous voulons peut-être aligner les indications de 
nuances sur une même ligne plutôt que de les voir monter et 
descendre avec les notes. La propriété qui gère cela est 
@code{staff-padding} ; la section suivante lui est consacrée.


@node Collisions of objects
@section Collisions of objects

@menu
* Moving objects::              
* Fixing overlapping notation::  
* Real music example::          
@end menu

@node Moving objects
@subsection Moving objects

@cindex déplacement d'objets se chevauchant
@cindex déplacement d'objets en collision
@cindex déplacement de grobs en collision
@cindex objets, évitement des collisions
@cindex grobs, évitement des collisions

Aussi surprenant que cela puisse paraître, LilyPond n'est pas parfait.
Certains éléments sur la partition peuvent se chevaucher, ce qui est 
regrettable mais, le plus souvent, facile à corriger. En général, quand 
on déplace des objets, c'est pour des raisons de lisibilité ou 
d'esthétique --- ils rendraient mieux avec un peu plus ou un peu moins 
d'espace autour d'eux. 

Il y a trois façons de résoudre les problèmes de chevauchement.  Il est 
préférable de les aborder dans l'ordre suivant :

@enumerate
@item
L'@strong{orientation} d'un objet qui en chevauche un autre peut être 
changée grâce aux commandes prédéfinies dont la liste a été donnée 
plus haut à propos des objets de portée (voir @ref{Within-staff objects}). 
Les queues de notes, les liaisons de phrasé et de prolongation, les 
crochets, les nuances et les nolets peuvent facilement être repositionnés 
de cette manière. En contrepartie, vous n'avez le choix qu'entre deux 
positions, sans personnalisation possible.

@item
Les @strong{propriétés d'objet}, auxquelles LilyPond a recours pour 
positionner les objets, sont modifiables avec @code{\override}.  Il y a deux 
avantages à changer ces propriétés : (a) d'autres objets pourront être 
déplacés automatiquement si nécessaire pour faire de la place, et (b) 
la même retouche peut s'appliquer à toutes les occurrences du même 
type d'objet.  Ces propriétés sont :

@itemize

@item
@code{direction}

Ce point a déjà été traité en détails --- voir @ref{Within-staff objects}.

@item
@code{padding}, @code{left-padding},
@code{right-padding}, @code{staff-padding}

@cindex décalage (padding)
@cindex left-padding, propriété
@cindex padding, propriété
@cindex right-padding, propriété
@cindex staff-padding, propriété

Au moment de positionner un objet, la valeur de sa propriété 
@code{padding} détermine l'espace à laisser libre entre celui-ci et le 
coin le plus proche de l'objet à côté duquel il est placé. Vous remarquerez 
que c'est la valeur @code{padding} de l'objet @strong{à placer} qui 
compte ; la valeur @code{padding} de l'objet déjà placé est ignorée. 
Les espaces libres déterminés par @code{padding} s'appliquent à tous 
les objets associés à la @code{side-position-interface}.

Le positionnement de groupes d'altérations est contrôlé par 
@code{left-padding} et @code{right-padding}, et non plus @code{padding}.
Ces propriétés appartiennent à l'objet @code{AccidentalPlacement}, qui, 
vous le remarquerez, prend place dans le contexte @strong{Staff}. Dans le 
processus de composition, les têtes de notes sont composées en premier, 
puis les altérations, s'il y en a, sont ajoutées à gauche des têtes de notes 
suivant la propriété @code{right-padding} qui détermine l'espacement par 
rapport aux têtes de notes. C'est pourquoi seule la propriété 
@code{right-padding} de l'objet @code{AccidentalPlacement} joue sur le 
positionnement des altérations. 

La propriété @code{staff-padding} est très proche de la propriété 
@code{padding} : @code{padding} contrôle l'espace minimum entre un 
objet qui accepte la @code{side-position-interface} et l'objet le plus 
proche (généralement une note ou une ligne de portée) ; @code{staff-padding} 
ne s'applique qu'aux objets qui sont toujours placés en-dehors de la portée -- 
il contrôle l'espace minimum à insérer entre l'objet et la portée. Attention : 
par défaut, @code{staff-padding} concerne les objets positionnés par rapport 
à la portée et n'a aucun effet sur les objets qui sont positionnés par
rapport à une note ; il est toutefois possible de le régler pour
fonctionner avec ces derniers. 

Pour trouver quelle propriété @code{padding} employer pour l'objet que vous 
cherchez à repositionner, il vous faut consulter les propriétés de l'objet dans 
la RPI. Prenez garde que les propriétés @code{padding} ne sont pas forcément 
traitées dans l'objet en question ; il faut alors regarder les objets
qui semblent s'en rapprocher. 

Toutes les valeurs @code{padding} sont exprimées en espaces de portée. 
Pour la plupart des objets, la valeur par défaut est aux alentours de 1.0, 
parfois moins (cela dépend de chaque objet). Il est possible de la modifier 
lorsqu'on a besoin d'un espace vide plus grand (ou plus petit).


@item
@code{self-alignment-X}

@cindex self-alignment-X,  propriété

Cette propriété sert à aligner les objets sur la gauche, sur la droite ou 
à les centrer par rapport au point de référence des objets parents. 
Elle peut être utilisée avec tous les objets qui acceptent la 
@code{self-alignment-interface}. Il s'agit, en général, des objets qui 
contiennent du texte. Les valeurs admises sont @code{LEFT}, 
@code{RIGHT} et @code{CENTER}. On peut aussi attribuer à 
la place une valeur numérique entre @code{-1} et @code{+1}, 
où @code{-1} signifie alignement sur la gauche, @code{+1} 
alignement sur la droite, et les nombres intermédiaires déplacent 
progressivement le texte de la gauche vers la droite. Des valeurs 
numériques supérieures à @code{1} sont également admises 
pour déplacer le texte encore plus loin vers la gauche, ou des 
valeurs inférieures à @code{-1} pour déplacer le texte encore 
plus loin vers la droite. Un écart de @code{1} en valeur 
correspond à un déplacement de la moitié de la longueur du 
texte.

@item
@code{extra-spacing-width}

@cindex extra-spacing-width, propriété

Cette propriété est utilisée pour tous les objets qui acceptent la 
@code{item-interface}. Elle reçoit deux nombres, le premier étant 
ajouté au bord gauche et le second au bord droit. Des nombres 
négatifs déplacent le coin vers la gauche, des nombres positifs 
vers la droite, si bien que pour élargir un objet, le premier nombre 
doit être négatif et le second positif. Attention : tous les objets 
n'acceptent pas forcément les deux nombres. Par exemple, l'objet 
@code{Accidental} ne retient que le premier nombre (coin gauche).


@item
@code{staff-position}

@cindex staff-position, propriété

@code{staff-position} est une propriété de la 
@code{staff-symbol-referencer-interface}, qui s'applique aux objets 
positionnés par rapport à la portée. Elle indique, en demi-espaces de 
portée, la position verticale des objets par rapport à la ligne médiane 
de la portée. C'est bien pratique pour résoudre des problèmes de 
collision entre des objets comme les silences valant mesure entière, 
les liaisons et les notes de différentes voix.

@item
@code{force-hshift}

@cindex force-hshift, propriété

Des notes très proches dans un accord, ou des notes simultanées dans 
différentes voix, peuvent être disposées sur deux colonnes, rarement 
plus, pour éviter que les têtes de notes ne se chevauchent. On parle 
alors de colonnes (ou empilement) de notes et un objet appelé
@code{NoteColumn} est créé pour placer les notes sur la colonne.

La propriété @code{force-hshift} appartient à @code{NoteColumn} (en 
réalité à la @code{note-column-interface}). Le fait de la modifier permet 
de déplacer une colonne de notes selon l'unité appropriée aux colonnes 
de notes, à savoir la largeur des têtes de notes de la première voix. Son 
utilisation est réservée à des situations complexes dans lesquelles les 
commandes habituelles @code{\shiftOn} 
(voir @ref{Explicitly instantiating voices}) ne suffisent plus à résoudre les 
conflits. Elle est alors préférable à l'utilisation de la propriété 
@code{extra-offset}, dans la mesure où on n'a pas besoin d'exprimer 
la distance en espaces de portée et où le fait de déplacer les notes à 
l'intérieur ou à l'extérieur d'une @code{NoteColumn} affecte d'autres 
actions comme les fusionnements de notes.

@end itemize

@item
Pour terminer, quand toutes les autres méthodes ont échoué, il est 
possible de repositionner verticalement les objets à la main par rapport 
à la ligne médiane de la portée, ou en les déplaçant à une distance 
donnée vers une nouvelle position. Les inconvénients sont qu'il faut
individuellement pour chaque objet trouver les valeurs correctes de 
repositionnement, souvent par tâtonnement, et que, puisque le 
mouvement est opéré après que LilyPond a placé tous les autres 
objets, c'est à l'utilisateur de résoudre tous les problèmes de collisions 
qui pourraient survenir. Et le pire avec cette méthode est que, le jour 
où la musique est modifiée, il faut de nouveau rechercher les 
valeurs de repositionnement. Les propriétés à utiliser pour ce type de 
repositionnement manuel sont :


@table @code
@item extra-offset

@cindex extra-offset, propriété

Cette propriété s'applique à tout objet acceptant la @code{grob-interface}. 
Elle reçoit une paire de nombre qui indiquent le déplacement supplémentaire 
dans le sens horizontal et vertical. Des nombres négatifs déplacent l'objet 
vers la gauche ou vers la droite. L'unité utilisée est l'espace de portée. Le 
déplacement supplémentaire intervient une fois que la composition des 
objets est achevée, si bien qu'un objet peut être repositionné à n'importe 
quel endroit sans que ça perturbe quoi que ce soit. 

@item positions

@cindex positions, propriété

Cette propriété est très utile pour ajuster manuellement l'inclinaison et 
la hauteur des barres de ligature, des liaisons et des nolets. Elle est  
suivie de deux nombres qui donnent la position des bords gauche et 
droit des barres, liaisons, etc., par rapport à la ligne médiane de la 
portée. L'unité de référence est l'intervalle de lignes de portée. Attention 
toutefois au fait que les liaisons et phrasés ne peuvent pas être repositionnés 
n'importe où. LilyPond commence par dresser la liste des emplacements 
possibles pour les liaisons et choisit par défaut la liaison qui @qq{semble 
la meilleure}. Si la propriété @code{positions} a été retouchée, la 
liaison la plus proche de la position demandée sera retenue dans la 
liste.
@end table

@end enumerate

Il est possible qu'un objet ne dispose pas de toutes ces propriétés. Il 
est donc nécessaire de consulter la RPI pour vérifier quelles sont les 
propriétés disponibles pour l'objet en question. 

Voici une liste d'objets les plus couramment impliqués dans les 
collisions, avec le nom de l'objet à consulter dans la RPI afin de trouver 
les propriétés à retoucher pour obtenir un déplacement.


@multitable @columnfractions .5 .5
@headitem Type d'objet              @tab Nom d'objet
@item Articulations                 @tab @code{Script}
@item Barres de ligature            @tab @code{Beam}
@item Doigté                        @tab @code{Fingering}
@item Liaisons de phrasé            @tab @code{Slur}   
@item Liaisons de prolongation      @tab @code{Tie}
@item Nolets                        @tab @code{TupletBracket}
@item Nuances (verticalement)       @tab @code{DynamicLineSpanner}
@item Nuances (horizontalement)     @tab @code{DynamicText}
@item Reprises / marques de texte   @tab @code{RehearsalMark}
@item Texte, p.ex. @code{^"texte"}  @tab @code{TextScript}
@end multitable


@node Fixing overlapping notation
@subsection Fixing overlapping notation

Voyons maintenant comment les propriétés décrites dans la section 
précédente peuvent nous aider à résoudre les collisions. 

@subheading padding property

@cindex décalage (padding)
@cindex résolution des chevauchements de notation
@cindex chevauchement de notation

En jouant sur la propriété @code{padding} (littéralement 
@qq{rembourrage}), on augmente (ou on diminue) la distance entre 
des symboles qui sont imprimés au-dessus ou en dessous des notes. 

@cindex Script, exemple de dérogation
@cindex padding, exemple d'utilisation de la propriété

@lilypond[quote,fragment,relative=1,verbatim]
c2\fermata
\override Script #'padding = #3
b2\fermata
@end lilypond

@cindex MetronomeMark, exemple de dérogation
@cindex padding, exemple d'utilisation de la propriété

@lilypond[quote,fragment,relative=1,verbatim]
% This will not work, see below:
\override MetronomeMark #'padding = #3
\tempo 4=120
c1
% This works:
\override Score.MetronomeMark #'padding = #3
\tempo 4=80
d1
@end lilypond

Vous remarquerez dans le second exemple à quel point il est important de 
préciser le nom du contexte qui contient l'objet. Puisque l'objet 
@code{MetronomeMark} appartient au contexte @code{Score}, le fait de 
modifier la propriété dans le contexte @code{Voice} passera inaperçu. 
Pour plus de détails, voir @ruser{Modifying properties}.

Si on augmente la propriété @code{padding} d'un objet alors que celui-ci 
fait partie d'un ensemble d'objets positionnés en fonction de leur 
@code{outside-staff-priority}, cet objet sera déplacé, ainsi que tous les 
autres objets du groupe. 

@subheading left-padding and right-padding

@cindex left-padding, propriété
@cindex right-padding, propriété

La propriété @code{right-padding} joue sur l'espacement entre une 
altération et la note sur laquelle elle porte. On ne l'utilise pas souvent, 
mais l'exemple ci-dessous montre une situation où elle est nécessaire. 
Imaginons que nous voulions faire apparaître un accord qui contienne 
à la fois un si bécarre et un si bémol. Pour qu'il n'y ait pas de doute, 
nous chercherions à précéder la note d'un signe bécarre et d'un signe 
bémol. Voici différentes tentatives pour y parvenir : 

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
<b bes>
<b! bes>
<b? bes>
@end lilypond

Aucune n'est satifaisante, et la seconde se solde même par une
collision  entre les deux signes. 

Une solution pour arriver à nos fins consiste à retoucher le stencil des 
altérations grâce à un markup qui contient les symboles bécarre et 
bémol, dans l'ordre que nous souhaitons, comme ceci :

@cindex Accidental, exemple de dérogation
@cindex text, exemple d'utilisation de la propriété
@cindex stencil, exemple d'utilisation de la propriété
@cindex AccidentalPlacement, exemple de dérogation
@cindex right-padding, exemple d'utilisation de la propriété

@lilypond[quote,ragged-right,verbatim]
naturalplusflat = \markup { \natural \flat }
\relative c'' {
  \once \override Accidental
    #'stencil = #ly:text-interface::print
  \once \override Accidental #'text = #naturalplusflat
  \once \override Score.AccidentalPlacement #'right-padding = #1.5
  <b bes>
}
@end lilypond

@noindent
Cette méthode utilise, pour le stencil des altérations, une retouche 
qui ne sera pas reprise par la suite. Le type de stencil est obligatoirement 
une procédure, qui consiste ici à imprimer le contenu de la propriété 
@code{text} de @code{Accidental}, déclaré comme étant un signe 
bécarre suivi d'un signe bémol. Celui-ci est ensuite repoussé devant la 
tête de note par la retouche de @code{right-padding}.

@noindent

@subheading staff-padding property

@cindex alignement d'objets sur une ligne de base
@cindex objets, alignement sur une ligne de base

@code{staff-padding} sert à aligner des objets tels que des nuances 
sur une ligne fictive à une hauteur donnée par rapport à la portée, plutôt 
qu'à une hauteur qui varie en fonction de la position de la note sur laquelle 
porte l'objet. Ce n'est pas une propriété de @code{DynamicText} mais de 
@code{DynamicLineSpanner}. Car la ligne fictive est destinée à s'appliquer 
autant à @strong{toutes} les nuances, notamment celles qui sont créées 
comme des bandeaux en longueur (en anglais @q{Spanners}). Tel est donc 
le moyen d'aligner les indications de nuances, comme dans cet exemple 
repris de la section précédente : 

@cindex DynamicText, exemple de dérogation
@cindex extra-spacing-width, exemple d'utilisation de la propriété
@cindex DynamicLineSpanner, exemple de dérogation
@cindex staff-padding, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\dynamicUp
% Extend width by 1 unit
\override DynamicText #'extra-spacing-width = #'(-0.5 . 0.5)
% Align dynamics to a base line 2 units above staff
\override DynamicLineSpanner #'staff-padding = #2
a4\f b\mf c\mp b\p
@end lilypond


@subheading self-alignment-X property

L'exemple suivant montre comment résoudre une collision entre une indication 
de corde et une queue de note, en alignant le coin droit sur le point de 
référence de la note parente :

@cindex StringNumber, exemple de dérogation
@cindex self-alignment-X, exemple d'utilisation de la propriété

@lilypond[quote,fragment,ragged-right,verbatim,relative=3]
\voiceOne
< a \2 >
\once \override StringNumber #'self-alignment-X = #RIGHT
< a \2 >
@end lilypond

@subheading staff-position property

@cindex collision d'objets à l'intérieur d'une portée

Dans une voix, un silence valant une mesure entière peut chevaucher les 
notes d'une autre voix.  Vu que ces silences sont centrés entre les deux 
barres de mesure, il serait très compliqué de programmer LilyPond pour
repérer ces risques de collision, dans la mesure où, normalement, toutes
les collisions entre notes ou entre notes et silences se produisent sur
des notes et silences simultanés. Voici un exemple de collision de ce type :

@lilypond[quote,verbatim,fragment,ragged-right, relative=1]
<< {c c c c} \\ {R1} >>
@end lilypond

Ici, la meilleure solution consiste à déplacer le symbole de pause vers
le bas --- puisque cette pause appartient à la voix deux.  Par défaut,
dans la @code{\voiceTwo} (c'est-à-dire dans la seconde voix d'une
construction  @code{<<@{...@} \\ @{...@}>>}), la propriété
@code{staff-position} est réglée sur -4 pour les MultiMeasureRest ; nous
avons donc besoin de la déplacer, disons, de quatre demi-intervalles
vers le bas, ce qui donne @code{-8}.


@cindex MultiMeasureRest, exemple de dérogation
@cindex staff-position, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,fragment,ragged-right, relative=1]
<<
  {c c c c}
\\
  \override MultiMeasureRest #'staff-position = #-8
  {R1}
>>
@end lilypond

C'est mieux que d'utiliser, par exemple, @code{extra-offset}, 
car la ligne supplémentaire au-dessus du silence est insérée 
automatiquement. 

@subheading extra-offset property

@cindex positionnement des objets
@cindex positionnement des grobs
@cindex objets, positionnement
@cindex grobs, positionnement

La propriété @code{extra-offset} offre la possibilité de contrôler 
entièrement le placement d'un objet, aussi bien horizontalement que 
verticalement. 

Dans l'exemple suivant, la seconde indication de doigté est déplacée 
légèrement vers la gauche et de 1,8 intervalle de lignes vers le bas :

@cindex Fingering, exemple de dérogation
@cindex extra-offset, exemple d'utilisation de la propriété

@lilypond[quote,fragment,relative=1,verbatim]
\stemUp
f-5
\once \override Fingering
    #'extra-offset = #'(-0.3 . -1.8)
f-5
@end lilypond


@subheading positions property

@cindex contrôle des nolets, liaisons, phrasés et ligatures
@cindex gestion manuelle des nolets, liaisons, phrasés et ligatures
@cindex ligatures de nolet, gestion manuelle
@cindex liaisons, gestion manuelle
@cindex phrasés, gestion manuelle
@cindex ligatures, gestion manuelle

La propriété @code{positions} permet de contrôler manuellement la 
position et l'inclinaison des nolets, coulés, liaisons de phrasé et barres 
de ligature. Voici un exemple avec une horrible liaison de phrasé --- 
horrible pour avoir tenté de contourner la liaison de l'acciaccature.

@lilypond[quote,verbatim,fragment,ragged-right,relative=1]
r4  \acciaccatura e8\( d8 c ~c d c d\)
@end lilypond

@noindent
Nous pourrions tout simplement déplacer la liaison de phrasé au-dessus des
notes, et ce serait la meilleure solution :

@lilypond[quote,verbatim,fragment,ragged-right,relative=1]
r4
\phrasingSlurUp
\acciaccatura e8\( d8 c ~c d c d\)
@end lilypond

@noindent
Mais si, pour une quelconque raison, cette solution n'était pas 
envisageable, l'autre solution consiste à déplacer légèrement vers le 
bas l'extrémité gauche de la liaison de phrasé, grâce à la propriété 
@code{positions}. Cela corrige en même temps la forme plutôt 
disgracieuse de la liaison.

@cindex PhrasingSlur, exemple de dérogation
@cindex positions, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,fragment,ragged-right,relative=1]
r4
\once \override PhrasingSlur #'positions = #'(-4 . -3)
\acciaccatura
e8\( d8 c ~c d c d\)
@end lilypond

Voici un autre exemple, tiré du début de la partie de main gauche 
du Prélude de Chopin, Op. 28, No 2. Comme nous pouvons le 
constater, les barres de ligature chevauchent les notes les plus hautes :

@lilypond[quote,verbatim,fragment,ragged-right]
{
\clef "bass"
<< {b,8 ais, b, g,} \\ {e, g e, g} >>
<< {b,8 ais, b, g,} \\ {e, g e, g} >>
}
@end lilypond

@noindent
On peut y remédier en déplaçant manuellement vers le haut les deux 
extrémités des barres de croches, non plus à 2 intervalles au-dessus 
de la ligne médiane mais, disons, à 3 :

@cindex Beam, exemple de dérogation
@cindex positions, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,fragment,ragged-right]
{
  \clef "bass"
  <<
    \override Beam #'positions = #'(3 . 3)
    {b,8 ais, b, g,}
  \\
    {e, g e, g}
  >>
  << {b,8 ais, b, g,} \\ {e, g e, g} >>
}
@end lilypond

@noindent
Vous remarquerez que la retouche continue à s'appliquer au 
second bloc de croches de la première voix mais qu'il ne s'applique 
à aucune barre de la deuxième voix.

@subheading force-hshift property

@c FIXME: formatting stuff  (ie not important right now IMO)
@c @a nchor Chopin finally corrected TODOgp

Maintenant, nous sommes prêts à appliquer les dernières corrections  à
l'exemple de Chopin présenté à la fin de @ref{I'm hearing Voices}, que 
nous avions laissé dans cet état :

@lilypond[quote,verbatim,fragment,ragged-right]
\new Staff \relative c'' {
  \key aes \major
  <<
    { c2 aes4. bes8 } \\
    { aes2 f4 fes   } \\
    { \voiceFour
      <ees c>2
      des2
    }
  >> |
  <c ees aes c>1 |
}
@end lilypond

@noindent
Les deux plus basses notes du premier accord (c'est-à-dire celles de la 
troisième voix) ne devraient pas être décalées de l'empilement des deux 
plus hautes notes. Pour y remédier, nous réglons le @code{force-hshift} 
--- qui est une propriété de @code{NoteColumn} --- de ces notes sur zéro. 
Ensuite, la note la plus basse du second accord serait mieux à droite des 
notes plus hautes. Pour cela, nous réglons le @code{force-hshift} de cette 
note sur 0,5 --- c'est-à-dire la moitié de la largeur d'une tête de note
vers la droite de la colonne des notes plus hautes.

Et voici le résultat final :

@cindex NoteColumn, exemple de dérogation
@cindex force-hshift, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,fragment,ragged-right]
\new Staff \relative c'' {
  \key aes \major
  <<
    { c2 aes4. bes8 } \\
    { aes2 f4 fes   } \\
    { \voiceFour
      \once \override NoteColumn #'force-hshift = #0 <ees c>2
      \once \override NoteColumn #'force-hshift = #0.5 des2
    }
  >> |
  <c ees aes c>1 |
}
@end lilypond


@node Real music example
@subsection Real music example

Pour terminer ce chapitre consacré aux retouches, voici, étape par 
étape, la mise en forme d'un exemple concret nécessitant un certain 
nombre de retouches jusqu'à l'obtention du résultat attendu. Cet exemple 
a été choisi en raison des problèmes inhabituels de notation qu'il soulevait 
et pour vous apprendre à les résoudre grâce au Manuel de notation.  Il
n'est pas représentatif d'une opération normale de gravure ; que ces 
difficultés ne vous découragent donc pas ! Des difficultés comme celles-ci 
ne sont, heureusement, pas courantes !

Cet exemple est tiré de la Première Ballade de Chopin, Op. 23, mesures 
6 à 9 ; cela correspond à la transition entre le Lento d'ouverture et le 
Moderato. Voici, pour commencer, ce à quoi nous voulons que la 
partition ressemble ; pour limiter les complications, nous n'avons pas 
fait apparaître les indications de nuances, de doigté ni de pédale.


@c The following should appear as music without code
@c This example should not be indexed
@lilypond[quote,ragged-right]
rhMusic = \relative c'' {
  r2
  c4.\( g8 |
  \once \override Tie #'staff-position = #3.5
  bes1~ |
  \bar "||"
  \time 6/4
  \mergeDifferentlyHeadedOn
  \mergeDifferentlyDottedOn
  bes2.^\markup {\bold "Moderato"} r8
  <<
    {c,8[ d fis bes a] | }
  \\
    % Reposition the c2 to the right of the merged note
    {c,8~ \once \override NoteColumn #'force-hshift = #1.0
    % Move the c2 out of the main note column so the merge will work
    \shiftOnn c2}
  \\
    % Stem on the d2 must be down to permit merging
    {s8 \stemDown \once \override Stem #'transparent = ##t d2}
  \\
    {s4 fis4.}
  >>
  \mergeDifferentlyHeadedOff
  \mergeDifferentlyDottedOff
  g2.\)
}

lhMusic = \relative c' {
  r2 <c g ees>2( |
  <d g, d>1)\arpeggio |
  r2. d,,4 r4 r |
  r4
}

\score {
  \new PianoStaff <<
    \new Staff = "RH"  <<
      \key g \minor
      \rhMusic
    >>
    \new Staff = "LH" <<
      \key g \minor
      \clef "bass"
      \lhMusic
    >>
  >>
}
@end lilypond

Nous constatons tout d'abord que, dans la troisième mesure, la main 
droite compte quatre voix. Ce sont les cinq croches avec une barre, 
le do avec liaison, le ré blanche qui se fond avec le ré croche, et le 
fa dièse noire pointée qui se fond lui aussi avec la croche de même 
hauteur. Tout le reste se réduit à une seule voix. Le plus simple est 
donc de créer temporairement ces quatre voix au moment opportun. 
Si vous avez oublié comment faire, reportez-vous à 
@ref{I'm hearing Voices}. Commençons par saisir les notes comme 
appartenant à deux variables, mettons en place l'ossature des 
portées dans un bloc score et voyons ce que LilyPond propose par 
défaut : 

@lilypond[quote,verbatim,ragged-right]
rhMusic = \relative c'' {
  r2 c4. g8 |
  bes1~ |
  \time 6/4
  bes2. r8
  % Start polyphonic section of four voices
  <<
    {c,8 d fis bes a | }
  \\
    {c,8~ c2 | }
  \\
    {s8 d2 | }
  \\
    {s4 fis4. | }
  >>
  g2.
}

lhMusic = \relative c' {
  r2 <c g ees>2 |
  <d g, d>1 |
  r2. d,,4 r4 r |
  r4
}

\score {
  \new PianoStaff <<
    \new Staff = "RH"  <<
      \key g \minor
      \rhMusic
    >>
    \new Staff = "LH" <<
      \key g \minor
      \clef "bass"
      \lhMusic
    >>
  >>
}
@end lilypond

Toutes les notes sont correctes mais l'allure générale est loin d'être 
satisfaisante. La liaison se heurte à l'indication de mesure lors du 
changement de chiffrage, la barre des croches n'est pas bonne dans la 
troisième mesure, les notes ne sont pas fusionnées et il manque plusieurs 
éléments de notation. Commençons par le plus simple. Nous pouvons 
corriger la barre des croches en la créant manuellement et nous pouvons 
facilement ajouter les limites droite et gauche de la liaison de phrasé, 
puisque tout cela a déjà été traité dans le tutoriel. Voici le résultat :

@lilypond[quote,verbatim,ragged-right]
rhMusic = \relative c'' {
  r2 c4.\( g8 |
  bes1~ |
  \time 6/4
  bes2. r8
  % Start polyphonic section of four voices
  <<
    {c,8[ d fis bes a] | }
  \\
    {c,8~ c2 | }
  \\
    {s8 d2 | }
  \\
    {s4 fis4. | }
  >>
  g2.\)
}

lhMusic = \relative c' {
  r2 <c g ees>2( |
  <d g, d>1) |
  r2. d,,4 r4 r |
  r4
}

\score {
  \new PianoStaff <<
    \new Staff = "RH"  <<
      \key g \minor
      \rhMusic
    >>
    \new Staff = "LH" <<
      \key g \minor
      \clef "bass"
      \lhMusic
    >>
  >>
}
@end lilypond

La première mesure est maintenant correcte. La seconde contient un arpège 
et doit se terminer par une double barre. Comment faire, puisque cela n'a pas 
été traité dans le Manuel d'initiation ? C'est alors qu'il faut nous
reporter au Manuel de notation.  Quand on cherche @qq{arpège} et @qq{barre
de mesure} dans l'index, on voit aisément qu'il faut ajouter
@code{\arpeggio} à un accord pour produire un arpège et qu'une double
barre est le résultat de la commande @code{\bar "||"}.  Rien de plus
facile ! Nous devons ensuite corriger la collision entre la liaison et
l'indication de mesure. Le mieux est de déplacer la liaison vers le
haut. La méthode pour déplacer les objets a déjà été présentée dans
@ref{Moving objects}, et l'on sait que, pour des objets positionnés par
rapport à la portée, il nous faut modifier leur propriété
@code{staff-position}, exprimée en demi-intervalles de lignes par
rapport à la ligne médiane de la portée.  Voici donc la retouche à
insérer juste devant la première note liée ; elle est censée déplacer la
liaison vers le haut de 3,5 demi-intervalles de lignes au-dessus de la
ligne médiane : 

@code{\once \override Tie #'staff-position = #3.5}

Cela s'adjoint à la deuxième mesure, pour donner :

@lilypond[quote,verbatim,ragged-right]
rhMusic = \relative c'' {
  r2 c4.\( g8 |
  \once \override Tie #'staff-position = #3.5
  bes1~ |
  \bar "||"
  \time 6/4
  bes2. r8
  % Start polyphonic section of four voices
  <<
    {c,8[ d fis bes a] | }
  \\
    {c,8~ c2 | }
  \\
    {s8 d2 | }
  \\
    {s4 fis4. | }
  >>
  g2.\)
}

lhMusic = \relative c' {
  r2 <c g ees>2( |
  <d g, d>1)\arpeggio |
  r2. d,,4 r4 r |
  r4
}

\score {
  \new PianoStaff <<
    \new Staff = "RH"  <<
      \key g \minor
      \rhMusic
    >>
    \new Staff = "LH" <<
      \key g \minor
      \clef "bass"
      \lhMusic
    >>
  >>
}
@end lilypond

Venons-en à la troisième mesure et au début de la section Moderato. Dans 
le Tutoriel, il est indiqué comment insérer du texte en gras à l'aide de la 
commande @code{\markup} ; pas de problème, du coup, pour ajouter 
@qq{Moderato} en gras. Mais comment faire pour fusionner les notes de 
différentes voix ? C'est là que le Manuel de notation peut nous venir en 
aide. Une recherche sur @qq{fusionnement de notes} dans l'index nous
renvoie au chapitre @ruser{Collision resolution}, et plus précisément
aux  commandes permettant de fusionner des notes en fonction de leur
type et selon que elles sont pointées ou non.  Dans notre exemple, pour
la durée de la polyphonie de la troisième mesure, nous avons besoin de
fusionner deux types de notes ; grâce aux informations trouvées dans le
Manuel de notation, nous ajoutons  

@example
\mergeDifferentlyHeadedOn
\mergeDifferentlyDottedOn
@end example

@noindent
au début de cette section et

@example
\mergeDifferentlyHeadedOff
\mergeDifferentlyDottedOff
@end example

@noindent
à la fin, ce qui donne : 

@lilypond[quote,verbatim,ragged-right]
rhMusic = \relative c'' {
  r2 c4.\( g8 |
  \once \override Tie #'staff-position = #3.5
  bes1~ |
  \bar "||"
  \time 6/4
  bes2.^\markup {\bold "Moderato"} r8
  \mergeDifferentlyHeadedOn
  \mergeDifferentlyDottedOn
  % Start polyphonic section of four voices
  <<
    {c,8[ d fis bes a] | }
  \\
    {c,8~ c2 | }
  \\
    {s8 d2 | }
  \\
    {s4 fis4. | }
  >>
  \mergeDifferentlyHeadedOff
  \mergeDifferentlyDottedOff
  g2.\)
}

lhMusic = \relative c' {
  r2 <c g ees>2( |
  <d g, d>1)\arpeggio |
  r2. d,,4 r4 r |
  r4
}

\score {
  \new PianoStaff <<
    \new Staff = "RH"  <<
      \key g \minor
      \rhMusic
    >>
    \new Staff = "LH" <<
      \key g \minor
      \clef "bass"
      \lhMusic
    >>
  >>
}
@end lilypond

Ces retouches ont permis de fusionner les deux fa dièse mais pas les 
deux ré. Pourquoi ? La réponse se trouve dans la même section du 
Manuel de notation : les notes à fusionner doivent avoir des queues dans 
des directions opposées et deux notes ne peuvent pas être fusionnées s'il 
y a une troisième note dans la même colonne. Ici, les deux ré ont leur 
queue orientée vers le haut et il y a une troisième note, do. Nous 
savons changer l'orientation de la queue avec @code{\stemDown} et 
le Manuel de notation nous indique également comment déplacer le do 
--- en produisant un décalage grâce à l'une des commandes @code{\shift}.
Mais laquelle ? Le do appartient à la deuxième voix et n'est pas décalé ; 
les deux ré appartiennent respectivement à la première et à la troisième 
voix, et l'un n'est pas décalé tandis que l'autre l'est. Il nous faut donc 
décaler largement le do avec la commande @code{\shiftOnn} pour 
éviter une interférence avec les deux ré. Voici ce que donnent ces 
modifications : 

@cindex Tie, exemple de dérogation
@cindex staff-position, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,ragged-right]
rhMusic = \relative c'' {
  r2 c4.\( g8 |
  \once \override Tie #'staff-position = #3.5
  bes1~ |
  \bar "||"
  \time 6/4
  bes2.^\markup {\bold "Moderato"} r8
  \mergeDifferentlyHeadedOn
  \mergeDifferentlyDottedOn
  % Start polyphonic section of four voices
  <<
    {c,8[ d fis bes a] | }
  \\
    % Move the c2 out of the main note column so the merge will work
    {c,8~ \shiftOnn c2 | }
  \\
    % Stem on the d2 must be down to permit merging
    {s8 \stemDown d2 | }
  \\
    {s4 fis4. | }
  >>
  \mergeDifferentlyHeadedOff
  \mergeDifferentlyDottedOff
  g2.\)
}

lhMusic = \relative c' {
  r2 <c g ees>2( |
  <d g, d>1)\arpeggio |
  r2. d,,4 r4 r |
  r4
}

\score {
  \new PianoStaff <<
    \new Staff = "RH"  <<
      \key g \minor
      \rhMusic
    >>
    \new Staff = "LH" <<
      \key g \minor
      \clef "bass"
      \lhMusic
    >>
  >>
}
@end lilypond

Pas loin. Il ne reste plus que deux problèmes : les ré une fois fusionnés 
ne devraient plus avoir de queue vers le bas, et le do serait mieux à la 
droite des ré. Nous savons remédier à ces deux problèmes grâce aux 
retouches précédentes : nous allons rendre la queue transparente et 
déplacer le do avec la propriété @code{force-hshift}. Et voici le 
résultat final : 

@cindex NoteColumn, exemple de dérogation
@cindex force-hshift, exemple d'utilisation de la propriété
@cindex Stem, exemple de dérogation
@cindex transparent, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,ragged-right]
rhMusic = \relative c'' {
  r2
  c4.\( g8 |
  \once \override Tie #'staff-position = #3.5
  bes1~ |
  \bar "||"
  \time 6/4
  bes2.^\markup {\bold "Moderato"} r8
  \mergeDifferentlyHeadedOn
  \mergeDifferentlyDottedOn
  <<
    {c,8[ d fis bes a] | }
  \\
    % Reposition the c2 to the right of the merged note
    {c,8~ \once \override NoteColumn #'force-hshift = #1.0
    % Move the c2 out of the main note column so the merge will work
    \shiftOnn c2}
  \\
    % Stem on the d2 must be down to permit merging
    {s8 \stemDown \once \override Stem #'transparent = ##t d2}
  \\
    {s4 fis4.}
  >>
  \mergeDifferentlyHeadedOff
  \mergeDifferentlyDottedOff
  g2.\)
}

lhMusic = \relative c' {
  r2 <c g ees>2( |
  <d g, d>1)\arpeggio |
  r2. d,,4 r4 r |
  r4
}

\score {
  \new PianoStaff <<
    \new Staff = "RH"  <<
      \key g \minor
      \rhMusic
    >>
    \new Staff = "LH" <<
      \key g \minor
      \clef "bass"
      \lhMusic
    >>
  >>
}

@end lilypond


@node Further tweaking
@section Further tweaking

@menu
* Other uses for tweaks::       
* Using variables for tweaks::  
* Other sources of information::  
* Avoiding tweaks with slower processing::  
* Advanced tweaks with Scheme::  
@end menu

@node Other uses for tweaks
@subsection Other uses for tweaks

@cindex transparent, utilisation de la propriété
@cindex création d'objet invisible
@cindex suppression d'objets
@cindex objets, suppression d'
@cindex masquage d'objets
@cindex objets, masquage d'
@cindex invisibles, objets
@cindex objets, invisibles
@cindex liaison de tenue avec changement de voix

@subheading Tying notes across voices

Voici un exemple qui montre comment créer une liaison de 
prolongation entre des notes appartenant à des voix différentes. En 
temps normal, seules deux notes appartenant à une même voix 
peuvent être ainsi liées. La solution consiste à utiliser deux voix, 
dont l'une avec les notes liées

@lilypond[quote,fragment,relative=2]
<< { b8~ b8\noBeam }
\\ { b[ g8] }
>>
@end lilypond

@noindent
et à rendre transparente la première queue de note de cette voix ; 
on a alors l'impression que la liaison couvre les deux voix.

@cindex Stem, exemple de dérogation
@cindex transparent, exemple d'utilisation de la propriété

@lilypond[quote,fragment,relative=2,verbatim]
<<
  {
    \once \override Stem #'transparent = ##t
    b8~ b8\noBeam
  }
\\
  { b[ g8] }
>>
@end lilypond

Pour être sûr que la queue que nous avons rendue transparente 
n'empiète pas trop sur le trait de liaison, nous pouvons l'allonger en 
réglant la longueur (@code{length}) sur @code{8},

@lilypond[quote,fragment,relative=2,verbatim]
<<
  {
    \once \override Stem #'transparent = ##t
    \once \override Stem #'length = #8
    b8~ b8\noBeam
  }
\\
  { b[ g8] }
>>
@end lilypond

@subheading Simulating a fermata in MIDI

@cindex stencil, utilisation de la propriété
@cindex point d'orgue, rendu en MIDI

En ce qui concerne les objets extérieurs à la portée, quand on veut les 
faire disparaître de la partition imprimée , il est généralement préférable 
de modifier leur propriété @code{stencil} plutôt que leur propriété 
@code{transparent}. Le fait d'attribuer à la propriété @code{stencil} 
d'un objet la valeur @code{#f} supprimera entièrement celui-ci de la 
partition. Il ne risquera donc pas de gêner le placement d'autres objets.

Par exemple, si nous voulons changer le réglage de métronome pour 
simuler un point d'orgue dans le fichier MIDI, nous ne voulons surtout 
pas que cette indication métronomique apparaisse sur la partition ni 
qu'elle influence l'espacement entre les deux systèmes ou la position 
des annotations voisines sur la portée. Le fait d'attribuer à la propriété 
@code{stencil} la valeur @code{#f} est donc la bonne solution. Nous 
montrons ci-dessous le résultat des deux méthodes : 

@cindex MetronomeMark, exemple de dérogation
@cindex transparent, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,ragged-right]
\score {
  \relative c'' {
    % Visible tempo marking
    \tempo 4=120
    a4 a a
    \once \override Score.MetronomeMark #'transparent = ##t
    % Invisible tempo marking to lengthen fermata in MIDI
    \tempo 4=80
    a\fermata
    % New tempo for next section
    \tempo 4=100
    a a a a
  }
  \layout { }
  \midi { }
}
@end lilypond

@cindex MetronomeMark, exemple de dérogation
@cindex stencil, exemple d'utilisation de la propriété

@lilypond[quote,verbatim,ragged-right]
\score {
  \relative c'' {
    % Visible tempo marking
    \tempo 4=120
    a4 a a
    \once \override Score.MetronomeMark #'stencil = ##f
    % Invisible tempo marking to lengthen fermata in MIDI
    \tempo 4=80
    a\fermata
    % New tempo for next section
    \tempo 4=100
    a a a a
  }
  \layout { }
  \midi { }
}
@end lilypond

@noindent
Les deux méthodes permettent d'enlever l'indication métronomique qui
allonge le point d'orgue de la partition, et toutes deux modifient le
rythme MIDI comme souhaité, mais, dans la première, l'indication
métronomique transparente repousse vers le haut l'indication de tempo,
contrairement à la seconde (avec le stencil désactivé) qui la laisse à
sa place. 


@node Using variables for tweaks
@subsection Using variables for tweaks

@cindex variables, utilisation dans les retouches
@cindex utilisation de variables dans les retouches
@cindex retouches et utilisation de variables

Les commandes de retouche sont souvent longues et pénibles à 
taper, et ne tolèrent pas la moindre erreur. Lorsqu'on a besoin de 
faire plusieurs fois les mêmes retouches, il est préférable de 
définir des variables qui les contiennent. 

Imaginons que nous voulions accentuer certains mots dans des paroles en
les mettant en italiques.  Au lieu des commandes @code{\italic} et
@code{\bold}, qui ne fonctionnent dans les paroles que si elles sont
enchâssées dans un @code{\markup}, ce qui les rend pénibles à saisir,
pouvons-nous employer les commandes @code{\override} et @code{\revert} ?

@example
@code{\override Lyrics . LyricText #'font-shape = #'italic}
@code{\override Lyrics . LyricText #'font-series = #'bold}

@code{\revert Lyrics . LyricText #'font-shape}
@code{\revert Lyrics . LyricText #'font-series}
@end example

Là encore, ce serait extrêmement pénible à saisir, surtout s'il y avait 
beaucoup de mots à retoucher de cette façon. Plutôt que cette 
solution, nous déclarons ces commandes comme étant deux variables 
et les utilisons comme suit --- quoique on choisirait sans doute pour
les variables des noms plus courts pour simplifier la frappe : 

@cindex LyricText, exemple de dérogation
@cindex font-shape, exemple d'utilisation de la propriété
@cindex font-series, exemple d'utilisation de la propriété

@lilypond[quote,verbatim]
emphasize = {
  \override Lyrics . LyricText #'font-shape = #'italic
  \override Lyrics . LyricText #'font-series = #'bold
}
normal = {
  \revert Lyrics . LyricText #'font-shape
  \revert Lyrics . LyricText #'font-series
}

global = { \time 4/4 \partial 4 \key c \major}
SopranoMusic   = \relative c' { c4 | e4. e8 g4  g  | a a g }
AltoMusic  = \relative c' { c4 | c4. c8 e4  e  | f f e }
TenorMusic = \relative c  { e4 | g4. g8 c4. b8 | a8 b c d e4 }
BassMusic  = \relative c  { c4 | c4. c8 c4  c  | f8 g a b c4 }
VerseOne   = \lyrics { E -- | ter -- nal \emphasize Fa -- ther, \normal | strong to save, }
VerseTwo   = \lyricmode { O | \emphasize Christ, \normal whose voice the | wa -- ters heard, }
VerseThree = \lyricmode { O | \emphasize Ho -- ly Spi -- rit, \normal | who didst brood }
VerseFour  = \lyricmode { O | \emphasize Tri -- ni -- ty \normal of | love and pow'r }

\score {
  \new ChoirStaff <<
    \new Staff <<
      \clef "treble"
      \new Voice = "Soprano"  { \voiceOne \global \SopranoMusic }
      \new Voice = "Alto" { \voiceTwo \AltoMusic }
      \new Lyrics \lyricsto "Soprano" { \VerseOne   }
      \new Lyrics \lyricsto "Soprano" { \VerseTwo   }
      \new Lyrics \lyricsto "Soprano" { \VerseThree }
      \new Lyrics \lyricsto "Soprano" { \VerseFour  }
    >>
    \new Staff <<
      \clef "bass"
      \new Voice = "Tenor" { \voiceOne \TenorMusic }
      \new Voice = "Bass"  { \voiceTwo \BassMusic  }
    >>
  >>
}
@end lilypond


@node Other sources of information
@subsection Other sources of information

La Référence du programme contient beaucoup d'informations sur 
LilyPond.  Cependant vous pouvez en découvrir encore plus en consultant
les fichiers internes de LilyPond.  Pour cela, il vous faut d'abord
connaître le répertoire @emph{ad hoc} sur votre système.  L'emplacement
du répertoire dépend (a) du fait que, pour vous procurer LilyPond, vous
avez téléchargé un paquet précompilé sur lilypond.org, ou vous l'avez
installé grâce à votre gestionnaire de paquetages (c'est-à-dire
distribué avec Linux ou installé avec fink ou cygwin), ou encore vous
l'avez compilé directement à partir des sources ; et (b) du système
d'exploitation sous lequel il tourne. 

@strong{Téléchargé depuis lilypond.org}

@itemize @bullet
@item Linux

@file{@var{INSTALLDIR}/lilypond/usr/share/lilypond/current/}

@item MacOS X

@file{@var{INSTALLDIR}/LilyPond.app/Contents/Resources/share/lilypond/current/}
Pour accéder à ce dossier, deux possibilités : soit, dans un Terminal,
taper @code{cd} suivi du chemin complet ci-dessus ; soit
Control-cliquer (ou clic droit) sur l'application LilyPond
et sélectionner @qq{Afficher le contenu du paquet}.

@item Windows

Dans l'Explorateur Windows, voir
@file{@var{INSTALLDIR}/LilyPond/usr/share/lilypond/current/}

@end itemize

@strong{Installé par un gestionnaire de paquetages ou compilé d'après
les sources} 

@file{@var{PREFIX}/share/lilypond/@var{X.Y.Z}/}, où
@var{PREFIX} est déterminé par votre gestionnaire de paquetages ou par
le script @code{configure}, et @var{X.Y.Z} est le numéro de version de
LilyPond. 

@smallspace

Dans ce répertoire, deux sous-répertoires sont particulièrement
intéressants : 

@itemize
@item @file{ly/} --- contient les fichiers en format LilyPond
@item @file{scm/} --- contient les fichiers en format Scheme
@end itemize

Commençons par examiner quelques fichiers contenus dans @file{ly/}.
Nous ouvrons @file{ly/property-init.ly} dans un éditeur de texte ---
celui que vous avez l'habitude d'utiliser pour les fichiers @code{.ly}
fera très bien l'affaire.  Ce fichier contient les définitions de toutes
les commandes standard prédéfinies de LilyPond, comme @code{\stemUp} et  
@code{\slurDotted}.  Vous pouvez constater que ce n'est rien d'autre 
que des définitions de variables composées d'un ou plusieurs groupes 
de commandes @code{\override}.  Par exemple, @code{\tieDotted} 
est défini comme :

@example
tieDotted = @{
  \override Tie #'dash-period = #0.75
  \override Tie #'dash-fraction = #0.1
@}
@end example

Si vous n'aimez pas les valeurs par défaut, les commandes prédéfinies 
peuvent être facilement redéfinies, comme n'importe quelle autre
variable, en tête de votre fichier d'entrée.

Voici les fichiers les plus utiles dans le répertoire @file{ly/} :

@multitable @columnfractions .4 .6
@headitem Nom de fichier
  @tab Contenu
@item @file{ly/engraver-init.ly}
  @tab Définitions des Contextes de graveurs
@item @file{ly/paper-defaults-init.ly}
  @tab Réglages papier par défaut
@item @file{ly/performer-init.ly}
  @tab Définitions des Contextes d'interprétation
@item @file{ly/property-init.ly}
  @tab Définitions de toutes les commandes prédéfinies courantes
@item @file{ly/spanner-init.ly}
  @tab Définitions des commandes prédéfinies pour les bandeaux 
@end multitable

Les autres réglages (comme les définitions de commandes @emph{markup})
sont conservés comme fichiers @code{.scm} (Scheme).  Le langage de 
programmation Scheme offre une interface programmable dans le 
processus interne de LilyPond.  De plus amples explications sur ces 
fichiers dépasseraient le cadre de ce manuel, dans la mesure où elles 
requièrent la connaissance du langage Scheme.  Les utilisateurs qui 
souhaiteraient comprendre le fonctionnement de ces fichiers de 
configuration doivent être avertis que des connaissances techniques 
substantielles et beaucoup de temps sont nécessaires (voir le 
@ref{Scheme tutorial}).

Si c'est votre cas, les fichiers Scheme les plus utiles à connaître sont :

@multitable @columnfractions .4 .6
@headitem Nom de fichier
  @tab Contenu
@item @file{scm/auto-beam.scm}
  @tab Régles par défaut des ligatures subalternes
@item @file{scm/define-grobs.scm}
  @tab Réglages par défaut des propriétés de grobs
@item @file{scm/define-markup-commands.scm}
  @tab Spécification de toutes les commandes de @emph{markup}
@item @file{scm/midi.scm}
  @tab Réglages par défaut pour les sorties MIDI
@item @file{scm/output-lib.scm}
  @tab Réglages affectant l'apparence des frets, couleurs, altérations,
       barres de mesure, etc.
@item @file{scm/parser-clef.scm}
        @tab Définition des clefs prises en charge
@item @file{scm/script.scm}
        @tab Réglages par défaut des articulations
@end multitable



@node Avoiding tweaks with slower processing
@subsection Avoiding tweaks with slower processing

LilyPond peut effectuer des vérifications supplémentaires lors du 
traitement des fichiers ; cependant, le rendu nécessitera alors plus de 
temps.  En contrepartie, il y aura moins d'ajustements manuels à
réaliser.  Si une indication textuelle ou des paroles  débordent dans la
marge, ces vérifications auront pour effet de serrer la ligne
suffisamment pour faire tenir le texte entre les marges.  

Pour pouvoir fonctionner en toutes circonstances, ces vérifications
doivent être activées ; il faut pour cela placer les retouches dans un
bloc @code{Score \with}, plutôt qu'à l'intérieur du fragment musical,
comme ceci : 

@example
\new Score \with @{
  % Pour s'assurer que les indications textuelles et paroles 
  % seront à l'intérieur des marges de la page.
  \override PaperColumn #'keep-inside-line = ##t
  \override NonMusicalPaperColumn #'keep-inside-line = ##t
@} @{
   ..
@}
@end example


@node Advanced tweaks with Scheme
@subsection Advanced tweaks with Scheme

Nous avons vu à quel point le résultat obtenu avec LilyPond peut 
être largement personnalisé à l'aide de commandes comme 
@code{\override} et @code{\tweak}.  Et pourtant l'utilisation de 
Scheme ouvre des possibilités encore plus grandes.
Le code écrit dans le langage de programmation Scheme peut être 
intégré directement dans le processus interne de LilyPond.  Bien sûr, 
il faut pour cela connaître un minimum de programmation en langage 
Scheme.  Pour des explications complètes là-dessus, consultez le 
@ref{Scheme tutorial}.

En guise d'illustration --- et ce n'est qu'une possibilité parmi tant 
d'autres --- nous allons attribuer à une propriété non pas une valeur 
préétablie mais une procédure Scheme qui sera lancée à chaque 
utilisation de la propriété par LilyPond.  De cette façon, nous obtenons  
un réglage dynamique de la propriété par le simple fait d'invoquer la 
procédure.  Dans cet exemple, nous colorons les têtes de notes en
fonction de leur position sur la portée. 


@cindex x11-color, exemple d'utilisaation de la fonction
@cindex NoteHead, exemple de dérogation
@cindex color, détermination de la propriété par une procédure Scheme

@lilypond[quote,verbatim,ragged-right]
#(define (color-notehead grob)
  "Color the notehead according to its position on the staff."
  (let ((mod-position (modulo (ly:grob-property grob 'staff-position) 7)))
    (case mod-position
      ;;   Return rainbow colors
      ((1) (x11-color 'red    ))  ; for C
      ((2) (x11-color 'orange ))  ; for D
      ((3) (x11-color 'yellow ))  ; for E
      ((4) (x11-color 'green  ))  ; for F
      ((5) (x11-color 'blue   ))  ; for G
      ((6) (x11-color 'purple ))  ; for A
      ((0) (x11-color 'violet ))  ; for B
    )
  )
)

\relative c' {
  % Arrange to obtain color from color-notehead procedure
  \override NoteHead #'color = #color-notehead
  c2 c' |
  b4 g8 a b4 c |
  c,2 a' |
  g1 |
}
\addlyrics {
  Some -- where o -- ver the Rain -- bow, way up high,
}
@end lilypond

Vous trouverez dans @ref{Tweaking with Scheme} d'autres exemples
d'utilisation de ces interfaces programmables.