Dist documentation text file too.

[lilypond.git] / Documentation / fr / user / changing-defaults.itely

@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-
@c This file is part of ../user/lilypond.tely
@ignore
    Translation of GIT committish: 76de7e168dbc9ffc7671d99663c5ce50dae42abb

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

@node Changing defaults
@chapter Changing defaults


LilyPond est conçu pour engendrer, par défaut, des partitions de la
plus haute qualité.  Cependant, on peut parfois avoir à modifier cette
mise en page par défaut.  Celle-ci est réglée par tout un ensemble de
@qq{leviers et manettes}, dont ce chapitre ne cherche pas à faire
l'inventaire exhaustif.  Le propos est plutôt ici de mettre en évidence
les différents groupes auxquels s'apparentent ces contrôles, et d'expliquer
comment trouver le bon levier pour obtenir tel ou tel effet en particulier.

@cindex Référence du programme

Les moyens de contrôle des différents réglages sont décrits dans un document
séparé, la
@iftex
référence du programme
@end iftex
@ifnottex
@ref{Top,Référence du programme,,lilypond-internals}.
@end ifnottex
Ce guide répertorie toutes les variables, fonctions et autres options que
LilyPond met à votre disposition.  Il est consultable 
@c leave the @uref as one long line.
@uref{http://@/lilypond@/.org/@/doc/@/stable/@/Documentation/@/user/@/lilypond@/-internals/,en@tie{}ligne},
au format HTML, mais est également inclus dans la documentation
fournie avec le logiciel.

Il est quatre domaines dans lesquels on peut modifier les réglages par défaut :

@itemize @bullet
@item
La notation automatique, ce qui revient à modifier la manière dont les éléments
de notation sont automatiquement créés -- par exemple, les règles de ligatures.

@item
L'apparence, qui se rapporte aux objets pris individuellement -- ainsi de la direction 
des hampes, du placement des indications textuelles.

@item
Les contextes, qui recouvrent la manière dont les évènements musicaux sont représentés sous forme de
notation -- par exemple, le fait d'attribuer un chiffre de mesure distinct à chaque portée.

@item
La mise en page, autrement dit les marges, l'espacement, la taille du papier ; tous ces facteurs
font l'objet des chapitres @ref{Non-musical notation} et @ref{Spacing issues}.
@end itemize

En sous-main, LilyPond se sert du langage Scheme (un dérivé du LISP) comme
infrastructure.  Modifier les choix de mise en page revient à pénétrer dans
les entrailles du programme, et de ce fait requiert l'emploi du Scheme.
Les fragments de Scheme, dans un fichier @code{.ly}, sont introduits par le
caractère @q{hash}, (@code{#}, improprement surnommé @q{dièse}).@footnote{Le 
@ref{Scheme tutorial} fournit quelques notions de base pour saisir des nombres,
des listes, des chaînes de caractères ou des symboles, en Scheme.}


@menu
* Automatic notation::          
* Interpretation contexts::     
* The \override command::       
@end menu


@node Automatic notation
@section Automatic notation

Cette section s'intéresse au réglage de l'impression automatique des
altérations accidentelles et ligatures.

@menu
* Automatic accidentals::       
* Setting automatic beam behavior::  
@end menu

@node Automatic accidentals
@subsection Automatic accidentals
@cindex Altérations accidentelles automatiques

Une fonction a été créée pour regrouper les règles suivant lesquelles
s'impriment les altérations.  Elle s'invoque de la manière suivante :

@funindex set-accidental-style
@example
#(set-accidental-style 'REGLE)
@end example

@c TODO: check the context stuff below
@c -does it *really* work?
@c -the default contexts as specified in
@c  scm/music-function.scm seem to be different -vv

Cette fonction prend pour argument le nom de la règle d'altérations,
auquel peut s'ajouter, comme argument facultatif, le contexte
devant être affecté :

@example
#(set-accidental-style 'REGLE #('CONTEXTE#))
@end example

Si aucun contexte n'est spécifié, le contexte @code{Staff} sera affecté ; 
cependant on peut souhaiter l'appliquer au contexte @code{Voice} en lieu 
et place.

Les régles d'altérations suivantes sont possibles :

@table @code
@item default
C'est la règle d'impression par défaut, qui se rapporte à l'usage 
en vigueur au XVIIIème siècle : les altérations accidentelles sont valables toute
une mesure, et uniquement à leur propre octave.


@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               %#(set-accidental-style 'default) 
       \musicA }
       \context Staff = "down"{
               %#(set-accidental-style 'default)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'default" }}}
}
@end lilypond

@item voice
En principe, LilyPond se souvient de toutes les altérations présentes sur la
portée (contexte Staff).  Avec cette règle, cependant, les altérations sont indépendantes
pour chacune des voix. 


@example
 \new Staff <<
        #(set-accidental-style 'voice)
        @{ @dots{} @}
        >>
@end example

De ce fait, les altérations d'une voix sont ignorées dans les autres voix,
ce qui peut donner lieu à un résultat malencontreux.  Dans l'exemple suivant,
il est difficile de dire si le deuxième @samp{la} est dièse ou naturel.

@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'voice) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'voice)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'voice" }}}
}
@end lilypond

La règle @code{voice} n'est à envisager que dans le cas de voix devant être lues par
des musiciens différents.  S'il s'agit d'un @q{conducteur}, ou d'une portée destinée
à un seul musicien, il vaut mieux utiliser @code{modern} ou @code{modern-cautionary}.


@item modern
@funindex modern style accidentals
Cette règle est la plus courante au XXème siècle.  Les altérations accidentelles
sont imprimées comme avec le style @code{default}, mais lorsqu'une note non-altérée
apparaît à une octave différente, ou bien dans la mesure suivante, des bécarres de précaution
sont ajoutés.  Dans l'exemple suivant, notez ainsi les deux bécarres dans la
deuxième mesure de la main droite.

@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'modern) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'modern)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'modern" }}}
}
@end lilypond

@item @code{modern-cautionary}
@funindex modern-cautionary
Cette règle est équivalente à @code{modern}, mais les bécarres de précaution sont
imprimés de façon particulière : soit plus petits, soit (par défaut) entre parenthèses.
Il est possible de le définir au moyen de la propriété @code{cautionary-style}
pour l'objet @internalsref{AccidentalSuggestion}.

@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'modern-cautionary) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'modern-cautionary)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'modern-cautionary" }}}
}
@end lilypond

@funindex modern-voice
@item modern-voice
Cette règle sert aux altérations dans de la musique polyphonique destinée
autant à des musiciens différents qu'à quelqu'un qui lirait l'ensemble des voix.
Les altérations sont imprimées voix par voix, mais les autres voix, dans le même 
contexte @internalsref{Staff}, en @emph{tiennent compte} cette fois.

@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'modern-voice) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'modern-voice)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'modern-voice" }}}
}
@end lilypond

@funindex modern-voice-cautionary
@item modern-voice-cautionary
Cette régle est similaire à la précédente, mais les altérations de précautions
(celles que n'aurait pas ajoutées @code{voice}), sont imprimées de façon
particulière.  On retrouve donc toutes les altérations qu'imprimerait
@code{default}, mais certaines sont considérées comme étant @qq{de précaution}.

@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'modern-voice-cautionary) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'modern-voice-cautionary)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'modern-voice-cautionary" }}}
}
@end lilypond

@item piano
@funindex piano accidentals
Cette règle est adaptée aux contextes GrandStaff -- ce qui n'empêche pas de devoir la spécifier 
pour chaque portée individuelle au sein du contexte GrandStaff.

