+\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
* Orchestral music::
* Ancient notation::
* Contemporary notation::
+* Special notation::
* Tuning output::
+* Text markup::
* Global layout::
* Sound::
@end menu
* Stems::
* Ties::
* Tuplets::
-* Easy Notation note heads::
@end menu
@cindex quarter tones
@cindex semi-flats, semi-sharps
-@lilypond[verbatim,relative 2]
+@lilypond[verbatim,relative=2]
ceses4
ceseh
ces
@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]
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}
+Examples: if you want less ties created for a chord, see
+@inputfileref{input/test,tie-sparse.ly}.
For tying only a subset of the note heads of a pair of chords, see
@inputfileref{input/regression,tie-chord-partial.ly}.
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}.
-
-
-@cindex Xdvi
-@cindex ghostscript
+tuplet brackets should be moved manually, which is demonstrated in
+@inputfileref{input/regression,tuplet-nest.ly}.
-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
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
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
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
@seealso
-Internals: @internalsref{StaffSymbol},
+Internals: @internalsref{StaffSymbol}.
Examples: @inputfileref{input/test,staff-lines.ly},
-@inputfileref{input/test,staff-size.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
+
+@seealso
+
+Internals: @internalsref{OttavaBracket}.
-@internalsref{OttavaSpanner}.
+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
in every context, and that type is determined by the property
@code{systemStartDelimiter}.
+Examples: @inputfileref{input/test,bar-lines.ly},
+
@node Polyphony
@section Polyphony
@cindex polyphony
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
@subsection Setting automatic beam behavior
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
@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
@subsection 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
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,singleline]
+@lilypond[verbatim,raggedright]
\score {
\context Voice \notes\relative c' {
\repeat "tremolo" 8 { c16 d16 }
Tremolo marks can also be put on a single note. In this case, the
note should not be surrounded by braces.
-@lilypond[verbatim,singleline]
+@lilypond[verbatim,raggedright]
\repeat "tremolo" 4 c16
@end lilypond
Internals: tremolo beams are @internalsref{Beam} objects. Single stem
tremolos are @internalsref{StemTremolo}s. The music expression is
-@internalsref{TremoloEvent},
+@internalsref{TremoloEvent}.
Example files: @inputfileref{input/regression,chord-tremolo.ly},
@inputfileref{input/regression,stem-tremolo.ly}.
`@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': |
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}.
-@refbugs
+Internals: @internalsref{DrumStaff}, @internalsref{DrumVoice}.
+@refbugs
-Chords entered with @code{< @dots{} >} do not work. 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
quality output, staff switches should be specified manually.
+
@node Manual staff switches
@subsection Manual staff switches
@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}.
@lilypond[fragment,relative,verbatim]
\context PianoStaff <<
- \property PianoStaff.followVoice = ##t
+ \set PianoStaff.followVoice = ##t
\context Staff \context Voice {
c1
\change Staff=two
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}.
+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
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.
+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 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
@cindex singer's names
@cindex name of singer
-Stanza numbers can be added by setting @code{LyricsVoice.stanza}, e.g.
+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{LyricsVoice.stanza} being interpreted as a single
+prevent @code{stanza} being interpreted as a single
string.
-Names of the singers should be added using @code{LyricsVoice
-. instrument} and @code{LyricsVoice . instr}, analogous to instrument
+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
@end example
This results in the following output:
-@lilypond[singleline]
+
+@lilypond[raggedright]
upper = \notes \relative c {
\clef "treble"
\key c \minor
@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
@lilypond[fragment,verbatim]
\context TabStaff <<
- \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
-@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:
+@example
+ \transpose a c @dots{}
+@end example
+
+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
@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
@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
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]
- \property Staff.StaffSymbol \set #'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]
- \property Staff.StaffSymbol \set #'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]
- \property Staff.StaffSymbol \set #'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]
- \property Staff.StaffSymbol \set #'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]
- \property Staff.StaffSymbol \set #'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]
- \property Staff.StaffSymbol \set #'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::
* Constructing a tweak::
* Applyoutput::
* Font selection::
-* Text markup::
@end menu
@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
@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.
-A property tweak of modifies a local copy of the object definition.
-After such a tweak, the definition is independent of the objects in
-enclosing contexts. For example
-
-@lilypond
- \property Voice.Stem \set #'neutral-direction = #1
- b'8
- \property Staff.Stem \set #'thickness = #4.0
- b'16
- \new Voice { b'32 }
-@end lilypond
-
-In this fragment, @code{neutral-direction} is tweaked. As a result,
-the current @internalsref{Voice} gets a private version of the
-@internalsref{Stem} object. The following tweak modifies the
-definition at @internalsref{Staff} level. Since it a different
-definition, the thickness of the @code{b'16} is unaffected. For the
-third note, a new Voice is created, which inherits the new definition,
-including the changed thickness, but excluding the new neutral
-direction.
-
-
-
@menu
* Constructing a tweak::
* Applyoutput::
@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
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-size} (see below), and does
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
@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}
@seealso
-@file{ly/paper20.ly} contains hints how new fonts may be added to
-LilyPond.
+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.
+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
-
-@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}
-
-@table @code
-@item \teeny
-@item \tiny
-@item \small
-@item \large
-@item \huge
-@end table
-
-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}
-
-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
-
-@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
-
-@cindex @code{\raise}
-
-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.
-
-@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.
-
-@item \fontsize #@var{size}
-@cindex @code{\fontsize}
-This sets the relative font size, eg.
-@example
-A \fontsize #2 @{ B C @} D
-@end example
-
-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, relative to its
-surroundings. This command cannot be used to move isolated scripts
-vertically, for the same reason that @code{\raise} cannot be used for
-that.
-
-@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:
-@example
-A \magnify #1.1 @{ A @} A
-@end example
+@verbatim
+ \markup { is \italic { anyone } home }
+@end verbatim
+@cindex font size, texts
-@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.
-@example
- m \override #'(font-family . math) m m
-@end example
-@end table
In markup mode you can compose expressions, similar to mathematical
expressions, XML documents and music expressions. The braces group
c1^\markup { \line < a b c > }
@end lilypond
+
Markups can be stored in variables, and these variables
may be attached to notes, like
@verbatim
\notes { a^\allegro b c d }
@end verbatim
-The markup mechanism is extensible. Refer to
-@file{scm/new-markup.scm} for more information.
+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.
-@seealso
-@internalsref{Markup-functions}, and @file{scm/new-markup.scm}.
-@refbugs
+@seealso
+
+Init files: @file{scm/new-markup.scm}.
-@cindex kerning
+@refbugs
Text layout is ultimately done by @TeX{}, which does kerning of
letters. LilyPond does not account for kerning, so texts will be
+@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
+(markup #:column (#:line (#:bold #:italic "hello" #:raise 0.4 "world")
+ #:bigger #:line ("foo" "bar" "baz")))
+@end example
+
+@noindent
+is equivalent to:
+@example
+\markup \column < @{ \bold \italic "hello" \raise #0.4 "world" @}
+ \bigger @{ foo bar baz @} >
+@end example
+
+@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
+
+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}).
+
+@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
+
+What follows is the content of the command: we should interpret
+the @code{argument} as a markup, i.e.
+
+@example
+ (interpret-markup paper @dots{} argument)
+@end example
+
+@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:
+
+@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.
+
+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:
+
+@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
+
+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
+
+
@node Global layout
@section Global layout
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 spaces on
either side of the center staff line. The argument of
@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.
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::