@c -*- coding: utf-8; mode: texinfo; -*-
+@c This file is part of lilypond.tely
+@ignore
+ Translation of GIT committish: FILL-IN-HEAD-COMMITTISH
+
+ When revising a translation, copy the HEAD committish of the
+ version that you are working on. See TRANSLATION for details.
+@end ignore
+
@node Changing defaults
@chapter Changing defaults
The purpose of LilyPond's design is to provide the finest output
quality as a default. Nevertheless, it may happen that you need to
change this default layout. The layout is controlled through a large
-number of proverbial ``knobs and switches.'' This chapter does not
+number of proverbial @q{knobs and switches.} This chapter does not
list each and every knob. Rather, it outlines what groups of controls
are available and explains how to lookup which knob to use for a
particular effect.
-@cindex Program reference
+@cindex Internals Reference
The controls available for tuning are described in a separate
document, the
@iftex
-Program reference
+Internals Reference manual.
@end iftex
@ifnottex
-@ref{Top,Program reference,,lilypond-internals}.
+@ref{Top,Internals Reference,,lilypond-internals}.
@end ifnottex
-manual. That manual
+That manual
lists all different variables, functions and options available in
LilyPond. It is written as a HTML document, which is available
-@uref{http://@/lilypond@/.org/@/doc/@/v2.5/@/Documentation/@/user/@/out@/-www/@/lilypond@/-internals/,on@/-line},
+@c leave the @uref as one long line.
+@uref{http://@/lilypond@/.org/@/doc/@/stable/@/Documentation/@/user/@/lilypond@/-internals/,on@/-line},
but is also included with the LilyPond documentation package.
-There are three areas where the default settings may be changed:
+There are four areas where the default settings may be changed:
+
+@itemize
+@item
+Automatic notation: changing the automatic creation of notation
+elements. For example, changing the beaming rules.
-@itemize @bullet
@item
Output: changing the appearance of individual
objects. For example, changing stem directions or the location of
subscripts.
-
+
@item
Context: changing aspects of the translation from music events to
-notation. For example, giving each staff a separate time signature.
-
+notation. For example, giving each staff a separate time signature.
+
@item
-Global layout: changing the appearance of the spacing, line
-breaks, and page dimensions.
+Page layout: changing the appearance of the spacing, line
+breaks, and page dimensions. These modifications are discussed
+in @ref{Non-musical notation}, and @ref{Spacing issues}.
@end itemize
-Then there are separate systems for typesetting text (like
-@emph{ritardando}) and selecting different fonts. This chapter also
-discusses these.
-
Internally, LilyPond uses Scheme (a LISP dialect) to provide
infrastructure. Overriding layout decisions in effect accesses the
program internals, which requires Scheme input. Scheme elements are
introduced in a @code{.ly} file with the hash mark
-@code{#}.@footnote{@ref{Scheme tutorial} contains a short tutorial
+@code{#}.@footnote{@rlearning{Scheme tutorial}, contains a short tutorial
on entering numbers, lists, strings, and symbols in Scheme.}
* The \override command::
@end menu
-
+
@node Interpretation contexts
@section Interpretation contexts
+This section describes what contexts are, and how to modify them.
+
+@menu
+* Contexts explained::
+* Creating contexts::
+* Changing context properties on the fly::
+* Modifying context plug-ins::
+* Layout tunings within contexts::
+* Changing context default settings::
+* Defining new contexts::
+* Aligning contexts::
+* Vertical grouping of grobs::
+@end menu
+
+
+@node Contexts explained
+@subsection Contexts explained
+
When music is printed, a lot of notational elements must be added to the
-input, which is often bare bones. For example, compare the input and
-output of the following example:
+output. For example, compare the input and output of the following example:
@lilypond[quote,verbatim,relative=2,fragment]
cis4 cis2. g4
The input is rather sparse, but in the output, bar lines, accidentals,
clef, and time signature are added. LilyPond @emph{interprets} the
input. During this step, the musical information is inspected in time
-order, similar to reading a score from left to right. While reading,
-the input, the program remembers where measure boundaries are, and what
-pitches need explicit accidentals. This information can be presented on
+order, similar to reading a score from left to right. While reading
+the input, the program remembers where measure boundaries are, and which
+pitches require explicit accidentals. This information can be presented on
several levels. For example, the effect of an accidental is limited
to a single staff, while a bar line must be synchronized across the
entire score.
Within LilyPond, these rules and bits of information are grouped in
-so-called Contexts. Examples of context are @context{Voice},
-@context{Staff}, and @context{Score}. They are hierarchical, for
-example, a @context{Staff} can contain many @context{Voice}s, and a
-@context{Score} can contain many @context{Staff} contexts.
+@emph{Contexts}. Some examples of contexts are @code{Voice},
+@code{Staff}, and @code{Score}. They are hierarchical, for
+example: a @code{Staff} can contain many @code{Voice}s, and a
+@code{Score} can contain many @code{Staff} contexts.
+
+@quotation
+@sourceimage{context-example,5cm,,}
+@end quotation
Each context has the responsibility for enforcing some notation rules,
creating some notation objects and maintaining the associated
-properties. So, the synchronization of bar lines is handled at
-@context{Score} context. The @context{Voice} may introduce an
-accidental and then the @context{Staff} context maintains the rule to
-show or suppress the accidental for the remainder of the measure.
-
-For simple scores, contexts are created implicitly, and you need not
-be aware of them. For larger pieces, such as piano music, they must be
+properties. For example, the @code{Voice} context may introduce an
+accidental and then the @code{Staff} context maintains the rule to
+show or suppress the accidental for the remainder of the measure. The
+synchronization of bar lines is handled at @code{Score} context.
+
+However, in some music we may not want the bar lines to be
+synchronized -- consider a polymetric score in 4/4 and 3/4 time. In
+such cases, we must modify the default settings of the @code{Score}
+and @code{Staff} contexts.
+
+For very simple scores, contexts are created implicitly, and you need
+not be aware of them. For larger pieces, such as anything with more
+than one staff, they must be
created explicitly to make sure that you get as many staves as you
need, and that they are in the correct order. For typesetting pieces
with specialized notation, it can be useful to modify existing or
@ifhtml
@internalsref{Contexts}.
@end ifhtml
-@ifnothtml
-Translation @arrow{} Context.
+@ifnothtml
+Translation @expansion{} Context.
@end ifnothtml
@c [TODO: describe propagation]
-@menu
-* Creating contexts::
-* Changing context properties on the fly::
-* Modifying context plug-ins::
-* Layout tunings within contexts::
-* Changing context default settings::
-* Defining new contexts::
-@end menu
-
@node Creating contexts
@subsection Creating contexts
-For scores with only one voice and one staff, correct contexts are
+For scores with only one voice and one staff, contexts are
created automatically. For more complex scores, it is necessary to
create them by hand. There are three commands that do this.
+@itemize
+
+@item
The easiest command is @code{\new}, and it also the quickest to type.
It is prepended to a music expression, for example
-@cindex @code{\new}
+@funindex \new
@cindex new contexts
@cindex Context, creating
interpreting the @var{music expression} with that.
A practical application of @code{\new} is a score with many
-staves. Each part that should be on its own staff, is preceded with
+staves. Each part that should be on its own staff, is preceded with
@code{\new Staff}.
-@lilypond[quote,verbatim,relative=2,raggedright,fragment]
-<< \new Staff { c4 c }
- \new Staff { d4 d }
+@lilypond[quote,verbatim,relative=2,ragged-right,fragment]
+<<
+ \new Staff { c4 c }
+ \new Staff { d4 d }
>>
@end lilypond
-@cindex @code{\context}
+The @code{\new} command may also give a name to the context,
+@example
+\new @var{type} = @var{id} @var{music}
+@end example
+However, this user specified name is only used if there is no other
+context already earlier with the same name.
+
+
+@funindex \context
+
+@item
Like @code{\new}, the @code{\context} command also directs a music
-expression to a context object, but gives the context an extra name. The
+expression to a context object, but gives the context an explicit name. The
syntax is
@example
@end example
This form will search for an existing context of type @var{type}
-called @var{id}. If that context does not exist yet, it is created.
-This is useful if the context is referred to later on. For example, when
+called @var{id}. If that context does not exist yet, a new
+context with the specified name is created. This is useful if
+the context is referred to later on. For example, when
setting lyrics the melody is in a named context
@example
so the texts can be properly aligned to its notes,
@example
-\new Lyrics \lyricsto "@b{tenor}" @var{lyrics}
+\new Lyrics \lyricsto "@b{tenor}" @var{lyrics}
@end example
@noindent
-Another possibility is funneling two different music expressions into
-one context. In the following example, articulations and notes are
-entered separately,
+Another possible use of named contexts is funneling two different
+music expressions into one context. In the following example,
+articulations and notes are entered separately,
@example
music = @{ c4 c4 @}
arts = @{ s4-. s4-> @}
@end example
-They are combined by sending both to the same @context{Voice} context,
+They are combined by sending both to the same @code{Voice} context,
@example
-<< \new Staff \context Voice = "A" \music
- \context Voice = "A" \arts
+<<
+ \new Staff \context Voice = "A" \music
+ \context Voice = "A" \arts
>>
@end example
-@lilypond[quote,raggedright]
+@lilypond[quote,ragged-right]
music = { c4 c4 }
arts = { s4-. s4-> }
\relative c'' <<
@cindex creating contexts
+@item
The third command for creating contexts is
@example
\context @var{type} @var{music}
This variant is used with music expressions that can be interpreted at
several levels. For example, the @code{\applyOutput} command (see
@ref{Running a function on all layout objects}). Without an explicit
-@code{\context}, it is usually applied to @context{Voice}
+@code{\context}, it is usually applied to @code{Voice}
@example
-\applyOutput #@var{function} % apply to Voice
+\applyOutput #'@var{context} #@var{function} % apply to Voice
@end example
-To have it interpreted at the @context{Score} or @context{Staff} level use
+To have it interpreted at the @code{Score} or @code{Staff} level use
these forms
@example
-\context Score \applyOutput #@var{function}
-\context Staff \applyOutput #@var{function}
+\applyOutput #'Score #@var{function}
+\applyOutput #'Staff #@var{function}
@end example
+@end itemize
+
@node Changing context properties on the fly
@subsection Changing context properties on the fly
@cindex properties
-@cindex @code{\set}
+@funindex \set
@cindex changing properties
Each context can have different @emph{properties}, variables contained
For example,
@lilypond[quote,verbatim,relative=2,fragment]
-R1*2
+R1*2
\set Score.skipBars = ##t
R1*2
@end lilypond
this case, it is @code{#t}, the boolean True value.
If the @var{context} argument is left out, then the current bottom-most
-context (typically @context{ChordNames}, @context{Voice}, or
-@context{Lyrics}) is used. In this example,
+context (typically @code{ChordNames}, @code{Voice}, or
+@code{Lyrics}) is used. In this example,
@lilypond[quote,verbatim,relative=2,fragment]
c8 c c c
have no effect.
@lilypond[quote,verbatim,relative=2,fragment]
-R1*2
+R1*2
\set skipBars = ##t
R1*2
@end lilypond
Contexts are hierarchical, so if a bigger context was specified, for
-example @context{Staff}, then the change would also apply to all
-@context{Voice}s in the current stave. The change is applied
-`on-the-fly', during the music, so that the setting only affects the
+example @code{Staff}, then the change would also apply to all
+@code{Voice}s in the current stave. The change is applied
+@q{on-the-fly}, during the music, so that the setting only affects the
second group of eighth notes.
-@cindex @code{\unset}
+@funindex \unset
There is also an @code{\unset} command,
@example
specified for a bottom context, so the two statements
@example
-\set Voice.autoBeaming = ##t
-\set autoBeaming = ##t
-@end example
+\set Voice.autoBeaming = ##t
+\set autoBeaming = ##t
+@end example
@noindent
are equivalent.
@internalsref{Tunable context properties}.
@end ifhtml
@ifnothtml
-Translation @arrow{} Tunable context properties.
+Translation @expansion{} Tunable context properties.
@end ifnothtml
@node Modifying context plug-ins
@subsection Modifying context plug-ins
-Notation contexts (like Score and Staff) not only store properties,
-they also contain plug-ins, called ``engravers'' that create notation
-elements. For example, the Voice context contains a
-@code{Note_head_engraver} and the Staff context contains a
+Notation contexts (like @code{Score} and @code{Staff}) not only
+store properties,
+they also contain plug-ins called @q{engravers} that create notation
+elements. For example, the @code{Voice} context contains a
+@code{Note_head_engraver} and the @code{Staff} context contains a
@code{Key_signature_engraver}.
-For a full a description of each plug-in, see
+For a full a description of each plug-in, see
@ifhtml
@internalsref{Engravers}.
@end ifhtml
@ifnothtml
-Program reference @arrow Translation @arrow{} Engravers.
+Internals Reference @expansion{} Translation @expansion{} Engravers.
@end ifnothtml
Every context described in
@ifhtml
@internalsref{Contexts}
@end ifhtml
-@ifnothtml
-Program reference @arrow Translation @arrow{} Context.
+@ifnothtml
+Internals Reference @expansion{} Translation @expansion{} Context.
@end ifnothtml
lists the engravers used for that context.
It can be useful to shuffle around these plug-ins. This is done by
-starting a new context, with @code{\new} or @code{\context}, and
-modifying it like this,
+starting a new context with @code{\new} or @code{\context}, and
+modifying it,
+
+@funindex \with
@example
\new @var{context} \with @{
\remove @dots{}
@emph{etc.}
@}
-@emph{..music..}
+@{
+ @emph{..music..}
+@}
@end example
@noindent
@code{Clef_engraver} from a @code{Staff} context,
@lilypond[quote,relative=1,verbatim,fragment]
-<< \new Staff {
+<<
+ \new Staff {
f2 g
}
\new Staff \with {
In the second staff there are no time signature or clef symbols. This
is a rather crude method of making objects disappear since it will affect
-the entire staff. The spacing is adversely influenced too. A more
-sophisticated method of blanking objects is shown in @ref{Common tweaks}.
+the entire staff. This method also influences the spacing, which may or
+may not be desirable. A more
+sophisticated method of blanking objects is shown in @rlearning{Common tweaks}.
The next example shows a practical application. Bar lines and time
signatures are normally synchronized across the score. This is done
@cindex polymetric scores
@cindex Time signatures, multiple
-@lilypond[quote,relative=1,raggedright,verbatim,fragment]
+@lilypond[quote,relative=1,ragged-right,verbatim,fragment]
\new Score \with {
\remove "Timing_translator"
\remove "Default_bar_line_engraver"
objects. The settings used for printing these objects are also stored by
context. By changing these settings, the appearance of objects can be
altered.
-
+
The syntax for this is
@example
Here @var{name} is the name of a graphical object, like @code{Stem} or
@code{NoteHead}, and @var{property} is an internal variable of the
-formatting system (`grob property' or `layout property'). The latter is a
+formatting system (@q{grob property} or @q{layout property}). The latter is a
symbol, so it must be quoted. The subsection @ref{Constructing a
-tweak} explains what to fill in for @var{name}, @var{property}, and
+tweak}, explains what to fill in for @var{name}, @var{property}, and
@var{value}. Here we only discuss the functionality of this command.
The command
@verbatim
-\override Staff.Stem #'thickness = #4.0
+\override Staff.Stem #'thickness = #4.0
@end verbatim
@noindent
makes stems thicker (the default is 1.3, with staff line thickness as a
-unit). Since the command specifies @context{Staff} as context, it only
+unit). Since the command specifies @code{Staff} as context, it only
applies to the current staff. Other staves will keep their normal
appearance. Here we see the command in action:
@lilypond[quote,verbatim,relative=2,fragment]
c4
-\override Staff.Stem #'thickness = #4.0
+\override Staff.Stem #'thickness = #4.0
c4
c4
c4
@end lilypond
The @code{\override} command changes the definition of the @code{Stem}
-within the current @context{Staff}. After the command is interpreted
+within the current @code{Staff}. After the command is interpreted
all stems are thickened.
Analogous to @code{\set}, the @var{context} argument may be left out,
-causing it to default to @context{Voice}, and adding @code{\once} applies
-the change during one timestep only
+causing the default context @code{Voice} to be used. Adding
+@code{\once} applies the change during one timestep only.
@lilypond[quote,fragment,verbatim,relative=2]
c4
-\once \override Stem #'thickness = #4.0
+\once \override Stem #'thickness = #4.0
+c4
c4
-c4
@end lilypond
The @code{\override} must be done before the object is
-started. Therefore, when altering @emph{Spanner} objects, like slurs or
-beams, the @code{\override} command must be executed at the moment when
-the object is created. In this example,
-
+started. Therefore, when altering @emph{Spanner} objects such as slurs
+or beams, the @code{\override} command must be executed at the moment
+when the object is created. In this example,
@lilypond[quote,fragment,verbatim,relative=2]
\override Slur #'thickness = #3.0
c8[( c
\override Beam #'thickness = #0.6
-c8 c])
+c8 c])
@end lilypond
@noindent
the slur is fatter but the beam is not. This is because the command for
-@code{Beam} comes after the Beam is started. Therefore it has no effect.
+@code{Beam} comes after the Beam is started, so it has no effect.
Analogous to @code{\unset}, the @code{\revert} command for a context
undoes an @code{\override} command; like with @code{\unset}, it only
\revert Staff.Stem #'thickness
@end example
+Some tweakable options are called @q{subproperties} and reside inside
+properties. To tweak those, use commands of the form
+
+@c leave this as a long long
+@example
+\override @var{context}.@var{name} #'@var{property} #'@var{subproperty} = #@var{value}
+@end example
+
+@noindent
+such as
+@example
+\override Stem #'details #'beamed-lengths = #'(4 4 3)
+@end example
@seealso
The adjustments of the previous subsections (@ref{Changing context
properties on the fly}, @ref{Modifying context plug-ins}, and
@ref{Layout tunings within contexts}) can also be entered separately
-from the music, in the @code{\layout} block,
+from the music in the @code{\layout} block,
@example
\layout @{
@}
@end example
-Here
-@example
-\Staff
-@end example
-
-@noindent
-takes the existing definition for context @context{Staff} from the
-identifier @code{\Staff}.
+The @code{\Staff} command brings in the existing definition of the
+staff context so that it can be modified.
The statements
@example
@end example
@noindent
-affect all staves in the score.
-
-Other contexts can be modified analogously.
+affect all staves in the score. Other contexts can be modified
+analogously.
The @code{\set} keyword is optional within the @code{\layout} block, so
@refbugs
-It is not possible to collect context changes in a variable, and apply
-them to one @code{\context} definition by referring to that variable.
+It is not possible to collect context changes in a variable and apply
+them to a @code{\context} definition by referring to that variable.
-The @code{\RemoveEmptyStaffContext} will override your current
-@code{\Staff} variable. If you wish to change the defaults for a
-staff that uses @code{\RemoveEmptyStaffContext}, you must do so
-after calling @code{\RemoveemptyStaffContext}, ie
+The @code{\RemoveEmptyStaffContext} will overwrite your current
+@code{\Staff} settings. If you wish to change the defaults for a
+staff which uses @code{\RemoveEmptyStaffContext}, you must do so
+after calling @code{\RemoveEmptyStaffContext}, ie
@example
\layout @{
@node Defining new contexts
@subsection Defining new contexts
-Specific contexts, like @context{Staff} and @code{Voice}, are made of
-simple building blocks, and it is possible to compose engraver
-plug-ins in different combinations, thereby creating new types of
-contexts.
+Specific contexts, like @code{Staff} and @code{Voice}, are made of
+simple building blocks. It is possible to create new types of
+contexts with different combinations of engraver plug-ins.
The next example shows how to build a different type of
-@context{Voice} context from scratch. It will be similar to
-@code{Voice}, but prints centered slash noteheads only. It can be used
-to indicate improvisation in Jazz pieces,
+@code{Voice} context from scratch. It will be similar to
+@code{Voice}, but only prints centered slash note heads. It can be used
+to indicate improvisation in jazz pieces,
-@lilypond[quote,raggedright]
+@lilypond[quote,ragged-right]
\layout { \context {
\name ImproVoice
\type "Engraver_group"
}}
\relative c'' {
- a4 d8 bes8 \new ImproVoice { c4^"ad lib" c
- c4 c^"undress" c_"while playing :)" c }
- a1
+ a4 d8 bes8 \new ImproVoice { c4^"ad lib" c
+ c4 c^"undress" c_"while playing :)" c }
+ a1
}
@end lilypond
-These settings are again done within a @code{\context} block inside a
+These settings are defined within a @code{\context} block inside a
@code{\layout} block,
@example
@}
@end example
-In the following discussion, the example input shown should go on the
-@dots{} in the previous fragment.
+In the following discussion, the example input shown should go in place
+of the @dots{} in the previous fragment.
-First, the context gets a name. Instead of @context{Voice} it
-will be called @context{ImproVoice},
+First it is necessary to define a name for the new context:
@example
\name ImproVoice
@end example
-Since it is similar to the @context{Voice}, we want commands that work
-on (existing) @context{Voice}s to remain working. This is achieved by
-giving the new context an alias @context{Voice},
+Since it is similar to the @code{Voice}, we want commands that work
+on (existing) @code{Voice}s to remain working. This is achieved by
+giving the new context an alias @code{Voice},
@example
\alias Voice
@end example
-The context will print notes, and instructive texts
+The context will print notes and instructive texts, so we need to add
+the engravers which provide this functionality,
@example
\consists Note_heads_engraver
\consists Text_engraver
@end example
-but only on the center line,
+but we only need this on the center line,
@example
\consists Pitch_squash_engraver
position to the value of @code{squashedPosition}, in this case@tie{}@code{0},
the center line.
-The notes look like a slash, without a stem,
+The notes look like a slash, and have no stem,
@example
\override NoteHead #'style = #'slash
\override Stem #'transparent = ##t
@end example
-
All these plug-ins have to cooperate, and this is achieved with a
special plug-in, which must be marked with the keyword @code{\type}.
This should always be @internalsref{Engraver_group},
@}
@end example
-Contexts form hierarchies. We want to hang the @context{ImproVoice}
-under @context{Staff}, just like normal @code{Voice}s. Therefore, we
+@funindex \accepts
+Contexts form hierarchies. We want to hang the @code{ImproVoice}
+under @code{Staff}, just like normal @code{Voice}s. Therefore, we
modify the @code{Staff} definition with the @code{\accepts}
-command,@footnote{The opposite of @code{\accepts} is @code{\denies},
-which is sometimes needed when reusing existing context definitions.}
-
-
+command,
@example
\context @{
\Staff
- \accepts ImproVoice
+ \accepts ImproVoice
@}
@end example
+@funindex \denies
+The opposite of @code{\accepts} is @code{\denies},
+which is sometimes needed when reusing existing context definitions.
+
Putting both into a @code{\layout} block, like
@example
\relative c'' @{
a4 d8 bes8
\new ImproVoice @{
- c4^"ad lib" c
+ c4^"ad lib" c
c4 c^"undress"
c c_"while playing :)"
@}
a1
@}
@end example
-
-
-@node The \override command
-@section The \override command
+@node Aligning contexts
+@subsection Aligning contexts
-In the previous section, we have already touched on a command that
-changes layout details: the @code{\override} command. In this section,
-we will look in more detail at how to use the command in practice.
-First, we will give a few versatile commands that are sufficient
-for many situations. The next section will discuss the general use of
-@code{\override}.
+New contexts may be aligned above or below exisiting contexts. This
+could be useful in setting up a vocal staff (@rlearning{Vocal ensembles}) and
+in ossia,
+FIXME: this section doens't work in pdf. (?)
-@menu
-* Common tweaks::
-* Constructing a tweak::
-* Navigating the program reference::
-* Layout interfaces::
-* Determining the grob property::
-* Difficult tweaks::
-@end menu
-
+@cindex ossia
+@findex alignAboveContext
+@findex alignBelowContext
+@lilypond[quote,ragged-right]
+ossia = { f4 f f f }
+\score{
+ \relative c' \new Staff = "main" {
+ c4 c c c
+ <<
+ \new Staff \with {alignAboveContext=main} \ossia
+ { d8 f d f d f d f }
+ >>
+ }
+}
+@end lilypond
-@node Common tweaks
-@subsection Common tweaks
-@c Should we point at ly/property-init.ly ? -gp
-Some overrides are so common that predefined commands are provided as
-short-cuts, for example, @code{\slurUp} and @code{\stemDown}. These
-commands are described in
-@ifhtml
-the
-@end ifhtml
-@c @ref{Notation manual},
-Notation manual
-@c FIXME
-under the sections for slurs and stems
-respectively.
-
-The exact tuning possibilities for each type of layout object are
-documented in the program reference of the respective
-object. However, many layout objects share properties, which can be
-used to apply generic tweaks. We mention a few of these:
-
-@itemize @bullet
-@item The @code{extra-offset} property, which
-@cindex @code{extra-offset}
-has a pair of numbers as value, moves objects around in the printout.
-The first number controls left-right movement; a positive number will
-move the object to the right. The second number controls up-down
-movement; a positive number will move it higher. The units of these
-offsets are staff-spaces. The @code{extra-offset} property is a
-low-level feature: the formatting engine is completely oblivious to
-these offsets.
-
-In the following example, the second fingering is moved a little to
-the left, and 1.8 staff space downwards:
-
-@cindex setting object properties
-
-@lilypond[quote,fragment,relative=1,verbatim]
-\stemUp
-f-5
-\once \override Fingering
- #'extra-offset = #'(-0.3 . -1.8)
-f-5
-@end lilypond
+@node Vertical grouping of grobs
+@subsection Vertical grouping of grobs
-@item
-Setting the @code{transparent} property will cause an object to be printed
-in `invisible ink': the object is not printed, but all its other
-behavior is retained. The object still takes up space, it takes part in
-collisions, and slurs, ties, and beams can be attached to it.
-
-@cindex transparent objects
-@cindex removing objects
-@cindex hiding objects
-@cindex invisible objects
-The following example demonstrates how to connect different voices
-using ties. Normally, ties only connect two notes in the same
-voice. By introducing a tie in a different voice,
-
-@lilypond[quote,fragment,relative=2]
-<< {
- b8~ b8\noBeam
-} \\ {
- b[ g8]
-} >>
-@end lilypond
+The VerticalAlignment and VerticalAxisGroup grobs work together.
+VerticalAxisGroup groups together different grobs like Staff, Lyrics,
+etc. VerticalAlignment then vertically aligns the different grobs
+grouped together by VerticalAxisGroup. There is usually only one
+VerticalAlignment per score but every Staff, Lyrics, etc. has its own
+VerticalAxisGroup.
-@noindent
-and blanking the first up-stem in that voice, the tie appears to cross
-voices:
-@lilypond[quote,fragment,relative=2,verbatim]
-<< {
- \once \override Stem #'transparent = ##t
- b8~ b8\noBeam
-} \\ {
- b[ g8]
-} >>
-@end lilypond
+@node The \override command
+@section The @code{\override} command
-@item
-The @code{padding} property for objects with
-@cindex @code{padding}
-@code{side-position-interface} can be set to increase the distance between
-symbols that are printed above or below notes. We provide two
-examples; a more elaborate explanation is in @ref{Constructing a
-tweak}:
-
-@lilypond[quote,fragment,relative=1,verbatim]
-c2\fermata
-\override Script #'padding = #3
-b2\fermata
-@end lilypond
+In the previous section, we have already touched on a command that
+changes layout details: the @code{\override} command. In this section,
+we will look in more detail at how to use the command in practice. The
+general syntax of this command is:
-@lilypond[quote,fragment,relative=1,verbatim]
-% This will not work, see below:
-\override MetronomeMark #'padding = #3
-\tempo 4=120
-c1
-% This works:
-\override Score.MetronomeMark #'padding = #3
-\tempo 4=80
-d1
-@end lilypond
+@example
+\override @var{context}.@var{layout_object} #'@var{layout_property} = #@var{value}
+@end example
-Note in the second example how important it is to figure out what
-context handles a certain object. Since the @code{MetronomeMark} object
-is handled in the Score context, property changes in the @code{Voice}
-context will not be noticed.
+This will set the @var{layout_property} of the specified @var{layout_object},
+which is a member of the @var{context}, to the @var{value}.
-@end itemize
+@menu
+* Constructing a tweak::
+* Navigating the program reference::
+* Layout interfaces::
+* Determining the grob property::
+* Objects connected to the input::
+* Using Scheme code instead of \tweak::
+* \set versus \override::
+* Difficult tweaks::
+@end menu
-More specific overrides are also possible. The next section
-discusses in depth how to figure out these statements for yourself.
@node Constructing a tweak
@subsection Constructing a tweak
-The general procedure of changing output, that is, entering
-a command like
+Commands which change output generally look like
@example
\override Voice.Stem #'thickness = #3.0
@end example
@noindent
-means that we have to determine these bits of information:
+To construct this tweak we must determine these bits of information:
@itemize
-@item the context: here @context{Voice}.
+@item the context: here @code{Voice}.
@item the layout object: here @code{Stem}.
-@item the layout property: here @code{thickness}
-@item a sensible value: here @code{3.0}
-@end itemize
+@item the layout property: here @code{thickness}.
+@item a sensible value: here @code{3.0}.
+@end itemize
+Some tweakable options are called @q{subproperties} and reside inside
+properties. To tweak those, use commands in the form
+
+@example
+\override Stem #'details #'beamed-lengths = #'(4 4 3)
+@end example
@cindex internal documentation
@cindex finding graphical objects
-@cindex graphical object descriptions
+@cindex graphical object descriptions
@cindex tweaking
-@cindex @code{\override}
+@funindex \override
@cindex internal documentation
+For many properties, regardless of the data type of the property, setting the
+property to false ( @code{##f} ) will result in turning it off, causing
+Lilypond to ignore that property entirely. This is particularly useful for
+turning off grob properties which may otherwise be causing problems.
+
We demonstrate how to glean this information from the notation manual
and the program reference.
+
+
+
@node Navigating the program reference
@subsection Navigating the program reference
@end lilypond
If you visit the documentation on fingering instructions (in
-@ref{Fingering instructions}), you will notice that there is written:
+@ref{Fingering instructions}), you will notice:
@quotation
@seealso
-Program reference: @internalsref{FingerEvent} and @internalsref{Fingering}.
+Internals Reference: @internalsref{Fingering}.
@end quotation
-
+@c outdated info; probably will delete.
+@ignore
This fragment points to two parts of the program reference: a page
on @code{FingerEvent} and one on @code{Fingering}.
@quotation
Accepted by: @internalsref{Fingering_engraver},
-@end quotation
+@end quotation
@noindent
That link brings us to the documentation for the Engraver, the
In other words, once the @code{FingerEvent}s are interpreted, the
@code{Fingering_engraver} plug-in will process them.
+@end ignore
+
+@ignore
+@c I can't figure out what this is supposed to mean. -gp
+
The @code{Fingering_engraver} is also listed to create
@internalsref{Fingering} objects,
-
-Lo and behold, that is also the
+@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. By clicking around in the program reference, we can follow the
-flow of information within the program, either forward (like we did
-here), or backwards, following links like this:
+manual.
+@end ignore
+
+@ifnothtml
+The programmer's reference is available as an HTML document. It is
+highly recommended that you read it in HTML form, either online or
+by downloading the HTML documentation. This section will be much more
+difficult to understand if you are using the
+PDF manual.
+@end ifnothtml
-@itemize @bullet
+Follow the link to @internalsref{Fingering}. At the top of the
+page, you will see
+
+@quotation
+Fingering objects are created by: @internalsref{Fingering_engraver} and
+@internalsref{New_fingering_engraver}.
+@end quotation
+
+By following related links inside the program reference, we can follow the
+flow of information within the program:
+
+@itemize
@item @internalsref{Fingering}:
@internalsref{Fingering} objects are created by:
-@b{@internalsref{Fingering_engraver}}
+@internalsref{Fingering_engraver}
@item @internalsref{Fingering_engraver}:
-Music types accepted: @b{@internalsref{fingering-event}}
+Music types accepted: @internalsref{fingering-event}
@item @internalsref{fingering-event}:
Music event type @code{fingering-event} is in Music expressions named
-@b{@internalsref{FingerEvent}}
+@internalsref{FingerEvent}
@end itemize
This path goes against the flow of information in the program: it
-starts from the output, and ends at the input event.
+starts from the output, and ends at the input event. You could
+also start at an input event, and read with the flow of
+information, eventually ending up at the output object(s).
The program reference can also be browsed like a normal document. It
-contains a chapter on
+contains chapters on
@ifhtml
@internalsref{Music definitions},
@end ifhtml
@code{Music definitions}
@end ifnothtml
on @internalsref{Translation}, and the @internalsref{Backend}. Every
-chapter lists all the definitions used, and all properties that may be
+chapter lists all the definitions used and all properties that may be
tuned.
-
+
@node Layout interfaces
@subsection Layout interfaces
@cindex layout interface
@cindex grob
-The HTML page that we found in the previous section, describes the
+The HTML page that we found in the previous section describes the
layout object called @internalsref{Fingering}. Such an object is a
symbol within the score. It has properties that store numbers (like
thicknesses and directions), but also pointers to related objects. A
@quotation
@code{padding} (dimension, in staff space):
-
-@code{0.6}
+
+@code{0.5}
@end quotation
@noindent
-which means that the number will be kept at a distance of at least 0.6
+which means that the number will be kept at a distance of at least 0.5
of the note head.
typographical element. For example, the Fingering object
has the following aspects
-@itemize @bullet
+@itemize
@item
Its size is independent of the horizontal spacing, unlike slurs or beams.
@item
Horizontally, the center of the symbol should be aligned to the
-center of the notehead.
+center of the note head.
@item
Vertically, the symbol is placed next to the note and the staff.
@item
-The vertical position is also coordinated with other super- and subscript
-symbols.
+The vertical position is also coordinated with other superscript
+and subscript symbols.
@end itemize
Each of these aspects is captured in so-called @emph{interface}s,
Clicking any of the links will take you to the page of the respective
object interface. Each interface has a number of properties. Some of
-them are not user-serviceable (``Internal properties''), but others
-are.
+them are not user-serviceable (@q{Internal properties}), but others
+can be modified.
We have been talking of @emph{the} @code{Fingering} object, but actually it
-does not amount to much. The initialization file
-@file{scm/@/define@/-grobs@/.scm} shows the soul of the `object',
+does not amount to much. The initialization file (see
+@rlearning{Default files})
+@file{scm/@/define@/-grobs@/.scm} shows the soul of the @q{object},
@example
(Fingering
- . ((print-function . ,Text_interface::print)
- (padding . 0.6)
- (staff-padding . 0.6)
+ . ((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)
- (font-size . -5)
- (meta . ((interfaces . (finger-interface font-interface
- text-script-interface text-interface
- side-position-interface
- self-alignment-interface
- item-interface))))))
+ (stencil . ,ly:text-interface::print)
+ (direction . ,ly:script-interface::calc-direction)
+ (font-encoding . fetaNumber)
+ (font-size . -5) ; don't overlap when next to heads.
+ (meta . ((class . Item)
+ (interfaces . (finger-interface
+ font-interface
+ text-script-interface
+ text-interface
+ side-position-interface
+ self-alignment-interface
+ item-interface))))))
@end example
@noindent
As you can see, the @code{Fingering} object is nothing more than a
-bunch of variable settings, and the webpage in the Program Reference
+bunch of variable settings, and the webpage in the Internals Reference
is directly generated from this definition.
+
@node Determining the grob property
@subsection Determining the grob property
-
-Recall that we wanted to change the position of the @b{2} in
+Recall that we wanted to change the position of the @b{2} in
@lilypond[quote,fragment,relative=2,verbatim]
c-2
Since the @b{2} is vertically positioned next to its note, we have to
meddle with the interface associated with this positioning. This is
-done using @code{side-position-interface}. The page for this interface
+done using @code{side-position-interface}. The page for this interface
says
@quotation
@cindex padding
@noindent
-below this description, the variable @code{padding} is described as
+Below this description, the variable @code{padding} is described as
@quotation
@table @code
@item padding
(dimension, in staff space)
-Add this much extra space between objects that are next to each other.
+Add this much extra space between objects that are next to each other.
@end table
@end quotation
-By increasing the value of @code{padding}, we can move away the
-fingering. The following command inserts 3 staff spaces of white
+By increasing the value of @code{padding}, we can move the
+fingering away from the note head. The following command inserts
+3 staff spaces of white
between the note and the fingering:
@example
\once \override Voice.Fingering #'padding = #3
@end lilypond
-In this case, the context for this tweak is @context{Voice}. This
+In this case, the context for this tweak is @code{Voice}. This
fact can also be deduced from the program reference, for the page for
the @internalsref{Fingering_engraver} plug-in says
@quotation
-Fingering_engraver is part of contexts: @dots{} @b{@internalsref{Voice}}
+Fingering_engraver is part of contexts: @dots{} @internalsref{Voice}
@end quotation
-@node Difficult tweaks
-@subsection Difficult tweaks
-There are a few classes of difficult adjustments.
+@node Objects connected to the input
+@subsection Objects connected to the input
-@itemize @bullet
-First, when there are
-several of the same objects at one point, and you want to adjust only
-one.
+@funindex \tweak
-For example, if you want to change only one note head in a chord.
+In some cases, it is possible to take a short-cut for tuning graphical
+objects. For objects that result directly from a piece of the input,
+you can use the @code{\tweak} function, for example
-In this case, the @code{\applyOutput} function must be used. The
-next example defines a Scheme function @code{set-position-font-size}
-that sets the @code{font-size} property, but only
-on objects that have @internalsref{note-head-interface} and are at the
-right Y-position.
+@lilypond[relative=2,fragment,verbatim,ragged-right]
+<
+ c
+ \tweak #'color #red d
+ g
+ \tweak #'duration-log #1 a
+>4-\tweak #'padding #10 -.
+@end lilypond
-@lilypond[quote,verbatim]
-#(define ((set-position-font-size pos size) grob origin current)
- (let*
- ((meta (ly:grob-property grob 'meta))
- (interfaces (cdr (assoc 'interfaces meta)))
- (position (ly:grob-property grob 'staff-position)))
- (if (and
- ; is this a note head?
- (memq 'note-head-interface interfaces)
+As you can see, properties are set in the objects directly,
+without mentioning the grob name or context where this should be
+applied.
- ; is the Y coordinate right?
- (= pos position))
+This technique only works for objects that are directly connected to
+an @internalsref{Event} from the input, for example
- ; then do it.
- (set! (ly:grob-property grob 'font-size) size))))
+@itemize
+@item note heads, caused by chord-pitch (i.e., notes inside a chord)
+@item articulation signs, caused by articulation instructions
+@end itemize
-\relative {
- c
- \applyOutput #(set-position-font-size -2 4)
- <c e g>
-}
-@end lilypond
+It notably does not work for stems and accidentals (these are caused
+by note heads, not by music events) or clefs (these are not caused by
+music inputs, but rather by the change of a property value).
+
+There are very few objects which are @emph{directly} connected to
+output. A normal note (like @code{c4}) is not directly connected
+to output, so
+
+@example
+\tweak #'color #red c4
+@end example
+
+@noindent
+does not change color. See @ref{Displaying music expressions}, for
+details.
+
+
+@node Using Scheme code instead of \tweak
+@subsection Using Scheme code instead of @code{\tweak}
+
+The main disadvantage of @code{\tweak} is its syntactical
+inflexibility. For example, the following produces a syntax error.
+
+@example
+F = \tweak #'font-size #-3 -\flageolet
+
+\relative c'' @{
+ c4^\F c4_\F
+@}
+@end example
@noindent
-A similar technique can be used for accidentals. In that case, the
-function should check for @code{accidental-interface}.
+With other words, @code{\tweak} doesn't behave like an articulation
+regarding the syntax; in particular, it can't be attached with
+@code{^} and @code{_}.
+
+Using Scheme, this problem can be circumvented. The route to the
+result is given in @ref{Adding articulation to notes (example)},
+especially how to use @code{\displayMusic} as a helping guide.
+
+@example
+F = #(let ((m (make-music 'ArticulationEvent
+ 'articulation-type "flageolet")))
+ (set! (ly:music-property m 'tweaks)
+ (acons 'font-size -3
+ (ly:music-property m 'tweaks)))
+ m)
+
+\relative c'' @{
+ c4^\F c4_\F
+@}
+@end example
+
+@noindent
+Here, the @code{tweaks} properties of the flageolet object
+@code{m} (created with @code{make-music}) are extracted with
+@code{ly:music-property}, a new key-value pair to change the
+font size is prepended to the property list with the
+@code{acons} Scheme function, and the result is finally
+written back with @code{set!}. The last element of the
+@code{let} block is the return value, @code{m} itself.
+
+
+@node \set versus \override
+@subsection @code{\set} vs. @code{\override}
+
+We have seen two methods of changing properties: @code{\set} and
+@code{\override}. There are actually two different kinds of
+properties.
+
+Contexts can have properties, which are usually named in
+@code{studlyCaps}. They mostly control the translation from
+music to notatino, eg. @code{localKeySignature} (for determining
+whether to print accidentals), @code{measurePosition} (for
+determining when to print a bar line). Context properties can
+change value over time while interpreting a piece of music;
+@code{measurePosition} is an obvious example of
+this. Context properties are modified with @code{\set}.
+
+There is a special type of context property: the element
+description. These properties are named in @code{StudlyCaps}
+(starting with capital letters). They contain the
+@q{default settings} for said graphical object as an
+association list. See @file{scm/@/define@/-grobs@/.scm}
+to see what kind of settings there are. Element descriptions
+may be modified with @code{\override}.
+
+@code{\override} is actually a shorthand;
+
+@example
+\override @var{context}.@var{name} #'@var{property} = #@var{value}
+@end example
+
+@noindent
+is more or less equivalent to
+
+@c leave this long line -gp
+@example
+\set @var{context}.@var{name} #'@var{property} = #(cons (cons '@var{property} @var{value}) <previous value of @var{context})
+@end example
+
+The value of @code{context} (the alist) is used to initalize
+the properties of individual grobs. Grobs also have
+properties, named in Scheme style, with
+@code{dashed-words}. The values of grob properties change
+during the formatting process: formatting basically amounts
+to computing properties using callback functions.
+
+@code{fontSize} is a special property: it is equivalent to
+entering @code{\override ... #'font-size} for all pertinent
+objects. Since this is a common change, the special
+property (modified with @code{\set}) was created.
+
+
+@node Difficult tweaks
+@subsection Difficult tweaks
+
+There are a few classes of difficult adjustments.
+
+@itemize
+
@item
-Another difficult adjustment is the appearance of spanner objects,
+One type of difficult adjustment is the appearance of spanner objects,
such as slur and tie. Initially, only one of these objects is created,
and they can be adjusted with the normal mechanism. However, in some
cases the spanners cross line breaks. If this happens, these objects
in. These are clones of the original object and inherit all
properties, including @code{\override}s.
+
In other words, an @code{\override} always affects all pieces of a
broken spanner. To change only one part of a spanner at a line break,
it is necessary to hook into the formatting process. The
-@code{after-line-breaking-callback} property contains the Scheme procedure
-that is called after the line breaks have been determined, and layout
+@code{after-line-breaking} callback contains the Scheme procedure that
+is called after the line breaks have been determined, and layout
objects have been split over different systems.
In the following example, we define a procedure
@code{my-callback}. This procedure
-
-@itemize @bullet
+
+@itemize
@item
determines if we have been split across line breaks
@item
This procedure is installed into @internalsref{Tie}, so the last part
of the broken tie is translated up.
-
-@lilypond[quote,verbatim,raggedright]
+@lilypond[quote,verbatim,ragged-right]
#(define (my-callback grob)
(let* (
- ; have we been split?
+ ; have we been split?
(orig (ly:grob-original grob))
; if yes, get the split pieces (our siblings)
(eq? (car (last-pair siblings)) grob))
(ly:grob-set-property! grob 'extra-offset '(-2 . 5)))))
-\relative c'' {
- \override Tie #'after-line-breaking-callback =
+\relative c'' {
+ \override Tie #'after-line-breaking =
#my-callback
c1 ~ \break c2 ~ c
}
@end lilypond
@noindent
-When applying this trick, the new @code{after-line-breaking-callback}
-should also call the old @code{after-line-breaking-callback}, if there
-is one. For example, if using this with @code{Slur},
-@code{Slur::after_line_breaking} should also be called.
+When applying this trick, the new @code{after-line-breaking} callback
+should also call the old one @code{after-line-breaking}, if there is
+one. For example, if using this with @code{Hairpin},
+@code{ly:hairpin::after-line-breaking} should also be called.
@item Some objects cannot be changed with @code{\override} for
-technical reasons. Examples of those are @code{NonMusicalPaperColumn}
+technical reasons. Examples of those are @code{NonMusicalPaperColumn}
and @code{PaperColumn}. They can be changed with the
-@code{\outputProperty} function, which works similar to @code{\once
-\override}, but uses a different syntax,
+@code{\overrideProperty} function, which works similar to @code{\once
+\override}, but uses a different syntax.
-@example
-\outputProperty
+@example
+\overrideProperty
#"Score.NonMusicalPaperColumn" % Grob name
-#'line-break-system-details % Property name
+#'line-break-system-details % Property name
#'((next-padding . 20)) % Value
@end example
+Note, however, that @code{\override}, applied to
+@code{NoteMusicalPaperColumn} and @code{PaperColumn}, still works as
+expected within @code{\context} blocks.
+
@end itemize
projects / lilypond.git / blobdiff