@example
\new GrandStaff @{ <<
  \new Staff = "up" @{ <<
    #(set-accidental-style 'piano)
    @{ @dots{} @}
  >> @}
  \new Staff = "down"@{ <<
    #(set-accidental-style 'piano)
  @{ @dots{} @}
  >> @}
>> @}
@end example

Cette règle est communément employée pour les partitions de piano au XXème siècle.
Très similaire à @code{modern} de par son comportement, elle s'en distingue en ce que
les altérations tiennent compte des autre portées du contexte @internalsref{GrandStaff} ou
@internalsref{PianoStaff}.

@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'piano) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'piano)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'piano" }}}
}
@end lilypond

@item piano-cautionary
@funindex #(set-accidental-style 'piano-cautionary)
Identique à @code{#(set-accidental-style 'piano)}, mais les altérations de précaution
sont imprimées différemment.

@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'piano-cautionary) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'piano-cautionary)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'piano-cautionary" }}}
}
@end lilypond

@item no-reset
@funindex no-reset accidental style
C'est la même règle que @code{default}, mais l'effet des altérations accidentelles
ne cesse jamais, même dans les mesures suivantes.
@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'no-reset) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'no-reset)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'no-reset" }}}
}
@end lilypond

@item forget
Tout le contraire de @code{no-reset}: l'effet des altérations cesse aussitôt,
et de ce fait, toutes les altérations, quelque soit leur place dans la mesure, sont
imprimées, en fonction de l'éventuelle armure.

