+\version "2.1.22"
@c Note: -*-texinfo-*-
-@c
+@c This file is part of lilypond.tely
+
@c A menu is needed before every deeper *section nesting of @node's; run
@c M-x texinfo-all-menus-update
@c to automagically fill in these menus before saving changes
* Tablatures::
* Chord names::
* Orchestral music::
-* Ancient notation ::
+* Ancient notation::
* Contemporary notation::
+* Special notation::
* Tuning output::
+* Text markup::
* Global layout::
* Sound::
@end menu
* Stems::
* Ties::
* Tuplets::
-* Easy Notation note heads ::
@end menu
@code{as}, but both forms are accepted. Similarly, both
@code{es} and @code{ees} are accepted.
+Half-flats and half-sharps are formed by adding @code{-eh} and
+@code{-ih}; the following is a series of Cs with increasing pitches:
+
+@cindex quarter tones
+@cindex semi-flats, semi-sharps
+
+@lilypond[verbatim,relative=2]
+ ceses4
+ ceseh
+ ces
+ ceh
+ c
+ cih
+ cis
+ cisih
+ cisis
+@end lilypond
+
There are predefined sets of note names for various other languages.
To use them, include the language specific init file. For
example: @code{\include "english.ly"}. The available language files
@seealso
-@noindent
-
-bla
-
-@internalsref{NoteEvent}, and @internalsref{NoteHead}.
+Internals: @internalsref{NoteEvent}, and @internalsref{NoteHead}.
@node Chromatic alterations
@subsection Chromatic alterations
after the pitch. A cautionary accidental
@cindex cautionary accidental
@cindex parenthesized accidental
-(an accidental within parentheses) can be obtained by adding the
+(i.e. an accidental within parentheses) can be obtained by adding the
question mark `@code{?}' after the pitch:
@lilypond[fragment,verbatim]
articulations, just like simple notes.
-@node Rests
+@node Rests
@subsection Rests
@cindex Rests
Rests are entered like notes, with the note name @code{r}:
-@lilypond[singleline,verbatim]
+@lilypond[raggedright,verbatim]
r1 r2 r4 r8
@end lilypond
formatting in polyphonic music easier. Rest collision testing will
leave these rests alone:
-@lilypond[singleline,verbatim]
+@lilypond[raggedright,verbatim]
a'4\rest d'4\rest
@end lilypond
@seealso
-@internalsref{RestEvent}, and @internalsref{Rest}.
+Internals: @internalsref{RestEvent}, and @internalsref{Rest}.
@c FIXME: naming.
An invisible rest (also called a `skip') can be entered like a note
with note name `@code{s}' or with @code{\skip @var{duration}}:
-@lilypond[singleline,verbatim]
+@lilypond[raggedright,verbatim]
a2 s4 a4 \skip 1 a4
@end lilypond
-The @code{s} syntax is only available in Note mode and Chord mode. In
+The @code{s} syntax is only available in note mode and chord mode. In
other situations, you should use the @code{\skip} command:
-@lilypond[singleline,verbatim]
+@lilypond[raggedright,verbatim]
\score {
\new Staff <<
{ \time 4/8 \skip 2 \time 4/4 }
The skip command is merely an empty musical placeholder. It does not
produce any output, not even transparent output.
+The @code{s} skip command does create @internalsref{Staff} and
+@internalsref{Voice} when necessary, similar to note and rest
+commands. For example, the following results in an empty staff.
+
+@lilypond[raggedright,verbatim]
+\score { \notes { s4 } }
+@end lilypond
+
+The same fragment using @code{\skip} results in an empty page.
+
@seealso
-@internalsref{SkipEvent}.
+Internals: @internalsref{SkipEvent}, @internalsref{SkipMusic}.
a half note is entered using a @code{2} (since it is a 1/2 note). For notes
longer than a whole you must use variables:
-@c FIXME: what is an identifier? I do not think it's been introduced yet.
-@c and if it has, I obviously skipped that part. - Graham
-
@example
c'\breve
c'1 c'2 c'4 c'8 c'16 c'32 c'64 c'64
\translator {
\StaffContext
\remove "Clef_engraver"
- \remove "Staff_symbol_engraver"
- \remove "Time_signature_engraver"
+ StaffSymbol \set #'transparent = ##t
+ TimeSignature \set #'transparent = ##t
\consists "Pitch_squash_engraver"
}
}
will not affect the appearance of the notes or rests produced.
In the following example, the first three notes take up exactly two
beats:
-@lilypond[fragment,relative 2,verbatim]
+@lilypond[fragment,relative=2,verbatim]
\time 2/4
a4*2/3 gis4*2/3 a4*2/3
a4
@seealso
-@internalsref{Dots}, and @internalsref{DotColumn}.
-
-@refbugs
-
-In dense chords, dots can overlap.
+Internals: @internalsref{Dots}, and @internalsref{DotColumn}.
@node Stems
@subsection Stems
to the augmentation dot; in the following example there are two ways of
notating exactly the same concept:
@c
-@lilypond[fragment, singleline,quote]
+@lilypond[fragment,raggedright,quote]
\time 3/4 c'2. c'2 ~ c'4
@end lilypond
If you need to tie a lot of notes over bars, it may be easier to use automatic
-note splitting (See @ref{Automatic note splitting}).
+note splitting (see @ref{Automatic note splitting}).
@refcommands
@seealso
-@internalsref{TieEvent}, @internalsref{NewTieEvent},
-@internalsref{Tie}, and @ref{Automatic note splitting}.
+In this manual: @ref{Automatic note splitting}.
-If you want less
-ties created for a chord, see @inputfileref{input/test,tie-sparse.ly}.
+Internals: @internalsref{TieEvent}, @internalsref{NewTieEvent},
+@internalsref{Tie}
-@refbugs
+Examples: if you want less ties created for a chord, see
+@inputfileref{input/test,tie-sparse.ly}.
-Tieing only a subset of the note heads of a pair of chords is not
-supported in a simple way.
+For tying only a subset of the note heads of a pair of chords, see
+@inputfileref{input/regression,tie-chord-partial.ly}.
+
+@refbugs
-@ignore
-It can be achieved by moving the
-tie-engraver into the @internalsref{Thread} context and turning on and
-off ties per @internalsref{Thread}.
-@end ignore
Switching staves when a tie is active will not produce a slanted tie.
example, there are two triplets shown, while @code{\times} was only
used once:
-@lilypond[fragment, relative, singleline, verbatim]
-\property Voice.tupletSpannerDuration = #(ly:make-moment 1 4)
+@lilypond[fragment,relative,raggedright,verbatim]
+\set tupletSpannerDuration = #(ly:make-moment 1 4)
\times 2/3 { c'8 c c c c c }
@end lilypond
@seealso
-@internalsref{TupletBracket}, and @internalsref{TimeScaledMusic}.
+Internals: @internalsref{TupletBracket}, and @internalsref{TimeScaledMusic}.
+
+Examples: @inputfileref{input/regression,tuplet-nest.ly}.
@refbugs
Nested tuplets are not formatted automatically. In this case, outer
-tuplet brackets should be moved manually.
-
-@node Easy Notation note heads
-@subsection Easy Notation note heads
-
-@cindex easy notation
-@cindex Hal Leonard
-
-The `easy play' note head includes a note name inside the head. It is
-used in music aimed at beginners:
-
-@lilypond[singleline,verbatim,26pt]
-\score {
- \notes { c'2 e'4 f' | g'1 }
- \paper { \translator { \EasyNotation } }
-}
-@end lilypond
-
-The @code{EasyNotation} variable overrides a @internalsref{Score} context.
-You probably will want to print it with magnification or a
-large font size to make it more readable. To print with
-magnification, you must create a DVI file (with @file{lilypond}) and
-then enlarge it with something like @file{dvips -x 2000 file.dvi}.
-See the @code{dvips} documentation for more details. To print with a
-larger font, see @ref{Font Size}.
+tuplet brackets should be moved manually, which is demonstrated in
+@inputfileref{input/regression,tuplet-nest.ly}.
-@cindex Xdvi
-@cindex ghostscript
-
-If you view the result with Xdvi, then staff lines will show through
-the letters. Printing the PostScript file obtained does produce the
-correct result.
-
@node Easier music entry
@section Easier music entry
* Octave check::
* Bar check::
* Skipping corrected music::
-* Automatic note splitting ::
+* Automatic note splitting::
@end menu
predecessor of the first note of @var{musicexpr}.
Here is the relative mode shown in action:
-@lilypond[fragment,singleline,verbatim,center]
+@lilypond[fragment,raggedright,verbatim,center]
\relative c'' {
b c d c b c bes a
}
@subsection Octave check
-Octave checks make octave errors easier to correct.
-The syntax is
+Octave checks make octave errors easier to correct: a note may be
+followed by @code{=}@var{quotes} which indicates what its absolute
+octave should be. In the following example,
+@example
+ \relative c'' @{ c='' b=' d,='' @}
+@end example
+
+@noindent
+@c take care with @code, adds confusing quotes.
+the d will generate a warning, because a d'' is expected, but a d' is
+found. In the output, the octave is corrected this and the following
+notes.
+
+
+
+There is also a syntax that is separate from the notes.
@example
\octave @var{pitch}
@end example
}
@end lilypond
-
-
@node Bar check
@subsection Bar check
@cindex Bar check
\time 3/4 c2 e4 | g2 |
@end example
+Bar checks can also be used in lyrics, for example
+
+@example
+ \lyrics @{
+ \time 2/4
+ Twin -- kle | Twin -- kle
+ @}
+@end example
@cindex skipTypesetting
This can be used to skip over the parts of a score that have already
been checked for errors:
-@lilypond[fragment,singleline,verbatim]
+@lilypond[fragment,raggedright,verbatim]
\relative c'' { c8 d
-\property Score.skipTypesetting = ##t
+\set Score.skipTypesetting = ##t
e f g a g c, f e d
-\property Score.skipTypesetting = ##f
+\set Score.skipTypesetting = ##f
c d b bes a g c2 }
@end lilypond
-@node Automatic note splitting
+@node Automatic note splitting
@subsection Automatic note splitting
Long notes can be converted automatically to tied notes. This is done
by replacing the @internalsref{Note_heads_engraver} by the
-@internalsref{Completion_heads_engraver}:
+@internalsref{Completion_heads_engraver}.
+In the following examples, notes crossing the barline are split and tied.
-@example
- \paper @{ \translator @{
- \ThreadContext
- \remove "Note_heads_engraver"
- \consists "Completion_heads_engraver"
- @} @}
-@end example
-
-which will make long notes tied in the following example:
-@example
- \time 2/4
- c2. c8 d4 e f g a b c8 c2 b4 a g16 f4 e d c8. c2
-@end example
-@lilypond[noindent]
-\score{
- \notes\relative c'{
- \time 2/4
- c2. c8 d4 e f g a b c8 c2 b4 a g16 f4 e d c8. c2
- }
- \paper { \translator {
- \ThreadContext
+@lilypond[noindent,verbatim,relative=1]
+\new Voice \with {
\remove "Note_heads_engraver"
\consists "Completion_heads_engraver"
- } }
- }
+} {
+ c2. c8 d4 e f g a b c8 c2 b4 a g16 f4 e d c8. c2
+}
@end lilypond
This engraver splits all running notes at the bar line, and inserts
Not all durations (especially those containing tuplets) can be
represented exactly; the engraver will not insert tuplets.
+@seealso
+
+Examples: @inputfileref{input/regression,completion-heads.ly}.
+Internals: @internalsref{Completion_heads_engraver}.
@node Staff notation
@cindex thickness of staff lines, setting
@cindex number of staff lines, setting
-This object is created whenever a @internalsref{Staff} context is
-created. The appearance of the staff symbol cannot be changed by
-using @code{\override} or @code{\set}. At the moment that
-@code{\property Staff} is interpreted, a @internalsref{Staff} context
-is made, and the @internalsref{StaffSymbol} is created before any
-@code{\override} is effective. Properties can be changed in a
-@code{\translator} definition, or by using @code{\outputproperty}.
+@seealso
+
+Internals: @internalsref{StaffSymbol}.
+
+Examples: @inputfileref{input/test,staff-lines.ly},
+@inputfileref{input/test,staff-size.ly}.
@refbugs
@seealso
-@internalsref{KeyChangeEvent}, and @internalsref{KeySignature}.
+Internals: @internalsref{KeyChangeEvent}, and @internalsref{KeySignature}.
@cindex @code{keySignature}
@seealso
-The object for this symbol is @internalsref{Clef}.
+Internals: the object for this symbol is @internalsref{Clef}.
a b }
@end lilypond
-Internally the @code{set-octavation} function sets the properties
+The @code{set-octavation} function also takes -1 (for 8va bassa) and 2
+(for 15ma) as arguments. Internally the function sets the properties
@code{ottavation} (eg. to @code{"8va"}) and
-@code{centralCPosition}. The function also takes arguments -1 (for 8va
-bassa) and 2 (for 15ma).
+@code{centralCPosition}. For overriding the text of the bracket, set
+@code{ottavation} after invoking @code{set-octavation}, i.e.,
+
+@example
+ #(set-octavation 1)
+ \set Staff.ottavation = #"8"
+@end example
-@internalsref{OttavaSpanner}.
+@seealso
+
+Internals: @internalsref{OttavaBracket}.
+
+Examples: @inputfileref{input/regression,ottava.ly},
+@inputfileref{input/regression,ottava-broken.ly}.
@refbugs
@seealso
-@internalsref{TimeSignature}, and @internalsref{Timing_engraver}.
+Internals: @internalsref{TimeSignature}, and @internalsref{Timing_engraver}.
@refbugs
Partial measures, for example in upsteps, are entered using the
@code{\partial} command:
-@lilypond[fragment,verbatim,relative 1]
+@lilypond[fragment,verbatim,relative=1]
\partial 16*5 c16 cis d dis e | a2. c,4 | b2
@end lilypond
@end example
This is internally translated into
@example
- \property Timing.measurePosition = -@var{length of duration}
+ \set Timing.measurePosition = -@var{length of duration}
@end example
@cindex @code{|}
The property @code{measurePosition} contains a rational number
@end lilypond
The following bar types are available:
-@lilypond[fragment, relative, singleline, verbatim]
+@lilypond[fragment,relative,raggedright,verbatim]
c4
\bar "|" c
\bar "" c
\bar ":|" c
\bar ".|" c
\bar ".|." c
-\bar "|."
+\bar ":|:" c
+\bar "|." c
+\bar ":" c
@end lilypond
For allowing linebreaks, there is a special command,
@example
automatically applied to all staves. The resulting bar lines are
connected between different staves of a @internalsref{StaffGroup}:
@c
-@lilypond[fragment, verbatim]
+@lilypond[fragment,verbatim]
<< \context StaffGroup <<
\new Staff { e'4 d'
\bar "||"
The command @code{\bar @var{bartype}} is a short cut for doing
-@code{\property Score.whichBar = @var{bartype}} Whenever
+@code{\set Score.whichBar = @var{bartype}} Whenever
@code{whichBar} is set to a string, a bar line of that type is
created. At the start of a measure it is set to
@code{defaultBarType}. The contents of @code{repeatCommands} are used
@seealso
-@ref{Repeats}.
+In this manual: @ref{Repeats}.
-The bar line objects that are created at @internalsref{Staff} level
-are called @internalsref{BarLine}, the bar lines that span staves are
-@internalsref{SpanBar}s.
+Internals: the bar line objects that are created at
+@internalsref{Staff} level are called @internalsref{BarLine}, the bar
+lines that span staves are @internalsref{SpanBar}s.
@cindex bar lines at start of system
@cindex start of system
The barlines at the start of each system are
@internalsref{SystemStartBar}, @internalsref{SystemStartBrace}, and
-@internalsref{SystemStartBracket}. They are spanner objects and
-typically must be tuned from a @code{\translator} block.
+@internalsref{SystemStartBracket}. Only one of these types is created
+in every context, and that type is determined by the property
+@code{systemStartDelimiter}.
+Examples: @inputfileref{input/test,bar-lines.ly},
@node Polyphony
@section Polyphony
}
@end lilypond
-The separator causes @internalsref{Voice} contexts to be
-instantiated. They
-bear the names @code{"1"}, @code{"2"}, etc. In each of these
-contexts, vertical direction of slurs, stems, etc. is set
+The separator causes @internalsref{Voice} contexts@footnote{Polyphonic
+voices are sometimes called "layers" other notation packages}
+@cindex layers
+to be instantiated. They bear the names @code{"1"}, @code{"2"}, etc. In
+each of these contexts, vertical direction of slurs, stems, etc. is set
appropriately.
+@cindex @code{\voiceOne}
+@cindex @code{\voiceFour}
+
This can also be done by instantiating @internalsref{Voice} contexts
by hand, and using @code{\voiceOne}, up to @code{\voiceFour} to assign
a stem directions and horizontal shift for each part:
@c
-@lilypond[singleline, verbatim]
+@lilypond[raggedright,verbatim]
\relative c''
\context Staff << \new Voice { \voiceOne cis2 b }
\new Voice { \voiceThree b4 ais ~ ais4 gis4 }
\new Voice { \voiceTwo fis4~ fis4 f ~ f } >>
@end lilypond
+@noindent
+The command @code{\oneVoice} will revert back to the normal setting.
+@cindex @code{\oneVoice}
+
+
Normally, note heads with a different number of dots are not merged, but
when the object property @code{merge-differently-dotted} is set in
the @internalsref{NoteCollision} object, they are merged:
-@lilypond[verbatim,fragment,singleline]
+@lilypond[verbatim,fragment,raggedright]
\relative c'' \context Voice << {
g8 g8
- \property Staff.NoteCollision \override
+ \override Staff.NoteCollision
#'merge-differently-dotted = ##t
g8 g8
} \\ { g8.[ f16] g8.[ f16] }
Similarly, you can merge half note heads with eighth notes, by setting
@code{merge-differently-headed}:
-@lilypond[fragment, relative=2,verbatim]
+@lilypond[fragment,relative=2,verbatim]
\context Voice << {
c8 c4.
- \property Staff.NoteCollision
- \override #'merge-differently-headed = ##t
+ \override Staff.NoteCollision
+ #'merge-differently-headed = ##t
c8 c4. } \\ { c2 c2 } >>
@end lilypond
LilyPond also vertically shifts rests that are opposite of a stem:
-@lilypond[singleline,fragment,verbatim]
+@lilypond[raggedright,fragment,verbatim]
\context Voice << c''4 \\ r4 >>
@end lilypond
@cindex @code{\voiceFour}
@code{\voiceFour}.
+
The following commands specify in what chords of the current voice
should be shifted: the outer voice has @code{\shiftOff}, and the inner
voices have @code{\shiftOn}, @code{\shiftOnn}, etc.
@seealso
-The objects responsible for resolving collisions are
-@internalsref{NoteCollision} and @internalsref{RestCollision}. See
-also example files @inputfileref{input/regression,collision-dots.ly},
+Internals: the objects responsible for resolving collisions are
+@internalsref{NoteCollision} and @internalsref{RestCollision}.
+
+Examples: See also example files
+@inputfileref{input/regression,collision-dots.ly},
@inputfileref{input/regression,collision-head-chords.ly},
@inputfileref{input/regression,collision-heads.ly},
@inputfileref{input/regression,collision-mesh.ly}, and
When using @code{merge-differently-headed} with an upstem 8th or a shorter
note, and a downstem half note, the 8th note gets the wrong offset.
+There is no support for clusters where the same note occurs with
+different accidentals in the same chord. In this case, it is
+recommended to use enharmonic transcription, or to use special cluster
+notation (see @ref{Clusters}).
+
@node Beaming
@section Beaming
Beams are used to group short notes into chunks that are aligned with
the metrum. They are inserted automatically in most cases:
-@lilypond[fragment,verbatim, relative=2]
+@lilypond[fragment,verbatim,relative=2]
\time 2/4 c8 c c c \time 6/8 c c c c8. c16 c8
@end lilypond
@seealso
-@internalsref{Beam}.
+Internals: @internalsref{Beam}.
@cindex Automatic beams
+@menu
+* Manual beams::
+* Setting automatic beam behavior::
+@end menu
+
+@node Manual beams
@subsection Manual beams
@cindex beams, manual
@cindex @code{]}
Normally, beaming patterns within a beam are determined automatically.
When this mechanism fouls up, the properties
-@code{Voice.stemLeftBeamCount} and @code{Voice.stemRightBeamCount} can
+@code{stemLeftBeamCount} and @code{stemRightBeamCount} can
be used to control the beam subdivision on a stem. If either property
is set, its value will be used only once, and then it is erased.
@lilypond[fragment,relative,verbatim]
\context Staff {
f8[ r16 f g a]
- f8[ r16 \property Voice.stemLeftBeamCount = #1 f g a]
+ f8[ r16 \set stemLeftBeamCount = #1 f g a]
}
@end lilypond
@cindex @code{stemRightBeamCount}
@lilypond[relative=1,verbatim,noindent]
c16[ c c c c c c c]
- \property Voice.subdivideBeams = ##t
+ \set subdivideBeams = ##t
c16[ c c c c c c c]
- \property Score.beatLength = #(ly:make-moment 1 8)
+ \set Score.beatLength = #(ly:make-moment 1 8)
c16[ c c c c c c c]
@end lilypond
@cindex subdivideBeams
-@menu
-* Setting automatic beam behavior ::
-@end menu
-
-@ignore
-@no de Beam typography
-@sub section Beam typography
-
-One of the strong points of LilyPond is how beams are formatted. Beams
-are quantized, meaning that the left and right endpoints beams start
-exactly on staff lines. Without quantization, small wedges of white
-space appear between the beam and staff line, and this looks untidy.
-Beams are also slope-damped: melodies that go up or down should also
-have beams that go up or down, but the slope of the beams should be
-less than the slope of the notes themselves.
-
-Some beams should be horizontal. These are so-called concave beams.
-
-[TODO: some pictures.]
-@end ignore
-
-
-@node Setting automatic beam behavior
+@node Setting automatic beam behavior
@subsection Setting automatic beam behavior
@cindex @code{autoBeamSettings}
In normal time signatures, automatic beams can start on any note but can
only end in a few positions within the measure: beams can end on a beat,
or at durations specified by the properties in
-@code{Voice.autoBeamSettings}. The defaults for @code{autoBeamSettings}
+@code{autoBeamSettings}. The defaults for @code{autoBeamSettings}
are defined in @file{scm/auto-beam.scm}.
The value of @code{autoBeamSettings} is changed using
@code{\override} and restored with @code{\revert}:
@example
-\property Voice.autoBeamSettings \override #'(@var{BE} @var{P} @var{Q} @var{N} @var{M}) = @var{dur}
-\property Voice.autoBeamSettings \revert #'(@var{BE} @var{P} @var{Q} @var{N} @var{M})
+\override autoBeamSettings #'(@var{BE} @var{P} @var{Q} @var{N} @var{M}) = @var{dur}
+\property autoBeamSettings \revert #'(@var{BE} @var{P} @var{Q} @var{N} @var{M})
@end example
Here, @var{BE} is the symbol @code{begin} or @code{end}. It determines
whether the rule applies to begin or end-points. The quantity
@var{P}/@var{Q} refers to the length of the beamed notes (and `@code{*
*}' designates notes of any length), @var{N}/@var{M} refers to a time
-signature (wildcards, `@code{* *}' may be entered to designate all time
+signature (wildcards `@code{* *}' may be entered to designate all time
signatures).
For example, if automatic beams should end on every quarter note, use
the following:
@example
-\property Voice.autoBeamSettings \override
+\override autoBeamSettings
#'(end * * * *) = #(ly:make-moment 1 4)
@end example
Since the duration of a quarter note is 1/4 of a whole note, it is
The same syntax can be used to specify beam starting points. In this
example, automatic beams can only end on a dotted quarter note:
@example
-\property Voice.autoBeamSettings \override
+\override autoBeamSettings
#'(end * * * *) = #(ly:make-moment 3 8)
@end example
In 4/4 time signature, this means that automatic beams could end only on
3/8 and on the fourth beat of the measure (after 3/4, that is 2 times
-3/8 has passed within the measure).
+3/8, has passed within the measure).
Rules can also be restricted to specific time signatures. A rule that
should only be applied in @var{N}/@var{M} time signature is formed by
replacing the second asterisks by @var{N} and @var{M}. For example, a
rule for 6/8 time exclusively looks like
@example
-\property Voice.autoBeamSettings \override
+\override autoBeamSettings
#'(begin * * 6 8) = ...
@end example
@cindex automatic beam generation
@cindex autobeam
-@cindex @code{Voice.autoBeaming}
+@cindex @code{autoBeaming}
@cindex lyrics
For melodies that have lyrics, you may want to switch off
-automatic beaming. This is done by setting @code{Voice.autoBeaming} to
+automatic beaming. This is done by setting @code{autoBeaming} to
@code{#f}.
@refcommands
end at 3 eights; the third beam can only be corrected by specifying
manual beaming.
-@lilypond[singleline,fragment,relative,noverbatim,quote]
- \property Voice.autoBeamSettings
- \override #'(end * * * *) = #(ly:make-moment 3 8)
+@lilypond[raggedright,fragment,relative,noverbatim,quote]
+ \override autoBeamSettings
+ #'(end * * * *) = #(ly:make-moment 3 8)
% rather show case where it goes wrong
%\time 12/8 c'8 c c c16 c c c c c c[ c c c] c8[ c] c4
\time 12/8 c'8 c c c16 c c c c c c c c c c8 c c4
>>
@}
@end example
-@lilypond[singleline]
+@lilypond[raggedright]
\score {
\notes \relative c'' <<
\new Staff { cis4 d e2 }
This leads to some weird and often unwanted results
because accidentals from one voice do not get cancelled in other
voices:
-@lilypond[singleline,relative,fragment,verbatim,quote]
+@lilypond[raggedright,relative,fragment,verbatim,quote]
\context Staff <<
\voiceAccidentals
<<
You get all the same accidentals, but temporary
accidentals also get cancelled in other octaves. Furthermore,
in the same octave, they also get cancelled in the following measure:
-@lilypond[singleline,fragment,verbatim]
+@lilypond[raggedright,fragment,verbatim]
\modernAccidentals
cis' c'' cis'2 | c'' c'
@end lilypond
``extra'' accidentals (the ones not typeset by
@code{\defaultAccidentals}) are typeset as cautionary accidentals.
They are printed in reduced size or with parentheses:
-@lilypond[singleline,fragment,verbatim]
+@lilypond[raggedright,fragment,verbatim]
\modernCautionaries
cis' c'' cis'2 | c'' c'
@end lilypond
@cindex @code{\noResetKey}
Same as @code{\defaultAccidentals} but with accidentals lasting
``forever'' and not only until the next measure:
-@lilypond[singleline,fragment,verbatim,relative]
+@lilypond[raggedright,fragment,verbatim,relative]
\noResetKey
c1 cis cis c
@end lilypond
are not remembered at all---and hence all accidentals are
typeset relative to the key signature, regardless of what was
before in the music:
-@lilypond[singleline,fragment,verbatim,relative]
+@lilypond[raggedright,fragment,verbatim,relative]
\forgetAccidentals
\key d\major c4 c cis cis d d dis dis
@end lilypond
@var{context} is @internalsref{Score} then all staves share
accidentals, and if @var{context} is @internalsref{Staff} then all
voices in the same staff share accidentals, but staves do not.
+
@item octavation:
Whether the accidental changes all octaves or only the current
- octave.
-@item lazyness:
- Over how many barlines the accidental lasts.
- If @var{lazyness} is @code{-1} then the accidental is forget
- immediately, and if @var{lazyness} is @code{#t} then the accidental
- lasts forever.
-
-@c [TODO: should use +infinity for this case?]
-
+ octave. Valid choices are
+
+ @table @samp
+ @item same-octave:
+ This is the default algorithm. Accidentals are typeset if the note changes
+ the accidental of that note in that octave. Accidentals lasts to the end of the measure
+ and then as many measures as specified in the value. I.e. 1 means to the end
+ of next measure, -1 means to the end of previous measure (that is: no duration at all), etc. #t means forever.
+ @item any-octave:
+ Accidentals are typeset if the note is different from
+ the previous note on the same pitch in any octave. The value has same meaning as in
+ same-octave.
+ @end table
+
+@item lazyness
+
+ Over how many barlines the accidental lasts.
+ If @var{lazyness} is @code{-1} then the accidental is forget
+ immediately, and if @var{lazyness} is @code{#t} then the accidental
+ lasts forever.
@end table
+
@refcommands
@cindex @code{\defaultAccidentals}
@seealso
-@internalsref{Accidental_engraver}, @internalsref{Accidental}, and
-@internalsref{AccidentalPlacement}.
+Internals: @internalsref{Accidental_engraver},
+@internalsref{Accidental}, and @internalsref{AccidentalPlacement}.
@refbugs
accidentals depending on the order in which the notes occur in the
input file:
-@lilypond[singleline,fragment,verbatim]
-\property Staff.autoAccidentals = #'( Staff (any-octave . 0) )
+@lilypond[raggedright,fragment,verbatim]
+\set Staff.autoAccidentals = #'( Staff (any-octave . 0) )
cis'4 <c'' c'> r2 | cis'4 <c' c''> r2
| <cis' c''> r | <c'' cis'> r |
@end lilypond
@c fingering?
@menu
-* Slurs ::
+* Slurs::
* Phrasing slurs::
* Breath marks::
* Metronome marks::
* Fingering instructions::
* Text scripts::
* Grace notes::
-* Glissando ::
+* Glissando::
* Dynamics::
@end menu
-@node Slurs
+@node Slurs
@subsection Slurs
@cindex Slurs
@syntax
They are entered using parentheses:
-@lilypond[relative 1,fragment,verbatim,center]
+@lilypond[relative=1,fragment,verbatim,center]
f( g)( a) a8 b( a4 g2 f4)
<c e>2( <b d>2)
@end lilypond
@lilypond[fragment,relative,verbatim]
\slurUp
- \property Voice.Stem \set #'length = #5.5
+ \override Stem #'length = #5.5
g'8(g g4)
- \property Voice.Slur \set #'attachment = #'(stem . stem)
+ \override Slur #'attachment = #'(stem . stem)
g8( g g4)
@end lilypond
@lilypond[fragment,relative,verbatim]
\stemUp \slurUp
d32( d'4 d8..)
- \property Voice.Slur \set #'attachment = #'(stem . stem)
+ \override Slur #'attachment = #'(stem . stem)
d,32( d'4 d8..)
@end lilypond
@seealso
-@seeinternals{Slur}, and @internalsref{SlurEvent}.
+Internals: @seeinternals{Slur}, and @internalsref{SlurEvent}.
@refbugs
@seealso
-See also @internalsref{PhrasingSlur}, and
+Internals: see also @internalsref{PhrasingSlur}, and
@internalsref{PhrasingSlurEvent}.
@refbugs
any markup text. For example,
@lilypond[fragment,verbatim,relative]
c'4
-\property Voice.BreathingSign \override #'text
+\override BreathingSign #'text
= #(make-musicglyph-markup "scripts-rvarcomma")
\breathe
d4
@seealso
-@internalsref{BreathingSign}, @internalsref{BreathingSignEvent}, and
-@inputfileref{input/regression,breathing-sign.ly}.
+Internals: @internalsref{BreathingSign},
+@internalsref{BreathingSignEvent}.
+
+Examples: @inputfileref{input/regression,breathing-sign.ly}.
@node Metronome marks
@seealso
-@internalsref{MetronomeChangeEvent}.
+Internals: @internalsref{MetronomeChangeEvent}.
@lilypond[fragment,relative,verbatim]
\relative c' { c1
- \property Voice.TextSpanner \set #'direction = #-1
- \property Voice.TextSpanner \set #'edge-text = #'("rall " . "")
+ \override TextSpanner #'direction = #-1
+ \override TextSpanner #'edge-text = #'("rall " . "")
c2\startTextSpan b c\stopTextSpan a }
@end lilypond
@seealso
-@internalsref{TextSpanEvent},
-@internalsref{TextSpanner}, and
-@inputfileref{input/regression,text-spanner.ly}.
+Internals @internalsref{TextSpanEvent},
+@internalsref{TextSpanner}.
+
+Examples: @inputfileref{input/regression,text-spanner.ly}.
@node Analysis brackets
@internalsref{Staff} context. A bracket is started with
@code{\startGroup} and closed with @code{\stopGroup}:
-@lilypond[singleline,verbatim]
+@lilypond[raggedright,verbatim]
\score { \notes \relative c'' {
c4\startGroup\startGroup
c4\stopGroup
@seealso
-@internalsref{HorizontalBracket}, @internalsref{NoteGroupingEvent}, and
-@inputfileref{input/regression,note-group-bracket.ly}.
+Internals: @internalsref{HorizontalBracket},
+@internalsref{NoteGroupingEvent}.
+
+Examples: @inputfileref{input/regression,note-group-bracket.ly}.
@node Articulations
by adding a dash and the character signifying the
articulation. They are demonstrated here:
-@lilypondfile[notexidoc]{script-abbreviations.ly}
+@lilypondfile[]{script-abbreviations.ly}
The meanings of these shorthands can be changed: see
@file{ly/script-init.ly} for examples.
The script is automatically placed, but if you need to force
directions, you can use @code{_} to force them down, or @code{^} to
put them up:
-@lilypond[fragment, verbatim]
+@lilypond[fragment,verbatim]
c''4^^ c''4_^
@end lilypond
can be forced up or down using @code{^} and @code{_},
eg.
-@lilypond[verbatim,fragment,relative 2]
+@lilypond[verbatim,fragment,relative=2]
c\fermata c^\fermata c_\fermata
@end lilypond
@cindex coda
@cindex varcoda
-@lilypondfile[notexidoc]{script-chart.ly}
+@lilypondfile[]{script-chart.ly}
@refcommands
@seealso
-@internalsref{ScriptEvent}, and @internalsref{Script}.
+Internals: @internalsref{ScriptEvent}, and @internalsref{Script}.
@refbugs
- These note ornaments appear in the printed output but have no
+These note ornaments appear in the printed output but have no
effect on the MIDI rendering of the music.
@end example
For finger changes, use markup texts:
@c
-@lilypond[verbatim, singleline, fragment]
+@lilypond[verbatim,raggedright,fragment]
c'4-1 c'4-2 c'4-3 c'4-4
c'^\markup { \fontsize #-3 \number "2-3" }
@end lilypond
@cindex subscript
You can use the thumb-script to indicate that a note should be
-played with your thumb (used in cello music):
+played with the thumb (e.g. in cello music):
-@lilypond[verbatim, singleline, fragment]
+@lilypond[verbatim,raggedright,fragment]
<a' a''-3>8(_\thumb <b' b''-3>)_\thumb
<c'' c'''-3>(_\thumb <d'' d'''-3>)_\thumb
@end lilypond
Fingerings for chords can also be added to individual notes
of the chord by adding them after the pitches:
-@lilypond[verbatim,singleline,fragment,relative=1]
+@lilypond[verbatim,raggedright,fragment,relative=1]
< c-1 e-2 g-3 b-5 > 4
@end lilypond
-Setting @code{fingeringOrientations} will put fingerings next
+@noindent
+In this case, setting @code{fingeringOrientations} will put fingerings next
to note heads:
-@lilypond[verbatim,singleline,fragment,relative=1]
- \property Voice.fingeringOrientations = #'(left down)
+@lilypond[verbatim,raggedright,fragment,relative=1]
+ \set fingeringOrientations = #'(left down)
<c-1 es-2 g-4 bes-5 > 4
- \property Voice.fingeringOrientations = #'(up right down)
+ \set fingeringOrientations = #'(up right down)
<c-1 es-2 g-4 bes-5 > 4
@end lilypond
+
+By using single note chords, fingering instructions can be put close
+to note heads in monophonic music.
@seealso
-@internalsref{FingerEvent}, and @internalsref{Fingering}.
+Internals: @internalsref{FingerEvent}, and @internalsref{Fingering}.
+Examples: @inputfileref{input/regression,finger-chords.ly}.
@node Text scripts
@subsection Text scripts
@cindex Text scripts
+@cindex text items, non-empty
+@cindex non-empty texts
+
It is possible to place arbitrary strings of text or markup text (see
@ref{Text markup}) above or below notes by using a string:
@code{c^"text"}. By default, these indications do not influence the
note spacing, but by using the command @code{\fatText}, the widths
will be taken into account:
@c
-@lilypond[fragment,singleline,verbatim] \relative c' {
+@lilypond[fragment,raggedright,verbatim] \relative c' {
c4^"longtext" \fatText c4_"longlongtext" c4 }
@end lilypond
be avoided because the exact dimensions of the string can then no
longer be computed.
+@refcommands
+
+@refcommand{fatText}, @refcommand{emptyText}.
+
@seealso
-@internalsref{TextScriptEvent}, @internalsref{TextScript}, and
-@ref{Text markup}.
+In this manual: @ref{Text markup}.
+
+Internals: @internalsref{TextScriptEvent}, @internalsref{TextScript}.
+
denotes the logical time, one denotes the grace timing. The above
example is shown here with timing tuples:
-@lilypond[singleline]
+@lilypond[raggedright]
<<
\relative c''{
c4 \grace c16 c4 \grace {
If you want to end a note with a grace, then the standard trick
is to put the grace notes after a ``space note'', e.g.
-@lilypond[fragment,verbatim, relative=2]
+@lilypond[fragment,verbatim,relative=2]
\context Voice {
<< { d1^\trill ( }
{ s2 \grace { c16[ d] } } >>
for example, to produce smaller type, and set directions. Hence, when
introducing layout tweaks, they should be inside the grace section,
for example,
-@lilypond[fragment,verbatim,relative 1]
+@lilypond[fragment,verbatim,relative=1]
\new Voice {
\acciaccatura {
- \property Voice.Stem \override #'direction = #-1
+ \override Stem #'direction = #-1
f16->
- \property Voice.Stem \revert #'direction
+ \revert Stem #'direction
}
g4
}
Another option is to change the variables @code{startGraceMusic},
@code{stopGraceMusic}, @code{startAccacciaturaMusic},
@code{stopAccacciaturaMusic}, @code{startAppoggiaturaMusic},
-@code{stopAppoggiaturaMstuic}. More information is in the file
+@code{stopAppoggiaturaMusic}. More information is in the file
@file{ly/grace-init.ly}
@seealso
-@internalsref{GraceMusic}.
+Internals: @internalsref{GraceMusic}.
@refbugs
-Grace notes cannot be used in the smallest size (@file{paper11.ly}).
-
A score that starts with an @code{\grace} section needs an explicit
@code{\context Voice} declaration, otherwise the main note and grace
note end up on different staves.
expressions. Nesting or juxtaposing grace sections is not supported,
and might produce crashes or other errors.
-Overriding settings cannot be done in separate styles for appoggiatura
-and acciaccatura.
-
-@node Glissando
+@node Glissando
@subsection Glissando
@cindex Glissando
@seealso
-@internalsref{Glissando}, and @internalsref{GlissandoEvent}.
+Internals: @internalsref{Glissando}, and @internalsref{GlissandoEvent}.
@refbugs
@code{\fff}, @code{\fff}, @code{\fp}, @code{\sf}, @code{\sff},
@code{\sp}, @code{\spp}, @code{\sfz}, and @code{\rfz}:
-@lilypond[verbatim,singleline,fragment,relative]
+@lilypond[verbatim,raggedright,fragment,relative]
c'\ppp c\pp c \p c\mp c\mf c\f c\ff c\fff
c2\sf c\rfz
@end lilypond
example:
@example
- \property Staff.Hairpin \override #'minimum-length = #5
+ \override Staff.Hairpin #'minimum-length = #5
@end example
You can also use a text saying @emph{cresc.} instead of hairpins. Here
You can also supply your own texts:
@lilypond[fragment,relative,verbatim]
\context Voice {
- \property Voice.crescendoText = \markup { \italic "cresc. poco" }
- \property Voice.crescendoSpanner = #'dashed-line
+ \set crescendoText = \markup { \italic "cresc. poco" }
+ \set crescendoSpanner = #'dashed-line
a'2\< a a a\!\mf
}
@end lilypond
@seealso
-@internalsref{CrescendoEvent}, @internalsref{DecrescendoEvent}, and
+Internals: @internalsref{CrescendoEvent}, @internalsref{DecrescendoEvent}, and
@internalsref{AbsoluteDynamicEvent}.
Dynamics are objects of @internalsref{DynamicText} and
@inputfileref{input,star-spangled-banner.ly}.
@end ignore
+@c tremolo, beamed
@item tremolo
Make tremolo beams.
alternative is assumed to be played more than once.
Normal notation repeats are used like this:
-@lilypond[fragment,verbatim,relative 1]
+@lilypond[fragment,verbatim,relative=1]
c1
\repeat volta 2 { c4 d e f }
\repeat volta 2 { f e d c }
@end lilypond
With alternative endings:
-@lilypond[fragment,verbatim,relative 1]
+@lilypond[fragment,verbatim,relative=1]
c1
\repeat volta 2 {c4 d e f}
\alternative { {d2 d} {f f,} }
@end lilypond
-@lilypond[fragment,verbatim,relative 1]
+@lilypond[fragment,verbatim,relative=1]
\context Staff {
\partial 4
\repeat volta 4 { e | c2 d2 | e2 f2 | }
stops a running volta bracket:
@end table
-@lilypond[verbatim, fragment,relative 2]
+@lilypond[verbatim,fragment,relative=2]
c4
- \property Score.repeatCommands = #'((volta "93") end-repeat)
+ \set Score.repeatCommands = #'((volta "93") end-repeat)
c4 c4
- \property Score.repeatCommands = #'((volta #f))
+ \set Score.repeatCommands = #'((volta #f))
c4 c4
@end lilypond
@seealso
-@internalsref{VoltaBracket}, @internalsref{RepeatedMusic},
+Internals: @internalsref{VoltaBracket}, @internalsref{RepeatedMusic},
@internalsref{VoltaRepeatedMusic},
@internalsref{UnfoldedRepeatedMusic}, and
@internalsref{FoldedRepeatedMusic}.
To place tremolo marks between notes, use @code{\repeat} with tremolo
style:
-@lilypond[verbatim,center,singleline]
+@lilypond[verbatim,raggedright]
\score {
\context Voice \notes\relative c' {
\repeat "tremolo" 8 { c16 d16 }
\repeat "tremolo" 4 { c16 d16 }
\repeat "tremolo" 2 { c16 d16 }
- \repeat "tremolo" 4 c16
}
}
@end lilypond
-@seealso
+Tremolo marks can also be put on a single note. In this case, the
+note should not be surrounded by braces.
+@lilypond[verbatim,raggedright]
+ \repeat "tremolo" 4 c16
+@end lilypond
-Tremolo beams are @internalsref{Beam} objects. Single stem tremolos
-are @internalsref{StemTremolo}s. The music expression is
-@internalsref{TremoloEvent}.
+A similar mechanism is the tremolo subdivision, described in
+@ref{Tremolo subdivisions}.
+
+@seealso
+In this manual: @ref{Tremolo subdivisions}, @ref{Repeats}.
-@refbugs
+Internals: tremolo beams are @internalsref{Beam} objects. Single stem
+tremolos are @internalsref{StemTremolo}s. The music expression is
+@internalsref{TremoloEvent}.
-The single stem tremolo must be entered without @code{@{} and
-@code{@}}.
+Example files: @inputfileref{input/regression,chord-tremolo.ly},
+@inputfileref{input/regression,stem-tremolo.ly}.
@node Tremolo subdivisions
@subsection Tremolo subdivisions
`@code{:}[@var{length}]' after the note. The length must be at least 8.
A @var{length} value of 8 gives one line across the note stem. If the
length is omitted, then then the last value (stored in
-@code{Voice.tremoloFlags}) is used:
+@code{tremoloFlags}) is used:
@lilypond[verbatim,fragment,center]
c'2:8 c':32 | c': c': |
Tremolos in this style do not carry over into the MIDI output.
+@seealso
+
+In this manual: @ref{Tremolo repeats}.
+
+Elsewhere: @internalsref{StemTremolo}, @internalsref{TremoloEvent}.
@node Measure repeats
@subsection Measure repeats
Patterns of a one and two measures are replaced by percent-like signs,
patterns that divide the measure length are replaced by slashes:
-@lilypond[verbatim,singleline]
+@lilypond[verbatim,raggedright]
\context Voice { \repeat "percent" 4 { c'4 }
\repeat "percent" 2 { c'2 es'2 f'4 fis'4 g'4 c''4 }
}
@seealso
-@internalsref{RepeatSlash}, @internalsref{PercentRepeat},
+Internals: @internalsref{RepeatSlash}, @internalsref{PercentRepeat},
@internalsref{PercentRepeatedMusic}, and
@internalsref{DoublePercentRepeat}.
@node Rhythmic music
@section Rhythmic music
+
+@menu
+* Showing melody rhythms::
+* Entering percussion::
+* Percussion staves::
+@end menu
+
+
+@node Showing melody rhythms
+@subsection Showing melody rhythms
+
Sometimes you might want to show only the rhythm of a melody. This
can be done with the rhythmic staff. All pitches of notes on such a
staff are squashed, and the staff itself has a single line:
}
@end lilypond
-@menu
-* Percussion staves::
-* Percussion MIDI output::
-@end menu
+@seealso
+
+Internals: @internalsref{RhythmicStaff}.
+
+Examples: @inputfileref{input/regression,rhythmic-staff.ly}.
+
+
+@node Entering percussion
+@subsection Entering percussion
+
+@cindex percussion
+@cindex drums
+
+@syntax
+
+Percussion notes may be entered in @code{\drums} mode, which is
+similar to @code{notes}. Each piece of percussion has a full name and
+an abbreviated name, and both be used in input files:
+
+@lilypond[raggedright]
+ \drums { hihat4 hh4 }
+@end lilypond
+
+The complete list of drum names is in the init file
+@file{ly/drumpitch-init.ly}.
+@c TODO: properly document this.
+
+@seealso
+
+Internals: @internalsref{DrumNoteEvent}.
@node Percussion staves
@subsection Percussion staves
multiline staff where each position in the staff refers to one piece
of percussion.
-@syntax
-Percussion staves are typeset with help of a set of Scheme
-functions. The system is based on the general MIDI drum-pitches.
-Include @file{drumpitch-init.ly} to use drum pitches. This file
-defines the pitches from the Scheme variable @code{drum-pitch-names},
-the definition of which can be read in @file{scm/drums.scm}. Each
-piece of percussion has a full name and an abbreviated name, and either
-the full name or the abbreviation may be used in input files.
-
-To typeset the music on a staff apply the function @code{drums->paper}
-to the percussion music. This function takes a list of percussion
-instrument names, notehead scripts and staff positions (that is:
-pitches relative to the C-clef) and transforms the input
-music by moving the pitch, changing the notehead and (optionally)
-adding a script:
+To typeset the music, the notes must be interpreted in a
+@internalsref{DrumStaff} and @internalsref{DrumVoice} contexts:
+
@c
-@lilypond[singleline,verbatim,quote]
-\include "drumpitch-init.ly"
-up = \notes { crashcymbal4 hihat8 halfopenhihat hh hh hh openhihat }
-down = \notes { bassdrum4 snare8 bd r bd sn4 }
+@lilypond[raggedright,verbatim,quote]
+up = \drums { crashcymbal4 hihat8 halfopenhihat hh hh hh openhihat }
+down = \drums { bassdrum4 snare8 bd r bd sn4 }
\score {
- \apply #(drums->paper 'drums) \context Staff <<
- \clef percussion
- \new Voice { \voiceOne \up }
- \new Voice { \voiceTwo \down }
- >>
-}
-
+ \new DrumStaff
+ << \new DrumVoice { \voiceOne \up }
+ \new DrumVoice { \voiceTwo \down }
+>> }
@end lilypond
-In the above example the music was transformed using the list @code{'drums}.
-The following lists are defined in @file{scm/drums.scm}:
+
+There are also other layout possibilities. To use these, set the
+property @code{drumStyleTable} in context @internalsref{DrumVoice}.
+The following variables have been predefined:
+
@table @code
-@item 'drums
-to typeset a typical drum kit on a five-line staff:
+@item drums-style
+is the default. It typesets a typical drum kit on a five-line staff
@lilypond[noindent]
-\include "drumpitch-init.ly"
nam = \lyrics { cymc cyms cymr hh hhc hho hhho hhp cb hc
bd sn ss tomh tommh tomml toml tomfh tomfl }
-mus = \notes { cymc cyms cymr hh hhc hho hhho hhp cb hc
+mus = \drums { cymc cyms cymr hh | hhc hho hhho hhp | \break cb hc
bd sn ss tomh tommh tomml toml tomfh tomfl s16 }
\score {
- <<
- \apply #(drums->paper 'drums) \context Staff <<
- \clef percussion
- \mus
- >>
- \context Lyrics \nam
- >>
- \paper {
- linewidth = 100.0\mm
- \translator {
- \StaffContext
+ << \new DrumStaff\with {
\remove Bar_engraver
\remove Time_signature_engraver
+ Stem \set #'transparent = ##t
+ Stem \set #'Y-extent-callback = ##f
minimumVerticalExtent = #'(-4.0 . 5.0)
- }
- \translator {
- \VoiceContext
- \remove Stem_engraver
- }
- }
-}
+ } \mus
+ \context Lyrics \nam
+ >>
+ \paper {
+ %% need to do this, because of indented @itemize
+ linewidth= 9 \cm
+ \translator { \ScoreContext
+ BarNumber \set #'transparent =##T
+}}}
@end lilypond
The drum scheme supports six different toms. When there fewer toms, simply
the three middle lines you use @code{tommh}, @code{tomml} and
@code{tomfh}.
-Because general MIDI does not contain rimshots the sidestick is used
-for this purpose instead.
-@item 'timbales
+@item timbales-style
to typeset timbales on a two line staff:
-@lilypond[singleline]
-\include "drumpitch-init.ly"
+@lilypond[raggedright]
nam = \lyrics { timh ssh timl ssl cb }
-mus = \notes { timh ssh timl ssl cb s16 }
+mus = \drums { timh ssh timl ssl cb s16 }
\score {
<<
- \apply #(drums->paper 'timbales) \context Staff <<
- \clef percussion
- \mus
- >>
- \context Lyrics \nam
- >>
- \paper {
- \translator {
- \StaffContext
+ \context DrumStaff \with {
\remove Bar_engraver
\remove Time_signature_engraver
+ Stem \set #'transparent = ##t
+ Stem \set #'Y-extent-callback = ##f
StaffSymbol \override #'line-count = #2
StaffSymbol \override #'staff-space = #2
minimumVerticalExtent = #'(-3.0 . 4.0)
- }
- \translator {
- \VoiceContext
- \remove Stem_engraver
- }
-
- }
+ drumStyleTable = #timbales-style
+ } \mus
+ \context Lyrics \nam
+ >>
}
@end lilypond
-@item 'congas
+@item congas-style
to typeset congas on a two line staff:
-@lilypond[singleline]
-\include "drumpitch-init.ly"
+@lilypond[raggedright]
nam = \lyrics { cgh cgho cghm ssh cgl cglo cglm ssl }
-mus = \notes { cgh cgho cghm ssh cgl cglo cglm ssl s16 }
+mus = \drums { cgh cgho cghm ssh cgl cglo cglm ssl s16 }
\score {
<<
- \apply #(drums->paper 'congas) \context Staff <<
- \clef percussion
- \mus
- >>
- \context Lyrics \nam
- >>
- \paper {
- \translator {
- \StaffContext
+ \context DrumStaff\with {
\remove Bar_engraver
\remove Time_signature_engraver
+ drumStyleTable = #congas-style
StaffSymbol \override #'line-count = #2
+
+ %% this sucks; it will lengthen stems.
StaffSymbol \override #'staff-space = #2
- minimumVerticalExtent = #'(-3.0 . 4.0)
- }
- \translator {
- \VoiceContext
- \remove Stem_engraver
- }
- }
+ Stem \set #'transparent = ##t
+ Stem \set #'Y-extent-callback = ##f
+ } \mus
+ \context Lyrics \nam
+ >>
}
@end lilypond
-@item 'bongos
+@item bongos-style
to typeset bongos on a two line staff:
-@lilypond[singleline]
-\include "drumpitch-init.ly"
+@lilypond[raggedright]
nam = \lyrics { boh boho bohm ssh bol bolo bolm ssl }
-mus = \notes { boh boho bohm ssh bol bolo bolm ssl s16 }
+mus = \drums { boh boho bohm ssh bol bolo bolm ssl s16 }
\score {
<<
- \apply #(drums->paper 'bongos) \context Staff <<
- \clef percussion
- \mus
- >>
- \context Lyrics \nam
- >>
- \paper {
- \translator {
- \StaffContext
+ \context DrumStaff\with {
\remove Bar_engraver
\remove Time_signature_engraver
StaffSymbol \override #'line-count = #2
+ drumStyleTable = #bongos-style
+
+ %% this sucks; it will lengthen stems.
StaffSymbol \override #'staff-space = #2
- minimumVerticalExtent = #'(-3.0 . 4.0)
- }
- \translator {
- \VoiceContext
- \remove Stem_engraver
- }
- }
+ Stem \set #'transparent = ##t
+ Stem \set #'Y-extent-callback = ##f
+ } \mus
+ \context Lyrics \nam
+ >>
}
@end lilypond
-@item 'percussion
+
+@item percussion-style
to typeset all kinds of simple percussion on one line staves:
-@lilypond[singleline]
-\include "drumpitch-init.ly"
+@lilypond[raggedright]
nam = \lyrics { tri trio trim gui guis guil cb cl tamb cab mar hc }
-mus = \notes { tri trio trim gui guis guil cb cl tamb cab mar hc s16 }
+mus = \drums { tri trio trim gui guis guil cb cl tamb cab mar hc s16 }
\score {
<<
- \apply #(drums->paper 'percussion) \context Staff <<
- \clef percussion
- \mus
- >>
- \context Lyrics \nam
- >>
- \paper {
- \translator {
- \StaffContext
+ \context DrumStaff\with{
\remove Bar_engraver
- \remove Time_signature_engraver
+ drumStyleTable = #percussion-style
StaffSymbol \override #'line-count = #1
- minimumVerticalExtent = #'(-2.0 . 3.0)
- }
- \translator {
- \VoiceContext
- \remove Stem_engraver
- }
- }
+ \remove Time_signature_engraver
+ Stem \set #'transparent = ##t
+ Stem \set #'Y-extent-callback = ##f
+ } \mus
+ \context Lyrics \nam
+ >>
}
@end lilypond
@end table
If you do not like any of the predefined lists you can define your own
list at the top of your file:
-@lilypond[singleline, verbatim]
-#(set-drum-kit 'mydrums `(
- (bassdrum default #f ,(ly:make-pitch -1 2 0))
- (snare default #f ,(ly:make-pitch 0 1 0))
- (hihat cross #f ,(ly:make-pitch 0 5 0))
- (pedalhihat xcircle "stopped" ,(ly:make-pitch 0 5 0))
- (lowtom diamond #f ,(ly:make-pitch -1 6 0))
+@lilypond[raggedright,verbatim]
+#(define mydrums '(
+ (bassdrum default #f -1)
+ (snare default #f 0)
+ (hihat cross #f 1)
+ (pedalhihat xcircle "stopped" 2)
+ (lowtom diamond #f 3)
))
-\include "drumpitch-init.ly"
-up = \notes { hh8 hh hh hh hhp4 hhp }
-down = \notes { bd4 sn bd toml8 toml }
-\score {
- \apply #(drums->paper 'mydrums) \context Staff <<
- \clef percussion
- \new Voice { \voiceOne \up }
- \new Voice { \voiceTwo \down }
- >>
-}
-@end lilypond
-
-To use a modified existing list, one can prepend modifications to the
-the existing list:
-
-@example
-#(set-drum-kit 'mydrums (append `(
- (bassdrum default #f ,(ly:make-pitch -1 2 0))
- (lowtom diamond #f ,(ly:make-pitch -1 6 0))
-) (get-drum-kit 'drums)))
-@end example
-
-You can easily combine percussion notation with pitched notation.
-Indeed, the file @file{drumpitch-init.ly} replaces the normal pitch
-names, so you will have to reinclude @file{nederlands.ly} after the
-drum-pattern-definitions to enter normal notes:
-@c
-@lilypond[singleline,verbatim]
-\include "drumpitch-init.ly"
-up = \notes { crashcymbal4 hihat8 halfopenhihat hh hh hh openhihat }
-down = \notes { bassdrum4 snare8 bd r bd sn4 }
-\include "nederlands.ly"
-bass = \notes \transpose c c,, { a4. e8 r e g e }
+up = \drums { hh8 hh hh hh hhp4 hhp }
+down = \drums { bd4 sn bd toml8 toml }
\score {
- <<
- \apply #(drums->paper 'drums) \new Staff <<
- \clef percussion
- \new Voice { \voiceOne \up }
- \new Voice { \voiceTwo \down }
- >>
- \new Staff { \clef "F_8" \bass }
+ \new DrumStaff <<
+ \set DrumStaff.drumStyleTable
+ = #(alist->hash-table mydrums)
+ \new DrumVoice { \voiceOne \up }
+ \new DrumVoice { \voiceTwo \down }
>>
}
@end lilypond
-@node Percussion MIDI output
-@subsection Percussion MIDI output
-In order to produce correct MIDI output you need to produce two score
-blocks---one for the paper and one for the MIDI output. To use the
-percussion channel you set the property @code{instrument} to
-@code{'drums}. Because the drum-pitches themselves are similar to the
-general MIDI pitches all you have to do is to insert the voices with
-none of the scheme functions to get the correct MIDI output:
+@seealso
-@example
-\score @{
- \apply #(drums->paper 'mydrums) \context Staff <<
- \clef percussion
- @{ \up @} \\
- @{ \down @}
- >>
- \paper@{@}
-@}
-\score @{
- \context Staff <<
- \property Staff.instrument = #'drums
- \up \down
- >>
- \midi@{@}
-@}
-@end example
+Init files: @file{ly/drumpitch-init.ly}.
+
+Internals: @internalsref{DrumStaff}, @internalsref{DrumVoice}.
@refbugs
-This scheme is a temporary implementation.
+Short polyphonic notation, @code{<< @dots{} \\ @dots{} >>}, does not
+work for @internalsref{DrumVoices}.
+Because general MIDI does not contain rimshots the sidestick is used
+for this purpose instead.
@node Piano music
@section Piano music
There is no support for putting chords across staves. You can get
this result by increasing the length of the stem in the lower stave so
it reaches the stem in the upper stave, or vice versa. An example is
-included with the distribution as @inputfileref{input/test,stem-cross-staff.ly}.
+included with the distribution as
+@inputfileref{input/test,stem-cross-staff.ly}.
Dynamics are not centered, but kludges do exist. See
@inputfileref{input/template,piano-dynamics.ly}.
Voices can switch automatically between the top and the bottom
staff. The syntax for this is
@example
- \autochange Staff \context Voice @{ @dots{}@var{music}@dots{} @}
+ \autochange \context Voice @{ @dots{}@var{music}@dots{} @}
@end example
The two staffs of the piano staff must be named @code{up} and
@code{down}.
point), and it looks ahead skipping over rests to switch in
advance. Here is a practical example:
-@lilypond[verbatim,singleline,quote]
+@lilypond[verbatim,raggedright,quote]
\score { \notes \context PianoStaff <<
\context Staff = "up" {
- \autochange Staff \context Voice = VA << \relative c' {
- g4 a b c d r4 a g } >> }
+ \autochange \new Voice \relative c' {
+ g4 a b c d r4 a g } }
\context Staff = "down" {
\clef bass
s1*2
@seealso
-@internalsref{AutoChangeMusic}.
+In this manual: @ref{Manual staff switches}.
+
+Internals: @internalsref{AutoChangeMusic}.
+
+
@refbugs
The staff switches often do not end up in optimal places. For high
quality output, staff switches should be specified manually.
-
+
@node Manual staff switches
@subsection Manual staff switches
Voices can be switched between staves manually, using the following command:
@example
- \translator Staff = @var{staffname} @var{music}
+ \change Staff = @var{staffname} @var{music}
@end example
@noindent
@code{"down"}.
+
@node Pedals
@subsection Pedals
@cindex Pedals
@code{pedalSustainStyle} property to @code{bracket} objects:
@lilypond[fragment,verbatim]
- \property Staff.pedalSustainStyle = #'bracket
+ \set Staff.pedalSustainStyle = #'bracket
c''4\sustainDown d''4 e''4
a'4\sustainUp\sustainDown
f'4 g'4 a'4\sustainUp
@end lilypond
A third style of pedal notation is a mixture of text and brackets,
-obtained by setting @code{pedal-type} to @code{mixed}:
+obtained by setting the @code{pedalSustainStyle} style property to
+@code{mixed}:
@lilypond[fragment,verbatim]
- \property Staff.pedalSustainStyle = #'mixed
+ \set Staff.pedalSustainStyle = #'mixed
c''4\sustainDown d''4 e''4
c'4\sustainUp\sustainDown
f'4 g'4 a'4\sustainUp
@end lilypond
The default `*Ped' style for sustain and damper pedals corresponds to
-@code{\pedal-type = #'text}. However, @code{mixed} is the default style
-for a sostenuto pedal:
+style @code{#'text}. The sostenuto pedal uses @code{mixed} style by
+default.
@lilypond[fragment,verbatim]
c''4\sostenutoDown d''4 e''4 c'4 f'4 g'4 a'4\sostenutoUp
bracket may be extended to the end of the note head:
@lilypond[fragment,verbatim]
-\property Staff.PianoPedalBracket \override
+\override Staff.PianoPedalBracket
#'shorten-pair = #'(0 . -1.0)
c''4\sostenutoDown d''4 e''4 c'4
f'4 g'4 a'4\sostenutoUp
@lilypond[fragment,relative,verbatim]
\context PianoStaff <<
- \property PianoStaff.connectArpeggios = ##t
+ \set PianoStaff.connectArpeggios = ##t
\new Staff { <c' e g c>\arpeggio }
\new Staff { \clef bass <c,, e g>\arpeggio }
>>
@lilypond[fragment,relative,verbatim]
\context Voice {
- \property Voice.Arpeggio \set #'arpeggio-direction = #1
+ \override Arpeggio #'arpeggio-direction = #1
<c e g c>\arpeggio
- \property Voice.Arpeggio \set #'arpeggio-direction = #-1
+ \override Arpeggio #'arpeggio-direction = #-1
<c e g c>\arpeggio
}
@end lilypond
A square bracket on the left indicates that the player should not
arpeggiate the chord. To draw these brackets, set the
-@code{molecule-callback} property of @code{Arpeggio} or
+@code{print-function} property of @code{Arpeggio} or
@code{PianoStaff.Arpeggio} objects to @code{\arpeggioBracket}, and use
@code{\arpeggio} statements within the chords as before:
@lilypond[fragment,relative,verbatim]
- \property PianoStaff.Arpeggio \override
- #'molecule-callback = \arpeggioBracket
+ \override PianoStaff.Arpeggio
+ #'print-function = \arpeggioBracket
<c' e g c>\arpeggio
@end lilypond
@seealso
-@internalsref{ArpeggioEvent} music expressions lead to
+Internals: @internalsref{ArpeggioEvent} music expressions lead to
@internalsref{Arpeggio} objects. Cross staff arpeggios are
@internalsref{PianoStaff}.@internalsref{Arpeggio}.
It is not possible to mix connected arpeggios and unconnected
arpeggios in one @internalsref{PianoStaff} at the same time.
-@node Staff switch lines
+@node Staff switch lines
@subsection Staff switch lines
@lilypond[fragment,relative,verbatim]
\context PianoStaff <<
- \property PianoStaff.followVoice = ##t
+ \set PianoStaff.followVoice = ##t
\context Staff \context Voice {
c1
- \translator Staff=two
+ \change Staff=two
b2 a
}
\context Staff=two { \clef bass \skip 1*2 }
resulting string. As a consequence, spaces must be inserted around
@code{\property} commands:
@example
- \property Lyrics . LyricText \set #'font-shape = #'italic
+ \override Lyrics .LyricText #'font-shape = #'italic
@end example
@cindex @code{_}
@seealso
-@internalsref{LyricEvent}, @internalsref{HyphenEvent}, and
+Internals: @internalsref{LyricEvent}, @internalsref{HyphenEvent}, and
@internalsref{ExtenderEvent}.
+Examples: @inputfileref{input/test,lyric-hyphen-retain.ly}.
+
@refbugs
-The definition of lyrics mode is too complex.
+The definition of lyrics mode is too complex.
+
+
@node The Lyrics context
@subsection The Lyrics context
-Lyrics are printed by interpreting them in @internalsref{Lyrics} context:
+Lyrics are printed by interpreting them in a @internalsref{Lyrics} context:
@example
\context Lyrics \lyrics @dots{}
@end example
@cindex automatic syllable durations
-@cindex @code{\addlyrics}
+@cindex @code{\lyricsto}
@cindex lyrics and melodies
This will place the lyrics according to the durations that were
entered. The lyrics can also be aligned under a given melody
automatically. In this case, it is no longer necessary to enter the
correct duration for each syllable. This is achieved by combining the
-melody and the lyrics with the @code{\addlyrics} expression:
+melody and the lyrics with the @code{\lyricsto} expression:
@example
-\addlyrics
- \notes @dots{}
- \context Lyrics @dots{}
+\lyricsto @var{name} \new Lyrics @dots{}
@end example
-@cindex staff order, with @code{\addlyrics}
+This aligns the lyrics to the
+@c
+notes of the @internalsref{Voice} context called @var{name}, which has
+to exist. Therefore, normally the @code{Voice} is specified first, and
+then the lyrics are specified with @code{\lyricsto}.
-Normally, this will put the lyrics below the staff. For different or
-more complex orderings, the best way is to setup the hierarchy of
-staves and lyrics first, e.g.
+For different or more complex orderings, the best way is to setup the
+hierarchy of staves and lyrics first, e.g.
@example
\context ChoirStaff \notes <<
- \context Lyrics = sopr @{ s1 @}
- \context Staff = soprStaff @{ s1 @}
+ \context Lyrics = sopranoLyrics @{ s1 @}
+ \context Voice = soprano @{ @emph{music} @}
\context Lyrics = tenor @{ s1 @}
- \context Staff = tenorStaff @{ s1 @}
+ \context Voice = tenorLyrics @{ @emph{music} @}
>>
@end example
and then combine the appropriate melodies and lyric lines:
@example
- \addlyrics
- \context Staff = soprStaff @emph{the music}
- \context Lyrics = sopr @emph{the lyrics}
+ \lyricsto "soprano" \new Lyrics @emph{the lyrics}
@end example
-putting both together, you would get
+@noindent
+The final input would resemble
+
@example
-\context ChoirStaff \notes <<
- \context Lyrics = @dots{}
- \context Staff = @dots{}
- \addlyrics @dots{}
->>
-@end example
+ << \context ChoirStaff \notes << @emph{setup the music} >>
+ \lyricsto "soprano" @emph{etc}
+ \lyricsto "alto" @emph{etc}
+ @emph{etc}
+ >>
+@end example
+
+
+The @code{\lyricsto} command detects melismata: it only puts one
+syllable under a tied or slurred group of notes. If you want to force
+an unslurred group of notes to be a melisma, then insert
+@code{\melisma} after the first note of the group, and
+@code{\melismaEnd} after the last one, e.g.
+
+@lilypond[relative=1,raggedright,fragment,verbatim]
+<< \context Voice = "lala" { \time 3/4
+ f4 g8
+ \melisma
+ f e f
+ \melismaEnd
+ e2 }
+ \lyricsto "lala" \new Lyrics \lyrics {
+ la di __ daah
+ } >>
+@end lilypond
+
+In addition, notes are considered a melisma if they are manually
+beamed, and automatic beaming (see @ref{Setting automatic beam
+behavior}) is switched off. The criteria for deciding melismata
+can be tuned with the property @code{melismaBusyProperties}. See
+@internalsref{Melisma_engraver} for more information.
+
+When multiple stanzas are put on the same melody, it can happen that
+two stanzas have melismata in different locations. This can be
+remedied by switching off melismata for one
+@internalsref{Lyrics}. This is achieved by setting
+the @code{ignoreMelismata} property to @code{#t}. An example is shown
+in @inputfileref{input/regression,lyric-combine-new.ly}.
@cindex SATB
@cindex choral score
A complete example of a SATB score setup is in the file
@inputfileref{input/template,satb.ly}.
+
+@refcommands
+
+@code{\melisma}, @code{\melismaEnd}
+@cindex @code{\melismaEnd}
+@cindex @code{\melisma}
+
@seealso
-@internalsref{LyricCombineMusic}, @internalsref{Lyrics}, and
-@inputfileref{input/template,satb.ly}.
+Internals: Music expressions: @internalsref{LyricCombineMusic},
+Contexts: @internalsref{Lyrics}, @internalsref{Melisma_engraver}.
+Examples: @inputfileref{input/template,satb.ly},
+@inputfileref{input/regression,lyric-combine-new.ly}.
+
@refbugs
-@code{\addlyrics} is not automatic enough: melismata are not detected
-automatically, and melismata are not stopped when they hit a rest. A
-melisma on the last note in a melody is not printed.
+Melismata are not detected automatically, and extender lines must be
+inserted by hand.
+
+For proper processing of extender lines, the
+@internalsref{Lyrics} and @internalsref{Voice} should be
+linked. This can be achieved either by using @code{\lyricsto} or by
+setting corresponding names for both contexts. The latter is explained
+in @ref{More stanzas}.
@node More stanzas
@subsection More stanzas
-
@cindex phrasing, in lyrics
-When multiple stanzas are printed underneath each other, the vertical
-groups of syllables should be aligned around punctuation. This can be
-done automatically when corresponding lyric lines and melodies are
-marked.
+
+The lyrics should be aligned with the note heads of the melody. To
+achieve this, each line of lyrics should be marked to correspond with
+the melodic line. This is done automatically when @code{\lyricsto},
+but it can also be done manually.
To this end, give the @internalsref{Voice} context an identity:
@example
g2 e4 a2 f4 g2. @}
@end example
-Then set the @internalsref{LyricsVoice} contexts to names starting with
+Then set the @internalsref{Lyrics} contexts to names starting with
that identity followed by a dash. In the preceding example, the
@internalsref{Voice} identity is @code{duet}, so the identities of the
-@internalsref{LyricsVoice}s are marked @code{duet-1} and @code{duet-2}:
+@internalsref{Lyrics}s are marked @code{duet-1} and @code{duet-2}:
@example
- \context LyricsVoice = "duet-1" @{
+ \context Lyrics = "duet-1" @{
Hi, my name is bert. @}
- \context LyricsVoice = "duet-2" @{
+ \context Lyrics = "duet-2" @{
Ooooo, ch\'e -- ri, je t'aime. @}
@end example
-The convention for naming @internalsref{LyricsVoice} and
-@internalsref{Voice} must also be used to get melismata correct in
-conjunction with rests.
The complete example is shown here:
-@lilypond[singleline,verbatim]
+@lilypond[raggedright,verbatim]
\score {
-\addlyrics
- \notes \relative c'' \context Voice = duet { \time 3/4
+ << \notes \relative c'' \context Voice = duet { \time 3/4
g2 e4 a2 f4 g2. }
- \lyrics \context Lyrics <<
- \context LyricsVoice = "duet-1" {
- \property LyricsVoice . stanza = "Bert"
- Hi, my name is bert. }
- \context LyricsVoice = "duet-2" {
- \property LyricsVoice . stanza = "Ernie"
+ \lyrics << \lyricsto "duet" \new Lyrics {
+ \set stanza = "1"
+ Hi, my name is bert. }
+ \lyricsto "duet" \new Lyrics {
+ \set stanza = "2"
Ooooo, ch\'e -- ri, je t'aime. }
- >>
+ >> >>
}
@end lilypond
-Stanza numbers, or the names of the singers can be added by setting
-@code{LyricsVoice.Stanza} (for the first system) and
-@code{LyricsVoice.stz} for the following systems. Notice how dots are
-surrounded with spaces in @code{\lyrics} mode:
+@cindex stanza number
+@cindex singer's names
+@cindex name of singer
+
+Stanza numbers can be added by setting @code{stanza}, e.g.
@example
- \property LyricsVoice . stanza = "Bert"
+ \set stanza = "Bert"
@dots{}
- \property LyricsVoice . stanza = "Ernie"
+ \set stanza = "Ernie"
@end example
+Notice how dots are surrounded with spaces in @code{\lyrics} mode, to
+prevent @code{stanza} being interpreted as a single
+string.
+
+Names of the singers should be added using @code{Lyrics
+. vocalName} and @code{Lyrics . vocNam}, analogous to instrument
+annotations for staves.
+
To make empty spaces in lyrics, use @code{\skip}.
+@seealso
+
+Internals: Layout objects @internalsref{LyricText}
+@internalsref{VocalName}. Music expressions:
+@internalsref{LyricEvent}.
@refbugs
@subsection Ambitus
@cindex ambitus
-The term @emph{ambitus} denotes a range of pitches for a given voice in
-a part of music. It also may denote the pitch range that a musical
-instrument is capable of playing. Most musical instruments have their
-ambitus standardized (or at least there is agreement upon the minimal
-ambitus of a particular type of instrument), such that a composer or
-arranger of a piece of music can easily meet the ambitus constraints of
-the targeted instrument. However, the ambitus of the human voice
-depends on individual physiological state, including education and
-training of the voice. Therefore, a singer potentially has to check for
-each piece of music if the ambitus of that piece meets his individual
-capabilities. This is why the ambitus of a piece may be of particular
-value to vocal performers.
+The term @emph{ambitus} (plural: ambituses) denotes a range of pitches
+for a given voice in a part of music. It also may denote the pitch
+range that a musical instrument is capable of playing. Most musical
+instruments have their ambitus standardized (or at least there is
+agreement upon the minimal ambitus of a particular type of
+instrument), such that a composer or arranger of a piece of music can
+easily meet the ambitus constraints of the targeted instrument.
+However, the ambitus of the human voice depends on individual
+physiological state, including education and training of the voice.
+Therefore, a singer potentially has to check for each piece of music
+if the ambitus of that piece meets his individual capabilities. This
+is why the ambitus of a piece may be of particular value to vocal
+performers.
The ambitus is typically notated on a per-voice basis at the very
beginning of a piece, e.g. nearby the initial clef or time signature of
@end example
This results in the following output:
-@lilypond[singleline]
+
+@lilypond[raggedright]
upper = \notes \relative c {
\clef "treble"
\key c \minor
@internalsref{Ambitus_engraver} to the @internalsref{Staff} context
rather than to the @internalsref{Voice} context.
-It is possible to tune individual ambiti for multiple voices on a
+It is possible to tune individual ambituses for multiple voices on a
single staff, for example by erasing or shifting them horizontally. An
example is in @inputfileref{input/test,ambitus-mixed.ly}
@seealso
-@internalsref{Ambitus}, @inputfileref{input/regression,ambitus.ly},
+Internals: @internalsref{Ambitus}.
+
+Examples: @inputfileref{input/regression,ambitus.ly},
@inputfileref{input/test,ambitus-mixed.ly}.
@refbugs
}
@end lilypond
+@cindex minimumFret
+
When no string is specified, the first string that does not give a
fret number less than @code{minimumFret} is selected. The default
value for @code{minimumFret} is 0:
@example
e8 fis gis a b cis' dis' e'
-\property TabStaff.minimumFret = #8
+\set TabStaff.minimumFret = #8
e8 fis gis a b cis' dis' e'
@end example
@lilypond[noindent]
frag = \notes {
\key e \major
e8 fis gis a b cis' dis' e'
- \property TabStaff.minimumFret = #8
+ \set TabStaff.minimumFret = #8
e8 fis gis a b cis' dis' e'
}
\score {
@seealso
-@internalsref{TabStaff}, @internalsref{TabVoice}, and
+Internals: @internalsref{TabStaff}, @internalsref{TabVoice}, and
@internalsref{StringNumberEvent}.
@refbugs
@cindex Non-guitar tablatures
You can change the number of strings, by setting the number of lines
-in the @internalsref{TabStaff} (the @code{line-count} property of
-@internalsref{TabStaff} can only be changed using
-@code{\outputproperty}, for more information, see @ref{Tuning
-objects}).
+in the @internalsref{TabStaff}.
You can change the tuning of the strings. A string tuning is given as
a Scheme list with one integer number for each string, the number
@lilypond[fragment,verbatim]
\context TabStaff <<
-
- \outputproperty #(make-type-checker 'staff-symbol-interface)
- #'line-count = #4
- \property TabStaff.stringTunings = #'(-5 -10 -15 -20)
+ \set TabStaff.stringTunings = #'(-5 -10 -15 -20)
\notes {
a,4 c' a e' e c' a e'
set of pitches, so they can be transposed:
-@lilypond[verbatim,singleline]
+@lilypond[verbatim,raggedright]
twoWays = \notes \transpose c c' {
\chords {
c1 f:sus4 bes/f
names. It is introduced by the keyword @code{\chords}.
In chords mode, a chord is entered by the root, which is entered
like a common pitch:
-@lilypond[fragment,verbatim,quote, relative=1]
+@lilypond[fragment,verbatim,quote,relative=1]
\chords { es4. d8 c2 }
@end lilypond
@cindex chord entry
The chords may be entered either using the notation
described above, or directly using @code{<} and @code{>}:
-@lilypond[verbatim,singleline]
+@lilypond[verbatim,raggedright]
scheme = \notes {
\chords {a1 b c} <d' f' a'> <e' g' b'>
}
display chord names when there is a change in the chords scheme and at
the start of a new line:
-@lilypond[verbatim, linewidth=9cm]
+@lilypond[verbatim,linewidth=9\cm]
scheme = \chords {
c1:m c:m \break c:m c:m d
}
\score {
\notes <<
\context ChordNames {
- \property ChordNames.chordChanges = ##t
+ \set chordChanges = ##t
\scheme }
\context Staff \transpose c c' \scheme
>>
@lilypond[fragment,verbatim]
\context ChordNames \chords {
c:7sus4
- \property ChordNames.chordNameSeparator
- = \markup { \typewriter "|" }
+ \set chordNameSeparator
+ = \markup { \typewriter "|" }
c:7sus4 }
@end lilypond
@seealso
-@inputfileref{input/regression,chord-name-major7.ly},
+Examples: @inputfileref{input/regression,chord-name-major7.ly},
@inputfileref{input/regression,chord-name-exceptions.ly},
@inputfileref{input/test,chord-names-jazz.ly},
-@inputfileref{input/test,chord-names-german.ly},
-@file{scm/chords-ignatzek.scm}, and @file{scm/chord-entry.scm}.
+@inputfileref{input/test,chord-names-german.ly}.
+
+Init files: @file{scm/chords-ignatzek.scm}, and @file{scm/chord-entry.scm}.
@refbugs
To print a rehearsal mark, use the @code{\mark} command:
@lilypond[fragment,verbatim]
\relative c'' {
- c1 \mark "A"
- c1 \mark "B"
- c1 \mark "12"
- c1 \mark "13"
- c1
+ c1 \mark \default
+ c1 \mark \default
+ c1 \mark #8
+ c1 \mark \default
+ c1 \mark \default
}
@end lilypond
+@noindent
+(The letter I is skipped in accordance with engraving traditions.)
+
The mark is incremented automatically if you use @code{\mark
-\default}. The value to use is stored in the property
-@code{rehearsalMark} is used and automatically incremented.
+\default}, but you can also use an integer argument to set the mark
+manually. The value to use is stored in the property
+@code{rehearsalMark}.
+
+The style is defined by the property @code{markFormatter}. It is a
+function taking the current mark (an integer) and the current context
+as argument. It should return a markup object. In the following
+example, @code{markFormatter} is set to a canned procedure. After a
+few measures, it is set to function that produces a boxed number.
+
+@lilypond[verbatim,fragment,relative=1]
+ \set Score.markFormatter = #format-mark-numbers
+ c1 \mark \default
+ c1 \mark \default
+ \set Score.markFormatter
+ = #(lambda (mark context)
+ (make-bold-markup (make-box-markup (number->string mark))))
+ c1 \mark \default
+ c1 \mark \default
+@end lilypond
+
+The file @file{scm/translation-functions.scm} contains the definitions
+of @code{format-mark-numbers} (the default format) and
+@code{format-mark-letters}. They can be used as inspiration for other
+formatting functions.
+
+
+@cindex coda on bar line
+@cindex segno on bar line
+@cindex fermata on bar line
+@cindex bar lines, symbols on
The @code{\mark} command can also be used to put signs like coda,
segno and fermatas on a barline. Use @code{\markup} to
c1
@end lilypond
-In this case, during line breaks,
-marks must also be printed at the end of the line, and not at the
-beginning. Use the following to force that behavior:
+In this case, during line breaks, marks must also be printed at the
+end of the line, and not at the beginning. Use the following to force
+that behavior:
@example
-\property Score.RehearsalMark \override
+\override Score.RehearsalMark
#'break-visibility = #begin-of-line-invisible
@end example
-See @inputfileref{input/test,boxed-molecule.ly} for putting boxes
-around the marks.
-
@cindex fermatas
@cindex coda
@cindex segno
@seealso
-@internalsref{MarkEvent}, @internalsref{RehearsalMark}, and
-@inputfileref{input/test,boxed-molecule.ly}.
+Internals: @internalsref{MarkEvent}, @internalsref{RehearsalMark}
+
+Init files: @file{scm/translation-functions.scm} contains the
+definition of @code{format-mark-numbers} and
+@code{format-mark-letters}. They can be used as inspiration for other
+formatting functions.
+
+Examples: @inputfileref{input/regression,rehearsal-mark-letter.ly},
+@inputfileref{input/regression,rehearsal-mark-number.ly}.
@node Bar numbers
whose source is available as
@inputfileref{input/test,bar-number-regular-interval.ly}:
-@lilypondfile[notexidoc]{bar-number-regular-interval.ly}
+@lilypondfile[]{bar-number-regular-interval.ly}
@seealso
-@internalsref{BarNumber},
-@inputfileref{input/test,bar-number-every-five-reset.ly}, and
-@inputfileref{input/test,bar-number-regular-interval.ly}.
+Internals: @internalsref{BarNumber}.
+
+Examples: @inputfileref{input/test,bar-number-every-five-reset.ly},
+and @inputfileref{input/test,bar-number-regular-interval.ly}.
@refbugs
used, for the next ones @code{instr} is used:
@quotation
-@lilypond[verbatim,singleline]
- \property Staff.instrument = "ploink " { c''4 }
+@lilypond[verbatim,raggedright]
+ \set Staff.instrument = "ploink " { c''4 }
@end lilypond
@end quotation
names:
@quotation
-@lilypond[fragment,verbatim,singleline]
+@lilypond[fragment,verbatim,raggedright]
\notes {
- \property Staff.instrument = \markup {
+ \set Staff.instrument = \markup {
\column < "Clarinetti"
{ "in B"
\smaller \musicglyph #"accidentals--1"
@seealso
-@internalsref{InstrumentName}.
+Internals: @internalsref{InstrumentName}.
@refbugs
\transpose @var{from} @var{to} @var{musicexpr}
@end example
-This means that @var{musicexpr} is transposed by the interval
-between @var{from} and @var{to}.
+This means that @var{musicexpr} is transposed by the interval between
+the pitches @var{from} and @var{to}: any note with pitch @code{from}
+is changed to @code{to}.
+
+
+For example, consider a piece written in the key of D major. If
+this piece is a little too low for its performer, it can be
+transposed up to E major with
+@example
+ \tranpose d e @dots{}
+@end example
+
+Consider a part written for violin (a C instrument). If
+this part is to be played on the A clarinet, the following
+transposition will produce the appropriate part
+
+@example
+ \transpose a c @dots{}
+@end example
-@code{\transpose} distinguishes between enharmonic pitches: both
-@code{\transpose c cis} or @code{\transpose c des} will transpose up
-half a tone. The first version will print sharps and the second
-version will print flats:
+Since @var{from} and @var{to} are pitches, @code{\transpose} must be
+inside a @code{\notes} section. @code{\transpose} distinguishes
+between enharmonic pitches: both @code{\transpose c cis} or
+@code{\transpose c des} will transpose up half a tone. The first
+version will print sharps and the second version will print flats:
-@lilypond[singleline, verbatim]
+@lilypond[raggedright,verbatim]
mus =\notes { \key d \major cis d fis g }
\score { \notes \context Staff {
\clef "F" \mus
}}
@end lilypond
+
@seealso
-@internalsref{TransposedMusic}, and @internalsref{UntransposableMusic}.
+Internals: @internalsref{TransposedMusic}, and
+@internalsref{UntransposableMusic}.
@refbugs
-@node Multi measure rests
+@node Multi measure rests
@subsection Multi measure rests
@cindex multi measure rests
@cindex Rests, multi measure
@lilypond[fragment,verbatim]
\time 4/4 r1 | R1 | R1*2
- \property Score.skipBars = ##t R1*17 R1*4
+ \set Score.skipBars = ##t R1*17 R1*4
@end lilypond
The @code{1} in @code{R1} is similar to the duration notation used for
durations. This can be done with augmentation dots or fractions:
@lilypond[fragment,verbatim]
- \property Score.skipBars = ##t
+ \set Score.skipBars = ##t
\time 3/4
R2. | R2.*2
\time 13/8
R2.^\fermataMarkup
@end lilypond
+If you want to have a text on the left end of a multi-measure rest,
+attach the text to a zero-length skip note, i.e.
+
+@example
+ s1*0^"Allegro"
+ R1*4
+@end example
+
@cindex whole rests for a full measure
@seealso
-@internalsref{MultiMeasureRestEvent},
+Internals: @internalsref{MultiMeasureRestEvent},
@internalsref{MultiMeasureTextEvent},
@internalsref{MultiMeasureRestMusicGroup}, and
@internalsref{MultiMeasureRest}.
The syntax for part combining is
@example
- \partcombine @var{context} @var{musicexpr1} @var{musicexpr2}
+ \partcombine @var{musicexpr1} @var{musicexpr2}
@end example
-where the pieces of music @var{musicexpr1} and @var{musicexpr2} will be
-combined into one context of type @var{context}. The music expressions
-must be interpreted by contexts whose names should start with @code{one}
-and @code{two}.
+
+The music expressions will be interpreted as @internalsref{Voice}
+contexts.
The following example demonstrates the basic functionality of the part
combiner: putting parts on one staff, and setting stem directions and
polyphony:
-@lilypond[verbatim,singleline,fragment]
- \context Staff <<
- \context Voice=one \partcombine Voice
- \context Thread=one \relative c'' {
+@lilypond[verbatim,raggedright,fragment,relative=1]
+ \new Staff \partcombine
+ {
g a( b) r
}
- \context Thread=two \relative c'' {
+ {
g r4 r f
}
- >>
@end lilypond
The first @code{g} appears only once, although it was
If you just want the merging parts, and not the textual markings, you
may set the property @var{soloADue} to false:
-@lilypond[verbatim,singleline,fragment]
- \context Staff <<
- \property Staff.soloADue = ##f
- \context Voice=one \partcombine Voice
- \context Thread=one \relative c'' {
- b4 a c g
- }
- \context Thread=two \relative c'' {
- d,2 a4 g'
+@lilypond[verbatim,raggedright,fragment]
+ \new Staff <<
+ \set Staff.soloADue = ##f
+ \partcombine
+ {
+ g a( b) r
}
- >>
+ {
+ g r4 r f
+ } >>
@end lilypond
@seealso
-@internalsref{PartCombineMusic},
-@internalsref{Thread_devnull_engraver}, and
-@internalsref{Voice_devnull_engraver} and @internalsref{A2_engraver}.
+Internals: @internalsref{PartCombineMusic},
+@internalsref{SoloOneEvent}, and
+@internalsref{SoloTwoEvent}, and
+@internalsref{UnisonoEvent}.
@refbugs
-The syntax for naming contexts in inconsistent with the syntax for
-combining stanzas.
-
In @code{soloADue} mode, when the two voices play the same notes on and
off, the part combiner may typeset @code{a2} more than once in a
-measure:
+measure.
-@lilypond[fragment,singleline]
- \context Staff <<
- \context Voice=one \partcombine Voice
- \context Thread=one \relative c'' {
- c b c b c a c a
- }
- \context Thread=two \relative c'' {
- b b b b f a f a
- }
- >>
-@end lilypond
+@code{\partcombine} can not be inside @code{\times}.
-The part combiner is rather buggy, and it will be replaced by a better
-mechanism in the near future.
-@cindex @code{Thread_devnull_engraver}
-@cindex @code{Voice_engraver}
-@cindex @code{A2_engraver}
@node Hiding staves
@subsection Hiding staves
In orchestral scores, staff lines that only have rests are usually
removed. This saves some space. This style is called `French Score'.
-For @internalsref{Lyrics}, @internalsref{LyricsVoice},
+For @internalsref{Lyrics}, @internalsref{Lyrics},
@internalsref{ChordNames} and @internalsref{FiguredBass}, this is
switched on by default. When these line of these contexts turn out
empty after the line-breaking process, they are removed.
\tag #'part <<
R1 \\
@{
- \property Voice.fontSize = #-1
+ \set fontSize = #-1
c4_"cue" f2 g4 @}
>>
\tag #'score R1
@end example
would yield
-@lilypondfile[notexidoc]{tag-filter.ly}
+@lilypondfile[]{tag-filter.ly}
The argument of the @code{\tag} command should be a symbol, or a list
of symbols, for example,
@seealso
-@inputfileref{input/regression,tag-filter.ly}
+Examples: @inputfileref{input/regression,tag-filter.ly}.
@node Sound output for transposing instruments
@cindex @code{transposing}
@example
- \property Staff.instrument = #"Cl. in B-flat"
- \property Staff.transposing = #-2
+ \set Staff.instrument = #"Cl. in B-flat"
+ \set Staff.transposing = #-2
@end example
-@node Ancient notation
+@node Ancient notation
@section Ancient notation
@cindex Vaticana, Editio
The following example demonstrates the @code{neo_mensural} style:
-@lilypond[fragment,singleline,verbatim]
- \property Voice.NoteHead \set #'style = #'neo_mensural
+@lilypond[fragment,raggedright,verbatim]
+ \override NoteHead #'style = #'neo_mensural
a'\longa a'\breve a'1 a'2 a'4 a'8 a'16
@end lilypond
@seealso
-@inputfileref{input/regression,note-head-style.ly} gives an overview
-over all available note head styles.
-
+In this manual:
@ref{Percussion staves} use note head styles of their own that are
frequently used in contemporary music notation.
+Examples: @inputfileref{input/regression,note-head-style.ly} gives an
+overview over all available note head styles.
+
+
@node Ancient accidentals
@subsection Ancient accidentals
select ancient accidentals. Supported styles are
@code{mensural}, @code{vaticana}, @code{hufnagel} and @code{medicaea}.
-@lilypond[singleline,26pt]
+@lilypond[raggedright,staffsize=26]
\score {
\notes {
\fatText
@seealso
-@ref{Pitches}, @ref{Chromatic alterations} and @ref{Accidentals} give
-a general introduction into the use of accidentals. @ref{Key
-signature} gives a general introduction into the use of key
-signatures.
+In this manual: @ref{Pitches}, @ref{Chromatic alterations} and
+@ref{Accidentals} give a general introduction into the use of
+accidentals. @ref{Key signature} gives a general introduction into
+the use of key signatures.
+Internals: @internalsref{KeySignature}.
+
+Examples: @inputfileref{input/test,ancient-accidentals.ly}.
@node Ancient rests
@subsection Ancient rests
The following example demonstrates the @code{neo_mensural} style:
-@lilypond[fragment,singleline,verbatim]
- \property Voice.Rest \set #'style = #'neo_mensural
+@lilypond[fragment,raggedright,verbatim]
+ \override Rest #'style = #'neo_mensural
r\longa r\breve r1 r2 r4 r8 r16
@end lilypond
@seealso
-@ref{Rests} gives a general introduction into the use of rests.
+In this manual: @ref{Rests} gives a general introduction into the use of rests.
@node Ancient clefs
modern style mensural C clef @tab
@code{neo_mensural_c1}, @code{neo_mensural_c2},
@code{neo_mensural_c3}, @code{neo_mensural_c4} @tab
-@lilypond[relative 0, notime]
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+\override Staff.TimeSignature #'transparent = ##t
\clef "neo_mensural_c2" c
@end lilypond
@code{petrucci_c5}
@tab
-@lilypond[relative 0, notime]
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+\override Staff.TimeSignature #'transparent = ##t
\clef "petrucci_c2" c
@end lilypond
@code{clefs-petrucci_f} @tab
petrucci style mensural F clef @tab
@code{petrucci_f} @tab
-@lilypond[relative 0, notime]
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+\override Staff.TimeSignature #'transparent = ##t
\clef "petrucci_f" c
@end lilypond
@code{clefs-petrucci_g} @tab
petrucci style mensural G clef @tab
@code{petrucci_g} @tab
-@lilypond[relative 0, notime]
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+\override Staff.TimeSignature #'transparent = ##t
\clef "petrucci_g" c
@end lilypond
historic style mensural C clef @tab
@code{mensural_c1}, @code{mensural_c2}, @code{mensural_c3},
@code{mensural_c4} @tab
-@lilypond[relative 0, notime]
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+\override Staff.TimeSignature #'transparent = ##t
\clef "mensural_c2" c
@end lilypond
@code{clefs-mensural_f} @tab
historic style mensural F clef @tab
@code{mensural_f} @tab
-@lilypond[relative 0, notime]
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+\override Staff.TimeSignature #'transparent = ##t
\clef "mensural_f" c
@end lilypond
@code{clefs-mensural_g} @tab
historic style mensural G clef @tab
@code{mensural_g} @tab
-@lilypond[relative 0, notime]
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+\override Staff.TimeSignature #'transparent = ##t
\clef "mensural_g" c
@end lilypond
@code{clefs-vaticana_do} @tab
Editio Vaticana style do clef @tab
@code{vaticana_do1}, @code{vaticana_do2}, @code{vaticana_do3} @tab
-@lilypond[relative 0, notime]
-\context Staff
-\outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+ \override Staff.StaffSymbol #'line-count = #4
+\override Staff.TimeSignature #'transparent = ##t
\clef "vaticana_do2" c
@end lilypond
@code{clefs-vaticana_fa} @tab
Editio Vaticana style fa clef @tab
@code{vaticana_fa1}, @code{vaticana_fa2} @tab
-@lilypond[relative 0, notime]
-\context Staff
-\outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+ \override Staff.StaffSymbol #'line-count = #4
+\override Staff.TimeSignature #'transparent = ##t
\clef "vaticana_fa2" c
@end lilypond
@code{clefs-medicaea_do} @tab
Editio Medicaea style do clef @tab
@code{medicaea_do1}, @code{medicaea_do2}, @code{medicaea_do3} @tab
-@lilypond[relative 0, notime]
-\context Staff
-\outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+ \override Staff.StaffSymbol #'line-count = #4
+\override Staff.TimeSignature #'transparent = ##t
\clef "medicaea_do2" c
@end lilypond
@code{clefs-medicaea_fa} @tab
Editio Medicaea style fa clef @tab
@code{medicaea_fa1}, @code{medicaea_fa2} @tab
-@lilypond[relative 0, notime]
-\context Staff
-\outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+ \override Staff.StaffSymbol #'line-count = #4
+\override Staff.TimeSignature #'transparent = ##t
\clef "medicaea_fa2" c
@end lilypond
@code{clefs-hufnagel_do} @tab
historic style hufnagel do clef @tab
@code{hufnagel_do1}, @code{hufnagel_do2}, @code{hufnagel_do3} @tab
-@lilypond[relative 0, notime]
-\context Staff
-\outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+ \override Staff.StaffSymbol #'line-count = #4
+\override Staff.TimeSignature #'transparent = ##t
\clef "hufnagel_do2" c
@end lilypond
@code{clefs-hufnagel_fa} @tab
historic style hufnagel fa clef @tab
@code{hufnagel_fa1}, @code{hufnagel_fa2} @tab
-@lilypond[relative 0, notime]
-\context Staff
-\outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+ \override Staff.StaffSymbol #'line-count = #4
+\override Staff.TimeSignature #'transparent = ##t
\clef "hufnagel_fa2" c
@end lilypond
@code{clefs-hufnagel_do_fa} @tab
historic style hufnagel combined do/fa clef @tab
@code{hufnagel_do_fa} @tab
-@lilypond[relative 0, notime]
-\property Staff.TimeSignature \set #'transparent = ##t
+@lilypond[relative,notime]
+\override Staff.TimeSignature #'transparent = ##t
\clef "hufnagel_do_fa" c
@end lilypond
@c Supported clefs:
@c @code{percussion}
@c
-@c @lilypond{\property Staff.TimeSignature \set #'transparent = ##t \clef "percussion" c'}
+@c @lilypond{\override Staff.TimeSignature #'transparent = ##t \clef "percussion" c'}
@c
@c @item modern style tab clef (glyph: @code{clefs-tab})
@c
@c Supported clefs:
@c @code{tab}
@c
-@c @lilypond{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #6 \property Staff.TimeSignature \set #'transparent = ##t \clef "tab" c'}
+@c @lilypond{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #6 \override Staff.TimeSignature #'transparent = ##t \clef "tab" c'}
@emph{Modern style} means ``as is typeset in contemporary editions of
transcribed mensural music''.
@seealso
-For modern clefs, see @ref{Clef}. For the percussion clef, see
-@ref{Percussion staves}. For the @code{TAB} clef, see
-@ref{Tablatures}.
+In this manual: for the percussion clef, see @ref{Percussion staves}.
+For the @code{TAB} clef, see @ref{Tablatures}.
+
+Internals: for modern clefs, see @ref{Clef}.
+
+@refbugs
+
+The mensural g clef is temporarily mapped to the Petrucci g clef,
+until a new mensural g clef will have been implemented.
+
@node Ancient flags
select ancient flags. Besides the @code{default} flag style,
only @code{mensural} style is supported:
-@lilypond[fragment,singleline,verbatim]
- \property Voice.Stem \set #'flag-style = #'mensural
- \property Voice.Stem \set #'thickness = #1.0
- \property Voice.NoteHead \set #'style = #'mensural
+@lilypond[fragment,raggedright,verbatim]
+ \override Stem #'flag-style = #'mensural
+ \override Stem #'thickness = #1.0
+ \override NoteHead #'style = #'mensural
\autoBeamOff
c'8 d'8 e'8 f'8 c'16 d'16 e'16 f'16 c'32 d'32 e'32 f'32 s8
c''8 d''8 e''8 f''8 c''16 d''16 e''16 f''16 c''32 d''32 e''32 f''32
of the end of each flare is different between notes on staff lines and
notes between staff lines:
-@lilypond[fragment,singleline]
- \property Voice.Stem \set #'flag-style = #'mensural
- \property Voice.Stem \set #'thickness = #1.0
- \property Voice.Stem \set #'adjust-if-on-staffline = ##f
- \property Voice.NoteHead \set #'style = #'mensural
+@lilypond[fragment,raggedright]
+ \override Stem #'flag-style = #'mensural
+ \override Stem #'thickness = #1.0
+ \override Stem #'adjust-if-on-staffline = ##f
+ \override NoteHead #'style = #'mensural
\autoBeamOff
c'8 d'8 e'8 f'8 c'16 d'16 e'16 f'16 c'32 d'32 e'32 f'32 s8
c''8 d''8 e''8 f''8 c''16 d''16 e''16 f''16 c''32 d''32 e''32 f''32
@lilypond
\score {
\notes {
- \property Score.timing = ##f
- \property Score.barAlways = ##t
+ \set Score.timing = ##f
+ \set Score.barAlways = ##t
s_\markup { "$\\backslash$time 4/4" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural4/4" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural4/4" }
s
s_\markup { "$\\backslash$time 2/2" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural2/2" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural2/2" }
s
s_\markup { "$\\backslash$time 6/4" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural6/4" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural6/4" }
s
s_\markup { "$\\backslash$time 6/8" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural6/8" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural6/8" }
\break
s_\markup { "$\\backslash$time 3/2" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural3/2" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural3/2" }
s
s_\markup { "$\\backslash$time 3/4" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural3/4" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural3/4" }
s
s_\markup { "$\\backslash$time 9/4" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural9/4" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural9/4" }
s
s_\markup { "$\\backslash$time 9/8" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural9/8" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural9/8" }
\break
s_\markup { "$\\backslash$time 4/8" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural4/8" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural4/8" }
s
s_\markup { "$\\backslash$time 2/4" }
- ^\markup { " " \musicglyph #"timesig-neo\_mensural2/4" }
+ ^\markup { " " \musicglyph #"timesig-neo_mensural2/4" }
\break
}
\paper {
@seealso
-@ref{Time signature} gives a general introduction into the use of time
+Internals: @ref{Time signature} gives a general introduction into the use of time
signatures.
@refbugs
\score {
\notes {
a'1
- \property Staff.Custos \set #'style = #'mensural
+ \override Staff.Custos #'style = #'mensural
\break
g'
}
@seealso
-@internalsref{Custos} and @inputfileref{input/regression,custos.ly}.
+Internals: @internalsref{Custos}.
+
+Examples: @inputfileref{input/regression,custos.ly}.
@node Divisiones
Therefore, @code{gregorian-init.ly} also defines @code{\virgula} and
@code{\caesura}:
-@lilypondfile[notexidoc]{divisiones.ly}
+@lilypondfile[]{divisiones.ly}
@refcommands
@seealso
-@internalsref{BreathingSign}, @internalsref{BreathingSignEvent},
-@inputfileref{input/test,divisiones.ly}, and @ref{Breath marks}.
+In this manual: @ref{Breath marks}.
+
+Internals: @internalsref{BreathingSign}, @internalsref{BreathingSignEvent}.
+
+Examples: @inputfileref{input/test,divisiones.ly}.
@node Ligatures
@subsection Ligatures
By default, the @internalsref{LigatureBracket} engraver just puts a
square bracket above the ligature:
-@lilypond[singleline,verbatim]
+@lilypond[raggedright,verbatim]
\score {
\notes \transpose c c' {
\[ g c a f d' \]
For example,
@example
- \property Score.timing = ##f
- \property Score.defaultBarType = "empty"
- \property Voice.NoteHead \set #'style = #'neo_mensural
- \property Staff.TimeSignature \set #'style = #'neo_mensural
+ \set Score.timing = ##f
+ \set Score.defaultBarType = "empty"
+ \override NoteHead #'style = #'neo_mensural
+ \override Staff.TimeSignature #'style = #'neo_mensural
\clef "petrucci_g"
\[ g\longa c\breve a\breve f\breve d'\longa \]
s4
\[ e1 f1 a\breve g\longa \]
@end example
-@lilypond[singleline]
+@lilypond[raggedright]
\score {
\notes \transpose c c' {
- \property Score.timing = ##f
- \property Score.defaultBarType = "empty"
- \property Voice.NoteHead \set #'style = #'neo_mensural
- \property Staff.TimeSignature \set #'style = #'neo_mensural
+ \set Score.timing = ##f
+ \set Score.defaultBarType = "empty"
+ \override NoteHead #'style = #'neo_mensural
+ \override Staff.TimeSignature #'style = #'neo_mensural
\clef "petrucci_g"
\[ g\longa c\breve a\breve f\breve d'\longa \]
s4
@internalsref{Mensural_ligature_engraver}, the same music transcribes
to the following:
-@lilypond[singleline]
+@lilypond[raggedright]
\score {
\notes \transpose c c' {
- \property Score.timing = ##f
- \property Score.defaultBarType = "empty"
- \property Voice.NoteHead \set #'style = #'neo_mensural
- \property Staff.TimeSignature \set #'style = #'neo_mensural
+ \set Score.timing = ##f
+ \set Score.defaultBarType = "empty"
+ \override NoteHead #'style = #'neo_mensural
+ \override Staff.TimeSignature #'style = #'neo_mensural
\clef "petrucci_g"
\[ g\longa c\breve a\breve f\breve d'\longa \]
s4
@item
@code{1. Punctum}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.5cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.5\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=2.5cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=2.5\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{2. Virga}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{3. Apostropha vel Stropha}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{4. Oriscus}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{5. Clivis vel Flexa}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=2.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=2.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{6. Podatus vel Pes}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=2.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=2.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{7. Pes Quassus}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{8. Quilisma Pes}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{9. Podatus Initio Debilis}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{10. Torculus}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{11. Torculus Initio Debilis}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{12. Porrectus}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{13. Climacus}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{14. Scandicus}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{15. Salicus}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
}
@end lilypond
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@item
@code{16. Trigonus}
@tab
-@lilypond[noindent, 26pt, nofragment, linewidth=1.0cm]
+@lilypond[noindent,staffsize=26,nofragment,linewidth=1.0\cm]
\include "gregorian-init.ly"
\score {
\notes \transpose c c' {
@seealso
-@internalsref{BassFigureEvent} music, @internalsref{BassFigure} object,
+Internals: @internalsref{BassFigureEvent} music, @internalsref{BassFigure} object,
and @internalsref{FiguredBass} context.
@refbugs
@lilypond[raggedright,verbatim,noindent]
\include "gregorian-init.ly"
\score {
- \addlyrics
- \context VaticanaVoice {
- \property Score.BarNumber \set #'transparent = ##t
+<<
+ \context VaticanaVoice = "cantus" {
+ \override Score.BarNumber #'transparent = ##t
\notes {
- \[ c'( c' \flexa a \] \[ a \flexa \deminutum g) \] f \divisioMinima
- \[ f( \pes a c' c' \pes d') \] c' \divisioMinima \break
- \[ c'( c' \flexa a \] \[ a \flexa \deminutum g) \] f \divisioMinima
+ \[ c'\melisma c' \flexa a \] \[ a \flexa \deminutum g\melismaEnd \] f \divisioMinima
+ \[ f\melisma \pes a c' c' \pes d'\melismaEnd \] c' \divisioMinima \break
+ \[ c'\melisma c' \flexa a \] \[ a \flexa \deminutum g\melismaEnd \] f \divisioMinima
}
}
- \context Lyrics \lyrics {
+ \lyricsto "cantus" \new Lyrics \lyrics {
San- ctus, San- ctus, San- ctus
- }
+ } >>
+
}
@end lilypond
cluster-notes. Cluster notes are created by applying the function
@code{notes-to-clusters} to a sequence of chords, e.g.
@c
-@lilypond[relative 1,verbatim]
+@lilypond[relative=1,verbatim]
\apply #notes-to-clusters { <c e > <b f'> }
@end lilypond
@inputfileref{input/regression,cluster.ly}) shows what the result
looks like:
-@lilypondfile[notexidoc]{cluster.ly}
+@lilypondfile[]{cluster.ly}
By default, @internalsref{Cluster_spanner_engraver} is in the
@internalsref{Voice} context. This allows putting ordinary notes and
@seealso
-@internalsref{ClusterSpanner}, @internalsref{ClusterSpannerBeacon},
-@inputfileref{input/regression,cluster.ly},
-@internalsref{Cluster_spanner_engraver}, and @internalsref{ClusterNoteEvent}.
+Internals: @internalsref{ClusterSpanner},
+@internalsref{ClusterSpannerBeacon},
+@internalsref{Cluster_spanner_engraver}, and
+@internalsref{ClusterNoteEvent}.
+
+Examples: @inputfileref{input/regression,cluster.ly}.
@refbugs
The following are supported
-@lilypond[singleline]
+@lilypond[raggedright]
\score {
<< \addlyrics \notes {
b'
See @ref{Articulations} for general instructions how to apply scripts
such as fermatas to a @code{\notes@{@}} block.
+
+@node Special notation
+@section Special notation
+
+@menu
+* Balloon help::
+* Easy Notation note heads::
+@end menu
+
+@node Balloon help
+@subsection Balloon help
+
+Elements of notation can be marked and named with the help of a square
+balloon. The primary purpose of this feature is to explain notation.
+
+The following example demonstrates its use.
+
+@lilypond[verbatim,fragment,raggedright,relative=1]
+ \context Voice
+ \applyoutput
+ #(add-balloon-text 'NoteHead "heads, or tails?"
+ '(1 . -3))
+ c8
+@end lilypond
+
+@noindent
+The function @code{add-balloon-text} takes the name of a grob, the
+label to print and where to put the label relative to the object. In
+the above example, the text ``heads or tails?'' ends 3 spaces below
+the `balloon.'
+
+@cindex balloon
+@cindex notation, explaining
+
+@seealso
+
+Internals: @internalsref{text-balloon-interface}.
+
+Examples: @inputfileref{input/regression,balloon.ly}.
+
+@node Easy Notation note heads
+@subsection Easy Notation note heads
+
+@cindex easy notation
+@cindex Hal Leonard
+
+The `easy play' note head includes a note name inside the head. It is
+used in music aimed at beginners:
+
+@lilypond[raggedright,verbatim,staffsize=26]
+\score {
+ \notes { c'2 e'4 f' | g'1 }
+ \paper { \translator { \EasyNotation } }
+}
+@end lilypond
+
+The @code{EasyNotation} variable overrides a @internalsref{Score}
+context. To make the letters readable, it has to be printed in a
+large font size. To print with a larger font, see @ref{Font Size}.
+
+@cindex Xdvi
+@cindex ghostscript
+
+If you view the result with Xdvi, then staff lines may show through
+the letters. Printing the PostScript file obtained does produce the
+correct result.
+
+
+
@node Tuning output
@section Tuning output
properties. Translation properties always use a mixed caps style
naming, and are manipulated using @code{\property}:
@example
- \property Context.propertyName = @var{value}
+ \set Context.propertyName = @var{value}
@end example
+
Layout properties are use Scheme style variable naming, i.e. lower
case words separated with dashes. They are symbols, and should always
be quoted using @code{#'}. For example, this could be an imaginary
#'layout-property-name
@end example
+@seealso
+
+The introduction of the @ref{Technical manual} gives a more in-depth
+treatment of the difference between translation and layout.
+
@menu
-* Tuning objects ::
+* Tuning objects::
* Constructing a tweak::
* Applyoutput::
-* Outputproperty::
* Font selection::
-* Text markup::
@end menu
-@node Tuning objects
+@node Tuning objects
@subsection Tuning objects
@cindex object description
@example
(thickness . 1.3)
- (beamed-lengths . (0.0 2.5 2.0 1.5))
+ (beamed-lengths . (3.5 3.5 3.5 4.5 5.0))
(Y-extent-callback . ,Stem::height)
@var{...}
@end example
@code{\once}:
@example
-\once \property @var{context}.@var{objectname}
- \override @var{symbol} = @var{value}
+\once \override @var{context}.@var{objectname}
+ @var{symbol} = @var{value}
@end example
Here @var{symbol} is a Scheme expression of symbol type, @var{context}
and @var{objectname} is a string and @var{value} is a Scheme expression.
In the following example, only one @internalsref{Stem} object is
changed from its original setting:
-@lilypond[verbatim, fragment, relative=1]
+@lilypond[verbatim,fragment,relative=1]
c4
- \once \property Voice.Stem \set #'thickness = #4
+ \once \override Stem #'thickness = #4
c4
c4
@end lilypond
For changing more objects, the same command, without @code{\once} can
be used:
@example
-\property @var{context}.@var{objectname} \override @var{symbol} = @var{value}
+\override @var{context}.@var{objectname} @var{symbol} = @var{value}
@end example
This command adds @code{@var{symbol} = @var{value}} to the definition
of @var{objectname} in the context @var{context}, and this definition
and is often more convenient to use
@example
-\property @var{context}.@var{objectname} \set @var{symbol} = @var{value}
+\override @var{context}.@var{objectname} @var{symbol} = @var{value}
@end example
Some examples:
@lilypond[verbatim,quote]
-c'4 \property Voice.Stem \override #'thickness = #4.0
+c'4 \override Stem #'thickness = #4.0
c'4
-c'4 \property Voice.Stem \revert #'thickness
+c'4 \revert Stem #'thickness
c'4
@end lilypond
one (assuming the system default for stem thickness is 1.3):
@c
@lilypond[verbatim,quote]
- c'4 \property Voice.Stem \set #'thickness = #4.0
+ c'4 \override Stem #'thickness = #4.0
c'4
- c'4 \property Voice.Stem \set #'thickness = #1.3
+ c'4 \override Stem #'thickness = #1.3
c'4
@end lilypond
@end example
@end itemize
- The object description is an Scheme association
-list. Since a Scheme list is a singly linked list, we can treat it as
-a stack, and @code{\override} and @code{\revert} are push and pop
-operations. The association list is stored in a normal context
-property, hence
+The object description is an Scheme association list. Since a Scheme
+list is a singly linked list, we can treat it as a stack, and
+@code{\override} and @code{\revert} are push and pop operations. The
+association list is stored in a normal context property, hence
@example
- \property Voice.NoteHead = #'()
+ \set NoteHead = #'()
@end example
will effectively erase @internalsref{NoteHead}s from the current
@internalsref{Voice}. Typically, this will blank the object. However,
@seealso
-@internalsref{OverrideProperty}, @internalsref{RevertProperty},
+Internals: @internalsref{OverrideProperty}, @internalsref{RevertProperty},
@internalsref{PropertySet}, @internalsref{All-backend-properties}, and
@internalsref{All-layout-objects}.
crashes. Reverting properties that are system defaults may also lead
to crashes.
+@menu
+* Constructing a tweak::
+* Applyoutput::
+* Font selection::
+* Text markup::
+@end menu
+
@node Constructing a tweak
@subsection Constructing a tweak
@quotation
@seealso
-@internalsref{FingerEvent} and @internalsref{Fingering}.
+Internals: @internalsref{FingerEvent} and @internalsref{Fingering}.
@end quotation
fingering. The following command inserts 3 staff spaces of white
between the note and the fingering:
@example
-\once \property Voice.Fingering \set #'padding = #3
+\once \override Fingering #'padding = #3
@end example
Inserting this command before the Fingering object is created,
i.e. before @code{c2}, yields the following result:
@lilypond[relative=2,fragment,verbatim]
-\once \property Voice.Fingering
- \set #'padding = #3
+\once \override Fingering
+ #'padding = #3
c-2
\stemUp
f
@end example
so tuning the settings for Fingering should be done with
@example
- \property Voice.Fingering \set @dots{}
+ \override Fingering @dots{}
@end example
Of course, the tweak may also done in a larger context than
@seealso
-The program reference also contains alphabetical lists of
+Internals: the program reference also contains alphabetical lists of
@internalsref{Contexts}, @internalsref{All-layout-objects} and
-@internalsref{Music-expressions}, so you can also find which objects to
-tweak by browsing the internals document.
+@internalsref{Music-expressions}, so you can also find which objects
+to tweak by browsing the internals document.
@node Applyoutput
@item the context where @code{\applyoutput} is processed.
@end itemize
+
In addition, the cause of the layout object, i.e. the music
expression or object that was responsible for creating it, is in the
object property @code{cause}. For example, for a note head, this is a
@internalsref{NoteHead} event, and for a @internalsref{Stem} object,
this is a @internalsref{NoteHead} object.
+Here is a simple example of @code{\applyoutput}; it blanks note-heads on the
+center-line:
+@example
+(define (blanker grob grob-origin context)
+ (if (and (memq (ly:get-grob-property grob 'interfaces)
+ note-head-interface)
+ (eq? (ly:get-grob-property grob 'staff-position) 0))
+
+ (ly:set-grob-property! grob 'transparent #t)))
+@end example
+
@node Font selection
The most common thing to change about the appearance of fonts is their
size. The font size of any context can be easily changed by setting
-the @code{fontSize} property for that context. Its value is an
-integer: negative numbers make the font smaller, positive numbers
-larger. An example is given below:
+the @code{fontSize} property for that context. Its value is a number:
+negative numbers make the font smaller, positive numbers larger. An
+example is given below:
@c
@lilypond[fragment,relative=1,verbatim,quote]
- c4 c4 \property Voice.fontSize = #-1
+ c4 c4 \set fontSize = #-1
f4 g4
@end lilypond
-This command will set @code{font-relative-size} (see below), and does
+This command will set @code{font-size} (see below), and does
not change the size of variable symbols, such as beams or slurs.
-
-One of the uses of @code{fontSize} is to get smaller symbol for cue
+One of the uses of @code{fontSize} is to get smaller symbols for cue
notes. An elaborate example of those is in
@inputfileref{input/test,cue-notes.ly}.
@cindex magnification
-
-The size of the font may be scaled with the object property
-@code{font-magnification}. For example, @code{2.0} blows up all
-letters by a factor 2 in both directions.
-
-
@cindex cue notes
-@cindex font size
-@cindex size
-@cindex symbol size
-@cindex glyph size
The font used for printing a object can be selected by setting
@code{font-name}, e.g.
@example
- \property Staff.TimeSignature
- \set #'font-name = #"cmr17"
+ \override Staff.TimeSignature
+ #'font-name = #"cmr17"
@end example
@noindent
Any font can be used, as long as it is available to @TeX{}. Possible
fonts include foreign fonts or fonts that do not belong to the
-Computer Modern font family.
+Computer Modern font family. The size of fonts selected in this way
+can be changed with the @code{font-magnification} property. For
+example, @code{2.0} blows up all letters by a factor 2 in both
+directions.
+
+@cindex font size
+@cindex font magnification
Font selection for the standard fonts, @TeX{}'s Computer Modern fonts,
can also be adjusted with a more fine-grained mechanism. By setting
all three mechanisms work for every object that supports
@code{font-interface}:
+
@table @code
@item font-family
is a symbol indicating the general class of the typeface. Supported are
font series for each font family and shape. Choices are @code{medium}
and @code{bold}.
-@item font-relative-size
- is a number indicating the size relative the standard size. For example,
- with 20pt staff height, relative size -1 corresponds to 16pt staff
- height, and relative size +1 corresponds to 23 pt staff height.
-
- There are small differences in design between fonts designed for
-different sizes, hence @code{font-relative-size} is preferred over
-@code{font-magnification} for changing font sizes.
-
-
-@item font-design-size
-is a number indicating the design size of the font.
-
-This is a feature of the Computer Modern Font: each point size has a
-slightly different design. Smaller design sizes are relatively wider,
-which enhances readability.
@end table
For any of these properties, the value @code{*} (i.e. the symbol
@code{*}, entered as @code{#'*}), acts as a wildcard. This can be used
to override default setting, which are always present. For example:
@example
- \property Lyrics . LyricText \override #'font-series = #'bold
- \property Lyrics . LyricText \override #'font-family = #'typewriter
- \property Lyrics . LyricText \override #'font-shape = #'*
+ \override Lyrics .LyricText #'font-series = #'bold
+ \override Lyrics .LyricText #'font-family = #'typewriter
+ \override Lyrics .LyricText #'font-shape = #'*
@end example
@cindex @code{font-style}
+The font size is set by modifying the @code{font-size} property. Its
+value is a number indicating the size relative to the standard size.
+Each step up is an increase of approximately 12% of the font size. Six
+steps is exactly a factor two. The Scheme function @code{magstep}
+converts a @code{font-size} number to a scaling factor.
+
+LilyPond has fonts in different design sizes: the music fonts for
+smaller sizes are chubbier, while the text fonts are relatively wider.
+Font size changes are achieved by scaling the design size that is
+closest to the desired size.
+
+The @code{font-size} mechanism does not work for fonts selected
+through @code{font-name}. These may be scaled with
+@code{font-magnification}.
+
@refcommands
The following commands set @code{fontSize} for the current voice.
@cindex @code{\normalsize}
@code{\normalsize},
-@refbugs
+@seealso
-Relative size is not linked to any real size.
+Init files: @file{ly/declarations-init.ly} contains hints how new
+fonts may be added to LilyPond.
+
+@refbugs
There is no style sheet provided for other fonts besides the @TeX{}
-family, and the style sheet cannot be modified easily.
+Computer Modern family.
@cindex font selection
@cindex font magnification
@node Text markup
-@subsection Text markup
+@section Text markup
@cindex text markup
@cindex markup text
@noindent
For clarity, you can also do this for single arguments, e.g.
-@example
- \markup @{ is \italic @{ anyone @} home @}
-@end example
+
+@verbatim
+ \markup { is \italic { anyone } home }
+@end verbatim
@cindex font size, texts
-The following size commands set absolute sizes:
-@cindex @code{\teeny}
-@cindex @code{\tiny}
-@cindex @code{\small}
-@cindex @code{\large}
-@cindex @code{\huge}
+In markup mode you can compose expressions, similar to mathematical
+expressions, XML documents and music expressions. The braces group
+notes into horizontal lines. Other types of lists also exist: you can
+stack expressions grouped with @code{<}, and @code{>} vertically with
+the command @code{\column}. Similarly, @code{\center} aligns texts by
+their center lines:
-@table @code
-@item \teeny
-@item \tiny
-@item \small
-@item \large
-@item \huge
-@end table
+@lilypond[verbatim,fragment,relative=1]
+ c1^\markup { \column < a bbbb c > }
+ c1^\markup { \center < a bbbb c > }
+ c1^\markup { \line < a b c > }
+@end lilypond
-You can also make letter larger or smaller relative to their neighbors,
-with the commands @code{\larger} and @code{\smaller}.
-@cindex smaller
-@cindex larger
-@cindex font style, for texts
-@cindex @code{\bold}
-@cindex @code{\dynamic}
-@cindex @code{\number}
-@cindex @code{\italic}
+Markups can be stored in variables, and these variables
+may be attached to notes, like
+@verbatim
+allegro = \markup { \bold \large { Allegro } }
+\notes { a^\allegro b c d }
+@end verbatim
-The following font change commands are defined:
-@table @code
-@item \dynamic
-changes to the font used in dynamic signs. This font does not
-contain all characters of the alphabet, so when producing ``piu f'',
-the ``piu'' should be done in a different font.
-
-
-@item \number
-changes to the font used in time signatures. It only contains
-numbers and a few punctuation marks.
-@item \italic
-changes @code{font-shape} to @code{italic}.
-@item \bold
-changes @code{font-series} to @code{bold}.
-@end table
-@cindex raising text
-@cindex lowering text
-@cindex moving text
-@cindex translating text
+Some objects have alignment procedures of their own, which cancel out
+any effects of alignments applied to their markup arguments as a
+whole. For example, the @internalsref{RehearsalMark} is horizontally
+centered, so using @code{\mark \markup @{ \left-align .. @}} has no
+effect. Similarly, whole texts over notes cannot be moved vertically
+with @code{\raise}. For moving and aligning complete objects, grob
+properties should be used.
-@cindex @code{\sub}
-@cindex @code{\super}
-Raising and lowering texts can be done with @code{\super} and
-@code{\sub}:
-@lilypond[verbatim,fragment,relative=1]
- c1^\markup { E "=" mc \super "2" }
-@end lilypond
+@seealso
-@cindex @code{\raise}
+Init files: @file{scm/new-markup.scm}.
-If you want to give an explicit amount for lowering or raising, use
-@code{\raise}. This command takes a Scheme valued first argument, and
-a markup object as second argument:
-@c
-@lilypond[verbatim,fragment,relative=1,quote]
- c1^\markup { C \small \raise #1.0 \bold { "9/7+" }}
-@end lilypond
-The argument to @code{\raise} is the vertical displacement amount,
-measured in (global) staff spaces. @code{\raise} and @code{\super}
-raise objects in relation to their surrounding markups. They cannot be
-used to move a single text up or down, when it is above or below a
-note, since the mechanism that positions it next to the note cancels
-any vertical shift. For vertical positioning, use the @code{padding}
-and/or @code{extra-offset} properties.
-
-Other commands taking single arguments include
-@table @code
-@item \bracket, \hbracket
- Bracket the argument markup with normal and horizontal brackets
-respectively.
+@refbugs
-@item \musicglyph
-@cindex @code{\musicglyph}
- This is converted to a musical symbol, e.g. @code{\musicglyph
-#"accidentals-0"} will select the natural sign from the music font.
-See @ref{The Feta font} for a complete listing of the possible glyphs.
-@item \char
-This produces a single character, e.g. @code{\char #65} produces the
-letter 'A'.
-
-@item \note @var{log} @var{dots} @var{dir}
-@cindex @code{\note}
-
-This produces a note with a stem pointing in @var{dir} direction, with
-duration log @var{log} and @var{dots} augmentation dots. The duration
-log is the negative 2-logarithm of the duration denominator. For
-example, a quarter note has log 2, an eighth note 3 and a breve has
-log -1.
-
-@item \hspace #@var{amount}
-@cindex @code{\hspace}
-This produces a invisible object taking horizontal space.
-@example
-\markup @{ A \hspace #2.0 B @}
-@end example
-will put extra space between A and B, on top of the space that is
-normally inserted before elements on a line.
+Text layout is ultimately done by @TeX{}, which does kerning of
+letters. LilyPond does not account for kerning, so texts will be
+spaced slightly too wide.
-@item \fontsize #@var{size}
-@cindex @code{\fontsize}
-This sets the relative font size, eg.
-@example
-A \fontsize #2 @{ B C @} D
-@end example
+Syntax errors for markup mode are confusing.
+
+Markup texts cannot be used in the titling of the @code{\header}
+field. Titles are made by La@TeX{}, so La@TeX{} commands should be used
+for formatting.
-This will enlarge the B and the C by two steps.
-@item \translate #(cons @var{x} @var{y})
-@cindex \translate
-This translates an object. Its first argument is a cons of numbers
-@example
-A \translate #(cons 2 -3) @{ B C @} D
-@end example
-This moves `B C' 2 spaces to the right, and 3 down.
-@item \magnify #@var{mag}
-@cindex @code{\magnify}
-This sets the font magnification for the its argument. In the following
-example, the middle A will be 10% larger:
+@menu
+* Overview of text markup commands::
+* Markup construction in scheme::
+* Markup command definition::
+@end menu
+
+@node Overview of text markup commands
+@subsection Overview of text markup commands
+
+@include markup-commands.tely
+
+@node Markup construction in scheme
+@subsection Markup construction in scheme
+
+@cindex defining markup commands
+
+The @code{markup} macro builds markup expressions in Scheme while
+providing a LilyPond-like syntax. For example,
@example
-A \magnify #1.1 @{ A @} A
+(markup #:column (#:line (#:bold #:italic "hello" #:raise 0.4 "world")
+ #:bigger #:line ("foo" "bar" "baz")))
@end example
-
-@item \override #(@var{key} . @var{value})
-@cindex @code{\override}
-This overrides a formatting property for its argument. The argument
-should be a key/value pair, e.g.
+@noindent
+is equivalent to:
@example
- m \override #'(font-family . math) m m
+\markup \column < @{ \bold \italic "hello" \raise #0.4 "world" @}
+ \bigger @{ foo bar baz @} >
@end example
-@end table
-In markup mode you can compose expressions, similar to mathematical
-expressions, XML documents and music expressions. The braces group
-notes into horizontal lines. Other types of lists also exist: you can
-stack expressions grouped with @code{<}, and @code{>} vertically with
-the command @code{\column}. Similarly, @code{\center} aligns texts by
-their center lines:
+@noindent
+This example exposes the main translation rules between regular
+LilyPond markup syntax and scheme markup syntax, which are summed up
+is this table:
+@multitable @columnfractions .5 .5
+@item @b{LilyPond} @tab @b{Scheme}
+@item @code{\command} @tab @code{#:command}
+@item @code{\variable} @tab @code{variable}
+@item @code{@{ ... @}} @tab @code{#:line ( ... )}
+@item @code{\center < ... >} @tab @code{#:center ( ... )}
+@item @code{string} @tab @code{"string"}
+@item @code{#scheme-arg} @tab @code{scheme-arg}
+@end multitable
-@lilypond[verbatim,fragment,relative=1]
- c1^\markup { \column < a bbbb c > }
- c1^\markup { \center < a bbbb c > }
- c1^\markup { \line < a b c > }
-@end lilypond
+Besides, the whole scheme language is accessible inside the
+@code{markup} macro: thus, one may use function calls inside
+@code{markup} in order to manipulate character strings for
+instance. This proves useful when defining new markup commands (see
+@ref{Markup command definition}).
-The markup mechanism is extensible. Refer to
-@file{scm/new-markup.scm} for more information.
+@refbugs
+One can not feed the @code{#:line} (resp @code{#:center},
+@code{#:column}) command with a variable or the result of a function
+call. Eg:
+@lisp
+(markup #:line (fun-that-returns-markups))
+@end lisp
+is illegal. One should use the @code{make-line-markup} (resp
+@code{make-center-markup}, @code{make-column-markup}) function
+instead:
+@lisp
+(markup (make-line-markup (fun-that-returns-markups)))
+@end lisp
+
+@node Markup command definition
+@subsection Markup command definition
+
+New markup commands can be defined thanks to the @code{def-markup-command} scheme macro.
+@lisp
+(def-markup-command (@var{command-name} @var{paper} @var{props} @var{arg1} @var{arg2} ...)
+ (@var{arg1-type?} @var{arg2-type?} ...)
+ ..command body..)
+
+ @var{argi}: i@var{th} command argument
+ @var{argi-type?}: a type predicate for the i@var{th} argument
+ @var{paper}: the `paper' definition
+ @var{props}: a list of alists, containing all active properties.
+@end lisp
+
+As a simple example, we show how to add a @code{\smallcaps} command,
+which selects @TeX{}'s small caps font. Normally, we could select the
+small caps font as follows:
+
+@verbatim
+ \markup { \override #'(font-shape . caps) Text-in-caps }
+@end verbatim
+
+This selects the caps font by setting the @code{font-shape} property to
+@code{#'caps} for interpreting @code{Text-in-caps}.
+
+To make the above available as @code{\smallcaps} command, we have to
+define a function using @code{def-markup-command}. The command should
+take a single argument, of markup type. Therefore, the start of the
+definition should read
+@example
+ (def-markup-command (smallcaps paper props argument) (markup?)
+@end example
+@noindent
-@seealso
+What follows is the content of the command: we should interpret
+the @code{argument} as a markup, i.e.
-@internalsref{Markup-functions}, and @file{scm/new-markup.scm}.
+@example
+ (interpret-markup paper @dots{} argument)
+@end example
-@refbugs
+@noindent
+This interpretation should add @code{'(font-shape . caps)} to the active
+properties, so we substitute the the following for the @dots{} in the
+above example:
-@cindex kerning
+@example
+ (cons (list '(font-shape . caps) ) props)
+@end example
+@noindent
+The variable @code{props} is a list of alists, and we prepend to it by
+consing a list with the extra setting.
-Text layout is ultimately done by @TeX{}, which does kerning of
-letters. LilyPond does not account for kerning, so texts will be
-spaced slightly too wide.
+However, suppose that we are using a font that does not have a
+small-caps variant. In that case, we have to fake the small caps font,
+by setting a string in upcase, with the first letter a little larger:
-Syntax errors for markup mode are confusing.
+@example
+#(def-markup-command (smallcaps paper props str) (string?)
+ "Print the string argument in small caps. Syntax: \\smallcaps #\"string\""
+ (interpret-markup paper props
+ (make-line-markup
+ (map (lambda (s)
+ (if (= (string-length s) 0)
+ s
+ (markup #:large (string-upcase (substring s 0 1))
+ #:translate (cons -0.6 0)
+ #:tiny (string-upcase (substring s 1)))))
+ (string-split str #\Space)))))
+@end example
-Markup texts cannot be used in the titling of the @code{\header}
-field. Titles are made by La@TeX{}, so La@TeX{} commands should be used
-for formatting.
+The @code{smallcaps} command first splits its string argument into
+tokens separated by spaces (@code{(string-split str #\Space)}); for
+each token, a markup is built with the first letter made large and
+upcased (@code{#:large (string-upcase (substring s 0 1))}), and a
+second markup built with the following letters made tiny and upcased
+(@code{#:tiny (string-upcase (substring s 1))}). As LilyPond
+introduces a space between markups on a line, the second markup is
+translated to the left (@code{#:translate (cons -0.6 0) ...}). Then,
+the markups built for each token are put in a line
+(@code{(make-line-markup ...)}). Finally, the resulting markup is
+passed to the @code{interpret-markup} function, with the @code{paper}
+and @code{props} arguments.
+
+Finally, suppose that we are typesetting a recitative in an opera, and
+we would like to define a command that will show character names in a
+custom manner. Names should be printed with small caps and translated a
+bit to the left and top. We will define a @code{\character} command
+that takes into account the needed translation, and uses the newly
+defined @code{\smallcaps} command:
+
+@verbatim
+#(def-markup-command (character paper props name) (string?)
+ "Print the character name in small caps, translated to the left and
+ top. Syntax: \\character #\"name\""
+ (interpret-markup paper props
+ (markup "" #:translate (cons -4 2) #:smallcaps name)))
+@end verbatim
+
+There is one complication that needs explanation: texts above and below
+the staff are moved vertically to be at a certain distance (the
+@code{padding} property) from the staff and the notes. To make sure
+that this mechanism does not annihilate the vertical effect of our
+@code{#:translate}, we add an empty string (@code{""}) before the
+translated text. Now the @code{""} will be put above the notes, and the
+@code{name} is moved in relation to that empty string. The net effect is
+that the text is moved to the upper left.
+
+The final result is as follows:
+@verbatim
+\score {
+ \notes { \fatText
+ c''^\markup \character #"Cleopatra"
+ e'^\markup \character #"Giulio Cesare"
+ }
+}
+@end verbatim
+
+@lilypond[raggedright]
+#(def-markup-command (smallcaps paper props str) (string?)
+ "Print the string argument in small caps. Syntax: \\smallcaps #\"string\""
+ (interpret-markup paper props
+ (make-line-markup
+ (map (lambda (s)
+ (if (= (string-length s) 0)
+ s
+ (markup #:large (string-upcase (substring s 0 1))
+ #:translate (cons -0.6 0)
+ #:tiny (string-upcase (substring s 1)))))
+ (string-split str #\Space)))))
+
+#(def-markup-command (character paper props name) (string?)
+ "Print the character name in small caps, translated to the left and
+ top. Syntax: \\character #\"name\""
+ (interpret-markup paper props
+ (markup "" #:translate (cons -4 0) #:smallcaps name)))
+\score {
+ \notes { \fatText
+ c''^\markup \character #"Cleopatra"
+ e'^\markup \character #"Giulio Cesare"
+ }
+}
+@end lilypond
line breaks and the spacing. These all influence each other. The
choice of spacing determines how densely each system of music is set,
which influences where line breaks breaks are chosen, and thus
-ultimately how many pages a piece of music takes. In this section, the
-algorithm for spacing music is explained, and how spacing can be
-tuned.
+ultimately how many pages a piece of music takes. This section
+explains how to tune the algorithm for spacing.
Globally spoken, this procedure happens in three steps: first,
flexible distances (``springs'') are chosen, based on durations. All
of numbers, so if you want to make it smaller from its, then you could
set
@example
- \property Staff.minimumVerticalExtent = #'(-4 . 4)
+ \set Staff.minimumVerticalExtent = #'(-4 . 4)
@end example
-This sets the vertical size of the current staff to 4 staff-space on
+This sets the vertical size of the current staff to 4 staff spaces on
either side of the center staff line. The argument of
@code{minimumVerticalExtent} is interpreted as an interval, where the
center line is the 0, so the first number is generally negative. The
@seealso
-Vertical alignment of staves is handled by the
+Internals: Vertical alignment of staves is handled by the
@internalsref{VerticalAlignment} object.
durations get more space, shorter durations get less. The shortest
durations get a fixed amount of space (which is controlled by
@code{shortest-duration-space} in the @internalsref{SpacingSpanner} object).
-/The longer the duration, the more space it gets: doubling a
+The longer the duration, the more space it gets: doubling a
duration adds a fixed amount (this amount is controlled by
@code{spacing-increment}) of space to the note.
For example, the following piece contains lots of half, quarter and
8th notes, the eighth note is followed by 1 note head width (NHW).
The quarter note is followed by 2 NHW, the half by 3 NHW, etc.
-@lilypond[fragment, verbatim, relative=1] c2 c4. c8 c4. c8 c4. c8 c8
+@lilypond[fragment,verbatim,relative=1] c2 c4. c8 c4. c8 c4. c8 c8
c8 c4 c4 c4
@end lilypond
Normally, @code{shortest-duration-space} is set to 1.2, which is the
width of a note head, and @code{shortest-duration-space} is set to
-2.0, meaning that the shortest note gets 2 NHW (2 times
+2.0, meaning that the shortest note gets 2 NHW (i.e. 2 times
@code{shortest-duration-space}) of space. For normal notes, this space
is always counted from the left edge of the symbol, so the shortest
notes are generally followed by one NHW of space.
If one would follow the above procedure exactly, then adding a single
32th note to a score that uses 8th and 16th notes, would widen up the
entire score a lot. The shortest note is no longer a 16th, but a 32nd,
-thus adding 2 noteheads of space to every note. To prevent this, the
+thus adding 1 NHW to every note. To prevent this, the
shortest duration for spacing is not the shortest note in the score,
but the most commonly found shortest note. Notes that are even
-shorter this are followed by a space that is proportonial to their
+shorter this are followed by a space that is proportional to their
duration relative to the common shortest note. So if we were to add
only a few 16th notes to the example above, they would be followed by
half a NHW:
-@lilypond[fragment, verbatim, relative=2]
+@lilypond[fragment,verbatim,relative=2]
c2 c4. c8 c4. c16[ c] c4. c8 c8 c8 c4 c4 c4
@end lilypond
\score { \notes {
c'4 e''4 e'4 b'4 |
b'4 e''4 b'4 e''4|
- \property Staff.NoteSpacing \override #'stem-spacing-correction
+ \override Staff.NoteSpacing #'stem-spacing-correction
= #1.5
- \property Staff.StaffSpacing \override #'stem-spacing-correction
+ \override Staff.StaffSpacing #'stem-spacing-correction
= #1.5
c'4 e''4 e'4 b'4 |
b'4 e''4 b'4 e''4|
@seealso
-@internalsref{SpacingSpanner}, @internalsref{NoteSpacing},
+Internals: @internalsref{SpacingSpanner}, @internalsref{NoteSpacing},
@internalsref{StaffSpacing}, @internalsref{SeparationItem}, and
@internalsref{SeparatingGroupSpanner}.
@cindex staff size, setting
@cindex @code{paper} file
-The Feta font provides musical symbols at seven different sizes.
-These fonts are 11 point, 13 point, 16 point, 20 point, 23 point, and
-26 point. The point size of a font is the height of the corresponding
-staff (excluding line thicknesses).
-
-Definitions for these sizes are the files @file{paperSZ.ly}, where
-@code{SZ} is one of 11, 13, 16, 20, 23 and 26. If you include any
-of these files, the variables @code{paperEleven},
-@code{paperThirteen}, @code{paperSixteen},
-@code{paperTwenty}, @code{paperTwentythree}, and @code{paperTwentysix}
-are defined respectively. The default @code{\paper} block is also
-set. These files should be imported at toplevel, i.e.
+The Feta font provides musical symbols at eight seven different
+sizes. Each font is tuned for a different staff size: at smaller sizes
+the font gets heavier, to match the relatively heavier staff lines.
+The recommended font sizes are listed in the following table:
+
+@multitable @columnfractions .25 .25 .25 .25
+
+@item @b{name}
+@tab @b{staff height (pt)}
+@tab @b{staff height (mm)}
+@tab @b{use}
+
+@item feta11
+@tab 11.22
+@tab 3.9
+@tab pocket scores
+
+@item feta13
+@tab 12.60pt
+@tab 4.4mm
+@tab
+
+@item feta14
+@tab 14.14pt
+@tab 5.0mm
+@tab
+
+@item feta16
+@tab 15.87pt
+@tab 5.6mm
+@tab
+
+@item feta18
+@tab 17.82pt
+@tab 6.3mm
+@tab song books
+
+@item feta20
+@tab 17.82pt
+@tab 7.0mm
+@tab standard parts
+
+@item feta23
+@tab 22.45 pt
+@tab 7.9mm
+@tab
+
+@item feta20
+@tab 25.2 pt
+@tab 8.9mm
+@tab
+@c modern rental material ?
+
+@end multitable
+
+These fonts are available in any sizes. The context property
+@code{fontSize} and the layout property @code{staff-space} (in
+@internalsref{StaffSymbol}) can be used to tune size for individual
+staffs. The size of individual staffs are relative to the global size,
+which can be set in the following manner:
+
@example
- \include "paper26.ly"
- \score @{ ... @}
+ #(set-global-staff-size 14)
@end example
-The default font size settings for each staff heights are generated
-from the 20pt style sheet. For more details, see the file
-@file{scm/font.scm}.
+This sets the global default size to 14pt staff height, and scales all
+fonts accordingly.
+
@node Line breaking
For linebreaks at regular intervals use @code{\break} separated by
skips and repeated with @code{\repeat}:
@example
-<< \repeat unfold 7 @{ s1 * 4 \break @}
+<< \repeat unfold 7 @{
+ s1 \noBreak s1 \noBreak
+ s1 \noBreak s1 \break @}
@emph{the real music}
>>
@end example
@noindent
This makes the following 28 measures (assuming 4/4 time) be broken every
-4 measures.
+4 measures, and only there.
+
+@refcommands
+
+@code{\break}, @code{\noBreak}
+@cindex @code{\break}
+@cindex @code{\noBreak}
@seealso
-@internalsref{BreakEvent}.
+Internals: @internalsref{BreakEvent}.
@node Page layout
@cindex @code{interscorelinefill}
If the variable @code{lastpagefill} is defined,
-@c fixme: this should only be done if lastpagefill == #t
+@c fixme: this should only be done if lastpagefill= #t
systems are evenly distributed vertically on the last page. This
might produce ugly results in case there are not enough systems on the
last page. The @command{lilypond-book} command ignores
@cindex page size
@cindex @code{papersize}
-To change the paper size, you must first set the @code{papersize} paper
-variable variable as in the example below. Set it to
-the strings @code{a4}, @code{letter}, or @code{legal}. After this
-specification, you must set the font as described above. If you want
-the default font, then use the 20 point font.
-
+To change the paper size, use the following Scheme code:
@example
- \paper@{ papersize = "a4" @}
- \include "paper16.ly"
+ \paper@{
+ #(set-paper-size "a4")
+ @}
@end example
-The file @code{paper16.ly} will now include a file named @file{a4.ly}, which
-will set the paper variables @code{hsize} and @code{vsize} (used by
-@code{lilypond-book} and @code{lilypond}).
-
@refcommands
@seealso
-@ref{Invoking lilypond},
-@inputfileref{input/regression,between-systems.ly}, and
-@internalsref{NonMusicalPaperColumn}.
+In this manual: @ref{Invoking lilypond}.
+
+Examples: @inputfileref{input/regression,between-systems.ly}.
+
+Internals: @internalsref{NonMusicalPaperColumn}.
@refbugs
Many musically interesting effects, such as swing, articulation,
slurring, etc., are not translated to MIDI.
+Since slurs are not interpreted, @code{\lyricsto} and
+@code{\addlyrics} sections will be interpreted wrongly.
+
+The MIDI output allocates a channel for each Staff, and one for global
+settings. Hence, the MIDI file should not have more than 15 staves
+(or 14 if you do not use drums).
+
@menu
* MIDI block::
@cindex instrument names
@cindex @code{Staff.midiInstrument}
-@cindex @code{Staff.instrument}
The MIDI instrument name is set by the @code{Staff.midiInstrument}
-property or, if that property is not set, the @code{Staff.instrument}
property. The instrument name should be chosen from the list in
@ref{MIDI instruments}.
@refbugs
-If the selected string does not exactly match, then LilyPond uses the
-default (Grand Piano). It is not possible to select an instrument by
-number.
-
+If the selected string does not exactly match, then the default is
+used, which is the Grand Piano.
projects / lilypond.git / blobdiff