@c -*- coding: utf-8; mode: texinfo; documentlanguage: fr -*-

@ignore
   Translation of GIT committish: a5cf37bc53f57635bf984ecc2d1c5a067573b87c

   When revising a translation, copy the HEAD committish of the
   version that you are working on.  For details, see the Contributors'
   Guide, node Updating translation committishes.
@end ignore

@c \version "2.21.0"

@c Translators: Valentin Villenave, Jean-Charles Malahieude
@c Translation checkers: Gilles Thibault, Jean Abou Samra


@node Modification des réglages prédéfinis
@chapter Modification des réglages prédéfinis
@translationof Changing defaults

LilyPond est conçu pour générer, par défaut, des partitions de la
plus haute qualité.  Cependant, on peut parfois avoir à modifier cette
mise en forme par défaut.  Celle-ci est réglée par tout un ensemble de
« leviers et manettes » plus connus sous le terme de « propriétés »,
dont ce chapitre ne cherche pas à faire l'inventaire exhaustif -- le
chapitre @rlearning{Retouche de partition} du manuel d'initiation vous
en propose un aperçu.  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 des propriétés internes

Les moyens de contrôle des différents réglages sont décrits dans un
document séparé, @rinternalsnamed{Top,la référence des propriétés
internes}.  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{https://@/lilypond@/.org/@/doc/@/stable/@/Documentation/@/internals/,en ligne},
au format HTML ; il est également inclus dans la documentation
fournie avec le logiciel.

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
@file{.ly}, sont introduits par le caractère @emph{hash} (@code{#}),
improprement surnommé « dièse ».
@footnote{Le @rextend{Tutoriel Scheme} fournit quelques notions de base
pour saisir des nombres, des listes, des chaînes de caractères ou des
symboles, en Scheme.}

@menu
* Contextes d'interprétation::
* En quoi consiste la référence des propriétés internes::
* Modification de propriétés::
* Propriétés et contextes utiles::
@end menu


@node Contextes d'interprétation
@section Contextes d'interprétation
@translationof Interpretation contexts

Nous allons voir ici ce que sont les contextes et comment les modifier.

@menu
* Tout savoir sur les contextes::
* Création et référencement d'un contexte::
* Conservation d'un contexte::
* Modification des greffons de contexte::
* Modification des réglages par défaut d'un contexte::
* Définition de nouveaux contextes::
* Ordonnancement des contextes::
@end menu

@morerefs
Manuel d'initiation :
@rlearning{Contextes et graveurs}.

Fichiers d'initialisation :
@file{ly/engraver-init.ly},
@file{ly/performer-init.ly}.

Morceaux choisis :
@rlsrnamed{Contexts and engravers, Contextes et graveurs}.

Référence des propriétés internes :
@rinternals{Contexts},
@rinternals{Engravers and Performers}.
@endmorerefs


@node Tout savoir sur les contextes
@subsection Tout savoir sur les contextes
@translationof Contexts explained

@ignore
@c TODO Rethink and rewrite

>> > > - list of contexts: my *danger unmaintainable*
>> > > alarm just went off.  I'm

I knew it would... And leaving out some of them is perfectly fine with
me. I do think that a list like this, with the main contexts and a brief
description of what they do (perhaps also with a note about what default
behavior is associated with each of them, but this may be unmanageable),
should be there, and then we could simply list the remaining ones
without further explanation and with links to the IR.
@end ignore

@c TODO Improve layout, order and consistency of wording -td

@c TODO Add introduction which explains contexts in generality  -td

@c TODO Describe propagation of property values -td

Les contextes sont hiérarchisés :

@menu
* Définitions de la sortie -- hiérarchie des contextes::
* Score -- le père de tous les contextes::
* Contextes de haut niveau -- les systèmes::
* Contextes de niveau intermédiaire -- les portées::
* Contextes de bas niveau -- les voix::
@end menu


@node Définitions de la sortie -- hiérarchie des contextes
@unnumberedsubsubsec Définitions de la sortie -- hiérarchie des contextes
@translationof Output definitions -- blueprints for contexts

Les lignes qui suivent traitent de l'intérêt des définitions de sorties
lorsque l'on travaille avec les contextes.  Des exemples de définitions
seront présentés plus avant -- voir
@ref{Modification de tous les contextes d'un même type}.

@cindex définition de sortie
@cindex sortie, définition
@funindex \layout

Alors que la musique écrite dans un fichier fait référence à des types
ou noms de contexte, les contextes ne sont effectivement créés que
lorsque la musique est interprétée.  LilyPond interprète la musique sous
le contrôle d'une « définition de sortie », voire différemment selon
le cas, et génère ainsi différents résultats.  La définition de sortie
appropriée pour une sortie imprimable est spécifiée à l'aide d'un
@code{\layout}.

@funindex \midi

Une définition de sortie beaucoup plus simple sera utilisée pour
produire une sortie MIDI, spécifiée à l'aide d'un @code{\midi}.
LilyPond utilise en interne plusieurs autres définitions de sortie,
notamment dans le cadre du combinateur automatique de parties (voir
@ref{Regroupement automatique de parties}) ou la reproduction d'extraits
(voir @ref{Citation d'autres voix}).

Les définitions de sortie ont pour objet non seulement de définir la
relation entre les contextes, mais aussi leurs réglages par défaut.  Si
la plupart des adaptations prennent habituellement place au sein d'un
bloc @code{\layout}, les réglages affectant le Midi ne seront effectifs
que s'ils interviennent au sein d'un bloc @code{\midi}.


@funindex autoBeaming

Certains réglages affectent plusieurs sorties : par exemple, lorsque
@code{autoBeaming} est désactivé dans un contexte, les ligatures sont
considérées comme marquant un mélisme dans le but de faire correspondre
la musique aux paroles comme indiqué dans
@ref{Durée automatique des syllabes}.  Cette correspondance est
respectée autant à l'écrit qu'à l'oral.  Des modifications apportées à
@code{autoBeaming} par une définition de contexte au sein d'un bloc
@code{\layout} ne seront pas reportées dans le bloc @code{\midi}
correspondant ; paroles et musique ne seront alors plus synchrones dans
le fichier Midi.

@morerefs
Fichiers d'initialisation :
@file{ly/engraver-init.ly},
@file{ly/performer-init.ly}.
@endmorerefs


@node Score -- le père de tous les contextes
@unnumberedsubsubsec Score -- le père de tous les contextes
@translationof Score -- the master of all contexts

Il s'agit en l'occurrence du contexte le plus élevé, autrement dit le
plus important, en matière de notation.  En effet, c'est au niveau de la
partition -- @emph{score} en anglais -- que se gèrent le temps et la
tonalité ; c'est donc là qu'il faut s'assurer que les différents
éléments, tels les clefs, métriques et armures sont bien répercutés sur
toutes les portées.

Dès lors que LilyPond rencontre un bloc @code{\score @{@dots{}@}}
se crée implicitement un contexte @code{Score}.


@node Contextes de haut niveau -- les systèmes
@unnumberedsubsubsec Contextes de haut niveau -- les systèmes
@translationof Top-level contexts -- staff containers

De nombreuses partitions sont écrites sur plus d'une portée.  Ces
portées peuvent être regroupées de différentes manières.

@strong{@emph{StaffGroup}}

Le groupe de portées est attaché par un crochet et les barres de mesure
sont d'un seul tenant, de la première à la dernière portée.  Le
@code{StaffGroup} constitue le regroupement le plus simple.

@strong{@emph{ChoirStaff}}

Ce regroupement est identique au @code{StaffGroup}, à ceci près que les
barres de mesure ne traversent pas l'espace inter-portées.

@strong{@emph{GrandStaff}}

Le groupe de portées est attaché par une accolade sur la gauche et les
barres de mesure sont d'un seul tenant.

@strong{@emph{PianoStaff}}

Ce regroupement est identique au @code{GrandStaff}, à ceci près que le
nom de l'instrument sera directement attaché au système.


@node Contextes de niveau intermédiaire -- les portées
@unnumberedsubsubsec Contextes de niveau intermédiaire -- les portées
@translationof Intermediate-level contexts -- staves

@strong{@emph{Staff}}

La portée prend en charge les clefs, barres de mesure, armures et les
altérations accidentelles.  Un contexte @code{Staff} peut contenir
plusieurs contextes @code{Voice}.

@strong{@emph{RhythmicStaff}}

De même nature qu'un @code{Staff}, ce contexte est destiné à n'imprimer
que du rythme. Quelle que soit la hauteur, les notes seront imprimées
sur une même et unique ligne ; la sortie MIDI rendra les hauteurs
saisies.

@strong{@emph{TabStaff}}

Ce contexte permet de générer des tablatures.  La mise en forme par
défaut correspond à une tablature pour guitare, sur six lignes.

@strong{@emph{DrumStaff}}

Contexte dévolu tout spécialement aux parties de percussion ; il
peut contenir plusieurs @code{DrumVoice}.

@strong{@emph{VaticanaStaff}}

Identique au contexte @code{Staff}, à ceci près qu'il est tout
particulièrement adapté au grégorien.

@strong{@emph{MensuralStaff}}

Identique au contexte @code{Staff}, à ceci près qu'il est tout
particulièrement adapté au style mensural de musique ancienne.


@node Contextes de bas niveau -- les voix
@unnumberedsubsubsec Contextes de bas niveau -- les voix
@translationof Bottom-level contexts -- voices

Les contextes de niveau « voix » initialisent un certain nombre de
propriétés et activent les graveurs appropriés.  Un contexte de bas
niveau est un contexte n'ayant aucun contexte enfant -- ou
@code{defaultchild}.  Bien qu'ils puissent accepter ou contenir des
sous-contextes, ceux-ci devront être libellés et créés explicitement.

@strong{@emph{Voice}}

Correspond à une voix positionnée sur une portée.  Le contexte
@code{Voice} s'occupe des indications de nuance, des hampes, des
ligatures, des scripts placés au-dessus ou au-dessous de la portée, des
différentes liaisons et des silences.  Lorsque plusieurs voix doivent
cohabiter sur la même portée, il est indispensable de les instancier
explicitement.

@strong{@emph{VaticanaVoice}}

Fonctionnant comme le contexte @code{Voice}, il est tout
particulièrement destiné à gérer le grégorien.

@strong{@emph{MensuralVoice}}

Fonctionnant comme le contexte @code{Voice}, il est tout
particulièrement adapté aux musiques anciennes.

@strong{@emph{Lyrics}}

Correspond à une voix contenant des paroles.  Le contexte @code{Lyrics}
gère l'impression d'une ligne de paroles.

@strong{@emph{DrumVoice}}

Contexte de voix dévolu à une portée de percussions.

@strong{@emph{FiguredBass}}

Contexte prenant en charge les objets @code{BassFigure} -- la basse
chiffrée -- créés à partir de ce qui a été saisi en mode
@code{\figuremode}.

@strong{@emph{TabVoice}}

Contexte de voix dévolu au contexte @code{TabStaff}, il est
habituellement créé implicitement.

@strong{@emph{CueVoice}}

Contexte de voix utilisé essentiellement dans le cadre de citations
ajoutées à une portée -- voir @ref{Mise en forme d'une citation} --, il
est habituellement créé implicitement.

@strong{@emph{ChordNames}}

Permet d'imprimer des noms d'accord.

@ignore
TODO

Then the following, which I don't know what to do with:

    * GregorianTranscriptionVoice
    * GregorianTranscriptionStaff

    * FretBoards
        Engraves fretboards from chords. Not easy... Not
documented.
        There is now some documentation on FretBoards in the NR, under
         instrument-specific notation -- cds.

    * NoteNames

    * Global
        Hard coded entry point for LilyPond. Cannot be tuned.
    * Devnull
        Silently discards all musical information given to this
context.

@end ignore


@node Création et référencement d'un contexte
@subsection Création et référencement d'un contexte
@translationof Creating and referencing contexts

@cindex contexte, création
@cindex contexte, référencement

@funindex \new
@funindex \context

LilyPond crée automatiquement des contextes de bas niveau lorsque
l'expression musicale intervient avant qu'un contexte adéquat n'existe,
ce qui peut être pratique dans le cadre d'une partition simple ou de
courts fragments tels ceux inclus dans cette documentation. Dès que la
structure s'étoffe, il devient nécessaire de créer explicitement tous
les contextes, à l'aide des commandes @code{\new} ou @code{\context}.
Leur syntaxe est très similaire :

@example
[\new | \context] @var{Contexte} [ = @var{nom}] [@var{musique}]
@end example

@noindent
où peuvent intervenir aussi bien @code{\new} que @code{\context}.
Le @var{Contexte} est le nom du contexte à créer, qui éventuellement
s'appellera plus particulièrement @var{nom} ; il contient l'expression
musicale unique @var{musique} qui devra être interprétée dans ce
contexte par les graveurs ou exécutants.

Le préfixe @code{\new} non suivi d'un nom s'utilise principalement pour
créer une partition avec plusieurs portées :

@lilypond[quote,verbatim]
<<
  \new Staff \relative {
    % leave the Voice context to be created implicitly
    c''4 c
  }
  \new Staff \relative {
    d''4 d
}
>>
@end lilypond

@noindent
et pour regrouper des voix sur une même portée :

@lilypond[quote,verbatim]
\new Staff <<
  \new Voice \relative {
    \voiceOne
    c''8 c c4 c c
  }
  \new Voice \relative {
    \voiceTwo
    g'4 g g g
  }
>>
@end lilypond

@noindent
@code{\new} est à priviliégier lorsque les contextes ne sont pas nommés.

La différence entre les commandes @code{\new} et @code{\context} se
situe au niveau de leurs effets :

@itemize
@item
La commande @code{\new}, suivie ou non d'un nom, crée un tout
nouveau contexte même s'il en existe déjà un portant le même nom :

@lilypond[quote,verbatim]
\new Staff <<
  \new Voice = "A" \relative {
    \voiceOne
    c''8 c c4 c c
  }
  \new Voice = "A" \relative {
    \voiceTwo
    g'4 g g g
  }
>>
@end lilypond

@item
La commande @code{\context} avec nommage créera un contexte distinct
uniquement dans le cas où ne préexiste aucun contexte du même nom dans
la même hiérarchie de contextes.  Dans le cas contraire, il servira de
référence au contexte précédemment créé, et son expression musicale sera
transmise dans ce contexte pour interprétation.

Le nommage des contextes se révèle fort utile dans le cadre des paroles
ou de la basse chiffrée comme indiqué dans
@ref{Travail avec des paroles et variables} ou
@rlearning{Modèles pour ensemble vocal} pour le premier cas et
@ref{Gravure de la basse chiffrée} pour le second. Par ailleurs, cette
procédure est tout à fait pertinente lorsque l'on sépare mise en forme
de la partition et contenu musical.  Les deux formulations ci-après sont
tout à fait valides :

@lilypond[quote,verbatim]
\score {
  <<
    % score layout
    \new Staff <<
      \new Voice = "one" {
        \voiceOne
      }
      \new Voice = "two" {
        \voiceTwo
      }
    >>

    % musical content
    \context Voice = "one" {
      \relative {
        c''4 c c c
      }
    }
    \context Voice = "two" {
      \relative {
        g'8 g g4 g g
      }
    }
  >>
}
@end lilypond

@lilypond[quote,verbatim]
\score {
  <<
    % score layout
    \new Staff <<
      \context Voice = "one" {
        \voiceOne
      }
      \context Voice = "two" {
        \voiceTwo
      }
    >>

    % musical content
    \context Voice = "one" {
      \relative {
        c''4 c c c
      }
    }
    \context Voice = "two" {
      \relative {
        g'8 g g4 g g
      }
    }
  >>
}
@end lilypond

@noindent
Par ailleurs, le recours à des variables produira les mêmes effets --
voir @rlearning{Organisation du code source avec des variables}.

@item
@funindex \applyContext
La commande @code{\context} utilisée sans nommage recherchera le premier
de tous les contextes du même type précédemment créés dans la même
hiérarchie de contextes ; l'expression musicale lui sera alors transmise
pour interprétation.  Bien que rarement utilisée, cette formulation de
@code{\context} sans nommage ni expression musicale permet de définir le
contexte dans lequel une procédure Scheme comportant une clause
@code{\applyContext} devra s'exécuter.

@example
\new Staff \relative @{
  c'1
  \context Timing
  \applyContext #(lambda (ctx)
                   (newline)
                   (display (ly:context-current-moment ctx)))
  c1
@}
@end example

@end itemize

Un contexte auquel il est ultérieurement fait référence doit
impérativement être nommé.  C'est le cas par exemple lorsque des paroles
sont associées à de la musique :

@example
\new Voice = "tenor" @var{musique}
@dots{}
\new Lyrics \lyricsto "tenor" @var{paroles}
@end example

@noindent
L'association de paroles à de la musique est abordée en détails à la
rubrique @ref{Durée automatique des syllabes}.

Les propriétés de tous les contextes d'un même type se modifient au sein
d'un bloc @code{\layout}, selon une syntaxe différente -- voir
@ref{Modification de tous les contextes d'un même type}.  Une telle
construction permet de séparer mise en forme et contenu musical.
Lorsque un seul contexte requiert une adaptation, mieux vaut recourir à
un bloc @code{\with} -- voir
@ref{Modification d'un contexte particulier}.

@morerefs
Manuel d'initiation :
@rlearning{Organisation du code source avec des variables}.

Manuel de notation :
@ref{Durée automatique des syllabes},
@ref{Modification d'un contexte particulier}.
@endmorerefs


@node Conservation d'un contexte
@subsection Conservation d'un contexte
@translationof Keeping contexts alive

@cindex contexte, maintien actif
@cindex contexte, durée de vie

En règle générale, un contexte disparaît dès qu'il n'y a plus rien à
faire.  Autrement dit, un contexte @code{Voice} disparaît dès après le
dernier événement qu'il contient, et un contexte @code{Staff} dès que
les contextes @code{Voice} qu'il supporte ne contiennent plus rien.
Ceci peut avoir des conséquences néfastes lorsqu'il est fait référence à
un contexte alors disparu, comme dans le cas d'un changement de portée
introduit par la commande @code{\change}, l'association de paroles à
l'aide de la commande @code{\lyricsto} ou si des événements surviennent
à nouveau pour ce contexte précédemment actif.

Une exception cependant à cette règle : en présence d'un contexte
@code{Staff} ou dans une construction @code{<< @dots{} >>}, un seul des
contextes @code{Voice} inclus restera actif jusqu'à la fin du contexte
@code{Staff} ou de la construction @code{<< @dots{} >>}, y compris s'il y
a des « trous ».  Le contexte alors persistant sera le premier
rencontré dans la construction @code{@{ @dots{} @}} sans tenir compte
des éventuels @code{<< @dots{} >>} qu'elle pourrait contenir.

Un contexte restera actif dès lors qu'il s'y passera toujours quelque
chose.  Un contexte @code{Staff} restera actif si l'une des voix qu'il
supporte est toujours active.  L'un des moyens de s'en assurer
consiste à ajouter des silences invisibles parallèlement à la musique.
Vous devrez les ajouter dans tous les contextes @code{Voice} qui doivent
rester actifs.  Nous vous conseillons, lorsque plusieurs voix
interviennent de manière sporadique, de toutes les maintenir actives
plutôt que de vous fier aux exceptions mentionnées plus haut.

Dans l'exemple suivant, les deux voix A et B sont maintenues actives
jusqu'à la fin du morceau :

@lilypond[quote,verbatim]
musicA = \relative { d''4 d d d }
musicB = \relative { g'4 g g g }
keepVoicesAlive = {
  <<
    \new Voice = "A" { s1*5 }  % Keep Voice "A" alive for 5 bars
    \new Voice = "B" { s1*5 }  % Keep Voice "B" alive for 5 bars
  >>
}

music = {
  \context Voice = "A" {
    \voiceOneStyle
    \musicA
  }
  \context Voice = "B" {
    \voiceTwoStyle
    \musicB
  }
  \context Voice = "A" { \musicA }
  \context Voice = "B" { \musicB }
  \context Voice = "A" { \musicA }
}

\score {
  \new Staff <<
    \keepVoicesAlive
    \music
  >>
}
@end lilypond

@cindex paroles, alignement sur une mélodie épisodique

L'exemple suivant illustre la manière d'écrire selon cette méthode une
mélodie discontinue à laquelle se rattachent des paroles.  Dans la
réalité, mélodie et accompagnement feraient l'objet de portées séparées.

@lilypond[quote,verbatim]
melody = \relative { a'4 a a a }
accompaniment = \relative { d'4 d d d }
words = \lyricmode { These words fol -- low the mel -- o -- dy }
\score {
  <<
    \new Staff = "music" {
      <<
        \new Voice = "melody" {
          \voiceOne
          s1*4  % Keep Voice "melody" alive for 4 bars
        }
        {
          \new Voice = "accompaniment" {
            \voiceTwo
            \accompaniment
          }
          <<
            \context Voice = "melody" { \melody }
            \context Voice = "accompaniment" { \accompaniment }
          >>
          \context Voice = "accompaniment" { \accompaniment }
          <<
            \context Voice = "melody" { \melody }
            \context Voice = "accompaniment" { \accompaniment }
          >>
        }
      >>
    }
    \new Lyrics \with { alignAboveContext = "music" }
    \lyricsto "melody" { \words }
  >>
}
@end lilypond

Une autre méthode, qui s'avère plus productive dans nombre de cas,
consiste à maintenir active la ligne mélodique en y insérant des
silences invisibles tout au long de l'accompagnement :

@lilypond[quote,verbatim]
melody = \relative {
  s1  % skip a bar
  a'4 a a a
  s1  % skip a bar
  a4 a a a
}
accompaniment = \relative {
  d'4 d d d
  d4 d d d
  d4 d d d
  d4 d d d
}
words = \lyricmode { These words fol -- low the mel -- o -- dy }

\score {
  <<
    \new Staff = "music" {
      <<
        \new Voice = "melody" {
          \voiceOne
          \melody
        }
        \new Voice = "accompaniment" {
          \voiceTwo
          \accompaniment
        }
      >>
    }
    \new Lyrics \with { alignAboveContext = "music" }
    \lyricsto "melody" { \words }
  >>
}
@end lilypond


@node Modification des greffons de contexte
@subsection Modification des greffons de contexte
@translationof Modifying context plug-ins

@c TODO Should this be Modifying engravers or Modifying contexts?

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 (@emph{plug-ins} pour employer le terme consacré) nommés
« graveurs » (@emph{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_heads_engraver}, chargé des têtes de notes et, dans le
contexte @code{Staff}, un graveur @code{Key_engraver}, chargé de
l'armure.

Vous trouverez une description exhaustive de chaque graveur dans
@ifhtml
@rinternals{Engravers and Performers}.
@end ifhtml
@ifnothtml
Référence des propriétés internes @expansion{} Translation @expansion{} Engravers.
@end ifnothtml
Chaque contexte mentionné dans
@ifhtml
@rinternals{Contexts}
@end ifhtml
@ifnothtml
Référence des propriétés internes @expansion{} Translation @expansion{} Context.
@end ifnothtml
répertorie les graveurs mis en œuvre.

On peut faire, au moyen de ces graveurs, sa propre « cuisine », en
modifiant les contextes à volonté.

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

@funindex \with
@funindex \consists
@funindex \remove

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

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

@lilypond[quote,verbatim]
<<
  \new Staff \relative {
    f'2 g
  }
  \new Staff \with {
     \remove Time_signature_engraver
     \remove Clef_engraver
  } \relative {
    f'2 g2
  }
>>
@end lilypond

La clef 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{Visibilité et couleur des objets}).

@knownissues

L'ordre dans lequel les graveurs sont spécifiés correspond à leur ordre
d'apparition dans le processus d'élaboration de la partition.
En règle générale, l'ordre dans lequel les graveurs sont mentionnés
importe peu.  Il se peut toutefois qu'un graveur écrive une propriété
qui sera interprétée par un autre, ou qu'un graveur crée un objet
graphique qui sera traité par un autre ; l'ordre d'apparition de
ces graveurs prendra alors toute son importance.

Pour information, les ordonnancements suivants sont importants :

@itemize
@item
le @code{Bar_engraver} devrait toujours être le premier ;

@item
le @code{New_fingering_engraver} doit toujours précéder le
@code{Script_column_engraver} ;

@item
le @code{Timing_translator} doit toujours précéder le
@code{Bar_number_engraver}.

@end itemize

@morerefs
Fichiers d'initialisation :
@file{ly/engraver-init.ly}.
@endmorerefs


@node Modification des réglages par défaut d'un contexte
@subsection Modification des réglages par défaut d'un contexte
@translationof Changing context default settings

@cindex réglage par défaut, modification
@cindex contexte, modification des propriétés par défaut

Les propriétés des contextes et objets graphiques se modifient à l'aide
des commandes @code{\set} et @code{\override}, comme indiqué à la
rubrique @ref{Modification de propriétés}.  Ces commandes créent des
événements musicaux qui feront que la modification produira ses effets
dès l'instant où la musique est traitée.

Le propos est ici de voir comment modifier les valeurs @emph{par défaut}
des propriétés de contexte ou d'objet graphique dès la création de ces
contextes.  Deux manières de procéder sont envisageables : l'une
consiste à modifier les valeurs pour tous les contextes d'un même type,
l'autre s'attache à adapter les valeurs par défaut d'une instance
particulière d'un contexte.

@menu
* Modification de tous les contextes d'un même type::
* Modification d'un contexte particulier::
* Ordre de préséance::
@end menu


@node Modification de tous les contextes d'un même type
@unnumberedsubsubsec Modification de tous les contextes d'un même type
@translationof Changing all contexts of the same type

@cindex @code{\context} dans un bloc @code{\layout}

@funindex \context
@funindex \layout

L'adaptation des réglages par défaut d'un contexte, qu'il s'agisse de
@code{Score}, @code{Staff} ou @code{Voice}, peut se réaliser
indépendamment de la musique dans un bloc @code{\layout} -- placé dans
le bloc @code{\score} auquel ces modifications doivent s'appliquer -- au
moyen d'un bloc @code{\context}.

Les réglages dévolus à la sortie MIDI viendront quant à eux se placer
dans un bloc @code{\midi} -- voir
@ref{Définitions de la sortie -- hiérarchie des contextes}.

@example
\layout @{
  \context @{
    \Voice
    [réglage de contexte pour tous les contextes @emph{Voice}]
  @}
  \context @{
    \Staff
    [réglage de contexte pour tous les contextes @emph{Staff}]
  @}
@}
@end example

La spécification des adaptations peut se faire de différentes manières :

@itemize
@item
à l'aide d'une commande @code{\override}, sans lui adjoindre le nom du
contexte :

@c KEEP LY
@lilypond[quote,verbatim]
\score {
  \relative {
    a'4^"Hampes épaisses" a a a
    a4 a a\ff a
  }
  \layout {
    \context {
      \Staff
      \override Stem.thickness = #4.0
    }
  }
}
@end lilypond

@item
en définissant directement une propriété de contexte :

@c KEEP LY
@lilypond[quote,verbatim]
\score {
  \relative {
    a'4^"Fontes plus petites" a a a
    a4 a a\ff a
  }
  \layout {
    \context {
      \Staff
      fontSize = #-4
    }
  }
}
@end lilypond


@item
à l'aide d'une commande prédéfinie comme @code{\dynamicUp}, ou bien une
expression musicale telle que @code{\accidentalStyle dodecaphonic} :

@c KEEP LY
@lilypond[quote,verbatim]
\score {
  \relative {
    a'4^"Nuance en surplomb" a a a
    a4 a a\ff a
  }
  \layout {
    \context {
      \Voice
      \dynamicUp
    }
    \context {
      \Staff
      \accidentalStyle dodecaphonic
    }
  }
}
@end lilypond

@item
à l'aide d'une variable personnalisée contenant un bloc @code{\with} ;
pour de plus amples informations sur le bloc @code{\with}, voir
@ref{Modification d'un contexte particulier}.

@c KEEP LY
@lilypond[quote,verbatim]
StaffDefauts = \with {
  fontSize = #-4
}

\score {
  \new Staff {
    \relative {
      a'4^"Petite police" a a a
      a4 a a a
    }
  }
  \layout {
    \context {
      \Staff
      \StaffDefauts
    }
  }
}
@end lilypond

@end itemize

Les instructions destinées à modifier les propriétés peuvent se placer
dans un bloc @code{\layout} sans pour autant être incluses dans un bloc
@code{\context}.  Expliciter des réglages de la sorte équivaut à inclure
les commandes de modification des propriétés au début de chacun des
contextes du type en question.  Lorsque le contexte n'est pas spécifié,
@emph{tous} les contextes de bas niveau seront affectés -- voir
@ref{Contextes de bas niveau -- les voix}.  La syntaxe appropriée répond
aux mêmes critères que si la commande était écrite dans le flot
musical.

@c KEEP LY
@lilypond[quote,verbatim]
\score {
  \new Staff {
    \relative {
      a'4^"Petite police" a a a
      a4 a a a
    }
  }
  \layout {
    \accidentalStyle dodecaphonic
    \set fontSize = #-4
    \override Voice.Stem.thickness = #4.0
  }
}
@end lilypond


@node Modification d'un contexte particulier
@unnumberedsubsubsec Modification d'un contexte particulier
@translationof Changing just one specific context

@funindex \with

Dans le cas d'un contexte pris individuellement, ses propriétés se
modifient à l'aide d'un bloc @code{\with}.  Toutes les autres instances
de contexte appartenant au même type seront affectées des réglages
prédéfinis par LilyPond, modifiés le cas échéant au sein d'un bloc
@code{\layout}.  Le bloc @code{\with} se place directement à la suite de
la commande @code{\new} @var{type-de-contexte}.

@example
\new Staff \with @{
  [réglages pour ce contexte pris individuellement]
@} @{
  @dots{}
@}
@end example

De la même manière, si la musique est saisie à la suite d'une commande
abrégée, telle que @code{\chords} au lieu de @code{\chordmode},
l'instruction @code{\with} viendra se placer juste après la commande
spécifiant le mode :

@example
\chords \with @{
  [réglages pour ce contexte (implicite) pris individuellement]
@} @{
  @dots{}
@}
@end example

@noindent
puisque c'est le contexte implicite alors créé qui devra être modifié.
Cette manière de procéder s'applique à toutes les autres formes abrégées
de spécification du mode de saisie (@code{\drums}, @code{\figures}) --
voir @ref{Modes de saisie}.

Dans la mesure où une telle « modification de contexte » est spécifiée
au sein même de la musique, ses effets toucheront @b{toutes} les sorties
(imprimable @b{et} Midi), contrairement à ce qui se passe lorsque les
adaptations sont réalisées dans la définition d'une sortie.

La spécification des adaptations peut se faire de différentes manières :

@itemize
@item
à l'aide d'une commande @code{\override}, sans lui adjoindre le nom du
contexte :

@c KEEP LY
@lilypond[quote,verbatim]
\score {
  \new Staff {
    \new Voice \with { \override Stem.thickness = #4.0 }
    {
      \relative {
        a'4^"Hampes épaisses" a a a
        a4 a a a
      }
    }
  }
}
@end lilypond

@item
en définissant directement une propriété de contexte :

@lilypond[quote,verbatim]
\score {
  <<
    \new Staff {
      \relative {
        a'4^"Default font" a a a
        a4 a a a
      }
    }
    \new Staff \with { fontSize = #-4 }
    {
      \relative {
        a'4^"Smaller font" a a a
        a4 a a a
      }
    }
  >>
}
@end lilypond

@item
à l'aide d'une commande prédéfinie comme @code{\dynamicUp} :

@c KEEP LY
@lilypond[quote,verbatim]
\score {
  <<
    \new Staff {
      \new Voice {
        \relative {
          a'4^"Nuances en dessous" a a a
          a4 a a\ff a
        }
      }
    }
    \new Staff \with { \accidentalStyle dodecaphonic }
    {
      \new Voice \with { \dynamicUp }
      {
        \relative {
          a'4^"Nuances en surplomb" a a a
          a4 a a\ff a
        }
      }
    }
  >>
}
@end lilypond

@end itemize

@morerefs
Manuel de notation :
@ref{Modes de saisie}.
@endmorerefs


@node Ordre de préséance
@unnumberedsubsubsec Ordre de préséance
@translationof Order of precedence

La valeur d'une propriété qui doit s'appliquer à un instant particulier
est déterminée comme suit :

@itemize
@item
s'il y a une instruction @code{\override} ou @code{\set} active dans le
flot d'information, sa valeur s'applique,

@item
en l'absence de quoi sera utilisée la valeur par défaut telle que
définie dans une clause @code{\with} stipulée à l'initialisation du
contexte,

@item
en l'absence de quoi sera retenue la valeur par défaut issue du bloc
@code{\context} approprié le plus récent dans les blocs @code{\layout}
ou @code{\midi},

@item
en l'absence de quoi s'appliqueront les réglages prédéfinis de LilyPond.
@end itemize

@morerefs
Manuel d'initiation :
@rlearning{Modification des propriétés d'un contexte}.

Manuel de notation :
@ref{Contextes de bas niveau -- les voix},
@ref{La commande de dérogation (override)},
@ref{La commande de fixation (set)},
@ref{Le bloc layout},
@ref{Tout savoir sur les contextes}.
@endmorerefs


@node Définition de nouveaux contextes
@subsection Définition de nouveaux contextes
@translationof Defining new contexts


@unnumberedsubsubsec Généralités en matière de définition d'un contexte
@translationof Context definition overview

@cindex contexte, création
@cindex graveur, affectation à un contexte

@funindex \alias
@funindex \name
@funindex \type
@funindex \consists
@funindex \accepts
@funindex \denies

Les contextes tels que @code{Staff} ou @code{Voice} sont faits
de briques de construction 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 à @code{Voice}, mais qui n'imprime que des têtes de notes en
forme de barre oblique au centre de la portée.  Un tel contexte peut
servir, par exemple, à 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 Rhythmic_column_engraver
  \consists Text_engraver
  \consists Pitch_squash_engraver
  squashedPosition = #0
  \override NoteHead.style = #'slash
  \hide Stem
  \alias Voice
}
\context { \Staff
  \accepts ImproVoice
}}

\relative {
  a'4 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 placé
dans le bloc @code{\layout} :

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

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

@funindex \name
Tout d'abord, il convient de donner un nom à notre nouveau contexte :

@example
\name ImproVoice
@end example

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

@example
\alias Voice
@end example

@funindex \consists
Ce contexte doit pouvoir imprimer des notes et des indications
textuelles ; on ajoute donc les graveurs appropriés ainsi que celui
dévolu au regroupement sous forme de colonne des notes, hampes et
silences qui interviennent au même moment musical :

@example
\consists Note_heads_engraver
\consists Text_engraver
\consists Rhythmic_column_engraver
@end example

Toutes les notes devraient s'afficher au centre de la portée :

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

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

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

@example
\override NoteHead.style = #'slash
\hide Stem
@end example

@funindex \type
@funindex Engraver_group
Tous ces modules doivent communiquer sous le contrôle du contexte. Les
mécanismes permettant aux contextes de communiquer sont établis dès lors
que le mot-clé @code{\type} précède le contexte. La plupart des
contextes mentionnés au sein d'un bloc @code{\layout} seront de type
@code{Engraver@/_group}. Certains contextes spécifiques reposent sur
d'autres types de contexte. Recopier un contexte préexistant pour en
modifier la définition lui affecte le type adéquat. Dans la mesure où
notre exemple consiste à créer une définition de toute pièce, son type
doit être explicitement spécifié.

@example
\type Engraver_group
@end example

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

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

@funindex \accepts

Ce n'est pas tout.  En effet, on veut intégrer le nouveau contexte
@code{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 la définition du contexte @code{Staff},
au moyen de la commande @code{\accepts} :

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

@funindex \inherit-acceptability
Souvent, lorsque l'on réutilise le définition d'un contexte, le contexte
qui en résultera devrait pouvoir s'utiliser partout où le contexte
originel serait utile.

@example
\layout @{
  @dots{}
  \inherit-acceptability @var{résultant} @var{originel}
@}
@end example

@noindent
fera en sorte que les contextes de type @var{résultant} soient acceptés
par le contextes qui acceptent @var{originel}. Par exemple, libeller

@example
\layout @{
  @dots{}
  \inherit-acceptability ImproVoice Voice
@}
@end example

@noindent
aura pour effet d'ajouter un @code{\accepts} pour @code{ImproVoice} à la
fois aux définitions de @code{Staff} et @code{RhythmicStaff}.

@funindex \denies

Le contraire de @code{\accepts} est @code{\denies} ; il 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 ceci :

@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 @{
  a'4 d8 bes8
  \new ImproVoice @{
    c4^"ad lib" c
    c4 c^"dévêtez-vous"
    c c_"tout en jouant :)"
  @}
  a1
@}
@end example

@morerefs
Référence des propriétés internes :
@rinternalsnamed{Contexts,Contextes},
@rinternalsnamed{Engravers and Performers, Graveurs et exécutants}.
@endmorerefs


@unnumberedsubsubsec Création de contextes en MIDI
@translationof New contexts in MIDI

@cindex contexte, définition pour le MIDI
@cindex MIDI, définition de contexte
@funindex Performer_group

En matière de sortie MIDI, la syntaxe permettant de définir de nouveaux
types de contextes est identique, à ceci près que la section
@code{\context} viendra se placer au sein du bloc @code{\midi} et le
@code{\type} sera @code{Performer_@/group} au lieu de
@code{Engraver_@/group}. Le terme @emph{engraver} (graveur) fait
référence à un module de contexte chargé de générer une sotie visuelle,
alors qu'un @emph{performer} (exécutant) est dévolu exclusivement à une
sortie MIDI. Lorsque les noms de modules comportent @emph{translator}
(traducteur) au lieu de @emph{engraver} ou @emph{performer}, ils sont
alors fonctionnels tant pour des sorties graphiques qu'audio. Afin
d'adapter une définition de contexte pour le bloc @code{\midi}, il
faudra

@itemize
@item
la copier dans un bloc @code{\midi},
@item
changer @code{Engraver_@/group} en @code{Performer_@/group},
@item
supprimer les @code{\consists} propres aus graveurs (ils ne sont pas
pertinents) et éventuellement ajouter des @code{\consists} pour les
exécutants.
@end itemize

Il faut garder à l'esprit, afin de préserver une cohérence
d'interprétation entre les sorties imprimables et MIDI, qu'il est de bon
ton de reporter toute définition de contexte personnalisée dans le bloc
@code{\midi}. Cette duplication devrait au moins comporter les commandes
spécifiant la hiérarchie du contexte, telles que @code{\accepts},
@code{\defaultchild} et @code{\inherit-@/acceptability}. Recopier aussi
les alias est recommandé.

Ainsi, dans le but de compléter l'exemple vu plus haut, on peut y ajouter :

@example
\midi @{
  \context @{
    \name ImproVoice
    \type Performer_group
    \alias Voice
    \consists Note_performer
    \consists Beam_performer
    \consists Dynamic_performer
    \consists Tie_performer
    \consists Slur_performer
  @}
  \context @{
    \Staff
    \accepts ImproVoice
  @}
@}
@end example

Le contexte @code{ImproVoice} sera alors fonctionnel pour la sortie MIDI.


@unnumberedsubsubsec Remplacement du contexte @code{Score}
@translationof Replacing the Score context

@cindex @code{Score}, remplacement du contexte
@cindex contexte de niveau @code{Score}

@c This can also be done with \accepts in Global.  Since Global is
@c a very special context type, we avoid answering the question of
@c why certain things don't work on it by not mentioning it at
@c all.

Dans le but d'écrire un contexte @code{MonScore} qui agirait comme étant
le contexte le plus haut, à l'instar de ce que fait le contexte
@code{Score}, il faudra expliciter une instruction
@code{\inherit-@/acceptability MonScore Score}. L'exemple suivant
définit un contexte @code{ProportionalScore} pour lequel la notation
proportionnelle est activée (cf. @ref{Notation proportionnelle}).

@lilypond[verbatim,quote]
\layout {
  \context {
    \Score
    \name ProportionalScore
    \alias Score
    proportionalNotationDuration = #(ly:make-moment 1/4)
  }
  \inherit-acceptability ProportionalScore Score
}

\new ProportionalScore { c'1 2 4 8 16 32 64 64 }
@end lilypond

@funindex Score_engraver
@funindex Score_performer
Dans la mesure où le contexte sommital doit contenir certains graveurs
fondamentaux, hériter des réglages de @code{\Score} est facile dans la
plupart des cas. Néanmoins, la définition d'un contexte de niveau
@code{Score} à partir de zéro requiert que l'argument à @code{\type}
soit égal à @code{Score_@/engraver} (ou @code{Score_@/performer} dans le
bloc @code{\midi}) en lieu et place de @code{Engraver_@/group}. Par
ailleurs, affecter au contexte sommital l'alias @code{Score} est
fortement recommandé dans la mesure où un certin nombre de graveurs ont
besoin d'accéder au contexte sommital par son alias.


@node Ordonnancement des contextes
@subsection Ordonnancement des contextes
@translationof Context layout order

@cindex contextes, ordonnancement

@funindex \accepts
@funindex \denies

Les contextes viennent en principe se positionner selon leur ordre
d'apparition dans le fichier source.  Lorsque plusieurs contextes sont
imbriqués, le contexte englobant supportera les différents contextes
mentionnés dans le fichier source, à la stricte condition qu'ils soient
dûment « agréés ».  Les contextes imbriqués qui ne font pas partie de
la « liste d'agréments » du contexte englobant se retrouveront en
dessous de celui-ci au lieu d'y être imbriqués.

La liste des « agréments » d'un contexte se gère à l'aide des
instructions @code{\accepts} ou @code{\denies} -- @code{\accepts} pour
ajouter un contexte à la liste, @code{\denies} pour retirer l'agrément.

Par exemple, un @code{TabStaff} accepte par défaut des contextex
@code{TabVoice} mais ne supporte pas de contextes @code{Voice}. Un
contexte @code{Voice} apparaissant dans un @code{TabStaff} se
verrait repositionné sur une portée séparée.

@lilypond[verbatim,quote]
\score {
  \new TabStaff <<
    \new TabVoice { c'1 }
    \new Voice { d'1 }
    >>
}
@end lilypond

Néanmoins, et grâce à une instruction @code{\accepts}, un contexte
@code{Voice} peut se voir ajouté au @code{TabStaff} :

@lilypond[verbatim,quote]
\score {
  \new TabStaff <<
    \new TabVoice { c'1 }
    \new Voice { d'1 }
    >>
  \layout {
    \context {
      \TabStaff
      \accepts Voice
    }
  }
}
@end lilypond

L'instruction @code{\denies} permet, lorsqu'un nouveau contexte reprend
les définitions d'un contexte existant, d'en ajuster les composantes.
C'est par exemple le cas du contexte @code{VaticanaStaff}, réplique du
contexte @code{Staff}, au sein duquel le contexte @code{VaticanaVoice} se
substitue au contexte @code{Voice} dans la « liste d'agrément ».

@cindex contexte implicite
@cindex implicite, contexte
@funindex \defaultchild

Gardez à l'esprit que, face à une instruction qui ne s'appliquerait à
aucun contexte déjà existant, LilyPond créera un nouveau contexte
implicite.

Lors de la définition d'un contexte, les types de contextes
sous-jacents susceptibles d'être créés implicitement sont spécifiés à
l'aide d'une commande @code{\defaultchild}. Un certain nombre
d'événements musicaux requièrent un contexte de plus bas niveau ; face à
un tel événement, LilyPond crée autant de « sous-contextes » que
nécessaire, jusqu'au contexte ne comportant aucun @emph{defaultchild}.

La création implicite de contexte peut donc finir par engendrer de
manière intempestive une nouvelle portée ou une autre partition.
L'utilisation d'une instruction @code{\new} pour créer explicitement des
contextes permet d'éviter ces problèmes.

@funindex alignAboveContext
@funindex alignBelowContext

Il arrive qu'un contexte ne doive exister que pendant un court instant,
ce qui est le cas par exemple pour une @emph{ossia}.  Le plus simple
consiste alors à initialiser la définition d'un contexte à l'endroit
approprié, en parallèle avec le fragment correspondant dans la musique
principale.  Ce contexte temporaire sera par défaut positionné sous les
autres contextes existants.  Le repositionner au-dessus du contexte
« principal » demande de le définir ainsi :

@example
\new Staff \with @{ alignAboveContext = "principal" @}
@end example

Il en va de même pour les contextes temporaires de paroles au sein d'un
système à plusieurs portées comme un @code{ChoirStaff} lorsque, par
exemple, un couplet supplémentaire apparaît à l'occasion d'une reprise.
Ce contexte de paroles temporaire se place par défaut sous les portées
inférieures.  Lui adjoindre une instruction @code{alignBelowContext} dès
son initialisation permet de l'accoler au contexte de paroles (nommé)
qui contient le premier couplet.

Des exemples de repositionnement de contexte temporaire sont disponibles
aux rubriques @rlearning{Expressions musicales imbriquées},
@ref{Modification de portées individuelles} et
@ref{Situations particulières en matière de paroles}.

@morerefs
Manuel d'initiation :
@rlearning{Expressions musicales imbriquées}.

Manuel de notation :
@ref{Modification de portées individuelles},
@ref{Situations particulières en matière de paroles}.

Manuel d'utilisation :
@rprogram{Apparition d'une portée supplémentaire}.

Fichiers d'initialisation :
@file{ly/engraver-init.ly}.
@endmorerefs


@node En quoi consiste la référence des propriétés internes
@section En quoi consiste la référence des propriétés internes
@translationof Explaining the Internals Reference

@menu
* Navigation dans les références du programme::
* Interfaces de rendu::
* Détermination de la propriété d'un objet graphique (grob)::
@end menu

@morerefs
Manuel de notation :
@ref{Conventions de nommage}.
@endmorerefs


@node Navigation dans les références du programme
@subsection Navigation dans les références du programme
@translationof Navigating the program reference

@c TODO remove this (it's in the LM)
@c Replace with more factual directions

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

@lilypond[quote,fragment,verbatim]
c''-2
@end lilypond

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

@quotation
@strong{Voir aussi}

Référence des propriétés internes : @rinternals{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: @rinternals{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: @rinternals{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
@rinternals{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 difficile à comprendre dans un document au format PDF.
@end ifnothtml

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

@quotation
Fingering objects are created by: @rinternals{Fingering_engraver} and
@rinternals{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
@rinternals{Fingering_engraver} et @rinternals{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

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

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

@item @rinternals{fingering-event}:
Music event type @code{fingering-event} is in Music expressions named
@rinternals{FingeringEvent}
@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
@emph{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 des propriétés internes peut également se parcourir comme
un document normal. On y trouve des chapitres tels que
@ifhtml
@rinternals{Music definitions},
@end ifhtml
@ifnothtml
@code{Music definitions}
@end ifnothtml
@rinternals{Translation}, ou encore @rinternals{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
La Référence des propriétés internes 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
@rglosnamed{Top, glossaire} fort utile pour les utilisateurs
francophones.


@node Interfaces de rendu
@subsection Interfaces de rendu
@translationof Layout interfaces

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

Tous les éléments de notation sont considérés comme des objets
graphiques (en anglais @emph{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
@rinternals{grob-interface}.

Prenons l'exemple des doigtés (en anglais @emph{Fingering}).  La page
@code{Fingering} de la Référence des propriétés internes établit une
liste de définitions propres à ce type d'objet :

@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 @emph{Fingering})
possède les attributs suivants :

@itemize
@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
@rinternals{Fingering}.

@quotation
This object supports the following interfaces:
@rinternals{item-interface},
@rinternals{self-alignment-interface},
@rinternals{side-position-interface}, @rinternals{text-interface},
@rinternals{text-script-interface}, @rinternals{font-interface},
@rinternals{finger-interface}, and @rinternals{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 aux 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, d'autres non (les @emph{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{Autres sources de documentation}), en l'occurrence 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 . fetaText)
     (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 des
propriétés internes est en fait directement engendrée par cette
définition.


@node Détermination de la propriété d'un objet graphique (grob)
@subsection Détermination de la propriété d'un objet graphique (grob)
@translationof Determining the grob property

@c TODO remove this (it's in the LM)
@c Replace with more factual directions

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

@lilypond[quote,fragment,verbatim]
c''-2
@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ù positionner 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 ce tampon avant la création du doigté (de l'objet
@code{Fingering}), donc avant @code{c2}, on obtient le résultat
suivant :

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

Dans le cas présent, le réglage intervient dans le contexte @code{Voice},
ce qui pouvait également se déduire de la Référence des propriétés
internes, où la page du graveur @rinternals{Fingering_engraver}
indique :

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

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


@node Modification de propriétés
@section Modification de propriétés
@translationof Modifying properties

@menu
* Vue d'ensemble de la modification des propriétés::
* La commande de fixation (set)::
* La commande de dérogation (override)::
* La commande d'affinage (tweak)::
* set ou override::
* La commande de décalage (offset)::
* Modification de listes associatives::
@end menu


@node Vue d'ensemble de la modification des propriétés
@subsection Vue d'ensemble de la modification des propriétés
@translationof Overview of modifying properties

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.

Les contextes comportent deux types différents de propriétés : des
propriétés de contexte et des propriétés d'objet graphique.  Les
propriétés de contexte sont celles qui s'appliqueront globalement au
contexte en tant que tel ; elles gèrent la manière dont le contexte
apparaîtra.  Les propriétés d'objet graphique, par contre, s'appliquent
à des types particuliers d'objet qui apparaissent dans le contexte en
question.

Les commandes @code{\set} et @code{\unset} permettent de modifier les
valeurs des propriétés de contexte.  Les commandes @code{\override} et
@code{\revert} permettent de modifier les valeurs des propriétés des
objets graphiques.

@ignore
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) employée par le système de mise en
page.  La sous-section @ref{Élaboration d'une retouche} 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é @code{Staff} comme
contexte, ce réglage ne s'appliquera qu'à la portée courante ; les
autres portées demeureront intactes.

@lilypond[quote,fragment,verbatim]
c''4
\override Staff.Stem.thickness = #4.0
c''4
c''4
c''4
@end lilypond

La commande @code{\override} modifie donc la définition de l'objet
@code{Stem} dans le contexte @code{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, @code{Voice}) sera
employé.  La commande @code{\once} permet de n'appliquer la modification
qu'une seule fois.

@lilypond[quote,fragment,verbatim]
c''4
\once \override Stem.thickness = #4.0
c''4
c''4
@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]
\override Slur.thickness = #3.0
c''8[( c''
\override Beam.beam-thickness = #0.6
c''8 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 « 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

@end ignore

@morerefs
Référence des propriétés internes :
@rinternals{All layout objects},
@rinternals{Backend},
@rinternals{OverrideProperty},
@rinternals{PropertySet},
@rinternals{RevertProperty}.
@endmorerefs


@node La commande de fixation (set)
@subsection La commande de fixation @code{\set}
@translationof The set command

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

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

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

Dans la mesure où @var{valeur} est constituée d'un objet Scheme, elle
doit être précédée du caractère @code{#}.

Les propriétés des contextes se libellent sous la forme
@code{minusculeMajuscule}.  Leur rôle consiste principalement à traduire
la musique en notation : par exemple, @code{localAlterations}
déterminera quand imprimer une altération accidentelle, et
@code{measurePosition} quand imprimer une barre de mesure.  La valeur
des propriétés des contextes peut évoluer au fur et à mesure que l'on
avance dans le morceau -- @code{measurePosition} en est l'illustration
parfaite.

Ainsi la propriété de contexte @code{skipBars} permet de condenser les
mesures vides de notes, en des silences multimesures -- voir
@ref{Compression de mesures vides} à ce sujet. Il s'agit d'un objet
Scheme, auquel on attribue la valeur booléenne « vrai », c'est-à-dire la
lettre @code{#t} pour « True » en anglais :

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

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  @code{ChordNames}, @code{Voice} ou
@code{Lyrics}.

@lilypond[quote,fragment,verbatim]
\set Score.autoBeaming = ##f
\relative {
  e''8 e e e
  \set autoBeaming = ##t
  e8 e e e
} \\
\relative {
  c''8 c c c c8 c c c
}
@end lilypond

Ce changement étant appliqué « à la volée », il n'affecte que le second
groupe de notes.

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}, mais du contexte @code{Score} -- le code suivant ne
fonctionnera pas.

@lilypond[quote,fragment,verbatim]
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 @code{Staff}), la
propriété sera modifiée dans tous les contextes inférieurs (tous les
contextes @code{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 @var{propriété} a été définie dans ce
@var{contexte} précis.  En d'autres termes, la commande @code{\unset}
doit impérativement affecter le même contexte que la commande
@code{\set} d'origine, même en cas d'imbrication.

@lilypond[quote,fragment,verbatim]
\set Score.autoBeaming = ##t
\relative {
  \unset autoBeaming
  e''8 e e e
  \unset Score.autoBeaming
  e8 e e e
} \\
\relative {
  c''8 c c c c8 c c c
}
@end lilypond

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

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

@noindent
sont équivalentes si elles apparaissent dans un contexte @code{Voice}.

@funindex \once

Pour modifier une propriété de façon à ce que l'accommodement ne
s'applique qu'une seule fois, il convient d'adjoindre l'instruction
@code{\once} à la commande @code{\set} ou @code{\unset} :

@lilypond[quote,fragment,verbatim]
c''4
\once \set fontSize = #4.7
c''4
c''4
@end lilypond

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

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


@morerefs
Manuel de notation :
@ref{Compression de mesures vides}.

Référence des propriétés internes :
@rinternals{Tunable context properties}.
@endmorerefs


@node La commande de dérogation (override)
@subsection La commande de dérogation @code{\override}
@translationof The override command

@cindex grob, propriétés
@cindex objet graphique, propriétés
@cindex propriétés d'un grob
@cindex propriétés d'objet graphique

@funindex \override

La commande @code{\override} permet de modifier la mise en forme des
objets graphiques.  Les descriptions d'objet graphique, dont les noms
commencent par une majuscule, puis comprennent une ou plusieurs
majuscules (de style @code{TotoTata}), contiennent les réglages « 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}.

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

@example
\override [@var{contexte}.]@var{NomObjet}.@var{propriété} = #@var{valeur}
@end example

Nous pouvons donc par exemple accroître l'épaisseur des hampes en jouant
sur la propriété @code{thickness} de l'objet @code{stem} :

@lilypond[quote,fragment,verbatim]
c''4 c''
\override Voice.Stem.thickness = #3.0
c''4 c''
@end lilypond

Lorsqu'aucun contexte n'est spécifié dans une clause @code{\override},
celle-ci s'appliquera au contexte le plus bas :

@lilypond[quote,fragment,verbatim]
\override Staff.Stem.thickness = #3.0
<<
  \relative {
    e''4 e
    \override Stem.thickness = #0.5
    e4 e
  } \\
  \relative {
    c''4 c c c
  }
>>
@end lilypond

Certaines « 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

@noindent
ou, pour modifier les extrémités d'un objet à extension :

@example
\override TextSpanner.bound-details.left.text = "texte de gauche"
\override TextSpanner.bound-details.right.text = "texte de droite"
@end example

@cindex annulation d'un @emph{override}
@cindex @emph{override}, annulation des effets
@funindex \revert

Les effets d'un @code{\override} prennent fin à l'aide de l'instruction
@code{\revert}.

La syntaxe de la commande @code{\revert} command est :

@example
\revert [@var{contexte}.]@var{NomObjet}.@var{propriété}
@end example

Par exemple :

@lilypond[quote,verbatim]
\relative {
  c''4
  \override Voice.Stem.thickness = #3.0
  c4 c
  \revert Voice.Stem.thickness
  c4
}
@end lilypond

Les effets d'un @code{\override} ou d'un @code{\revert} s'appliquent dès
l'endroit où ils apparaissent, et à tous les objets dans le contexte
mentionné :

@lilypond[quote,verbatim]
<<
  \relative {
    e''4
    \override Staff.Stem.thickness = #3.0
    e4 e e
  } \\
  \relative {
    c''4 c c
    \revert Staff.Stem.thickness
    c4
  }
>>
@end lilypond

@cindex @emph{override} ponctuel
@funindex \once

Les instructions @code{\override} et @code{\revert} doivent être
précédées d'un @code{\once} dès lors que les effets de
l'accommodement ne concernent que l'événement qui les suit directement :

@lilypond[quote,verbatim]
<<
  \relative c {
    \override Stem.thickness = #3.0
    e''4 e e e
  } \\
  \relative {
    c''4
    \once \override Stem.thickness = #3.0
    c4 c c
  }
>>
@end lilypond

@ignore
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 @code{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

@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 « 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.

@end ignore

@morerefs
Référence des propriétés internes :
@rinternals{Backend}.
@endmorerefs


@node La commande d'affinage (tweak)
@subsection La commande d'affinage @code{\tweak}
@translationof The tweak command

@cindex retouche (@emph{tweak})
@cindex affinage (@emph{tweak})
@cindex ajustement (@emph{tweak})
@cindex @emph{tweak} (retouche, affinage)
@funindex \tweak

L'utilisation d'un @code{\override} pour modifier les propriétés d'un
objet graphique affectera toutes les instances de l'objet en question au
sein du contexte, et ce dès son apparition.  Il peut parfois être
préférable de n'affecter qu'un seul objet en particulier plutôt que tous
les objets du contexte.  C'est là le rôle de l'instruction @code{\tweak},
dont la syntaxe est :

@example
\tweak [@var{objet-de-rendu}.]objet-propriété valeur
@end example

Mention de l'@var{objet-de-rendu} est optionnel.
La commande @code{\tweak} s'applique à l'objet qui apparaît
immédiatement après @code{valeur}.

@ignore
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[verbatim,quote]
\relative {
  < c''
    \tweak color #red
    d
    g
    \tweak duration-log #1
    a
  > 4
  -\tweak padding #8
  -^
}
@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 (@rinternals{Event}) du fichier source.
Par exemple :

@itemize
@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 clefs, 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
à l'inverse de

@lilypond[verbatim,fragment,quote]
<\tweak color #red c''>4
@end lilypond
@end ignore

Pour une introduction à la syntaxe et l'utilisation des retouches, voir
le chapitre @rlearning{Méthodes de retouche}.

Lorsque plusieurs éléments de même nature surviennent au même instant,
il devient impossible d'utiliser l'instruction @code{\override} pour
n'en modifier qu'un seul individuellement, d'où l'intérêt de la commande
@code{\tweak}.  Entre autres éléments qui sont susceptibles de se
produire au même instant, nous citerons :

@c TODO expand to include any further uses of \tweak
@itemize
@item les têtes de notes au sein d'un accord,
@item les signes d'articulation,
@item les liaisons de prolongation sur des notes d'un accord,
@item les crochets de n-olets démarrant au même instant
@end itemize

@c TODO add examples of these

Dans l'exemple suivant, l'une des têtes de note de l'accord est
colorisée, et l'aspect d'une autre est changé.

@lilypond[verbatim,fragment,quote]
< c''
  \tweak color #red
  d''
  g''
  \tweak duration-log #1
  a''
> 4
@end lilypond

L'instruction @code{\tweak} permet aussi de modifier l'aspect d'une
liaison :

@lilypond[verbatim,quote]
\relative { c'-\tweak thickness #5 ( d e f) }
@end lilypond

La commande @code{\tweak} ne sera pleinement fonctionnelle que si elle
est directement rattachée à l'objet auquel elle doit s'appliquer alors
que le fichier source est converti en flux musical.  Vouloir modifier la
globalité d'un accord est sans résultat dans la mesure où il ne
constitue qu'un conteneur pour des événements musicaux et que tous les
objets seront créés à partir d'événements appartenant à un
@code{EventChord} (un événement d'accord) :

@lilypond[relative=2,verbatim,quote]
\tweak color #red c4
\tweak color #red <c e>4
<\tweak color #red c>4
@end lilypond

La commande @code{\tweak} simple ne saurait servir à modifier un élément
qui ne serait pas explicitement mentionné dans le fichier source.  C'est
notamment le cas des hampes, ligatures automatiques ou altérations, dans
la mesure où elles seront ultérieurement générées et après les têtes de
note (objets @code{NoteHead}), plutôt qu'au fil des éléments musicaux
saisis.

De tels objets créés indirectement ne peuvent être ajustés que par une
forme développée de la commande @code{\tweak}, autrement dit
lorsque l'objet est explicitement mentionné :

@lilypond[fragment,verbatim,quote]
\tweak Stem.color #(universal-color 'orange)
\tweak Beam.color #(universal-color 'skyblue) c''8 e''
<c'' e'' \tweak Accidental.font-size #-3 ges''>4
@end lilypond

La commande @code{\tweak} ne peut non plus servir à modifier clefs ou
métriques, puisqu'elles seront immanquablement séparées du @code{\tweak}
par l'insertion automatique d'autres éléments requis pour spécifier le
contexte.

Plusieurs commandes @code{\tweak} en enfilade permettent d'affecter un
même élément de notation :

@lilypond[verbatim,fragment,quote]
c'
  -\tweak style #'dashed-line
  -\tweak dash-fraction #0.2
  -\tweak thickness #3
  -\tweak color #red
  \glissando
f''
@end lilypond

Vous pouvez examiner le flux musical généré par une portion d'un
fichier source, y compris les éléments automatiquement insérés, en
suivant les indications portées à la rubrique
@rextend{Affichage d'expressions musicales}.  Ceci s'avère tout à fait
approprié pour déterminer ce qui peut se modifier à l'aide d'un
@code{\tweak} ou bien aider à rectifier votre source de telle sorte
que le @code{\tweak} produise ses effets.

@morerefs
Manuel d'initiation :
@rlearning{Méthodes de retouche}.

Manuel d'extension :
@rextend{Affichage d'expressions musicales}.
@endmorerefs

@knownissues

@cindex tweak et point de contrôle
@cindex point de contrôle et tweak

Lorsqu'il y a plusieurs liaisons de prolongation dans un accord, la
commande @code{\tweak} ne permet de modifier les points de contrôle que
pour la première rencontrée dans le fichier source.


@node set ou override
@subsection @code{\set} ou @code{\override}
@translationof set versus override

@c TODO -- Should't a bunch of that be explained earlier?

@funindex \set
@funindex \override

Les instructions @code{\set} et @code{\override} manipulent toutes deux
des propriétés associées à des contextes.  Dans tous les cas, ces
propriétés tiennent compte de la @emph{hiérarchie des contextes} : les
propriétés qui n'ont pas été définies dans le contexte lui-même
héritent des valeurs de leur contexte parent respectif.

Les valeurs et durée de vie des propriétés d'un contexte sont dynamiques
et ne sont accessibles qu'au moment où la musique est interprétée.  Lors
de la création d'un contexte, ses propriétés sont initialisées à partir
de la définition du contexte correspondant et de ses éventuelles
adaptations.  Toute modification ultérieure ne sera obtenue que par des
commandes d'adaptation des propriétés, libellées au sein même de la
musique.

Les définitions d'un objet graphique (@emph{graphical object} abrégé en
@emph{grob}) constituent une catégorie @emph{spécifique} de propriétés
de contexte, dans la mesure où leur structure, enregistrement et
utilisation diffèrent des propriétés de contextes habituelles.

Contrairement aux propriétés de contextes habituelles, les définitions
de @emph{grob} sont subdivisées en propriétés de @emph{grob}.  Un
@emph{grob} est créé par un graveur lors de l'interprétation d'une
expression musicale et reçoit ses propriétés initiales à partir de la
définition de @emph{grob} en cours dans le contexte du graveur.  Le
graveur (ou tout autre « agent » de LilyPond) peut alors ajouter ou
modifier des propriétés à cet objet, sans pour autant affecter la
définition du @emph{grob} dans ce contexte.

Ce que LilyPond appelle « propriétés de @emph{grob} » dans le cadre
de l'affinage par l'utilisateur sont en fait les propriétés de la
définition d'un objet dans un contexte.

Contrairement aux propriétés de contexte habituelles, les définitions
d'un @emph{grob} doivent être enregistrées pour pouvoir garder trace de
ses composants, les propriétés individuelles du @emph{grob} (ainsi que
leurs sous-propriétés) séparément.  Il sera dès lors possible de définir
ces composants dans différents contextes et ainsi disposer d'une
définition globale du @emph{grob} à l'instant où la création de cet
objet assemblera les éléments relatifs aux différents contextes attachés
au contexte en cours et à ses parents.

Les définitions de @emph{grob} se manipulent à l'aide des commandes
@code{\override} et @code{\revert}, et leur nom commence par une
capitale (comme @samp{NoteHead}) alors que les propriétés de contexte
ordinaires -- elles commencent par une minuscule -- se manipulent avec
@code{\set} et @code{\unset}.

@cindex @emph{tweak}, relation avec @code{\override}
@funindex \tweak
@funindex \overrideProperty

Les instructions spéciales @code{\tweak} et @code{\overrideProperty}
modifient les propriétés de @emph{grob} en court-circuitant totalement
les propriétés de contexte.  En fait, elles capturent les @emph{grobs}
au moment de leur création pour y injecter directement des propriétés
soit émanant d'un événement musical retouché par un @code{\tweak}, soit
lorsqu'ils sont d'une qualité particulière (un @code{\overrideProperty}).


@node La commande de décalage (offset)
@subsection La commande de décalage @code{\offset}
@translationof The offset command

@funindex \offset
@cindex décalage
@cindex offset (décalage)

Bien qu'il soit possible d'affecter de nouvelles valeurs aux propriétés
d'un objet graphique à l'aide des commandes @code{\override},
@code{\tweak} ou @code{\overrideProperty}, il est souvent plus pratique
de modifier de telles propriétés par rapport à une valeur par défaut.
Ceci est la raison d'être de la commande @code{\offset}.

La commande @code{\offset} répond à la syntaxe suivante :

@example
[-]\offset @var{propriété} @var{décalages} @var{élément}
@end example

La commande @code{\offset} agit par addition du contenu de
@var{décalages} au réglage par défaut de la propriété @var{propriété} de
l'objet graphique indiqué par @var{élément}.

Selon la manière dont la commande est formulée, @code{\offset} agira
tantôt comme un @code{\tweak}, tantôt comme un @code{\override}.  Les
différences entre ces utilisations seront abordées après avoir recensé
les propriétés qui peuvent être soumises à un @code{\offset}.

@subsubsubheading Propriétés acceptant des décalages
@c VO Properties which may be offset

Bon nombre de propriétés d'objet graphique, mais pas toutes, peuvent
faire l'objet d'un décalage. Si d'aventure @var{propriété} ne peut être
affectée, l'objet restera inchangé et sera émis un message
d'avertissement.  En pareil cas, l'objet doit être modifié par un
@code{\override} ou un @code{\tweak}.

Il est toujours possible de procéder à tâtons et laisser les
avertissement indiquer si tel objet peut ou ne peut pas être soumis à
@code{\offset}.  Néanmoins, une approche plus systématique est possible.

Les critères énoncés ci-après déterminent l'égibilité d'une propriété à
être modifiée par la commande @code{\offset}.

@itemize

@item
La propriété possède un « réglage par défaut » au niveau de la
définition de l'objet graphique.  Les propriétés en question sont
listées, pour chacun des @emph{grobs}, dans
@rinternalsnamed{All layout objects, Tous les objets de rendu} -- on les
trouvera aussi dans le fichier @file{scm/define-grobs.scm}.

@item
La propriété prend une valeur numérique.  Les valeurs numériques
comprennent @code{number}, liste de @code{number}s, @code{number-pair}
et @code{number-pair-list}. Les pages de
@rinternalsnamed{All layout objects, Tous les objets de rendu}
répertorient le type de donnée propre à chaque propriété.  Peu importe
que le réglage par défaut soit une fonction.

@item
La propriété ne saurait constituer une « sous-propriété » -- une
propriété résidant au sein d'une autre propriété.

@item
Les propriétés réglées sur des valeurs infinies ne peuvent faire l'objet
d'un décalage.  Il n'y a aucun moyen d'influencer l'infini, qu'il soit
positif ou négatif.
@end itemize

Les exemples qui suivent s'arrêtent sur plusieurs propriétés d'objet
graphique au regard des critères énoncés ci-dessus.

@itemize

@item Propriétés qui peuvent être décalées

@table @asis

@item @code{Hairpin.height}
Cette propriété n'est pas une sous-propriété, et est référencée à
@rinternalsnamed{Hairpin, Soufflet}.  En tant que valeur, elle prend une
« dimension, exprimée en espace de portée » réglée à @code{0.6666} --
clairement une valeur @code{number} non infini.

@item @code{Arpeggio.positions}
La page @rinternalsnamed{Arpeggio, Arpeggio} référence une propriété
@code{positions} qui accepte une « paire de nombres ». Sa valeur par
défaut est @code{ly:arpeggio::positions} -- une fonction de rappel qui
sera évaluée au cours de la phase de typographie pour donner une paire
de nombres pour tout objet @code{Arpeggio}.

@end table

@item Propriétés qui ne peuvent être décalées

@table @asis

@item @code{Hairpin.color}
Aucune référence à @code{color} n'est mentionnée dans
@rinternalsnamed{Hairpin, Soufflet}.

@item @code{Hairpin.circled-tip}
La référence à @code{Hairpin.circled-tip} dans
@rinternalsnamed{Hairpin, Soufflet} indique que cette propriété prend une
valeur @code{boolean}. Les boléens ne sont pas des nombres.

@item @code{Stem.details.lengths}
Bien que mentionnée dans @rinternalsnamed{Stem, Hampe} et ayant par
défaut une liste de @code{number}s, il s'agit d'une « sous-propriété ».
Il n'existe à ce jour aucune prise en charge des « propriétés
imbriquées ».

@end table

@end itemize


@subsubsubheading @code{\offset} en tant que dérogation
@c VO \offset as an override

Lorsque @var{élément} est un nom d'objet graphique comme @code{Arpeggio}
ou @code{Staff.OttavaBracket}, le comportement de la commande
@code{\offset} est assimilable à un @code{\override} sur le type d'objet
spécifié.

@example
\offset @var{propriété} @var{décalages} [@var{contexte}.]@var{NomGrob}
@end example

Notez bien qu'il n'y a jamais de tiret avant un comportement
« dérogatoire », tout comme il n'y en a jamais avec la commande
@code{\override} elle-même.

L'exemple suivant utilise la forme « dérogation » pour allonger les
arpeggios affichés dans la première mesure, jusqu'à couvrir l'accord
dans son intégralité.  Les arpeggios sont étirés d'un demi espace de
portée à leur sommet ainsi qu'à leur base.  Est aussi indiquée la même
opération sur le premier accord à l'aide d'une simple dérogation
appliquée à la propriété @code{positions}.  Cette méthode n'est pas la
plus illustrative pour « étirer d'un demi espace de portée » dans la
mesure où les extrémités doivent être spécifiées en coordonnées absolues
plutôt que relatives.  De plus, des dérogations individuelles seraient
nécessaires pour les autres accords en raison de leurs différentes
amplitude et position.

@lilypond[quote,verbatim]
arpeggioMusic = {
  <c' e' g'>\arpeggio <a' c'' e''>\arpeggio
  <d' f' a' c''>\arpeggio <c' e' g' b' d'' f'' a''>\arpeggio
}

{
  \arpeggioMusic
  \bar "||"
  \offset positions #'(-0.5 . 0.5) Arpeggio
  \arpeggioMusic
  \bar "||"
  \once \override Arpeggio.positions = #'(-3.5 . -0.5)
  <c' e' g'>1\arpeggio
  \bar "||"
}
@end lilypond

@funindex \once
@funindex \temporary

Dans cette utilisation d'@emph{override}, @code{\offset} peut se
préfixer de @code{\once} ou @code{\temporary} et être annulé à l'aide
d'un @code{\revert} suivi de @var{propriété} -- voir
@rextend{Fonctions de substitution intermédiaires}.  Ceci tient au fait
que @code{\offset} crée effectivement un @code{\override} de
@var{propriété}.

@lilypond[quote,verbatim]
music = { c'8\< d' e' f'\! }

{
  \music
  \offset height 1 Hairpin
  \music
  \music
  \revert Hairpin.height
  \music
  \bar "||"
  \once \offset height 1 Hairpin
  \music \music
  \bar "||"
  \override Hairpin.height = 0.2
  \music
  \temporary \offset height 2 Hairpin
  \music
  \music
  \revert Hairpin.height
  \music
  \bar "||"
}
@end lilypond

@funindex \single
@funindex \undo

Tout comme @code{\override}, la forme « dérogation » de @code{\offset}
peut s'utiliser avec @code{\undo} et @code{\single}.

@lilypond[quote,verbatim]
longStem = \offset length 6 Stem

{
 \longStem c'4 c''' c' c''
 \bar "||"
 \undo \longStem c'4 c''' c' c''
 \bar "||"
 \single \longStem c'4 c''' c' c''
 \bar "||"
}
@end lilypond

@subsubsubheading @code{\offset} en tant qu'affinage
@c VO offset as a tweak

Lorsque @var{élément} est une expression musicale, comme @code{(} ou
@code{\arpeggio}, le résultat sera la même expression musicale à
laquelle aura été appliqué un affinage.
@c closing )

@example
[-]\offset [@var{NomGrob}.]@var{propriété} @var{décalages} @var{expression-musicale}
@end example

La syntaxe de @code{\offset} dans sa forme « affinage » est en tout
point analogue à la commande @code{\tweak}, autant dans l'ordre des
arguments que dans la présence ou non du tiret l'introduisant.

L'exemple suivant utilise la forme « affinage » pour ajuster le
positionnement vertical de l'objet @code{BreathingSign}.  Les effets de
la simple commande @code{\tweak} sont présent à titre de comparaison.
Leur syntaxe est équivalente.  Néanmoins, le résultat de @code{\tweak}
est moins intuitif dans la mesure où @code{BreathingSign.Y-offset} est
calculé en référence à la ligne médiane.  Il n'est pas nécessaire de
savoir comment se calcule @code{Y-offset} dans le cas d'un
@code{\offset}.

@lilypond[quote,verbatim]
{
  c''4
  \breathe
  c''4
  \offset Y-offset 2 \breathe
  c''2
  \tweak Y-offset 3 \breathe
}
@end lilypond

Dans cet exemple, les objets affinés étaient créés directement à partir
du code saisi : la commande @code{\breathe} était une instruction
explicite pour renvoyer un objet @code{BreathingSign}.  Puisque la cible
de la commande était sans ambiguïté, point n'était besoin de spécifier
le nom de l'objet.  Cependant, lorsqu'un objet est créé
@emph{indirectement}, mention du nom de l'objet devient requise.  Il en
va de même pour la commende @code{\tweak}.

Dans l'exemple qui suit, l'objet @code{Beam} est abaissé de deux espaces
de portée par application de @code{\offset} à la propriété
@code{positions}.

La première application de @code{\offset} requiert mention du nom de
l'objet puisque rien dans le code ne crée explicitement de ligature.
Dans la seconde application, la ligature est explicitement créée par
l'expression musicale @code{[}, ce qui dispense de mentionner le nom de
l'objet.  Cette deuxième application comporte par ailleurs un
raccourci : un unique @code{number} s'appliquera aux deux membres d'un
@code{number-pair}.
@c close ]

@lilypond[quote,verbatim]
{
  c''8 g'' e'' d''
  \offset Beam.positions #'(-2 . -2)
  c''8 g'' e'' d''
  c''8 g'' e'' d''
  c''8-\offset positions #-2 [ g'' e'' d'']
}
@end lilypond

@subsubsubheading @code{\offset} et les bandeaux avec rupture
@c VO offset with broken spanners

Il est aussi possible de modifier indépendamment les segments d'un objet
étendu rencontrant des sauts de ligne.  Dans ce cas, @var{décalages} est
consitué d'une liste de valeurs pour le type de donnée requis par la
propriété.

Utilisée de telle manière, la commande @code{\offset} est similaire à la
commande @code{\alterBroken} -- voir
@ref{Modification de bandeaux avec rupture}.  Cependant, et
contrairement à la commande @code{\alterBroken}, les valeurs fournies à
@code{\offset} sont relatives.

Dans l'exemple suivant est déplacé l'objet « segmenté »
@code{OttavaBracket} au travers de sa propriété @code{staff-padding}.
Puisque cette propriété est affectée d'un @code{number}, @var{décalages}
est alimenté d'une liste de @code{number}s afin de prendre en compte les
deux segments créés par le saut de ligne.  La portion de crochet de la
première ligne n'est en fait pas touchée puisque @code{0} est ajouté à
la valeur par défaut de @code{staff-padding}.  Le segment de la deuxième
ligne est haussé de trois espaces de portée par rapport à sa hauteur par
défaut.  La hauteur par défaut est de @code{2}, bien qu'il ne soit pas
nécessaire de le savoir.

@lilypond[quote,verbatim]
{
 \offset staff-padding #'(0 3) Staff.OttavaBracket
  \ottava #1
  c'''2 c'''
  \break
  c'''2 c'''
}
@end lilypond

L'exemple ci-dessous reproduit les effets de la commande @code{\shape}
en décalant la propriété @code{control-points} de l'objet @code{Slur}.
Ici, @var{décalages} est constitué d'une liste de
@code{number-pair-list}s, une pour chaque segment de la liaison.  Cet
exemple produit un résultat identique à ce qui est illustré dans
@ref{Modification de l'allure des éléments}.

@lilypond[quote,verbatim]
{
  c'4-\offset control-points #'(
               ((0 . 0) (0 . 0) (0 . 0) (0 . 1))
               ((0.5 . 1.5) (1 . 0) (0 . 0) (0 . -1.5))
              ) ( f'4 g' c''
  \break
  d'4 c'' f' c')
}
@end lilypond


@node Modification de listes associatives
@subsection Modification de listes associatives
@translationof Modifying alists

@cindex liste associative, modification

Certaines propriétés configurables par l'utilisateur se présentent en
interne comme étant des listes associatives -- les puristes diront des
@emph{alists}.  Une @emph{alist} est en fait constituée de plusieurs
paires de @emph{clés} et @emph{valeurs}.  La structure d'un liste
associative ressemble à :

@example
'((@var{clé1} . @var{valeur1})
  (@var{clé2} . @var{valeur2})
  (@var{clé3} . @var{valeur3})
  @dots{})
@end example

Dans le cas où cette liste représente les propriétés d'un objet
graphique ou bien l'une des variables du bloc @code{\paper}, chaque clé
peut être modifiée individuellement sans que cela affecte les autres.

Par exemple, pour réduire l'espacement entre deux portées adjacentes
d'un même système, on utilisera la propriété @code{staff-staff-spacing}
qui est attachée à l'objet graphique @code{StaffGrouper}.  Cette
propriété est constituée d'une liste de quatre clés :
@code{basic-distance}, @code{minimum-distance}, @code{padding} et
@code{stretchability}.  Ses réglages par défaut tels que mentionnés à la
rubrique @emph{Backend} de la référence des propriétés internes -- voir
@rinternals{StaffGrouper} -- sont :

@example
'((basic-distance . 9)
  (minimum-distance . 7)
  (padding . 1)
  (stretchability . 5))
@end example

Afin de rapprocher nos deux portées, il suffit de réduire la valeur
(@code{9}) de la clé @code{basic-distance} au niveau de celle de la clé
@code{minimum-distance} (@code{7}).  La modification d'une seule clé
individuellement peut se réaliser sous la forme d'une @emph{déclaration
imbriquée} :

@lilypond[quote,verbatim]
% default space between staves
\new PianoStaff <<
  \new Staff { \clef treble c''1 }
  \new Staff { \clef bass   c1   }
>>

% reduced space between staves
\new PianoStaff \with {
  % this is the nested declaration
  \override StaffGrouper.staff-staff-spacing.basic-distance = #7
} <<
  \new Staff { \clef treble c''1 }
  \new Staff { \clef bass   c1   }
>>
@end lilypond

Le recours à une déclaration imbriquée touchera la clé indiquée
(@code{basic-distance} dans l'exemple ci-dessus) sans pour autant
modifier les autres clés de la propriété considérée.

Considérons maintenant que nous souhaitions que les portées soient le
plus proche possible les unes des autres, à la limite du chevauchement.
Il suffirait de mettre les quatre clés à zéro.  Nous pourrions saisir
quatre déclarations, chacune d'elles touchant une clé.  Nous pouvons
tout aussi bien redéfinir la propriété en une seule clause, sous la
forme d'une liste associative :

@lilypond[quote,verbatim]
\new PianoStaff \with {
  \override StaffGrouper.staff-staff-spacing =
    #'((basic-distance . 0)
       (minimum-distance . 0)
       (padding . 0)
       (stretchability . 0))
} <<
  \new Staff { \clef treble c''1 }
  \new Staff { \clef bass   c1   }
>>
@end lilypond

N'oubliez pas que dès lors qu'une clé n'apparaît pas dans la liste, elle
retourne à sa valeur @emph{sauf-mention-contraire}.  Autrement dit, dans
le cas de @code{staff-staff-spacing} qui nous occupe, toutes les clés
non mentionnées seront ramenées à zéro -- à l'exception de
@code{stretchability} qui prend par défaut la valeur de
@code{basic-distance}.  Les deux assertions suivantes sont donc
équivalentes.

@example
\override StaffGrouper.staff-staff-spacing =
  #'((basic-distance . 7))

\override StaffGrouper.staff-staff-spacing =
  #'((basic-distance . 7)
     (minimum-distance . 0)
     (padding . 0)
     (stretchability . 7))
@end example

L'une des conséquences, parfois involontaire, de ceci est la suppression
de réglages standards effectués par un fichier d'initialisation chargé à
chaque compilation d'un fichier source.  Dans l'exemple précédent, les
réglages standards de @code{padding} et @code{minimum-distance}, tels
que déterminés par @file{scm/define-grobs.scm}, se voient ramenés à leur
valeur @emph{si-non-définie} ; autrement dit, les deux clés sont mises à
zéro.  La définition d'une propriété ou d'une variable sous forme de
liste associative, quelle qu'en soit la taille, réinitialisera toujours
les clés non mentionnées à leur valeur @emph{si-non-définie}.  Si telle
n'est pas votre intention, nous vous recommandons alors de régler la
valeur des clés individuellement par des déclarations imbriquées.

@warning{Les déclarations imbriquées ne sont pas fonctionnelles dans le
cas des listes associatives des propriétés de contexte -- telles
@code{beamExceptions}, @code{keyAlterations},
@code{timeSignatureSettings}, etc.  Ces propriétés ne sont modifiables
qu'au travers d'une complète redéfinition de leur liste associative.}


@node Propriétés et contextes utiles
@section Propriétés et contextes utiles
@translationof Useful concepts and properties

Nous allons voir, au fil des paragraphes qui suivent, différentes
approches permettant de fignoler l'apparence d'une partition.

@menu
* Direction et positionnement::
* Distances et unités de mesure::
* Dimensions::
* Extenseurs et prolongateurs::
* Modification de bandeaux avec rupture
* Styles de ligne::
* Lignes de prolongation::
* Visibilité des objets::
* Rotation des objets::
* Alignement des objets::
* Modification des stencils::
* Modification de l'allure des éléments::
@end menu

@morerefs
Manuel d'initiation :
@rlearning{Autres sources de documentation},
@rlearning{Retouche de partition}.

Manuel de notation :
@ref{En quoi consiste la référence des propriétés internes},
@ref{Modification de propriétés}.

Manuel d'extension :
@rextend{Interfaces pour programmeurs}.

Fichiers d'initialisation :
@file{scm/define-grobs.scm}.

Morceaux choisis :
@rlsrnamed{Tweaks and overrides, Affinages}.

Référence des propriétés internes :
@rinternalsnamed{All layout objects, Tous les objets de rendu}.
@endmorerefs


@node Direction et positionnement
@subsection Direction et positionnement
@translationof Direction and placement

En matière de typographie musicale, l'orientation et le positionnement
de nombreux éléments est affaire de goût.  Par exemple, les hampes
peuvent être ascendantes ou descendantes, les paroles, nuances ou autres
indications d'expression peuvent apparaître au-dessus ou en dessous de
la portée, les indications textuelles s'alignent tantôt par la gauche,
tantôt par la droite, ou être centrées.  La plupart de ces choix peuvent
être laissés à l'appréciation de LilyPond.  Il peut être préférable,
dans certains cas, d'imposer l'orientation ou le positionnement des
éléments.

@menu
* Indicateurs de position d'une articulation::
* La propriété direction::
@end menu


@node Indicateurs de position d'une articulation
@unnumberedsubsubsec Indicateurs de position d'une articulation
@translationof Articulation direction indicators

Certains positionnements sont opérés par défaut -- toujours au-dessus ou
toujours en dessous (nuances ou points d'orgue) -- alors que d'autres
alterneront selon l'orientation des hampes (liaisons ou accents).

@c TODO Add table showing these

@cindex positionnement vertical des @emph{grobs}
@cindex vertical, positionnement forcé des @emph{grobs}
@cindex position, vertical, @emph{grobs}
@cindex @emph{grob}, positionnement vertical
@cindex direction, haut (@code{^})
@cindex direction, bas (@code{_})
@cindex direction, défaut (@code{-})
@cindex dessus, direction (@code{^})
@cindex bas, direction (@code{_})
@cindex défaut, vertical, positionnement (@code{-})

@funindex -
@funindex ^
@funindex _

Le positionnement par défaut peut être outrepassé à l'aide d'un
@emph{indicateur de positionnement}, qui vient s'insérer juste avant
l'articulation.  LilyPond met à votre disposition trois indicateurs de
positionnement : @code{^} (pour « au-dessus »), @code{_} (pour
« au-dessous »), et @code{-} (pour « appliquer le positionnement par
défaut »).  L'indicateur de positionnement n'est pas obligatoire ;
LilyPond considère alors qu'il y a un @code{-}.  Un indicateur de
positionnement est cependant @strong{obligatoire} dans les cas
suivants :

@itemize
@item une commande @code{\tweak},
@item une commande @code{\markup},
@item une commande @code{\tag},
@item les indications de corde, par exemple @code{-"corde"},
@item les indications de doigté, par exemple @w{@code{-1}},
@item les raccourcis d'articulation, par exemple @w{@code{-.}},
@w{@code{->}} ou @w{@code{--}}.
@end itemize

Les indicateurs de positionnement n'affectent que la note qui suit :

@lilypond[verbatim,quote]
\relative {
  c''2( c)
  c2_( c)
  c2( c)
  c2^( c)
}
@end lilypond


@node La propriété direction
@unnumberedsubsubsec La propriété @code{direction}
@translationof The direction property

Le positionnement ou l'orientation de nombreux objets de rendu sont
gérés par la propriété @code{direction}.

La propriété @code{direction} peut prendre la valeur @code{1}, qui
signifie « ascendant » ou « au-dessus », ou @w{@code{-1}}, qui
signifie « descendant » ou « au-dessous ».  Les symboliques @code{UP}
et @code{DOWN} peuvent remplacer respectivement @code{1}
et @w{@code{-1}}.  Les valeurs @code{0} ou @code{CENTER} permettent de
réaffecter à la propriété @code{direction} son comportement par défaut.
Certaines commandes prédéfinies permettent par ailleurs de spécifier un
comportement en matière d'orientation ou positionnement ; elles
sont de la forme

@example
\@var{xxx}Up, \@var{xxx}Down et \@var{xxx}Neutral
@end example

@noindent
auquel cas @code{\@var{xxx}Neutral} signifie « retour au comportement
par défaut » -- voir @rlearning{Objets inclus dans la portée}.

Dans quelques cas particuliers, comme l'indication d'un @emph{arpeggio},
la valeur affectée à la propriété @code{direction} déterminera si
l'objet doit se placer à gauche ou à droite de son parent.  Un
@w{@code{-1}} ou @code{LEFT} signifiera alors « sur la gauche », et un
@code{1} ou @code{RIGHT} « sur la droite ».  Comme de bien entendu, un
@code{0} ou @code{CENTER} signifiera « appliquer le positionnement par
défaut ».

@ignore
These all have side-axis set to #X
Arpeggio - works
StanzaNumber - not tried
TrillPitchAccidental - not tried
TrillPitchGroup - not tried
@end ignore

Notez que ces commandes resteront effectives jusqu'à ce qu'elles soient
annulées.

@lilypond[verbatim,quote]
\relative {
  c''2( c)
  \slurDown
  c2( c)
  c2( c)
  \slurNeutral
  c2( c)
}
@end lilypond

En matière de musique polyphonique, il est souvent plus judicieux
d'utiliser des contextes @code{Voice} explicites que de modifier
l'orientation des objets.  Pour de plus amples informations, voir
@ref{Plusieurs voix}.

@morerefs
Manuel d'initiation :
@rlearning{Objets inclus dans la portée}.

Manuel de notation :
@ref{Plusieurs voix}.
@endmorerefs


@node Distances et unités de mesure
@subsection Distances et unités de mesure
@translationof Distances and measurements

@cindex distance absolue
@cindex distance relative
@cindex distance extensible

@funindex \mm
@funindex \cm
@funindex \in
@funindex \pt

LilyPond considère deux types de distances : les distances absolues
et les distances relatives ou extensibles.

@funindex \staff-space

Les distances absolues permettent de spécifier les marges, indentations
et autres détails de mise en page ; elles s'expriment par défaut en
millimètres.  Vous pouvez utiliser d'autres systèmes de mesure dès lors
que la quantité est suivie de la mesure : @code{\mm}, @code{\cm},
@code{\in} (pouces) ou @code{\pt} (points, 1/72,27 pouce).
Les mesures de mise en page peuvent aussi s'exprimer en unité extensible
de portée @code{\staff-space} (voir ci-après).  Pour plus d'information
concernant la mise en page, voir la rubrique
@ref{Mise en forme de la page}.

Les distances relatives ou extensibles s'expriment toujours en « espace
de portée » ou, plus rarement, en « demi espace de portée ».  L'espace
de portée (@emph{staff-space}) correspond à la distance qui sépare deux
lignes adjacentes d'une portée.  Sa valeur par défaut est déterminée
globalement par la taille de portée.  Elle peut aussi s'ajuster
ponctuellement en jouant sur la propriété @code{staff-space} de l'objet
@code{StaffSymbol}.  Les distances relatives s'ajustent automatiquement
dès qu'une modification de la taille globale de portée ou bien de la
propriété @code{staff-space} du @code{StaffSymbol} intervient.
Cependant, les tailles de fonte ne s'ajusteront automatiquement que si
la modification touche la taille globale des portées.  La taille globale
de portée permet ainsi de gérer l'aspect général de la partition --
voir @ref{Définition de la taille de portée}.

@funindex magstep

Lorsque seulement une portion de partition doit apparaître dans une
taille, comme par exemple une portée d'ossia ou une note de bas de page,
influer sur la taille globale de portée affecterait l'intégralité de la
partition.  Il convient donc dans ce cas de modifier à la fois la
propriété @code{staff-space} du @code{StaffSymbol} et la taille des
fontes.  La fonction Scheme @code{magstep} est tout spécialement chargée
d'adapter une modification du @code{staff-space} aux fontes.  Pour de
plus amples informations, reportez-vous à la rubrique
@rlearning{Longueur et épaisseur des objets}.

@morerefs
Manuel d'initiation :
@rlearning{Longueur et épaisseur des objets}.

Manuel de notation :
@ref{Définition de la taille de portée},
@ref{Mise en forme de la page}.
@endmorerefs


@node Dimensions
@subsection Dimensions
@translationof Dimensions

@cindex dimension
@cindex @emph{bounding box} (boîte englobante)
@cindex boîte englobante @emph{(bounding box)}

Les dimensions d'un objet graphique spécifient la position des bords
droit et gauche ainsi que des bords supérieur et inférieur de la boîte
englobante de ces objets, en tant que distance par rapport au point de
référence de l'objet et en unité d'espace de portée.  Ces positions sont
normalement codées sous la forme de deux paires Scheme.  Par exemple, la
commande de @emph{markup} @code{\with-dimensions} prend trois arguments,
les deux premiers étant des paires Scheme donnant la position des bords
gauche et droit et celle des bords inférieur et supérieur :

@example
\with-dimensions #'(-5 . 10) #'(-3 . 15) @var{argument3}
@end example

Ceci spécifie une boîte englobante pour @var{argument3} dont le bord
gauche est à @minus{}5, le bord droit à 10, le bord inférieur
à @minus{}3 et le bord supérieur à 15 espaces de portée du point de
référence de cet objet.

@morerefs
Manuel de notation :
@ref{Distances et unités de mesure}.
@endmorerefs


@node Extenseurs et prolongateurs
@subsection Extenseurs et prolongateurs
@translationof Spanners

@cindex bandeau @emph{(spanner)}
@cindex @emph{spanner}, bandeau

De nombreux objets de notation musicale s'étendent sur plusieurs notes,
voire même sur plusieurs mesures.  Il en va ainsi des liaisons,
ligatures, crochets de n-olet, crochets de reprise, crescendos, trilles
ou glissandos.  Ces objets, que l'on englobe sous l'appellation
« d'extenseurs », sont pourvus de propriétés spécifiques destinées à
contrôler leur apparence et leur comportement. Ils font aussi
appel à des méthodes spécifiques en matière de retouches liées au
fait que certains peuvent être rompus lors d'un saut de ligne.

@menu
* Modification de bandeaux avec rupture::
* Affectation d'une longueur minimale aux extenseurs::
* Contrôle du point d'arrêt des bandeaux::
@end menu


@node Modification de bandeaux avec rupture
@unnumberedsubsubsec Modification de bandeaux avec rupture
@translationof Modifying broken spanners

@cindex extenseur, modification
@cindex bandeau, modification
@cindex bandeau avec rupture, modification
@cindex extension avec rupture, modification
@funindex \alterBroken

Lorsqu'un bandeau ou l'extension d'un objet rencontre un saut de ligne
ou une rupture, chacun de ses tronçons hérite des attributs de l'objet
originel.  Par voie de conséquence, la modification d'une extension avec
rupture produira les mêmes effets sur chacun de ses segments.  Dans
l'exemple ci-dessous, la modification apportée à @code{thickness}
s'applique aussi bien avant qu'après le saut de ligne.

@lilypond[verbatim,quote,ragged-right]
\relative c'' {
  r2
  \once\override Slur.thickness = 10
  c8( d e f
  \break
  g8 f e d) r2
}
@end lilypond

La commande @code{\alterBroken} permet de modifier indépendamment
l'apparence de chacune des parties d'un bandeau.  Selon le cas, cette
commande génèrera soit un @code{\override}, soit un @code{\tweak} qui
s'appliquera à la propriété du bandeau.

La commande @code{\alterBroken} répond à la syntaxe :

@example
[-]\alterBroken @var{propriété} @var{valeurs} @var{élément}
@end example

L'argument @var{valeurs} est constitué d'une liste de valeurs, une pour
chaque tronçon. Lorsque @var{élément} est un nom d'objet graphique, tels
@code{Slur} ou @code{Staff@/.PianoPedalBracket}, il en résulte un
@code{\override} du type de @emph{grob} spécifié. Lorsque @var{élément}
est une expression musicale comme « ( » ou « [ », en résulte cette même
expression musicale à laquelle s'applique un @code{\tweak}.
@c closing ) and ]

Le tiret introduisant la commande @code{\alterBroken} est impératif dans
le cadre d'un @code{\tweak} ; il est superflu pour un @code{\override}.

@funindex \once
@funindex \temporary

Dans sa variante @code{\override}, la commande @code{\alterBroken} peut
se préfixer d'un @code{\once} ou d'un @code{\temporary} qui seront
annulés par un @code{\revert} suivi de la @var{propriété} -- voir
@rextend{Fonctions de substitution intermédiaires}.

Le code ci-dessous applique un @code{\override} indépendant à chacun
des segments du phrasé de l'exemple précédent :

@lilypond[verbatim,quote,ragged-right]
\relative c'' {
  r2
  \alterBroken thickness #'(10 1) Slur
  c8( d e f
  \break
  g8 f e d) r2
}
@end lilypond

La commande @code{\alterBroken} peut s'utiliser avec tout objet étendu,
y compris @code{Tie}, @code{PhrasingSlur}, @code{Beam} et
@code{TextSpanner}.  Par exemple, un éditeur préparant une édition
critique pourrait faire ressortir l'absence d'une partie de liaison de
phrasé dans l'une des sources, en optant pour un tracé pointillé du
seul segment ajouté.  L'exemple ci-dessous illustre la manière de
procéder, ici avec la variante @code{\tweak} de la commande :

@lilypond[verbatim,quote,ragged-right]
% The empty list is conveniently used below, because it is the
% default setting of dash-definition, resulting in a solid curve.
\relative {
  c''2-\alterBroken dash-definition #'(() ((0 1.0 0.4 0.75))) \(e
  \break
  g2 e\)
}
@end lilypond

Il est important de considérer que @code{\alterBroken} affectera à
chaque portion d'un bandeau interrompu la valeur correspondante de
@var{valeurs}. Si d'aventure il y a moins de valeurs que de tronçons,
toute portion additionnelle se verra assigner une liste vide. Ceci peut
conduire à des résultats inattendus dans le cas où la propriété de rendu
ne bascule pas sur une liste vide par défaut. En pareil cas, chaque
segment devrait se voir assigner une valeur appropriée.

@knownissues
Les sauts de ligne peuvent intervenir à différents endroits pour
répondre à des modifications de mise en forme.  Les réglages adoptés par
@code{\alterBroken} peuvent devenir inadaptés si le bandeau n'est plus
rompu ou est découpé en plus de segments que prévu.  L'introduction
explicite d'un @code{\break} peut alors pallier ces situations.

La commande @code{\alterBroken} est inopérante sur les propriétés d'un
bandeau qui sont traitées avant la procédure de saut de ligne, comme
@code{direction}.

@morerefs
Manuel d'extension :
@rextend{Retouches complexes}.
@endmorerefs


@node Affectation d'une longueur minimale aux extenseurs
@unnumberedsubsubsec Affectation d'une longueur minimale aux extenseurs
@translationof Setting minimum lengths for spanners

L'interface @code{spanner-interface} fournit trois propriétés qui
s'appliquent à certains extenseurs.

@subsubsubheading La propriété @code{minimum-length}

La longueur minimale d'un extenseur est déterminée par la propriété
@code{minimum-length}.  Au plus sa valeur est élevée, au plus
l'espacement des notes qui le bornent sera grand.  Forcer sa valeur
restera néanmoins sans effet pour un certain nombre d'extenseurs dont la
longueur dépend d'autres considérations.  Voici quelques exemples de
mise en œuvre de cette propriété.

@ignore
Les propriétés 'minimum-length and 'minimum-length-after-break sont
pleinement fonctionnelle pour :
  Tie (liaison de prolongation)
  MultiMeasureRest (silence multimesures)
  Hairpin (soufflet)
  Slur (liaison d'articulation)
  PhrasingSlur (liaison de phrasé)

Cette propriété est fonctionnelles en présence d'un @emph{callback} :
  Glissando
  Beam (ligature)
  TextSpanner
  TrillSpanner

Cette propriété est sans effet sur :
  LyricSpace
  LyricHyphen
  LyricExtender
  System

@end ignore

@lilypond[verbatim,quote,fragment]
a'~ a'
a'
% increase the length of the tie
-\tweak minimum-length #5
~ a'
@end lilypond

@lilypond[verbatim,quote]
\relative \compressMMRests {
  a'1
  R1*23
  % increase the length of the rest bar
  \once \override MultiMeasureRest.minimum-length = #20
  R1*23
  a1
}
@end lilypond

@lilypond[verbatim,quote]
\relative {
  a' \< a a a \!
  % increase the length of the hairpin
  \override Hairpin.minimum-length = #20
  a \< a a a \!
}
@end lilypond

Cette propriété permet aussi de jouer sur l'envergure d'une liaison
d'articulation ou de phrasé.

@lilypond[verbatim,quote]
\relative {
  a'( g)
  a
  -\tweak minimum-length #5
  ( g)

  a\( g\)
  a
  -\tweak minimum-length #5
  \( g\)
}
@end lilypond

Certains objets requièrent un appel explicite à la procédure
@code{set-spacing-rods} pour que la propriété @code{minimum-length}
produise ses effets. La propriété @code{set-@/spacing-@/rods} doit alors
prendre pour valeur @code{ly:spanner::set-spacing-rods}. Par exemple, la
longueur minimale d'un glissando ne pourra être forcée tant que la
propriété @code{springs-and-rods} n'aura pas été définie :

@lilypond[verbatim,fragment,quote]
% default
e' \glissando c''

% not effective alone
\once \override Glissando.minimum-length = #20
e' \glissando c''

% effective only when both overrides are present
\once \override Glissando.minimum-length = #20
\once \override Glissando.springs-and-rods =
                  #ly:spanner::set-spacing-rods
e' \glissando c''
@end lilypond

Il en va de même pour l'objet @code{Beam} (ligature) :

@lilypond[verbatim,fragment,quote]
% not effective alone
\once \override Beam.minimum-length = #20
e'8 e' e' e'

% effective only when both overrides are present
\once \override Beam.minimum-length = #20
\once \override Beam.springs-and-rods =
                  #ly:spanner::set-spacing-rods
e'8 e' e' e'
@end lilypond


@subsubsubheading La propriété @code{minimum-length-after-break}

La propriété @code{minimum-length-after-break} peut s'utiliser pour
dimensionner le tronçon d'extenseur placé après un saut de ligne. Tout
comme la propriété @code{minimum-length}, elle nécessite souvent,
pour prendre effet, de régler la propriété @code{springs-and-rods}
sur @code{ly:spanner::set-spacing-rods}.

@lilypond[verbatim,quote,ragged-right]
{
  \once \override Tie.minimum-length-after-break = 20
  a1~
  \break
  a1

  \once \override Slur.minimum-length-after-break = 20
  a1(
  \break
  d'1)

  \once \override TextSpanner.springs-and-rods =
    #ly:spanner::set-spacing-rods
  \once \override TextSpanner.minimum-length-after-break = 20
  a1\startTextSpan
  \break
  a1\stopTextSpan

  \once \override Hairpin.after-line-breaking = ##t
  \once \override Hairpin.to-barline = ##f
  \once \override Hairpin.minimum-length-after-break = 20
  a1\<
  \break
  a1\!

  \once \override Glissando.springs-and-rods =
    #ly:spanner::set-spacing-rods
  \once \override Glissando.breakable = ##t
  \once \override Glissando.after-line-breaking = ##t
  \once \override Glissando.minimum-length-after-break = 20
  a1\glissando
  \break
  d'1
}
@end lilypond


@node Contrôle du point d'arrêt des bandeaux
@unnumberedsubsubsec Contrôle du point d'arrêt des bandeaux
@translationof Controlling spanner end points

La propriété @code{to-barline} fournie par la @code{spanner-interface},
activée par défaut, permet aux soufflets et autres extenseurs finissant
sur la première note d'une mesure de s'arrêter visuellement au niveau de
la barre de mesure qui la précède. Le fait de désactiver la propriété
@code{to-barline} aura pour effet de prolonger l'extenseur au delà de la
barre de mesure et jusqu'à la note qui le borne :

@lilypond[verbatim,quote]
\relative {
  a' \< a a a a \! a a a \break
  \override Hairpin.to-barline = ##f
  a \< a a a a \! a a a
}
@end lilypond

Cette propriété n'est pas opérationnelle pour tous les extenseurs.  Il
serait en effet quelque peu surprenant de l'activer (lui
affecter @code{#t}) dans le cas d'une liaison d'articulation ou de
phrasé !


@node Styles de ligne
@subsection Styles de ligne
@translationof Line styles

La @rinternals{line-interface} regroupe tous les objets affichant des
lignes. Tous les objets pris en charge par cette interface peuvent
adopter différents styles de ligne. L'exemple ci-dessous indique les
différentes valeurs disponibles.

@lilypond[ragged-right,verbatim,quote]
\relative {
  d''2 \glissando d'2
  \once \override Glissando.style = #'dashed-line
  d,2 \glissando d'2
  \override Glissando.style = #'dotted-line
  d,2 \glissando d'2
  \override Glissando.style = #'zigzag
  d,2 \glissando d'2
  \override Glissando.style = #'trill
  d,2 \glissando d'2
}
@end lilypond

Certains objets peuvent adopter d'autres styles spécifiques.


@node Lignes de prolongation
@subsection Lignes de prolongation
@translationof Line spanners

Certaines indications portées à l'attention de l'exécutant -- tels
@emph{rallentando}, @emph{accelerando} et @emph{trilles} -- apparaissent
sous la forme d'un texte qui peut s'étendre sur plusieurs mesures à
l'aide d'une ligne parfois pointillée ou ondulée.

@lilypond[quote,fragment,verbatim]
e''2 \glissando b'
\once \override Glissando.bound-details.left.Y = #3
\once \override Glissando.bound-details.right.Y = #-2
e''2 \glissando b'
@end lilypond

La propriété @code{Y} est valorisée en unités d'@dfn{espace de portée},
la ligne médiane de la portée correspondant au point zéro. Pour le
glissando qui nous occupe, il s'agit du @code{Y} à l'aplomb
(coordonnée-X) du centre de la tête de chacune des deux notes, si tant
est que la ligne doive s'étendre entre ces deux points.

Si le @code{Y} n'est pas défini, sa valeur sera calculée en fonction de
la position verticale du point d'attachement de l'extenseur.

Dans le cas où l'extenseur est interrompu par un saut de ligne, les
terminaisons à cet endroit se gèrent à l'aide des sous-clés
@code{left-broken} et @code{right-broken} de @code{bound-details}, comme
ci-dessous :

@lilypond[ragged-right,fragment,verbatim,quote]
\override Glissando.breakable = ##t
\override Glissando.bound-details.right-broken.Y = #-3
c''1 \glissando \break
f''1
@end lilypond

Les sous-propriétés @code{left} et @code{right} du @code{bound-details}
disposent d'autres clés modifiables de la même manière que @code{Y} :

@table @code
@item Y
Détermine l'ordonnée (coordonnée-Y) de la terminaison, avec un
décalage en espaces de portée par rapport à la ligne médiane de la
portée.  Il s'agit par défaut du centre de l'objet d'attachement, qui
est le centre vertical de la tête de note pour un glissando.

En ce qui concerne les extenseurs horizontaux, tels ceux comportant du
texte ou les trilles, il est fixé à @code{0}.

@item attach-dir
Détermine le début et la fin de la ligne sur l'axe des abscisses,
relativement à l'objet de rattachement.  Une valeur de @w{@code{-1}} (ou
@code{LEFT}) aura pour effet de commencer ou terminer la ligne sur la
gauche de la tête de note de rattachement.

@item X
Il s'agit de l'abscisse (coordonnée-X) absolue de la terminaison.  Elle
se calcule à la volée, et son forçage n'apporte rien de plus.

@item stencil
Les extenseurs linéaires peuvent commencer ou finir par un symbole,
enregistré dans cette sous-propriété.  Elle est conçue pour un usage
interne, aussi nous vous conseillons de plutôt recourir à @code{text}.

@item text
Il s'agit d'un @emph{markup} qui se poursuivra par l'extenseur. C'est la
sous-propriété utilisée pour ajouter @emph{cresc.}, @emph{tr} ou autre
texte à un extenseur horizontal.

@lilypond[quote,ragged-right,fragment,verbatim]
\override TextSpanner.bound-details.left.text
   = \markup { \small \bold Slower }
\relative { c''2\startTextSpan b c a\stopTextSpan }
@end lilypond

@item stencil-align-dir-y
@item stencil-offset
Lorsqu'aucune de ces deux sous-propriétés n'est définie, le stencil est
simplement positionné à l'extrémité, centré sur la ligne telle que
définie par les sous-propriétés @code{X} et @code{Y}.  L'utilisation de
@code{stencil-align-dir-y} ou @code{stencil-offset} permettra d'aligner
le symbole verticalement par rapport au coin de la ligne :

@lilypond[quote,fragment,verbatim]
\override TextSpanner.bound-details
            .left.stencil-align-dir-y = #-2
\override TextSpanner.bound-details
            .right.stencil-align-dir-y = #UP

\override TextSpanner.bound-details.left.text = "ggg"
\override TextSpanner.bound-details.right.text = "hhh"

\relative { c'4^\startTextSpan c c c \stopTextSpan }
@end lilypond

Vous n'aurez pas manqué de constater qu'une valeur négative place le
texte @emph{en haut} -- contrairement à ce que l'on serait en droit
d'attendre.  Ceci est dû au fait que la valeur @w{@code{-1}} ou
@code{DOWN} signifie « aligner le bord @emph{inférieur} du texte sur
la ligne d'extension ».  Une valeur égale à @code{1} ou @code{UP}
alignera le sommet du texte sur cette ligne d'extension.

@item arrow
L'activation de cette sous-propriété (lui affecter @code{#t}) ajoutera
à l'extenseur une terminaison en flèche.

@item padding
Cette sous-propriété contrôle l'espace qui doit séparer l'extrémité de
la ligne et la fin réelle de l'extenseur.  Sans ce « décalage », le
trait indiquant un glissando commencerait et finirait au beau milieu de
chacune des têtes de note.

@end table

@c FIXME: this should be somewhere else --JeanAS
@funindex \endSpanners

La fonction @code{\endSpanners} permet d'interrompre l'extenseur qui
vient dès la note suivante.  Autrement dit, il ne s'étendra que sur une
seule note, ou jusqu'à la prochaine barre de mesure si @code{to-barline}
a été activé et que survient une barre avant la note suivante.

@lilypond[verbatim,quote,ragged-right]
\relative c'' {
  \endSpanners
  c2 \startTextSpan c2 c2
  \endSpanners
  c2 \< c2 c2
}
@end lilypond

L'utilisation de @code{\endSpanners} permet de s'affranchir d'insérer un
@code{\stopTextSpan} pour clôturer un @code{\startTextSpan} ou un
@code{\!} pour terminer un soufflet.

@morerefs
Référence des propriétés internes :
@rinternals{Glissando},
@rinternals{line-spanner-interface},
@rinternals{TextSpanner},
@rinternals{TrillSpanner},
@rinternals{VoiceFollower}.
@endmorerefs


@node Visibilité des objets
@subsection Visibilité des objets
@translationof Visibility of objects

@cindex objet, visibilité
@cindex grob, visibilité
@cindex visibilité d'objets

La visibilité des objets de rendu se contrôle de quatre façons
différentes : vous pouvez supprimer leur stencil, les rendre
transparents, les coloriser en blanc ou bien encore forcer leur
propriété @code{break-visibility}.  Les trois premières options peuvent
s'appliquer à tous les objets, la dernière étant réservée aux objets
@emph{changeables}.  Le Manuel d'initiation contient une introduction à
ces quatre techniques, à la rubrique
@rlearning{Visibilité et couleur des objets}.

LilyPond met en œuvre quelques techniques particulières adaptées à
certains objets ; elles sont couvertes par une rubrique spécifique.

@menu
* Suppression des stencils::
* Transparence des objets::
* Blanchiment des objets::
* Utilisation de break-visibility::
* Considérations spécifiques::
@end menu


@node Suppression des stencils
@unnumberedsubsubsec Suppression des stencils
@translationof Removing the stencil

@cindex stencil, suppression

@funindex \omit

Tout objet de rendu se voit attribuer une propriété @code{stencil}.
Elle est par défaut définie par la fonction chargée de dessiner cet
objet.  Lorsque cette propriété est désactivée de force -- en lui
attribuant la valeur @code{#f} -- aucune fonction ne sera appelée ;
l'objet ne sera donc pas dessiné.  Le retour au comportement par défaut
s'opère à l'aide d'un @code{\revert}.

@lilypond[quote,fragment,verbatim]
a1 a
\override Score.BarLine.stencil = ##f
a a
\revert Score.BarLine.stencil
a a a
@end lilypond

Cette opération relativement courante fait l'objet du racourci
@code{\omit} :

@lilypond[quote,fragment,verbatim]
a1 a
\omit Score.BarLine
a a
\undo \omit Score.BarLine
a a a
@end lilypond


@node Transparence des objets
@unnumberedsubsubsec Transparence des objets
@translationof Making objects transparent

@cindex transparent, objet

@funindex \hide

Tout objet de rendu dispose d'une propriété de transparence, qui est par
défaut définie à @code{#f}.  Le fait de l'activer rendra l'objet
transparent tout en préservant la place qu'il occupe.

@lilypond[quote,fragment,verbatim]
a'4 a'
\once \override NoteHead.transparent = ##t
a' a'
@end lilypond

Cette opération relativement courante fait l'objet du racourci
@code{\hide} :

@lilypond[quote,fragment,verbatim]
a'4 a'
\once \hide NoteHead
a' a'
@end lilypond


@node Blanchiment des objets
@unnumberedsubsubsec Blanchiment des objets
@translationof Painting objects white

@cindex objet, couleur
@cindex couleur d'objet
@cindex @emph{layer} (calque)
@cindex calque @emph{(layer)}
@cindex impression, ordre
@cindex surimpression d'objet
@cindex objet, surimpression
@cindex grobs, superposition
@cindex @emph{whiteout} (blanchiment)

Tout objet de rendu dispose d'une propriété couleur, par défaut définie
à @code{black} (noir).  Le fait de la forcer à @code{white} (blanc)
rendra l'objet indistinct du fond blanc.  Néanmoins, lorsque cet objet
en recouvre d'autres, la couleur de leurs points de jonction dépendra de
l'ordre dans lequel ils sont dessinés, ce qui peut laisser apparaître
un fantôme de l'objet blanchi comme ci-dessous :

@lilypond[quote,fragment,verbatim]
\override Staff.Clef.color = #white
a'1
@end lilypond

Cet inconvénient peut être évité en modifiant l'ordre dans lequel les
objets sont dessinés.  Chaque objet de rendu dispose d'une propriété
@code{layer} (calque ou niveau) à laquelle est affecté un nombre entier.
Les objets ayant la plus faible valeur sont dessinés en premier, puis
les autres, de telle sorte qu'un objet ayant une valeur plus élevée les
recouvrira.  La plupart des objet ont un @code{layer} valorisé
à @code{1} -- quelques uns, dont @code{StaffSymbol} et
@code{BarLine}, ont une valeur à @code{0}.  L'ordre d'impression
d'objets ayant une même valeur de @code{layer} est indéterminé.

La clef de l'exemple précédent a par défaut un @code{layer}
à @code{1} ; elle est donc dessinée après les lignes de la
portée -- @code{layer} valorisé par défaut à @code{0} -- et donc
les recouvre.  Pour changer cet état de fait, l'objet @code{Clef} doit
avoir un @code{layer} de valeur inférieure, disons @w{@code{-1}}, pour
pouvoir être dessiné avant.

@lilypond[quote,fragment,verbatim]
\override Staff.Clef.color = #white
\override Staff.Clef.layer = #-1
a'1
@end lilypond

@snippets
@lilypondfile[verbatim,quote,ragged-right,texidoc,doctitle]
{snippets/using-the-whiteout-property.ly}


@node Utilisation de break-visibility
@unnumberedsubsubsec Utilisation de @code{break-visibility}
@translationof Using break-visibility

@c TODO Add making other objects breakable

@funindex break-visibility

La plupart des objets de rendu ne sont imprimés qu'une seule fois ;
certains cependant, tels les barres de mesure, clefs, métriques ou
armures, apparaîtront deux fois lors d'un saut de ligne -- une première
fois en fin de ligne, puis à nouveau au début de la ligne suivante.  Ces
objets, que l'on peut traiter de @emph{changeables} (@emph{breakable} en
anglais) disposent de la propriété @code{break-visibility} spécialement
chargée de contrôler leur visibilité aux trois endroits où il sont
susceptibles d'apparaître : en début de ligne, en cours de ligne ou
en fin de ligne -- si tant est qu'un changement s'y produise.

Par exemple, la métrique est imprimée par défaut au début de la première
ligne, et nulle part ailleurs.  En cas de modification, une nouvelle
métrique sera imprimée à l'endroit du changement.  Dans le cas où ce
changement intervient en fin de ligne, la nouvelle métrique s'imprime au
début de la ligne suivante, et une métrique « de précaution » viendra
se placer au bout de la ligne précédente.

Ce comportement est géré par la propriété @code{break-visibility}, dont
vous trouverez une explication à la rubrique
@rlearning{Visibilité et couleur des objets}.  Cette propriété est
constituée d'un vecteur de trois booléens qui, dans l'ordre, déterminent
si l'objet sera imprimé à la fin, en cours, et au début d'une ligne --
on pourrait aussi dire avant un saut de ligne, là où il n'y a pas de
saut de ligne, et après un saut de ligne.

Les huit combinaisons possibles sont aussi disponibles sous la forme de
fonctions prédéfinies, regroupées dans le fichier
@file{scm/output-lib.scm}.  Le tableau suivant vous les présente ;
les trois dernières colonnes indiquent l'endroit où l'objet sera visible.

@indentedBlock
@multitable {@code{begin-of-line-invisible}} {@code{#(#t #t #t)}} {apres} {apres} {apres}
@headitem Forme                      @tab Forme                  @tab Avant @tab Hors    @tab Après
@headitem fonctionnelle              @tab vectorielle            @tab saut  @tab saut    @tab saut

@item @code{all-visible}             @tab @code{#(#t #t #t)}    @tab oui    @tab oui    @tab oui
@item @code{begin-of-line-visible}   @tab @code{#(#f #f #t)}    @tab non    @tab non    @tab oui
@item @code{center-visible}          @tab @code{#(#f #t #f)}    @tab non    @tab oui    @tab non
@item @code{end-of-line-visible}     @tab @code{#(#t #f #f)}    @tab oui    @tab non    @tab non
@item @code{begin-of-line-invisible} @tab @code{#(#t #t #f)}    @tab oui    @tab oui    @tab non
@item @code{center-invisible}        @tab @code{#(#t #f #t)}    @tab oui    @tab non    @tab oui
@item @code{end-of-line-invisible}   @tab @code{#(#f #t #t)}    @tab non    @tab oui    @tab oui
@item @code{all-invisible}           @tab @code{#(#f #f #f)}    @tab non    @tab non    @tab non
@end multitable
@endIndentedBlock

Les réglages par défaut de la propriété @code{break-visibility}
diffèrent selon l'objet de rendu.  Le tableau suivant présente, pour la
plupart des  objets comportant la propriété @code{break-visibility},
ces réglages par défaut.

@indentedBlock
@multitable {@code{DoublePercentRepeat}} {@b{Contexte habituel}} {@code{begin-of-line-invisible}}

@headitem Objet de rendu   @tab Contexte habituel  @tab Réglage par défaut

@c omit Ambitus as it appears not to be affected by break-visibility -td
@c @item @code{Ambitus}          @tab as specified   @tab @code{begin-of-line-visible}
@item @code{BarLine}             @tab @code{Score}          @tab calculé
@item @code{BarNumber}           @tab @code{Score}          @tab @code{begin-of-line-visible}
@c omit the following item until it can be explained -td
@c @item @code{BreakAlignGroup}  @tab @code{Score}          @tab calculé
@item @code{BreathingSign}       @tab @code{Voice}          @tab @code{begin-of-line-invisible}
@item @code{Clef}                @tab @code{Staff}          @tab @code{begin-of-line-visible}
@item @code{Custos}              @tab @code{Staff}          @tab @code{end-of-line-visible}
@item @code{Divisio}             @tab @code{Staff}          @tab @code{begin-of-line-invisible}
@item @code{DoublePercentRepeat} @tab @code{Voice}          @tab @code{begin-of-line-invisible}
@c omit KeyCancellation until it can be explained -td
@c @item @code{KeyCancellation}  @tab ??             @tab @code{begin-of-line-invisible}
@item @code{KeySignature}        @tab @code{Staff}          @tab @code{begin-of-line-visible}
@c omit LeftEdge until it can be explained -td
@c @item @code{LeftEdge}         @tab @code{Score}          @tab @code{center-invisible}
@item @code{ClefModifier}       @tab @code{Staff}          @tab @code{begin-of-line-visible}
@item @code{RehearsalMark}       @tab @code{Score}          @tab @code{end-of-line-invisible}
@item @code{TimeSignature}       @tab @code{Staff}          @tab @code{all-visible}

@end multitable
@endIndentedBlock

Voici un exemple d'utilisation de la forme vectorielle pour contrôler la
visibilité des barres de mesure :

@lilypond[quote,verbatim,ragged-right]
\relative {
  f'4 g a b
  f4 g a b
  % Remove bar line at the end of the current line
  \once \override Score.BarLine.break-visibility = ##(#f #t #t)
  \break
  f4 g a b
  f4 g a b
}
@end lilypond

Lors d'un forçage de @code{break-visibility} sous une forme vectorielle,
les trois éléments doivent impérativement être mentionnés.  Ces formes
vectorielles ne sont d'ailleurs pas prises en charge par tous les objets
de rendu, et certaines combinaisons peuvent entraîner des erreurs ;
nous citerons entre autres :

@itemize @bullet
@item Une barre de mesure ne peut s'imprimer en début de ligne.

@item Un numéro de mesure ne peut apparaître au début de la première
ligne, à moins d'être différent de 1.

@item Clef -- voir ci-après.

@item Les répétitions en pourcentage sont soit toutes imprimées, soit
aucune. Vous devrez utiliser @code{begin-@/of-@/line-@/invisible} pour
les voir et @code{all-invisible} pour les masquer.

@item Armure -- voir ci-après.

@item Modificateur de clef -- voir ci-après.
@end itemize


@node Considérations spécifiques
@unnumberedsubsubsec Considérations spécifiques
@translationof Special considerations

@subsubsubheading Visibilité après changement explicite

@cindex armure, visibilité après changement explicite
@funindex explicitKeySignatureVisibility
@cindex clef, visibilité après changement explicite
@funindex explicitClefVisibility

La propriété @code{break-visibility} contrôle la visibilité des armures
ou changements de clef en début de ligne uniquement, donc après un saut.
Elle ne produit aucun effet sur la visibilité d'une armure ou d'une clef
après un changement explicite de tonalité ou de clef, ni en cours, ni en
fin de ligne.  Dans l'exemple suivant, l'armure est présente même après
le passage en si bémol majeur malgré l'activation de
@code{all-invisible} (@emph{tous invisibles}).

@lilypond[quote,verbatim,ragged-right]
\relative {
  \key g \major
  f'4 g a b
  % Try to remove all key signatures
  \override Staff.KeySignature.break-visibility = #all-invisible
  \key bes \major
  f4 g a b
  \break
  f4 g a b
  f4 g a b
}
@end lilypond

La visibilité lors de ces changements explicites d'armure ou de clef est
géré respectivement par les propriétés
@code{explicitKeySignatureVisibility} et @code{explicitClefVisibility}.
Leur fonctionnement est en tout point identique à celui de la propriété
@code{break-visibility} -- forme vectorielle à trois éléments ou forme
fonctionnelle comme indiqué ci-avant.  Toutes deux sont attachées au
contexte @code{Staff} (la portée) et non directement aux objets de
rendu ; elles sont de ce fait introduites par une instruction
@code{\set}.  Leur valeur par défaut est de toujours imprimer les objets
-- réglage sur @code{all-visible}.  Ces deux propriétés gèrent
uniquement la visibilité des armures et clefs lors d'un changement
explicite, et en dehors d'un début de ligne ; il faudra en pareil
cas forcer la @code{break-visibility} de ces objets pour les supprimer.

@lilypond[quote,verbatim,ragged-right]
\relative {
  \key g \major
  f'4 g a b
  \set Staff.explicitKeySignatureVisibility = #all-invisible
  \override Staff.KeySignature.break-visibility = #all-invisible
  \key bes \major
  f4 g a b \break
  f4 g a b
  f4 g a b
}
@end lilypond

@subsubsubheading Visibilité des bécarres de précaution

L'impression d'altérations de précaution au moment d'un changement
explicite de tonalité sera annulée dès lors que vous aurez désactivé la
propriété @code{printKeyCancellation} du contexte @code{Staff} :

@lilypond[quote,verbatim,ragged-right]
\relative {
  \key g \major
  f'4 g a b
  \set Staff.explicitKeySignatureVisibility = #all-invisible
  \set Staff.printKeyCancellation = ##f
  \override Staff.KeySignature.break-visibility = #all-invisible
  \key bes \major
  f4 g a b \break
  f4 g a b
  f4 g a b
}
@end lilypond

Avec de tels réglages particuliers, seules les altérations accidentelles
permettront d'indiquer le changement de tonalité.

Notez bien que lors d'une bascule en do majeur ou la mineur, seuls les
« bécarres d'annulation » permettent d'identifier le changement de
tonalité.  En pareil cas, désactiver @code{printKeyCancellation} sera
sans effet :

@lilypond[quote,verbatim,ragged-right]
\relative {
  \key g \major
  f'4 g a b
  \set Staff.explicitKeySignatureVisibility = #all-invisible
  \set Staff.printKeyCancellation = ##f
  \key c \major
  f4 g a b \break
  f4 g a b
  f4 g a b
}
@end lilypond

La suppression des bécarres d'annulation même lors d'un passage en do
majeur ou la mineur n'interviendra qu'après modification de la
visibilité de l'objet @code{KeyCancellation} :

@lilypond[quote,verbatim,ragged-right]
\relative {
  \key g \major
  f'4 g a b
  \set Staff.explicitKeySignatureVisibility = #all-invisible
  \override Staff.KeyCancellation.break-visibility = #all-invisible
  \key c \major
  f4 g a b \break
  f4 g a b
  f4 g a b
}
@end lilypond

@c TODO Add visibility of cautionary accidentals before notes


@subsubsubheading Clefs transposées

@cindex octaviation
@cindex clef transposée, visibilité
@cindex visibilité d'une clef transposée
@cindex clef, visibilité de la transposition

L'indication de transposition d'une clef est produite par l'objet
de rendu @code{ClefModifier}.  Sa visibilité étant gérée par
héritage direct de l'objet @code{Clef}, nul n'est besoin de forcer
un quelconque @code{break-visibility} au niveau des objets
@code{ClefModifier} pour éliminer une indication de transposition
lorsque la clef est invisible.

Lors d'un changement explicite de clef, la propriété
@code{explicitClefVisibility} gère à la fois le symbole de la clef et
l'indication de transposition qui lui est attachée.

@morerefs
Manuel d'initiation :
@rlearning{Visibilité et couleur des objets}.
@endmorerefs


@node Rotation des objets
@subsection Rotation des objets
@translationof Rotating objects

Qu'il s'agisse des objets de rendu ou d'éléments textuels sous forme de
@emph{markup}, vous pouvez les faire pivoter selon vos désirs et à
partir de n'importe quel point.  La méthode diffère cependant selon ce
que vous désirez manipuler.

@menu
* Rotation des objets de mise en forme::
* Rotation des étiquettes::
@end menu


@node Rotation des objets de mise en forme
@unnumberedsubsubsec Rotation des objets de mise en forme
@translationof Rotating layout objects

@cindex objet, rotation

Tout objet de rendu disposant de la @code{grob-interface} est
susceptible de pivoter, grâce à la propriété @code{rotation}.  Celle-ci
prend en argument une liste de trois éléments : l'angle de rotation
-- dans le sens inverse des aiguilles d'une montre -- ainsi que les
coordonnées @code{x} et @code{y} du point appartenant à l'objet en
question et à partir duquel doit s'effectuer cette rotation.  L'angle
est exprimé en degrés, les coordonnées en espaces de portée.

L'angle et les coordonnées ne peuvent se déterminer que par tâtonnement.

@cindex soufflet penché

Il existe assez peu de situations où faire pivoter un objet de mise en
forme soit réellement opportun ; en voici une :

@lilypond[quote,fragment,verbatim]
g4\< e' d'' f''\!
\override Hairpin.rotation = #'(15 -1 0)
g4\< e' d'' f''\!
@end lilypond


@node Rotation des étiquettes
@unnumberedsubsubsec Rotation des étiquettes
@translationof Rotating markup

@cindex @emph{markup}, rotation

Tout texte faisant l'objet d'un @emph{markup} peut pivoter selon
n'importe quel angle, à l'aide de la commande @code{\rotate}.  Celle-ci
prend deux arguments : l'angle de rotation exprimé en degrés --
dans le sens inverse des aiguilles d'une montre -- et le texte à
basculer.  Il ne s'agit pas ici de faire pivoter les extrémités du
texte ; celles-ci récupéreront leurs coordonnées x et y du @emph{markup}
pivoté.  Dans l'exemple ci-dessous, la propriété
@code{outside-staff-priority} à été fixée à @code{#f} afin de désactiver
l'évitement automatique des collisions qui pourrait repousser certains
textes trop haut.

@c KEEP LY
@lilypond[quote,fragment,verbatim]
\override TextScript.outside-staff-priority = ##f
g4^\markup { \rotate #30 "un sol" }
b^\markup { \rotate #30 "un si" }
des'^\markup { \rotate #30 "un ré bémol" }
fis'^\markup { \rotate #30 "un fa dièse" }
@end lilypond


@node Alignement des objets
@subsection Alignement des objets
@translationof Aligning objects

Les objets graphiques disposant des interfaces
@code{self-alignment-interface} ou @code{side-@/position-@/interface}
peuvent s'aligner par rapport à un objet précédemment positionné, ce de
différentes manières.  Ces objets sont référencés aux rubriques
@rinternals{self-alignment-interface} et
@rinternals{side-position-interface}.

Tous les objets graphiques ont un point de référence, une étendue
horizontale et une étendue verticale.  L'étendue horizontale est
représentée par une paire de nombres indiquant l'écart entre le point de
référence et les bords gauche et droit -- l'écart à gauche étant
négatif.  L'étendue verticale est représentée par une paire de nombres
indiquant l'écart entre le point de référence et les bords inférieur et
supérieur -- l'écart vers le bas étant négatif.

La position d'un objet sur la portée est donnée par la valeur des
propriétés @code{X-offset} et @code{Y-offset}.  La valeur de
@code{X-offset} indique l'écart en abscisse (coordonnée X) par rapport
au point de référence de l'objet parent ; la valeur de @code{Y-offset}
indique l'écart par rapport à la ligne médiane de la portée.  Les
valeurs de @code{X-offset} et @code{Y-offset} peuvent être fournies
arbitrairement, ou bien être calculé par des procédures spécifiques qui
détermineront l'alignement par rapport à l'objet parent.

@warning{Nombre d'objets sont affectés par des considérations
spécifiques en matière de positionnement ; jouer sur les valeurs de
@code{X-offset} ou @code{Y-offset} se révélera inefficace en pareil
cas, même si l'objet dispose de la @code{self-@/alignment-@/interface}.
Fixer arbitrairement les propriétés @code{X-offset} ou @code{Y-offset}
annihilera alors les effets de la propriété @code{self-alignment}
correspondante.}

Par exemple, une altération peut se repositionner verticalement grâce à
son @code{Y-offset} ; toute modification de son @code{X-offset}
restera par contre sans effet.

Les indications de repère s'alignent sur des objets de rupture -- tels
les barres de mesure, clefs, métriques et armures.  Certaines propriétés
spécifiques -- dépendant de la @code{break-@/aligned-@/interface} --
permettent de gérer le positionnement des indications de repère sur ces
objets.

@menu
* Détermination directe de X-offset et Y-offset::
* Utilisation de side-position-interface::
* Utilisation de self-alignment-interface::
* Utilisation de break-aligned-interface::
@end menu

@morerefs
Manuel de notation :
@ref{Utilisation de break-aligned-interface}.

Manuel d'extension :
@rextend{Fonctions de rappel}.
@endmorerefs


@node Détermination directe de X-offset et Y-offset
@unnumberedsubsubsec Détermination directe de @code{X-offset} et @code{Y-offset}
@translationof Setting X-offset and Y-offset directly

Vous pouvez fournir, pour de nombreux objets, des valeurs numériques aux
propriétés @code{X-offset} et @code{Y-offset}.  Voici par exemple une
note avec indication du doigté tout d'abord avec un positionnement par
défaut, puis repositionnement par modification successive du
@code{X-offset} et du @code{Y-offset}.

@lilypond[verbatim,fragment,quote]
a'-3
a'
-\tweak X-offset #0
-\tweak Y-offset #0
-3
a'
-\tweak X-offset #-1
-\tweak Y-offset #1
-3
@end lilypond

@c TODO write more


@node Utilisation de side-position-interface
@unnumberedsubsubsec Utilisation de @code{side-position-interface}
@translationof Using the side-position-interface

Un objet disposant de la @code{side-position-interface} peut se voir
accolé à son voisin de telle sorte que les bords des deux objets se
touchent.  Un tel objet peut se positionner au-dessus, en dessous, à
droite ou à gauche de son parent.  Ce parent ne saurait être
stipulé ; il est déterminé par l'ordre d'apparition des éléments
dans le flux des saisies.  La plupart de ces objets ont pour parent la
tête de note qui leur est associée.

Les valeurs des propriétés @code{side-axis} et @code{direction}
détermineront l'endroit où viendra se positionner l'objet, selon les
préceptes suivants :

@c TODO add an example of each to the table

@indentedBlock
@multitable {@b{Propriété @code{side-axis}}} {@b{Propriété @code{direction}}} {@b{Positionnement}}
@headitem Propriété @code{side-axis}
                      @tab Propriété @code{direction}
                                       @tab Positionnement

@item     @code{0}          @tab @code{-1}         @tab gauche
@item     @code{0}          @tab @code{1}          @tab droite
@item     @code{1}          @tab @code{-1}         @tab en dessous
@item     @code{1}          @tab @code{1}          @tab au-dessus

@end multitable
@endIndentedBlock

Pour un @code{side-axis} à @code{0}, le @code{X-offset} devrait engager
la procédure @code{ly:@/side-@/position-@/interface::@/x-aligned-@/side}.
Celle-ci renverra la valeur adéquate de @code{X-offset} permettant
d'accoler l'objet sur la droite ou sur la gauche de son parent, selon la
valeur de @code{direction}.

Pour un @code{side-axis} à @code{1}, le @code{Y-offset} devrait engager
la procédure @code{ly:@/side-@/position-@/interface::@/y-aligned-@/side}.
Celle-ci renverra la valeur adéquate de @code{Y-offset} permettant
d'accoler l'objet au-dessus ou en dessous de son parent, selon la valeur
de @code{direction}.

@c TODO Add examples


@node Utilisation de self-alignment-interface
@unnumberedsubsubsec Utilisation de @code{self-alignment-interface}
@translationof Using the self-alignment-interface

@subsubsubheading Réalignement d'objets horizontalement

L'alignement horizontal d'un objet disposant de la
@code{self-alignment-interface} dépend de la valeur de sa propriété
@code{self-alignment-X}, si tant est que la propriété @code{X-offset} de
cet objet engage la procédure
@code{ly:self-alignment-interface::x-aligned-on-self}.
La propriété @code{self-alignment-X} peut contenir un nombre réel,
l'unité de base étant la moitié de l'étendue horizontale de l'objet.
Une valeur négative décalera l'objet vers la droite, une valeur positive
vers la gauche.  La valeur @code{0} permet de centrer l'objet sur
le point de référence de son parent.  Une valeur de @w{@code{-1}}
alignera le bord gauche de l'objet sur le point de référence de son
parent, et une valeur de @code{1} alignera le bord droit de l'objet
sur le point de référence de son parent.  Les valeurs symboliques
@code{LEFT}, @code{CENTER} et @code{RIGHT} correspondent respectivement
à @w{@code{-1}}, @code{0} et @code{1}.

En règle générale, la valeur de @code{self-alignment-X} se modifie à
l'aide d'une commande @code{\override}.  Le recours à la commande
@code{\tweak} permet de traiter séparément plusieurs annotations
affectées à une même note :

@lilypond[quote,verbatim,fragment]
a'
-\tweak self-alignment-X #-1
^"left-aligned"
-\tweak self-alignment-X #0
^"center-aligned"
-\tweak self-alignment-X #RIGHT
^"right-aligned"
-\tweak self-alignment-X #-2.5
^"aligned further to the right"
@end lilypond


@subsubsubheading Réalignement d'objets verticalement

L'alignement vertical suit le même principe : la propriété
@code{Y-offset} doit alors engager la procédure
@code{ly:self-alignment-interface::y-aligned-on-self}.  Toutefois, il
arrive bien souvent que d'autres mécanismes interviennent dans
l'alignement vertical.  La valeur de @code{Y-offset} n'étant que l'une
des variables qui seront prises en compte, l'ajustement pour certains
objets peut se révéler fastidieux.  L'unité de base est relativement
réduite, puisqu'elle est de la moitié de l'étendue verticale de
l'objet ; le nombre à fournir en argument pourrait donc être
relativement élevé.  Une valeur de @w{@code{-1}} alignera le bord
inférieur de l'objet sur le point de référence de son parent, et une
valeur de @code{1} alignera le bord supérieur de l'objet sur le point de
référence de son parent.  La valeur @code{0} permet de centrer l'objet
sur le point de référence de son parent.  Les valeurs symboliques
@code{DOWN}, @code{CENTER} et @code{UP} correspondent respectivement
à @w{@code{-1}}, @code{0} et @code{1}.


@subsubsubheading Réalignement d'objets sur les deux axes

Définir à la fois @code{X-offset} et @code{Y-offset} permet de réaligner
un objet sur les deux axes.

Dans l'exemple ci-dessous, nous ajustons l'indication de doigté de telle
sorte qu'elle se place au plus près de la tête de note.

@lilypond[quote,verbatim,fragment]
a'
-\tweak self-alignment-X #0.5  % move horizontally left
-\tweak Y-offset #ly:self-alignment-interface::y-aligned-on-self
-\tweak self-alignment-Y #-1  % move vertically up
-3  % third finger
@end lilypond


@ignore
@unnumberedsubsubsec Utilisation de @code{aligned-on-parent}

@c Cannot document as they do not seem to operate consistently on all objects -td
@c TODO investigate further

The @code{aligned-on-parent} procedures are used in the same way
as the @code{aligned-on-self} procedures, they difference being
that they permit an object to be aligned with the @emph{edges} of
the parent rather than the parent's reference point.  The following
example shows the difference:

@c TODO Add example

@lilypond[verbatim,quote]
@end lilypond

@end ignore


@ignore
@unnumberedsubsubsec Utilisation de @code{centered-on-parent}

@c Cannot document as they do not seem to operate consistently on all objects -td
@c TODO investigate further

@end ignore

@c TODO The align-interface, BassFigureAlignment and VerticalAlignment


@node Utilisation de break-aligned-interface
@unnumberedsubsubsec Utilisation de @code{break-aligned-interface}
@translationof Using the break-alignable-interface

@cindex alignement sur un objet
@funindex break-align-symbols

Indications de repère, marques textuelles, numéros de mesure et plus
généralement tous les objets disposant de la
@rinternals{break-alignable-interface} -- que l'on pourrait regrouper
sous l'apellation de « jalons » -- sont susceptibles de se positionner
sur des objets de notation tels que barre de mesure, armure, métrique et
plus communément tout objet disposant de la
@rinternals{break-aligned-interface}. Pour être plus précis, ces
derniers disposent d'une propriété @code{break-@/align-@/symbol}, qui
est un symbole Scheme. Un jalon, donc un objet disposant de
@code{break-@/alignable-@/interface}, peut définir son point d'ancrage
aux éléments disposant de @code{break-@/aligned-@/interface}, ce au
moyen d'une liste de symboles qui correspondent aux valeurs de
@code{break-@/align-@/symbol} des éléments sur lesquels il peut
s'aligner. Une liste exhaustive des symboles est disponible au chapitre
@rinternals{break-alignment-interface}.

Chaque objet possède son propre point de référence par défaut, sur
lequel viendront s'aligner les jalons :

@lilypond[verbatim,quote,fragment]
\override Score.TextMark.self-alignment-X = #CENTER
% Le repère textuel s'alignera
% sur la droite de la clef
\override Score.TextMark.break-align-symbols =
            #'(clef)
\key a \major
\clef treble
\textMark "↓"
e'1
% Le repère textuel s'alignera
% sur la gauche de la métrique
\override Score.TextMark.break-align-symbols =
            #'(time-signature)
\key a \major
\clef treble
\time 3/4
\textMark "↓"
e'2.
% Le repère textuel sera centré
% au-dessus de la respiration
\override Score.TextMark.break-align-symbols =
            #'(breathing-sign)
\key a \major
\clef treble
\time 4/4
e'1
\breathe
\textEndMark "↓"
@end lilypond

Les différents objets sur lesquels l'alignement pourrait intervenir
seront regroupés dans une liste.  Si l'un des objets est invisible à
l'endroit voulu, en raison d'un réglage de @code{break-visibility} ou
bien par forçage de la visibilité des armures et clefs, le repère ou le
numéro de mesure viendra s'aligner sur le premier élément de cette liste
qui soit visible.  Dans le cas où aucun objet de la liste n'est visible,
l'alignement se fera sur la barre de mesure ou, dans le cas où la barre
de mesure est invisible, à l'endroit même où la barre prendrait place.

@lilypond[verbatim,quote,fragment]
\override Score.TextMark.self-alignment-X = #CENTER
% Le repère textuel s'alignera
% sur la droite de l'armure
\override Score.TextMark.break-align-symbols =
            #'(key-signature clef)
\key a \major
\clef treble
\textMark "↓"
e'1
% Le repère textuel s'alignera
% sur la droite de la clef
\set Staff.explicitKeySignatureVisibility = #all-invisible
\override Score.TextMark.break-align-symbols =
            #'(key-signature clef)
\key a \major
\clef bass
\textMark "↓"
gis,1
% Le repère textuel sera centré
% au-dessus de la barre de mesure
\set Staff.explicitKeySignatureVisibility = #all-invisible
\set Staff.explicitClefVisibility = #all-invisible
\override Score.TextMark.break-align-symbols =
            #'(key-signature clef)
\key a \major
\clef treble
\textMark "↓"
e'1
@end lilypond

L'alignement d'un jalon sur un objet de notation peut se modifier,
comme l'illustre l'exemple suivant.  Toutefois, si la partition comporte
plusieurs portées, ce réglage devra apparaître dans chacune des portées.

@lilypond[verbatim,quote,fragment]
\override Score.TextMark.self-alignment-X = #CENTER
% Le repère textuel s'alignera
% sur la droite de l'armure
\override Score.TextMark.break-align-symbols =
            #'(key-signature)
\key a \major
\clef treble
\time 4/4
\textMark "↓"
e'1
% Le repère textuel sera centré
% au-dessus de l'armure
\once \override Score.KeySignature.break-align-anchor-alignment =
                  #CENTER
\textMark "↓"
\key a \major
e'1
% Le repère textuel s'alignera
% sur la gauche de l'armure
\once \override Score.KeySignature.break-align-anchor-alignment =
                  #LEFT
\key a \major
\textMark "↓"
e'1
@end lilypond

Le bord gauche d'un jalon peut se décaler arbitrairement sur la gauche
ou sur la droite.  La valeur est exprimée en espaces de portée.

@lilypond[verbatim,quote,fragment]
\override Score.TextMark.self-alignment-X = #CENTER
% Le repère textuel s'alignera
% sur la gauche de l'armure
% puis décalé de 3,5 espaces de portée vers la droite
\override Score.TextMark.break-align-symbols =
            #'(key-signature)
\once \override Score.KeySignature.break-align-anchor = #3.5
\key a \major
\textMark "↓"
e'1
% Le repère textuel s'alignera
% sur la gauche de l'armure
% puis sera décalé de 2 espaces de portée vers la gauche
\once \override Score.KeySignature.break-align-anchor = #-2
\key a \major
\textMark "↓"
e'1
@end lilypond


@node Modification des stencils
@subsection Modification des stencils
@translationof Modifying stencils

Tout objet de rendu dispose d'une propriété @code{stencil} attachée à la
@code{grob-interface}.  En règle générale, cette propriété référence
par défaut une fonction spécifique à l'objet et taillée sur mesure pour
fournir le symbole qui va le représenter dans l'output.  Par exemple,
le réglage standard de la propriété @code{stencil} de l'objet
@code{MultiMeasureRest} est @code{ly:multi-measure-rest::print}.

Le symbole standard d'un objet quel qu'il soit peut être remplacé à
partir du moment où la propriété @code{stencil} référence une procédure
différente et écrite à cet effet.  Ceci requiert une bonne maîtrise du
fonctionnement interne de LilyPond, mais est grandement facilité dans
bien des cas et permet d'obtenir le résultat escompté.

En effet, rien ne nous interdit, à partir de la propriété
@code{stencil}, d'appeler la procédure qui génère du texte,
@code{ly:text-interface::print} en l'occurrence, et d'adjoindre à l'objet
une propriété @code{text} qui contiendra, sous forme de @emph{markup},
le symbole à dessein.  Grâce à l'extrême flexibilité des @emph{markups},
vous pourrez parvenir à bien des choses -- voir à ce sujet
@ref{Éléments graphiques dans du texte formaté}.

C'est la technique employée ici, où l'une des têtes de note est
remplacée par une croix inscrite dans un cercle :

@lilypond[verbatim,quote]
XinO = {
  \once \override NoteHead.stencil = #ly:text-interface::print
  \once \override NoteHead.text = \markup {
    \combine
      \halign #-0.7 \draw-circle #0.85 #0.2 ##f
      \musicglyph "noteheads.s2cross"
  }
}
\relative {
  a' a \XinO a a
}
@end lilypond

Tous les glyphes @code{Feta} de la fonte Emmentaler sont
accessibles à l'aide de la commande de @emph{markup} @code{\musicglyph}
-- voir @ref{La fonte Emmentaler}.

L'insertion de fichier @file{EPS} ou d'instructions Postscript sont
accessibles par les commandes de @emph{markup} @code{\epsfile} et
@code{\postscript} respectivement -- voir l'annexe
@rusernamed{Graphic, Graphisme}.

@morerefs
Manuel de notation :
@ref{Commandes pour markup},
@ref{Éléments graphiques dans du texte formaté},
@rusernamed{Graphic, Graphisme},
@ref{La fonte Emmentaler},
@ref{Mise en forme du texte}.
@endmorerefs


@node Modification de l'allure des éléments
@subsection Modification de l'allure des éléments
@translationof Modifying shapes

@menu
* Modification des liaisons::
@end menu


@node Modification des liaisons
@unnumberedsubsubsec Modification des liaisons
@translationof Modifying ties and slurs

@cindex liaison, modification
@cindex Bézier, points de contrôle d'une courbe
@cindex points de contrôle, courbe de Bézier

Les liaisons, qu'elles soient de prolongation (@code{Tie}),
d'articulation (@code{Slur}), de phrasé (@code{PhrasingSlur}), de
laisser-vibrer (@code{LaissezVibrerTie}) ou de reprise
(@code{RepeatTie}), sont dessinées sous la forme de courbes de Bézier de
degré trois.  Lorsque l'aspect de la liaison automatiquement calculé
n'est pas satisfaisant, il peut être modifié manuellement de deux
manières différentes :

@enumerate
@item
en spécifiant l'ajustement qui doit être apporté aux points de
contrôle de la courbe calculée automatiquement, ou

@item
en fournissant explicitement les quatre points de contrôle qui
permettront de définir cette courbe.
@end enumerate

Ces deux méthodes sont expliquées ci-dessous.  La première convient
mieux dans le cas d'une légère adaptation de la courbe ; la seconde sera
plus efficace lorsqu'il s'agira de créer une courbe sur une seule et
unique note.

@subsubsubheading Courbes de Bézier cubiques
@c VO  Cubic Bézier curves

Quatre points définissent une courbe de Bézier cubique. Les premier et
quatrième points sont les points de départ et d'arrivée de la courbe ;
les deux autres points de contrôle -- P1 et P2 -- en détermineront
l'allure. On peut trouver sur le @emph{web} des animations à propos du
dessin de telles courbes ; la description qui suit en propose un aperçu.
La courbe se trace en partant du point P0, en se dirigeant vers P1 et en
arrivant au point P3 selon la direction @w{P2-P3}. La courbe est à
l'intérieur du quadrilatère défini par les points de contrôle.

@lilypond
\markup \pad-around #0.5
\score {
  \new Staff \with {
    \remove Staff_symbol_engraver
    \remove Clef_engraver
    \remove Time_signature_engraver
  }
  \new Voice \with {
    \hide NoteHead
    \omit Stem
  }
  {
    \vshape #'((-2 . 0) (-1 . 2) (1 . 1.5) (2 . -2)) Slur
    c( c)
  }
}
@end lilypond

Tout déplacement (translation, rotation, échelonnement) des points de
contrôle sera répercuté sur le dessin de la courbe.


@subsubsubheading Spécification de l'ajustement des points de contrôle
@c VO Specifying displacements from current control points

@cindex galbe des liaisons
@funindex \shape

Voici par exemple une liaison de prolongation dont l'allure n'est pas
des plus heureuses, même en optant pour un @code{\tieDown}.

@lilypond[verbatim,quote]
<<
  { e'1~ 1 }
\\
  \relative { r4 <g' c,> <g c,> <g c,> }
>>
@end lilypond

L'ajustement des points de contrôle de cette liaison de tenue à
l'aide de @code{\shape} permet d'éviter les collisions.

L'instruction @code{\shape} obéit à la syntaxe

@example
[-]\shape @var{déplacements} @var{élément}
@end example

Ceci aura pour effet de repositionner les points de contrôle de
@var{élément} des différents montants fournis par @var{déplacements}.
L'argument @var{déplacements} est constitué d'une liste de paires de
nombres ou bien d'une liste de telles listes.  Chacun des membres de
l'une des paires indique l'ajustement de la coordonnée d'un point de
contrôle.  Lorsque @var{élément} est textuel, il en résulte une
dérogation particulière appliquée au type d'objet considéré, alors que
dans le cas d'une expression musicale sera appliqué un affinage
approprié.

En d'autres termes, la fonction @code{\shape} se comporte soit comme un
@code{\once \override}, soit comme un @code{\tweak} selon que l'argument
@var{élément} est un nom d'objet -- tel « Slur » -- ou une expression
musicale tel un « ( ».  L'argument @var{déplacements} spécifie les
ajustements à apporter aux quatre points de contrôle, sous la forme
d'une liste de paires @w{@code{(dx . dy)}} dont les valeurs sont
exprimées en espace de portée ; on utilisera une liste de listes de
paires dans le cas où la courbe comporte plusieurs segments.

@c close )

La fonction sera précédée d'un tiret si et seulement si elle doit
s'appliquer sous forme de @code{\tweak}.

Pour l'exemple qui nous occupe, l'adaptation sous forme dérogatoire --
recours à @code{\once\override} -- de la fonction @code{\shape}, nous
pouvons remonter la liaison d'un demi espace de portée :

@lilypond[verbatim,quote]
<<
  {
    \shape #'((0 . 0.5) (0 . 0.5) (0 . 0.5) (0 . 0.5)) Tie
    e'1~ 1
  }
\\
  \relative { r4 <g' c,> <g c,> <g c,> }
>>
@end lilypond

La liaison est maintenant mieux positionnée ; mais sa partie centrale
pourrait être un peu plus relevée, en procédant comme ci-dessous, cette
fois en utilisant la formulation d'affinage -- la forme @code{\tweak} :

@lilypond[verbatim,quote]
<<
  {
    e'1-\shape #'((0 . 0.5) (0 . 1) (0 . 1) (0 . 0.5)) ~ e'
  }
\\
  \relative { r4 <g' c,> <g c,> <g c,> }
>>
@end lilypond

LilyPond dispose de la fonction @code{\vshape} qui apporte une
assistance dans cette procédure d'affinage. Son nom signifie
@emph{visual shape}. Elle agit exactement comme la fonction
@code{\shape}, à ceci près que seront aussi affichés les points de
contrôle et le polygone.

@lilypond[verbatim,quote,ragged-right]
\relative {
  c''8(\( a) e4 gis a\)
  \vshape #'((0 . -0.3) (0.5 . -0.2)
             (0.5 . -0.3) (0 . -0.7)) PhrasingSlur
  c8(\( a) e4 gis a\)
}
@end lilypond

Il est conseillé de commencer avec @code{\vshape} et d'ajuster jusqu'à
obtenir un galbe satisfaisant, puis de simplement supprimer le « v » de
@code{\vshape}.

Il est possible de gérer distinctement le galbe de deux courbes débutant
au même instant musical :

@lilypond[verbatim,quote,ragged-right]
\relative {
  c''8(\( a) a'4 e c\)
  \shape #'((0.7 . -0.4) (0.5 . -0.4)
            (0.3 . -0.3) (0 . -0.2)) Slur
  \shape #'((0 . 0) (0 . 0.5)
            (0 . 0.5) (0 . 0)) PhrasingSlur
  c8(\( a) a'4 e c\)
}
@end lilypond

La fonction @code{\shape} permet aussi d'adapter les points de
contrôle d'une courbe qui se prolonge après un saut de ligne.
Chaque portion de la courbe peut se voir appliquer sa propre liste
d'ajustements.  Lorsque l'un des segments ne nécessite pas de
retouche, il suffit de lui fournir une liste vide.  Dans l'exemple
suivant, le saut de ligne laisse à croire qu'il y a non pas une
seule mais deux liaisons :

@lilypond[verbatim,quote,ragged-right]
\relative {
  c'4( f g c
  \break
  d,4 c' f, c)
}
@end lilypond

Regalber les deux moitiés de la liaison rend plus évident le fait
qu'elle s'étend par delà le saut de ligne :

@lilypond[verbatim,quote,ragged-right]
% () peut faire office de raccourci à ((0 . 0) (0 . 0) (0 . 0) (0 . 0))
% lorsque l'un des segments ne nécéssite pas de modification
\relative c' {
  \shape #'(
             (( 0 . 0) (0 . 0) (0 . 0) (0 . 1))
             ((0.5 . 1.5) (1 . 0) (0 . 0) (0 . -1.5))
           ) Slur
  c4( f g c
  \break
  d,4 c' f, c)
}
@end lilypond

La présence d'une courbe en esse requiert obligatoirement d'ajuster
manuellement les points de contrôle -- LilyPond n'optera jamais
automatiquement pour un tel galbe.

@lilypond[verbatim,quote]
\relative c'' {
  c8( e b-> f d' a e-> g)
  \shape #'((0 . -1) (5.5 . -0.5) (-5.5 . -10.5) (0 . -5.5))
         PhrasingSlur
  c8\( e b-> f d' a e-> g\)
}
@end lilypond


@subsubsubheading Déclaration explicite des points de contrôle
@c VO Specifying control points explicitly

Les coordonnées des points de contrôle sont données en unités d'espace
de portée.  L'abscisse est relative au point de référence de la note de
départ de la liaison ; l'ordonnée est relative à la ligne médiane de la
portée.  Les différentes coordonnées sont entrées sous la forme d'une
liste de quatre paires de nombres décimaux (ou nombres réels).  L'une
des manières de procéder consiste à tout d'abord estimer les coordonnées
des deux extrémités puis, par tâtonnement, déterminer les deux points
intermédiaires.  Gardez à l'esprit que ces valeurs pourront devoir être
revues si la musique ou sa mise en forme sont modifées.

L'une des situation où spécifier explicitement les points de contrôle se
révèle être tout à fait appropriée est lorsqu'ils se réfèrent à une
seule et unique note.  L'exemple suivant illustre l'un des moyens
d'indiquer une liaison qui se prolonge sur les alternatives d'une
répétition.

@lilypond[verbatim,quote]
\relative {
  c''1
  \repeat volta 3 { c4 d( e f }
  \alternative {
    \volta 1 { g2) d }
    \volta 2 {
      g2
        % create a slur and move it to a new position
        % the <> is just an empty chord to carry the slur termination
        -\tweak control-points
                  #'((-2 . 3.8) (-1 . 3.9) (0 . 4) (1 . 3.4)) ( <> )
      f,
    }
    \volta 3 {
      e'2
        % create a slur and move it to a new position
        -\tweak control-points
                  #'((-2 . 3) (-1 . 3.1) (0 . 3.2) (1 . 2.4)) ( <> )
      f,
    }
  }
}
@end lilypond

@knownissues
Lorsque plusieurs liaisons, quelle qu'en soit la nature, commencent au
même moment, jouer sur la propriété @code{control-points} est
impossible, et la commande @code{\tweak} inefficace.  Vous pouvez
néanmoins influer sur la propriété @code{tie-configuration} de l'objet
@code{TieColumn} pour déterminer la ligne de départ et l'orientation.

@morerefs
Référence des propriétés internes :
@rinternals{TieColumn}.
@endmorerefs