@lilypond[quote,ragged-right]
musicA = {  << \relative {  cis'8 fis, d'4 <a cis>8 f bis4 | cis2. <c, g'>4 | } \\
       \relative { ais'2 cis, | fis8 b a4 cis2 | } >> }

musicB = { \clef bass  \new Voice { \voiceTwo \relative { < fis, a cis>4 
        \change Staff = up cis' \change Staff = down <fis, a>  
        \change Staff = up dis' | \change Staff = down <fis, a cis>4 gis 
        <f a d>2 |  } }}

\score { 
        \new PianoStaff {
       << \context Staff = "up" {
               #(set-accidental-style 'forget) 
       \musicA }
       \context Staff = "down"{
               #(set-accidental-style 'forget)
       \musicB } >> }
       \header { piece = \markup {\fill-line { \fontsize #3  "'forget" }}}
}
@end lilypond
@end table


@seealso

Référence du programme : @internalsref{Accidental_engraver},
@internalsref{Accidental}, @internalsref{AccidentalSuggestion} et @internalsref{AccidentalPlacement}.


@refbugs

Les notes simultanées sont considérées comme des évènements séquentiels.
Ce qui implique que, dans un accord, les altérations accidentelles seront 
imprimées comme si les notes de l'accords apparaissaient une par une, en fonction
de l'ordre dans lequels elles ont été saisies -- ce qui peut poser problème lorsqu'au
sein d'un accord certaines altérations dépendent les unes des autres.
Ce problème est à résoudre manuellement, en insérant des @code{!} et des @code{?} après les notes
concernées.


@node Setting automatic beam behavior
@subsection Setting automatic beam behavior

@funindex autoBeamSettings
@funindex (end * * * *)
@funindex (begin * * * *)
@cindex ligatures automatiques, réglage
@cindex réglage des ligatures automatiques

@c [TODO: use \applyContext]

Dans les métriques courantes, les ligatures automatiques peuvent commencer
sur n'importe quelle note, mais ne peuvent se terminer qu'à certains points précis
dans la mesure : sur une pulsation, ou après toute durée spécifiée par les propriétés
nommées @code{autoBeamSettings}.  Ces propriétés consistent en une liste de règles
relatives au début ou à la fin des ligatures.  Par défaut, elles sont définies dans
le fichier
@file{scm/@/auto@/-beam@/.scm}.

On peut ajouter à cette liste une nouvelle règle, au moyen de la commande
@example
#(override-auto-beam-setting '(extrémité p q n m) a b [contexte])
@end example

@itemize @bullet

@item @code{extrémité} désigne le début (@code{begin}) ou la fin (@code{end}) de la ligature.

@item @code{p/q} désigne la valeur rythmique de la note que l'on veut affecter, ou de la
plus brève des notes concernées.  Si cette règle doit s'appliquer à toutes les ligatures,
remplacez @code{p} et @code{q} par des étoiles @qq{@code{*}}.


@item @code{n/m} est le chiffre de mesure dans lequel la règle doit
s'appliquer.  Si celle-ci doit s'appliquer dans toutes les métriques,
remplacez @code{n} et @code{m} par des étoiles @qq{@code{*}}.

@item @code{a/b} est l'emplacement, dans la mesure, auquel les ligatures doivent
débuter ou s'achever (suivant la valeur @q{extrémité} que nous venons de voir).


@item @code{contexte} est un argument facultatif, qui détermine le contexte dans lequel
la règle doit s'appliquer.  Par défaut, il s'agit de @code{'Voice}.
@code{#(score-override-auto-beam-setting '(A B C D) E F)} équivaut à
@code{#(override-auto-beam-setting '(A B C D) E F 'Score)}.

@end itemize

Par exemple, si l'on veut que les ligatures s'achèvent toujours après la première noire :


@example
#(override-auto-beam-setting '(end * * * *) 1 4)
@end example

On peut obliger une règle de ligatures à ne s'appliquer qu'à des groupes dont la note
la plus brève est d'une valeur précise :

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\time 2/4
#(override-auto-beam-setting '(end 1 16 * *) 1 16)
a16 a a a a a a a |
a32 a a a a16 a a a a a |
#(override-auto-beam-setting '(end 1 32 * *) 1 16)
a32 a a a a16 a a a a a |
@end lilypond

On peut obliger une règle de ligatures à ne s'appliquer que pour un chiffre de mesure
précis :

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\time 5/8
#(override-auto-beam-setting '(end * * 5 8) 2 8)
c8 c d d d
\time 4/4
e8 e f f e e d d
\time 5/8
c8 c d d d
@end lilypond

Enfin, on peut désactiver une règle de ligatures au moyen du réglage suivant :

@example
#(revert-auto-beam-setting '(extrémité p q n m) a b [contexte])
@end example

@noindent
@code{extrémité}, @code{p}, @code{q}, @code{n}, @code{m}, @code{a}, @code{b} et @code{contexte}
étant les mêmes que plus haut.  Il est même possible de désactiver des règles que l'on n'a pas
explicitement créées : les règles par défaut, qui se trouvent dans le fichier @file{scm/@/auto@/-beam@/.scm}.



@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\time 4/4
a16 a a a a a a a a a a a a a a a
#(revert-auto-beam-setting '(end 1 16 4 4) 1 4)
a16 a a a a a a a a a a a a a a a
@end lilypond

La commande @code{revert-auto-beam-setting} requiert exactement les mêmes arguments
que la règle d'origine.  En d'autres termes, les étoiles ne seront pas prises en compte ici.

@lilypond[quote,fragment,ragged-right,verbatim,relative=2]
\time 1/4
#(override-auto-beam-setting '(end 1 16 1 4) 1 8)
a16 a a a
#(revert-auto-beam-setting '(end 1 16 * *) 1 8) % ceci ne désactive pas la règle !
a a a a
#(revert-auto-beam-setting '(end 1 16 1 4) 1 8) % ceci marche
a a a a
@end lilypond



@c TODO:  old material -- not covered by above stuff, I think.
Si, dans une mesure à 5/4, l'on veut que les ligatures soient regroupées temps par temps,
il est nécessaire d'indiquer toutes les terminaisons de ligatures.
@example
#(override-auto-beam-setting '(end * * * *) 1 4 'Staff)
#(override-auto-beam-setting '(end * * * *) 1 2 'Staff)
#(override-auto-beam-setting '(end * * * *) 3 4 'Staff)
#(override-auto-beam-setting '(end * * * *) 5 4 'Staff)
@dots{}
@end example

La même syntaxe peut servir à définir les points de départ des ligatures.
Dans l'exemple suivant, les ligatures automatiques  ne peuvent se terminer 
que sur une noire pointée.
@example
#(override-auto-beam-setting '(end * * * *) 3 8)
#(override-auto-beam-setting '(end * * * *) 1 2)
#(override-auto-beam-setting '(end * * * *) 7 8)
@end example
@c ???? Je n'y comprends rien --vv
Dans une mesure à 4/4, cela implique que les ligatures ne peuvent se terminer que sur
la troisième croche, ou sur le quatrième temps (après la valeur de deux fois trois croches).

Si une ligature se fait de manière inattendue, pensez à vérifer les règles automatiques
dans le fichier @file{scm/@/auto@/-beam@/.scm} pour rechercher d'éventuels conflits, dans
la mesure ou les règles par défaut s'ajoutent à vos propres règles.  Il est alors nécessaire
de désactiver toute règle par défaut conduisant à des ligatures indésirables.

Ainsi, pour obtenir des ligatures en groupes de @code{(3 4 3 2)} croches, dans une mesure à 12/8,
il faudra préalablement utiliser :

@example
%%% annulons les réglages par défaut relatifs à 12/8, dans scm/auto-beam.scm 
#(revert-auto-beam-setting '(end * * 12 8) 3 8)
#(revert-auto-beam-setting '(end * * 12 8) 3 4)
#(revert-auto-beam-setting '(end * * 12 8) 9 8)

%%% puis ajoutons nos propres règles
#(override-auto-beam-setting '(end 1 8 12 8) 3 8)
#(override-auto-beam-setting '(end 1 8 12 8) 7 8)
#(override-auto-beam-setting '(end 1 8 12 8) 10 8)
@end example

@cindex ligatures automatiques
@cindex groupes de notes
@funindex autoBeaming
@cindex paroles

Si des ligatures sont utilisées dans les paroles d'une chanson (pour indiquer des mélismes),
les ligatures automatiques doivent être désactivées, avec @code{\autoBeamOff}.


@refcommands

@funindex \autoBeamOff
@code{\autoBeamOff},
@funindex \autoBeamOn
@code{\autoBeamOn}.

@commonprop

Les groupes de notes reliées par les ligatures peuvent être spécifiés au moyen
de la propriété @code{beatGrouping}.

@lilypond[quote,verbatim,relative=2,fragment,ragged-right]
\time 5/16
\set beatGrouping = #'(2 3)
c8[^"(2+3)" c16 c8]
\set beatGrouping = #'(3 2)
c8[^"(3+2)" c16 c8]
@end lilypond


@refbugs

Si une partition se termine alors qu'une ligature automatique est restée inachevée,
cette dernière ligature ne sera pas imprimée du tout.  C'est également valable dans
le cas d'une musique polyphonique, saisie avec la syntaxe @code{<< @dots{} \\ @dots{}
>>}, où une voix se terminerait sans que la dernière ligature
soit achevée.

@node Interpretation contexts
@section Interpretation contexts

Cette section traite des contextes.

@menu
* Changing context properties on the fly::  
* Modifying context plug-ins::  
* Layout tunings within contexts::  
* Changing context default settings::  
* Defining new contexts::       
* Aligning contexts::           
* Vertical grouping of grobs::  
@end menu


@node Changing context properties on the fly
@subsection Changing context properties on the fly

@cindex propriétés
@funindex \set
@cindex modifier des propriétés

Chaque contexte peut avoir plusieurs @emph{propriétés}, c'est-à-dire
des variables qu'il inclut.  Ces dernières peuvent être modifiées @qq{à la volée},
c'est-à-dire pendant que la compilation s'accomplit.  C'est là le rôle de la
commande @code{\set}.

@example
\set @var{contexte}.@var{propriété} = #@var{valeur}
@end example

Ainsi :
@lilypond[quote,verbatim,relative=2,fragment]
R1*2
\set Score.skipBars = ##t
R1*2
@end lilypond

Cette commande permet de condenser les mesures vides de notes, en des silences
multi-mesures.  Il s'agit d'un objet Scheme, auquel on attribue la valeur booléenne
@q{vrai}, c'est-à-dire la lettre @code{#t} pour @q{True} en anglais.

Ce changement étant appliqué @q{à la volée}, il n'affecte que le second groupe de notes.

Si l'argument @var{contexte} n'est pas spécifié, alors la propriété cherchera à s'appliquer
dans le contexte le plus restreint où elle est employée : le plus souvent
 @context{ChordNames}, @context{Voice}, ou @context{Lyrics}.  Dans l'exemple suivant,

@lilypond[quote,verbatim,relative=2,fragment]
c8 c c c
\set autoBeaming = ##f
c8 c c c
@end lilypond

@noindent
aucun argument @var{contexte} n'a été donné à la commande @code{\set}.
De ce fait, les ligatures automatiques sont désactivées dans le
contexte actuel, c'est-à-dire @internalsref{Voice}.  Notez que le
contexte le plus restreint n'est pas toujours le bon, 
et peut ne pas contenir la propriété qui vous intéresse : ainsi, la propriété 
@code{skipBars}, évoquée plus haut, ne relève pas du contexte @code{Voice}, 
et le code suivant ne fonctionnera pas.

@lilypond[quote,verbatim,relative=2,fragment]
R1*2
\set skipBars = ##t
R1*2
@end lilypond

Les contextes s'organisent de façon hiérarchique : aussi, lorsqu'un contexte de niveau
supérieur est spécifié (par exemple @context{Staff}), la propriété sera modifée dans
tous les contextes inférieurs (tous les contextes @context{Voice}, par exemple)
qu'il contient.

@funindex \unset

La commande @code{\unset} permet d'annuler la définition d'une propriété :

@example
\unset @var{contexte}.@var{propriété}
@end example

@noindent
si et seulement si cette propriété à été définie dans ce @var{contexte}
précis ; ainsi,

@example
\set Staff.autoBeaming = ##f
@end example

@noindent
même s'il s'applique à tous les contextes @code{Voice} contenus dans le
contexte @code{Staff}, ne peut être annulé au niveau @code{Voice}.  Le code
suivant sera sans effet.

@example
\unset Voice.autoBeaming
@end example

@noindent
En d'autres termes, la commande @code{\unset} doit impérativement être
accompagnée du même contexte que la commande @code{\set} d'origine.
Pour annuler l'effet, dans notre exemple, de @code{Staff.autoBeaming = ##f},
il faut donc entrer :
@example
\unset Staff.autoBeaming
@end example

Si l'on se trouve dans le contexte le plus restreint, il n'est pas obligatoire,
là encore, de spécifier le @var{contexte}.  Ainsi, les deux lignes suivantes sont équivalentes.


@example
\set Voice.autoBeaming = ##t
\set autoBeaming = ##t
@end example


@cindex \once
Pour modifier une propriété de façon à ce qu'elle ne s'applique qu'une seule fois,
il convient d'employer la commande @code{\once} :

@lilypond[quote,verbatim,relative=2,fragment]
c4
\once \set fontSize = #4.7
c4
c4
@end lilypond

Ici le changement de taille est annulé aussitôt après la note concernée.

La référence du programme contient une description exhaustive de toutes les
propriétés contexte par contexte : voir
@ifhtml
@internalsref{Tunable context properties}.
@end ifhtml
@ifnothtml
Translation @expansion{} Tunable context properties.
@end ifnothtml


@node Modifying context plug-ins
@subsection Modifying context plug-ins

Les contextes, tels que @code{Score} ou @code{Staff}, ne contiennent
pas que des propriétés ; ils mettent également en œuvre certains
sous-programmes (@q{plug-ins}, pour employer le terme consacré) nommés
@q{graveurs} (@q{engravers}, pour reprendre le terme anglais).
Ces sous-programmes sont chargés de créer les différents éléments de notation :
On trouve ainsi dans le contexte @code{Voice}, un graveur @code{Note_head_engraver},
chargé des têtes de notes, et dans le contexte @code{Staff}, un graveur
@code{Key_signature_engraver}, chargé de l'armure.

Vous trouverez une description exhaustive de chaque graveur dans
@ifhtml
@internalsref{Engravers}.
@end ifhtml
@ifnothtml
Program reference @expansion Translation @expansion{} Engravers.
@end ifnothtml
Chaque contexte mentionné dans
@ifhtml
@internalsref{Contexts}
@end ifhtml
@ifnothtml
Program reference @expansion Translation @expansion{} Context.
@end ifnothtml
répertorie les graveurs mis en œuvre.


On peut faire, au moyen de ces graveurs, sa propre @qq{cuisine}, en
modifiant les contextes à volonté.


Lorsque un contexte est créé, par la commande @code{\new} ou @code{\context}, on peut
y adjoindre un bloc @code{\with} (en anglais @q{avec}), dans lequel il est possible
d'ajouter (commande @code{\consists}) ou d'enlever (commande @code{\remove})
des graveurs :

@funindex \with

@example
\new @var{contexte} \with @{
  \consists @dots{}
  \consists @dots{}
  \remove @dots{}
  \remove @dots{}
  @emph{etc.}
@}
@{
  @emph{..musique..}
@}
@end example

@noindent
Ici les points de suspension @dots{} devront être remplacés par les noms
des graveurs désirés.  Dans l'exemple suivant, on enlève du contexte
@code{Staff}, le chiffre de mesure (graveur @code{Time_signature_engraver})
et la clé (graveur @code{Clef_engraver}).

@lilypond[quote,relative=1,verbatim,fragment]
<<
  \new Staff {
    f2 g
  }
  \new Staff \with {
     \remove "Time_signature_engraver"
     \remove "Clef_engraver"
  } {
    f2 g2
  }
>>
@end lilypond

La clé et le chiffre de mesure ont disparu de la deuxième portée.  C'est une méthode
quelque peu radicale, puisqu'elle affectera toute la portée jusqu'à la fin de la
partition.  L'espacement s'en trouve également affecté, ce qui peut être ou non
l'effet recherché.  Une méthode plus sophistiquée aurait été de rendre ces objets
transparents (voir @rlearning{Common tweaks}).

Dans l'exemple suivant, voici une mise en pratique plus utile.  En temps
normal, les barres de mesure et la métrique sont synchronisées verticalement
dans toute la partition.  Les graveurs qui en sont responsables se nomment
@code{Timing_translator} et @code{Default_bar_line_engraver}.
En les enlevant du contexte @code{Score} pour les attribuer au contexte
@code{Staff}, chaque portée peut désormais avoir sa propre métrique.

@cindex polymétrique, partition
@cindex Chiffres de mesure multiples

@lilypond[quote,relative=1,ragged-right,verbatim,fragment]
\new Score \with {
  \remove "Timing_translator"
  \remove "Default_bar_line_engraver"
} <<
  \new Staff \with {
    \consists "Timing_translator"
    \consists "Default_bar_line_engraver"
  } {
      \time 3/4
      c4 c c c c c
  }
  \new Staff \with {
    \consists "Timing_translator"
    \consists "Default_bar_line_engraver"
  } {
       \time 2/4
       c4 c c c c c
  }
>>
@end lilypond


@node Layout tunings within contexts
@subsection Layout tunings within contexts

Chaque contexte est chargé de créer plusieurs types d'objets graphiques.
Il contient également les réglages nécessaires pour chacun de ces objets.
Si l'on modifie ces réglages, les objets n'auront plus la même apparence.

La syntaxe employée pour ce faire est

@example
\override @var{contexte}.@var{objet} #'@var{propriété} = #@var{valeur}
@end example

Ici @var{objet} est un objet graphique, tel que @code{Stem} (les hampes)
ou @code{NoteHead} (les têtes de note) ; @var{propriété} est une variable
(désignée par un symbole, ce qui explique l'apostrophe) employée par le système
de mise en page.  La sous-section @ref{Constructing a tweak} vous
aidera à savoir quoi mettre à la place de @var{objet}, @var{propriété} et
@var{valeur} ; notre propos n'est ici que d'examiner l'emploi de cette commande.

La commande suivante :

@verbatim
\override Staff.Stem #'thickness = #4.0
@end verbatim

@noindent
rend les hampes plus épaisses (la valeur par défaut est 1.3, ce qui signifie qu'elles 
sont 1,3 fois plus épaisses que les lignes de la portée).  Dans la mesure où nous avons
indiqué @context{Staff} comme contexte, ce réglage ne s'appliquera qu'à la portée courante ;
les autres portées demeureront intactes.


@lilypond[quote,verbatim,relative=2,fragment]
c4
\override Staff.Stem #'thickness = #4.0
c4
c4
c4
@end lilypond

La commande @code{\override} modifie donc la définition de l'objet @code{Stem}
dans le contexte @context{Staff} ; toutes les hampes qui suivent seront affectées.

Tout comme avec la commande @code{\set}, l'argument @var{contexte} peut être omis, auquel
cas le contexte par défaut (ici, @context{Voice}) sera employé.  La commande @code{\once}
permet de n'appliquer la modification qu'une seule fois.

@lilypond[quote,fragment,verbatim,relative=2]
c4
\once \override Stem #'thickness = #4.0
c4
c4
@end lilypond

La commande @code{\override} doit être entrée @emph{avant} l'objet concerné.
Ainsi, lorsque l'on veut altérer un objet qui se prolonge, tel qu'une liaison,
une ligature ou tout autre objet dit @emph{Spanner}, la commande @code{\override}
doit être saisie avant que l'objet soit créé.

@lilypond[quote,fragment,verbatim,relative=2]
\override Slur #'thickness = #3.0
c8[( c
\override Beam #'thickness = #0.6
c8 c])
@end lilypond

@noindent
Dans cet exemple, la liaison (@emph{Slur}) est épaissie, mais non la ligature
(@emph{Beam}).  En effet, le code qui lui est relatif n'a pas été inséré avant le début de
la ligature, et demeure donc sans effet.

De même que la commande @code{\unset}, la commande @code{\revert} défait
ce qui a été fait par une commande @code{\override}.  Tout comme avec @code{\unset},
elle ne peut annuler que les réglages effectués dans le même contexte.
Ainsi dans l'exemple suivant, la commande @code{\revert} est sans effet.

@example
\override Voice.Stem #'thickness = #4.0
\revert Staff.Stem #'thickness
@end example

Il existe, à l'intérieur même de certaines propriétés, des options que l'on
nomme @q{sous-propriétés}.  La syntaxe est alors

@c leave this as a long long
@example
\override @var{contexte}.@var{objet} #'@var{propriété} #'@var{sous-propriété} = #@var{valeur}
@end example

@noindent
Ainsi, par exemple :

@example
\override Stem #'details #'beamed-lengths = #'(4 4 3)
@end example


@seealso

Référence du programme : @internalsref{OverrideProperty}, @internalsref{RevertProperty},
@internalsref{PropertySet}, @internalsref{Backend}, et
@internalsref{All layout objects}.


@refbugs

La sous-couche Scheme ne vérifie pas la saisie des propriétés de façon
très stricte.  Des références cycliques dans des valeurs Scheme peuvent
de ce fait interrompre, ou faire planter le programme -- ou bien les deux.


@node Changing context default settings
@subsection Changing context default settings

Les réglages montrés dans les sous-sections @ref{Changing context
properties on the fly}, @ref{Modifying context plug-ins} et
@ref{Layout tunings within contexts} peuvent également être saisis indépendamment
de la musique dans le bloc @code{\layout}, au moyen de la commande @code{\context} :

@example
\layout @{
  @dots{}
  \context @{
    \Staff

    \set fontSize = #-2
    \override Stem #'thickness = #4.0
    \remove "Time_signature_engraver"
  @}
@}
@end example

Le raccourci @code{\Staff} invoque les définitions inhérentes au contexte
@context{Staff}, de façon à ce qu'elles puissent être modifiées.

Les lignes suivantes affecteront toutes les portées (tous les contextes @context{Staff})
dans la partition.
@example
\set fontSize = #-2
\override Stem #'thickness = #4.0
\remove "Time_signature_engraver"
@end example

@noindent
Les autres contextes peuvent être modifiés de même manière.

La commande @code{\set}, dans le bloc @code{\layout}, est facultative ; aussi
les lignes suivantes produiront-elles le même effet.

@example
\context @{
  @dots{}
  fontSize = #-2
@}
@end example


@refbugs

Il est impossible de stocker des modifications de contexte dans un identificateur.

Le raccourci @code{\RemoveEmptyStaffContext} détruit tous les réglages
du contexte @code{\Staff}.  Pour modifier des propriétés de portées gouvernées
par @code{\RemoveEmptyStaffContext}, il faut le faire impérativement @emph{après}
avoir invoqué @code{\RemoveEmptyStaffContext} :

@example
\layout @{
  \context @{
    \RemoveEmptyStaffContext

    \override Stem #'thickness = #4.0
  @}
@}
@end example


@node Defining new contexts
@subsection Defining new contexts

Les contextes tels que @context{Staff} ou @code{Voice} sont faits
de briques de constructions empilées.  En combinant divers graveurs,
il est possible de créer de nouveaux types de contextes.

Dans l'exemple suivant, on construit, de zéro, un nouveau contexte très
semblable à @context{Voice}, mais qui n'imprime que des têtes de notes en forme
de barres obliques au centre de la portée.  Un tel contexte, par exemple, peut
servir à indiquer un passage improvisé dans un morceau de jazz.

@c KEEP LY
@lilypond[quote,ragged-right]
\layout { \context {
  \name ImproVoice
  \type "Engraver_group"
  \consists "Note_heads_engraver"
  \consists "Text_engraver"
  \consists Pitch_squash_engraver
  squashedPosition = #0
  \override NoteHead #'style = #'slash
  \override Stem #'transparent = ##t
  \alias Voice
}
\context { \Staff
  \accepts "ImproVoice"
}}

\relative c'' {
  a4 d8 bes8 \new ImproVoice { c4^"ad lib" c
   c4 c^"dévêtez-vous" c_"tout en jouant :)" c }
  a1
}
@end lilypond


On a rassemblé les réglages dans un bloc @code{\context}, lui-même dans
le bloc @code{\layout} :

@example
\layout @{
  \context @{
    @dots{}
  @}
@}
@end example

En lieu et place des points (@dots{}), voici les éléments à saisir :

@itemize @bullet
@item Tout d'abord, il convient de donner un nom @code{\name} à notre nouveau contexte :

@example
\name ImproVoice
@end example

@item Comme il est très semblable à @context{Voice}, nous souhaitons que toutes les
commandes associées au @context{Voice} déjà existant, restent valables.  D'où nécessité
de la commande @code{\alias}, qui va l'associer au contexte @context{Voice} :

@example
\alias Voice
@end example

@item Ce contexte doit pouvoir imprimer des notes, et des indications textuelles ;
on ajoute donc les graveurs appropriés.

@example
\consists Note_heads_engraver
\consists Text_engraver
@end example

@item Cependant, on veut que les notes s'affichent toutes au centre de la portée :

@example
\consists Pitch_squash_engraver
squashedPosition = #0
@end example

@noindent
Le graveur @internalsref{Pitch_squash_engraver} intercepte les notes créées par 
@internalsref{Note_heads_engraver}, et les @q{écrase} pour qu'elles aient toutes la
même position verticale, définie par @code{squashedPosition} : ici il s'agit de la
valeur@tie{}@code{0}, c'est-à-dire la ligne du milieu.

@item On veut que les notes aient la forme d'une barre oblique, sans aucune hampe :

@example
\override NoteHead #'style = #'slash
\override Stem #'transparent = ##t
@end example

@item Afin que tous ces graveurs puissent travailler de concert, on leur adjoint un
sous-programme spécial, introduit par la commande @code{\type} : il s'agit de
@internalsref{Engraver_group},

@example
\type "Engraver_group"
@end example

@end itemize

Récapitulons -- on se retrouve avec le bloc suivant :

@example
\context @{
  \name ImproVoice
  \type "Engraver_group"
  \consists "Note_heads_engraver"
  \consists "Text_engraver"
  \consists Pitch_squash_engraver
  squashedPosition = #0
  \override NoteHead #'style = #'slash
  \override Stem #'transparent = ##t
  \alias Voice
@}
@end example

@funindex \accepts
Ce n'est pas tout.  En effet, on veut intégrer le nouveau contexte
@context{ImproVoice} dans la hiérarchie des contextes.  Tout comme le
contexte @code{Voice}, sa place est au sein du contexte @code{Staff}.
Nous allons donc modifier le contexte @context{Staff},
au moyen de la commande @code{\accepts} :

@example
\context @{
  \Staff
  \accepts ImproVoice
@}
@end example

@funindex \denies
Le contraire de @code{\accepts} est @code{\denies},
qui est parfois utile lorsque l'on recycle des définitions de
contextes déjà existantes.

Enfin, tout cela doit prendre place dans le bloc @code{\layout},
comme suit :

@example
\layout @{
  \context @{
    \name ImproVoice
    @dots{}
  @}
  \context @{
    \Staff
    \accepts "ImproVoice"
  @}
@}
@end example

On peut alors saisir la musique, comme dans l'exemple plus haut :

@example
\relative c'' @{
  a4 d8 bes8
  \new ImproVoice @{
    c4^"ad lib" c
    c4 c^"dévêtez-vous"
    c c_"tout en jouant :)"
  @}
  a1
@}
@end example


@node Aligning contexts
@subsection Aligning contexts

Il est possible d'aligner verticalement chaque nouveau contexte,
en-dessous ou au-dessus, par exemple dans le cas de musique vocale
(@ref{Vocal ensembles}) ou d'@qq{ossias}.

@cindex ossia
@findex alignAboveContext
@findex alignBelowContext

@lilypond[quote,ragged-right]
ossia = { f4 f f f }
\score{
  \relative c' \new Staff = "main" {
    c4 c c c
    <<
      \new Staff \with {alignAboveContext=main} \ossia
      { d8 f d f d f d f }
    >>
  }
}
@end lilypond


@node Vertical grouping of grobs
@subsection Vertical grouping of grobs

Les objets @code{VerticalAlignment} et @code{VerticalAxisGroup}
travaillent de concert.  Comme leurs noms anglais l'indiquent,
@code{VerticalAxisGroup} regroupe différents objets tels que les portées
(@code{Staff}), les paroles (@code{Lyrics}) et ainsi de suite ; puis
@code{VerticalAlignment} synchronise verticalement ces différents groupes.
En général, il n'y a qu'un seul @code{VerticalAlignment} pour l'ensemble
de la partition, mais chaque contexte @context{Staff}, @context{Lyrics}, etc.
possède son propre @code{VerticalAxisGroup}.


@node The \override command
@section The @code{\override} command

La commande @code{\override} permet de modifier la mise en page
en détail.  Examinons son utilisation concrètementet dans les détails.
La syntaxe de cette commande ressemble généralement à :

@example
\override @var{contexte}.@var{objet} #'@var{propriété} = #@var{valeur}
@end example

La propriété @var{propriété} de l'objet @var{objet}, appartenant au contexte
@var{contexte}, se voit ainsi attribuer la valeur @var{valeur}.

@menu
* Constructing a tweak::        
* Navigating the program reference::  
* Layout interfaces::           
* Determining the grob property::  
* Objects connected to the input::  
* Using Scheme code instead of \tweak::  
* \set versus \override::       
* Difficult tweaks::            
@end menu



@node Constructing a tweak
@subsection Constructing a tweak

Les commandes permettant de modifier l'apparence de la partition
ressemblent en général à

@example
\override Voice.Stem #'thickness = #3.0
@end example

@noindent
Pour élaborer un réglage de ce type, on a besoin de connaître précisément :

@itemize
@item le contexte : ici @context{Voice} (la voix).
@item l'objet à affecter : ici @code{Stem} (les hampes).
@item la propriété à modifier : ici @code{thickness} (l'épaisseur du trait).
@item la valeur désirée : ici @code{3.0} (par défaut, elle est de 1.3).
@end itemize

Certaines @q{sous-propriétés} sont parfois contenues dans une propriété.
La commande devient alors :

@example
\override Stem #'details #'beamed-lengths = #'(4 4 3)
@end example

@cindex documentation exhaustive
@cindex trouver des objets graphiques
@cindex objets graphiques, description
@cindex régler
@funindex \override

Pour bien des propriétés, quel que soit le type de valeur requise,
attribuer la valeur @q{faux} (@code{##f} en Scheme) reviendra à désactiver
complètement l'action de la propriété qui se trouve ainsi purement
ignorée par LilyPond.  Cela peut s'avérer fort utile pour des propriétés
causant des désagréments.

@c such announcements are to be avoided -vv
@ignore
We demonstrate how to glean this information from the notation manual
and the program reference.
@end ignore



@node Navigating the program reference
@subsection Navigating the program reference

Comment, par exemple, déplacer le doigté dans le fragment suivant ?

@lilypond[quote,fragment,relative=2,verbatim]
c-2
\stemUp
f
@end lilypond

Sur la page de la documentation relative aux doigtés, c'est-à-dire
@ref{Fingering instructions}, se trouve l'indication suivante :

@quotation
@seealso

Référence du programme : @internalsref{Fingering}.

@end quotation


@c  outdated info; probably will delete.
@ignore
This fragment points to two parts of the program reference: a page
on @code{FingerEvent} and one on @code{Fingering}.

The page on @code{FingerEvent} describes the properties of the music
expression for the input @code{-2}.  The page contains many links
forward.  For example, it says

@quotation
Accepted by: @internalsref{Fingering_engraver},
@end quotation

@noindent
That link brings us to the documentation for the Engraver, the
plug-in, which says

@quotation
This engraver creates the following layout objects: @internalsref{Fingering}.
@end quotation

In other words, once the @code{FingerEvent}s are interpreted, the
@code{Fingering_engraver} plug-in will process them.
@end ignore

@ignore
@c  I can't figure out what this is supposed to mean.  -gp

The @code{Fingering_engraver} is also listed to create
@internalsref{Fingering} objects,

@c  old info?  it doesn't make any sense to me with our current docs.
This is also the
second bit of information listed under @b{See also} in the Notation
manual.
@end ignore

@ifnothtml
Ladite référence est disponible au format HTML, ce qui rend la navigation bien
plus aisée.  Il est possible soit de la lire en ligne, soit de la télécharger
dans ce format.  La démarche présentée ici sera plus difficle à comprendre
dans un document au format PDF.
@end ifnothtml

Suivons le lien @internalsref{Fingering}.  En haut de la nouvelle page,
on peut lire

@quotation
Fingering objects are created by: @internalsref{Fingering_engraver} and
@internalsref{New_fingering_engraver}.
@end quotation

En d'autres termes, @emph{Les indications de doigtés} 
(@code{Fingering} en anglais) @emph{sont créées par les graveurs
@internalsref{Fingering_engraver} et @internalsref{New_fingering_engraver}.}

En suivant derechef les liens propres à la référence du programme, on suit en fait
le cheminement qui aboutit à la création de la partition :

@itemize @bullet

@item @internalsref{Fingering}:
@internalsref{Fingering} objects are created by:
@internalsref{Fingering_engraver}

@item @internalsref{Fingering_engraver}:
Music types accepted: @internalsref{fingering-event}

@item @internalsref{fingering-event}:
Music event type @code{fingering-event} is in Music expressions named
@internalsref{FingerEvent}
@end itemize

Ce cheminement se produit, bien sûr, en sens inverse : nous sommes ici partis
du résultat, et avons abouti aux évènements (en anglais @q{Events}) engendrés
par le fichier d'entrée.  L'inverse est également possible : on peut partir d'un
évènement, et suivre le cheminement de LilyPond qui aboutit à la création d'un 
ou plusieurs objets graphiques.

La référence du programme peut également se parcourir comme un document normal.
On y trouve des chapitres tels que
@ifhtml
@internalsref{Music definitions},
@end ifhtml
@ifnothtml
@code{Music definitions}
@end ifnothtml
@internalsref{Translation}, ou encore @internalsref{Backend}.  Chaque chapitre
recense toutes les définitions employées, et les propriétés sujettes à 
ajustements.

@c -- what about adding a link to the glossary here ? -vv
@ignore
La Référence du programme n'est pas traduite en français -- notamment du fait
qu'elle est en évolution constante, tout comme LilyPond.  En revanche, les termes
musicaux font l'objet d'un @commentfairelelien{glossaire} fort utile pour les utilisateurs
francophones.
@end ignore


@node Layout interfaces
@subsection Layout interfaces

@cindex interfaces de rendu
@cindex rendu, interfaces de
@cindex objets graphiques

Tous les éléments de notation sont considérés comme des objets graphiques
(en anglais @q{Graphical Object}, d'où le diminutif @emph{Grob}).
Chaque objet est doté d'un certain nombre de propriétés (l'épaisseur du trait,
l'orientation, etc.), et lié à d'autres objets.
Le fonctionnement de ces objets est décrit en détail dans @internalsref{grob-interface}.

Prenons l'exemple des doigtés (en anglais @q{Fingering}).
La page @code{Fingering} de la Référence du programme établit une liste de définitions
propres à ce type d'objets :

@quotation
@code{padding} (dimension, in staff space):

@code{0.5}
@end quotation

@noindent
Ce qui signifie que les doigtés doivent être maintenus à une certaine distance (@emph{padding})
des notes : 0,5 unités @emph{staff-space} (espace de portée).


Chaque objet peut avoir plusieurs attributs, en tant qu'élément typographique
ou musical.  Ainsi, un doigté (objet @q{Fingering}) possède les attributs suivants :


@itemize @bullet
@item
Sa taille ne dépend pas de l'espacement horizontal, contrairement aux liaisons ou ligatures.

@item
C'est du texte -- un texte vraiment court, certes.

@item
Ce texte est imprimé au moyen d'une fonte, contrairement aux liaisons ou ligatures.

@item
Sur l'axe horizontal, le centre de ce symbole doit être aligné avec le centre de la note.

@item
Sur l'axe vertical, le symbole doit être proche de la note et de la portée.

@item
Sur l'axe vertical encore, il doit également s'ordonner avec les éventuels
autres symboles, ponctuations, ou éléments textuels.
@end itemize

Faire appliquer ces différents attributs est le rôle des @emph{interfaces},
que l'on trouve en bas de la page @internalsref{Fingering}.

@quotation
This object supports the following interfaces:
@internalsref{item-interface},
@internalsref{self-alignment-interface},
@internalsref{side-position-interface}, @internalsref{text-interface},
@internalsref{text-script-interface}, @internalsref{font-interface},
@internalsref{finger-interface}, and @internalsref{grob-interface}.
@end quotation

@noindent
En français,

@quotation
Cet objet admet les interfaces suivantes :
@end quotation

Suit la liste des interfaces en question, présentées comme autant de liens,
qui conduisent sur les pages dédiées à chacune d'entre elles.
Chaque interface est dotée d'un certain nombre de propriétés, dont certaines
peuvent être modifiées, et d'autres non (les @q{Internal properties}, ou 
propriétés internes).

Pour aller encore plus loin, plutôt que de simplement parler de l'objet
@code{Fingering}, ce qui ne nous avance pas à grand chose, on peut aller explorer
son âme même, dans les fichiers source de LilyPond (voir
@rlearning{Default files}), en l'occurence le fichier
@file{scm/@/define@/-grobs@/.scm} :

@example
(Fingering
  . ((padding . 0.5)
     (avoid-slur . around)
     (slur-padding . 0.2)
     (staff-padding . 0.5)
     (self-alignment-X . 0)
     (self-alignment-Y . 0)
     (script-priority . 100)
     (stencil . ,ly:text-interface::print)
     (direction . ,ly:script-interface::calc-direction)
     (font-encoding . fetaNumber)
     (font-size . -5)           ; don't overlap when next to heads.
     (meta . ((class . Item)
     (interfaces . (finger-interface
                    font-interface
                    text-script-interface
                    text-interface
                    side-position-interface
                    self-alignment-interface
                    item-interface))))))
@end example

@noindent
@dots{}où l'on découvre que l'objet @code{Fingering} n'est rien de plus qu'un
amas de variables et de réglages.  La page de la Référence du programme est
en fait directement engendrée par cette définition.

@node Determining the grob property
@subsection Determining the grob property

Nous voulions changer la position du chiffre @b{2} dans le fragment suivant :

@lilypond[quote,fragment,relative=2,verbatim]
c-2
\stemUp
f
@end lilypond

Dans la mesure où le @b{2} est placé, verticalement, à proximité de la note qui lui
correspond, nous allons devoir trouver l'interface en charge de ce placement, qui se
trouve être @code{side-position-interface}.  Sur la page de cette interface, on
peut lire :

@quotation
@code{side-position-interface}

Position a victim object (this one) next to other objects (the
support).  The property @code{direction} signifies where to put the
victim object relative to the support (left or right, up or down?)
@end quotation

@noindent
Ce qui signifie
@quotation
@code{side-position-interface}

Placer l'objet affecté à proximité d'autres objets.  La propriété
@code{direction} indique où placer l'objet (à droite ou à gauche,
en haut ou en bas).
@end quotation

@cindex padding
@noindent
En-dessous de cette description se trouve décrite la variable @code{padding} :

@quotation
@table @code
@item padding
(dimension, in staff space)

Add this much extra space between objects that are next to each other.
@end table
@end quotation

@noindent
Ce qui signifie
@quotation 
Ajouter tel espace supplémentaire entre des objets proches les uns des
autres.
@end quotation

@noindent
En augmentant la valeur de @code{padding}, on peut donc éloigner le doigté de la
note.  La commande suivante insère trois unités d'espace vide entre la note et le doigté :

@example
\once \override Voice.Fingering #'padding = #3
@end example

En ajoutant cette commande avant la création du doigté (de l'objet @q{Fingering}),
donc avant @code{c2}, on obtient le résultat suivant :

@lilypond[quote,relative=2,fragment,verbatim]
\once \override Voice.Fingering #'padding = #3
c-2
\stemUp
f
@end lilypond


Dans le cas présent, le réglage intervient dans le contexte @context{Voice},
ce qui pouvait également se déduire de la Référence du programme, où la page
du graveur @internalsref{Fingering_engraver} indique :

@quotation
Fingering_engraver is part of contexts: @dots{} @internalsref{Voice}
@end quotation

@noindent
Ce qui signifie
@quotation
Le graveur Fingering_engraver fait partie des contextes : @dots{} @internalsref{Voice}
@end quotation


@node Objects connected to the input
@subsection Objects connected to the input

@funindex \tweak

Dans certains cas, on peut passer par un raccourci pour arranger les
objets graphiques.  Lorsqu'un objet est directement engendré par un élément distinct
du fichier source, on peut utiliser la commande @code{\tweak}.

Dans l'accord suivant, les notes sont modifiées une par une :

@lilypond[relative=2,fragment,verbatim,ragged-right]
<
  c
  \tweak #'color #red d
  g
  \tweak #'duration-log #1  a
>4-\tweak #'padding #10 -.
@end lilypond

Comme on peut le voir, les propriétés sont ici modifiées directement
en même temps que les objets sont saisis.  Il n'est plus besoin de spécifier ni
le nom de l'objet (@emph{grob}), ni le contexte dans lequel cela doit s'appliquer.

Ce procédé ne marche que pour des objets directement liés aux évènements 
(@internalsref{Event}) du fichier source.  Par exemple :

@itemize @bullet
@item Les têtes de notes au sein d'un accord, qui sont directement engendrées par 
les hauteurs indiquées
@item Les signes d'articulation, engendrés par les indications de ponctuation.
@end itemize

En revanche, les hampes ou les altérations sont engendrées par les têtes de notes,
et non par des évènements dans le fichier source.  De même pour les clés, qui ne
sont pas directement engendrées par le fichier source, mais plutôt par le
changement d'une propriété interne.

En fait, très peu d'objets passent @emph{directement} du code source à la partition.
Une note toute simple, par exemple @code{c4}, fait l'objet d'un traitement et n'est donc
pas directement rendue ; c'est pourquoi le code suivant ne sera d'aucun effet :

@example
\tweak #'color #red c4
@end example

@noindent
Voir pour plus de détails @ref{Displaying music expressions}.


@node Using Scheme code instead of \tweak
@subsection Using Scheme code instead of @code{\tweak}

L'inconvénient principal de la commande @code{\tweak} est la rigidité de sa
syntaxe.  Par exemple, le code suivant produit une erreur.

@example
F = \tweak #'font-size #-3 -\flageolet

\relative c'' @{
  c4^\F c4_\F
@}
@end example

@noindent
En d'autres termes, @code{\tweak} ne se comporte pas comme une articulation :
il ne peut notamment pas être accolé avec les symboles @samp{^} ou @samp{_}.

C'est en se servant du langage Scheme que l'on peut résoudre ce problème.
Dans cet exemple, on a recours aux méthodes décrites dans @ref{Adding 
articulation to notes (example)}, en particulier quant à l'emploi de
@code{\displayMusic}.

@example
F = #(let ((m (make-music 'ArticulationEvent
                          'articulation-type "flageolet")))
       (set! (ly:music-property m 'tweaks)
             (acons 'font-size -3
                    (ly:music-property m 'tweaks)))
       m)
 
\relative c'' @{
  c4^\F c4_\F
@}
@end example

@noindent
Ici les propriétés @code{tweak} de l'objet flageolet nommé
@samp{m} (créé au moyen de @code{make-music}) sont extraites par
@code{ly:music-property}, une nouvelle valeur de la taille de fonte
est ajoutée à la liste de ses propriétés (grâce à la fonction Scheme
@code{acons}), et le résultat de cette opération est renvoyé par @code{set!}.
Le dernier élément, dans ce bloc @code{let}, est la valeur finale de
@samp{m} lui-même.


@node \set versus \override
@subsection @code{\set} vs. @code{\override}

Si les propriétés peuvent être modifiées de deux façons, par les commandes
@code{\set} et @code{\override}, c'est qu'il y a deux types de propriétés.

Les contextes peuvent avoir des propriétés, dont les noms commencent par une
minuscule puis comprennent une ou plusieurs majuscules (de style
@code{totoTutu}).  Elles ont surtout trait
à la notation des éléments musicaux : par exemple, @code{localKeySignature} permet
de choisir s'il faut ou non imprimer une altération, ou @code{measurePosition} permet
de choisir quand il faut imprimer une barre de mesure.  Ces propriétés de contextes
sont appelées à changer au long de l'interprétation de la partition :
@code{measurePosition} en est un exemple évident.  Ces propriétés doivent
être modifiées avec la commande @code{\set}.

Il existe un type particulier de propriétés : les descriptions
d'éléments.  Ces propriétés, dont les noms commencent par une majuscule, puis comprennent
une ou plusieurs majuscules (de style @code{TotoTata}), contiennent les réglages
@q{par défaut} pour les objets graphiques.  Ces réglages sont sous forme de liste Scheme ; on
peut les consulter dans le fichier @file{scm/@/define@/-grobs@/.scm}.
Les descriptions d'éléments doivent être modifiées avec la commande @code{\override}.

@code{\override} est en fait un raccourci :

@example
\override @var{contexte}.@var{objet} #'@var{propriété} = #@var{valeur}
@end example

@noindent
est plus ou moins l'équivalent de

@c  leave this long line -gp
@example
\set @var{contexte}.@var{objet} #'@var{propriété} = #(cons (cons '@var{propriété} @var{valeur}) <valeur précédente de @var{contexte})
@end example

La valeur de @code{context} (la liste Scheme, ou @q{alist}) sert à initialiser
les propriétés des objets un par un.  Les objets eux-même ont leurs propriétés,
dont les noms, dans la tradition du langage Scheme, comprennent un trait d'union
(@code{toto-titi}).  Ces propriétés internes changent constamment au cours de la mise
en page : en fait, la gravure d'une page n'est autre que le calcul de toutes
ces propriétés, au moyen de fonctions de rappel.

La propriété @code{fontSize} est une exception : c'est un raccourci, qui équivaudrait
à saisir @code{\override @dots{} #'font-size} pour tous les objets
textuels.  Dans la mesure où il s'agit d'une manipulation très
courante, une propriété spéciale a été créée.  Elle doit
être modifiée avec la commande @code{\set}.


@node Difficult tweaks
@subsection Difficult tweaks

Certains réglages sont plus délicats que d'autres.

@itemize @bullet


@item
L'un d'entre eux est l'apparence des objets dits @q{spanner}, qui s'étendent 
horizontalement, tels que les liaisons.  Si, en principe, un seul de ces objets
est créé à la fois et peut donc être modifié de façon habituelle, lorsque ces
objets doivent enjamber un changement de ligne, ils sont dupliqués au début
du ou des systèmes suivants.  Comme ces objets sont des clones de l'objet d'origine,
ils en héritent toutes les propriétés, y compris les éventuelles commandes @code{\override}.


En d'autres termes, une commande @code{\override} affecte toujours les deux extrémités
d'un objet @q{spanner}.  Pour ne modifier que la partie précédant ou suivant le changement
de ligne, il faut intervenir directement dans le processus de mise en page.  
La fonction de rappel @code{after-line-breaking} contient toute l'opération Scheme
effectuée lorsque les sauts de lignes ont été déterminés, et que des objets graphiques
ont été divisés sur des systèmes différents.

Dans l'exemple suivant, on définit une nouvelle opération nommée
@code{my-callback}.  Cette opération

@itemize @bullet
@item
détermine si l'objet a été divisé à l'occasion d'un changement de ligne
@item
si oui, recherche les différents morceaux de l'objet
@item
vérifie si l'objet considéré est bien la deuxième moitié d'un objet divisé
@item
si oui, applique un espacement supplémentaire (@code{extra-offset}).
@end itemize

On ajoute cette procédure à l'objet @internalsref{Tie} (liaison de tenue),
de façon à ce que le deuxième morceau d'une liaison divisée soit rehaussé.

@c KEEP LY
@lilypond[quote,verbatim,ragged-right]
#(define (my-callback grob)
  (let* (
         ; l'objet a-t-il été divisé ?
         (orig (ly:grob-original grob))

         ; si oui, rechercher les morceaux frères (siblings)
         (siblings (if (ly:grob? orig)
                     (ly:spanner-broken-into orig) '() )))

   (if (and (>= (length siblings) 2)
             (eq? (car (last-pair siblings)) grob))
     (ly:grob-set-property! grob 'extra-offset '(-2 . 5)))))

\relative c'' {
  \override Tie #'after-line-breaking =
  #my-callback
  c1 ~ \break c2 ~ c
}
@end lilypond

@noindent
Lorsque cette astuce va être appliquée, notre nouvelle fonction de rappel
@code{after-line-breaking} devra également appeler celle d'origine
(@code{after-line-breaking}), si elle existe.
Ainsi, pour l'utiliser dans le cas d'un crescendo (objet @code{Hairpin}),
il faudra appeler également @code{ly:hairpin::after-line-breaking}.


@item Pour des raisons d'ordre technique, certains objets ne peuvent être modifiés par
@code{\override}.  Parmi ceux-là, les objets @code{NonMusicalPaperColumn}
et @code{PaperColumn}.  La commande @code{\overrideProperty} sert à les modifier, de
façon similaire à @code{\once \override}, mais avec une syntaxe différente :

@example
\overrideProperty
#"Score.NonMusicalPaperColumn"  % Nom de l'objet
#'line-break-system-details     % Nom de la propriété
#'((next-padding . 20))         % valeur
@end example

Notez cependant que la commande @code{\override} peut tout de même être appliquée
à @code{NoteMusicalPaperColumn} et @code{PaperColumn} dans un bloc @code{\context}.

@end itemize