@c TODO: LilyPond LilyPond LilyPond
-
@node Tutorial
@chapter Tutorial
-
+
+@html
+<!--- @@WEB-TITLE@@=Tutorial --->
+@end html
+
@menu
* First steps:: Music language of LilyPond
* Simple legend:: Small table of music language symbols
* Running LilyPond:: Printing music
-* The first tune:: The first tune
+* The first real tune:: The first real tune
* Lyrics and chords:: Lyrics and chords
* More movements :: Joining separate pieces of music
* A piano excerpt:: Piano music
LilyPond to produce printed output; you should then be able to create
your first sheets of music.
-The tutorial continues with a bit more elaborate example of real music.
+The tutorial continues with a slightly more elaborate example of real music.
This piece introduces and explains some finer details of LilyPond.
Then, a number of more complex examples follow, that will help you to
produce most complex music with LilyPond.
This section shows how easy writing music with LilyPond actually is. If
you have not seen LilyPond input source before, this section is for you.
-The next section has a small legend of all symbols that are introduced
-here, you may want to keep an eye on that.
+The next section has a table (see @ref{Simple legend}) of all symbols
+that are introduced here, you may want to keep an eye on that.
Writing music with LilyPond is explained below by a number of small
examples. Each example has a small piece of text; the LilyPond input
@separate
The length of a note is specified by adding a number, ``@code{1}'' for a
-whole note, ``@code{2}'' for a halve note, and so on:
+whole note, ``@code{2}'' for a half note, and so on:
@quotation
@example
@end quotation
@separate
-A sharp is made by adding ``@code{is}'', a flat by adding ``@code{es}'':
+A sharp (@texisharp{}) is made by adding ``@code{is}'', a flat
+(@texiflat{}) by adding ``@code{es}'':
@quotation
@example
@end lilypond
@end quotation
+@c accidentals...
There are some interesting points to note in this example. Firstly,
-accidentals don't have to be marked explicitly: you just enter the
-pitch, and LilyPond determines whether or not to print an accidental.
-Secondly, bar lines and beams are drawn automatically. Thirdly,
-LilyPond calculates line breaks for you; it doesn't matter where you
-make new lines in the source file.
+accidentals (sharps and flats) don't have to be marked explicitly: you
+just enter the note name, and LilyPond determines whether or not to
+print an accidental. Secondly, bar lines and beams are drawn
+automatically. Thirdly, LilyPond calculates line breaks for you; it
+doesn't matter where you make new lines in the source file.
The example also indicates that a piece of music written in a high
register needs lots of quotes. This makes the input a bit unreadable,
You must also give a note from which relative starts, in this case
@code{c''}.
-@c In relative ocatave mode, quotes are used to mark large jumps in the
+@c In relative octave mode, quotes are used to mark large jumps in the
@c melody. Without any quotes or commas, the interval between a note and
@c its predecessor is assumed to be a fourth or less. Quotes and commas
@c add octaves in up and down direction.
@c grappig: Pa vond het heel logies, en slim toen-i eenmaal begreep.
@c in eerste instantie drong het `relative' niet door zonder extra uitleg.
You can make a large interval by adding octaviation quotes. Note that
-quotes or commas do not determine the absolote height of a note;
+quotes or commas do not determine the absolute height of a note;
the height of a note is relative to the previous one.
@c don't use commas or quotes in this sentence
For example: @code{c f,} goes down; @code{f, f} are both the same;
@quotation
@lilypond[fragment,relative 1, verbatim]
-c8( cis d )e
+d4( )c16( cis d e c cis d )e( )d4
@end lilypond
@end quotation
@separate
@separate
To print more than one staff, each piece of music that makes up a staff
-is marked by adding @code{\context Staff} before it. These staffs can
-be grouped inside @code{<} and @code{>}, as is demonstrated here:
+is marked by adding @code{\context Staff} before it. These
+@code{Staff}'s can be grouped inside @code{<} and @code{>}, as is
+demonstrated here:
@quotation
@lilypond[fragment,verbatim]
@end quotation
In this example, @code{staffA} and @code{staffB} are names that are
-given to the staffs. For now, it doesn't matter what names you give, as
+given to the staves. For now, it doesn't matter what names you give, as
long as each staff has a unique name.
@separate
-We can typeset a melody with two staffs now:
+We can typeset a melody with two staves now:
@quotation
@lilypond[verbatim]
Notice that the time signature is specified in one melody staff only
(the top staff), but is printed on both. LilyPond knows that the time
-signature should be the same for all staffs.
+signature should be the same for all staves.
@separate
@separate
Crescendi are started with the commands @code{\<} and @code{\>}. The
-command @code{\!} finishes a crescendo on the following.
+command @code{\!} finishes a crescendo on the following note.
@quotation
@lilypond[verbatim,relative 1]
c2\< \!c2-\ff \>c2 \!c2
@c hmm, te losjes, iig
In general, @code{ < @var{stuff} > } is used when @var{stuff} all
happens at the same time, like in chords, or (like in the two-staff
-example above) in a bunch of stacked staffs.
+example above) in a bunch of stacked staves.
@end ignore
Of course, you can combine beams and ties with chords. Notice that
@quotation
@multitable @columnfractions .10 .20 .40
-@item @code{[]}
+@item @code{[ ]}
@tab beam
@tab
@lilypond[fragment, relative 1]
d ~ d
@end lilypond
-@item @code{()}
+@item @code{( )}
@tab slur
@tab
@lilypond[fragment, relative 1]
c c,
@end lilypond
-@item @code{<>}
+@item @code{< >}
@tab chord
@tab
@lilypond[fragment, relative 1]
@unnumberedsubsec Windows users
Windows users start the terminal by clicking on the LilyPond icon.
Notepad is sufficient for editing the LilyPond file. Viewing the PS file
-can be done with @code{gsview32 test.ps}. Viewing DVI files can be done
-with @code{yap test.dvi}. The "print" button in Yap will print files.
-You can also print from the command line by executing @code{gsview32 /s
-test.ps}
+can be done with @code{gsview32 test.ps}.@footnote{ You can also view
+DVI files with @code{yap test.dvi}, but unfortunately the postscript
+interaction seems broken, meaning that you will not see slurs or beams
+in the Yap window.} You can also print from the command line by
+executing @code{gsview32 /s test.ps}
+
-@node The first tune
-@section The first tune
+@node The first real tune
+@section The first real tune
-This tutorial will demonstrate how to use Lilypond by presenting
-examples of input along with resulting output. We will use English
-terms for notation. In case you are not familiar with those, you may
-consult the glossary that is distributed with LilyPond.
+The rest of this tutorial will demonstrate how to use Lilypond by
+presenting examples of input along with resulting output. We will use
+English terms for notation. In case you are not familiar with those,
+you may consult the glossary that is distributed with LilyPond.
The examples discussed are included in the distribution, in the
subdirectory @file{input/tutorial/}@footnote{When we refer to filenames,
@end example
@cindex relative
-As we will see, each note is described by its note name, duration,
-octave and possibly a chromatic alteration. In this setup, the octave
-is indicated by using high quotes (@code{'}) and ``lowered quotes''
-(commas: @code{,}). The central C is denoted by @code{c'}. The C one
-octave higher is @code{c''}. One and two octaves below the central C is
-denoted by @code{c} and @code{c,} respectively.
+@c removed duplicate introduction to octave marks /MB
+@c Shorten even more?
+
+@c As we will see, each note is described by its note name, duration,
+@c octave and possibly a chromatic alteration. In this setup, the octave
+@c is indicated by using high quotes (@code{'}) and ``lowered quotes''
+@c (commas: @code{,}). The central C is denoted by @code{c'}. The C one
+@c octave higher is @code{c''}. One and two octaves below the central C is
+@c denoted by @code{c} and @code{c,} respectively.
Even though a piece of music often spans a range of several octaves, it
mostly moves in small intervals. LilyPond has a special entry mode to
@end example
Two more notes, with pitch @code{a} and @code{b}. Because their
duration is the same as the @code{g,8}, there is no need to enter the
-duration, but you may enter it anyway, i.e., @code{a4 b4}
+duration, but you may enter it anyway, i.e., @code{a8 b8}
@separate
@example
@end example
-Rests are denoted by the special notename @code{r}.
+Rests are denoted by the special note name @code{r}.
@separate
@example
\bar "|."
@}
@end example
-Here the music ends. LilyPond does not automatically typeset and end
-bar, we must explicitely request one, using @code{"|."}.
+Here the music ends. LilyPond does not automatically typeset an end
+bar, we must explicitly request one, using @code{"|."}.
@separate
@example
the @code{\header} block contains assignments. In each assignment, a
variable is set to a value. Lexically, both the variable name and the
assigned value are strings. The values have to be quoted here, because
-they contain spaces, the variable names could also be put within quotes
+they contain spaces. The variable names could also be put within quotes
but it is not necessary.
@separate
@example
@end example
-Some modifiers have predefined names, eg. @code{min} is the same as
+Some modifiers have predefined names, e.g. @code{min} is the same as
@code{3-}, so @code{d-min} is a minor @code{d} chord.
@separate
@example
@end example
-The second argument of @code{\addlyrics} is the melody. We instantiate
+The first argument of @code{\addlyrics} is the melody. We instantiate
a @code{Staff} context explicitly: should you choose to remove the
comment before the ``note heads'' version of the accompaniment, the
accompaniment will be on a nameless staff. The melody has to be on
staff different from the accompaniment. This is accomplished by giving
-the melody and accompaniment staffs different names.
+the melody and accompaniment staves different names.
@separate
@example
@cindex context variables
@cindex setting context variables
An interpretation context has variables, called properties, that tune
-its behaviour. One of the variables is @code{noAutoBeaming}. Setting
-this Staff's property to @code{##t}, which is the boolean value @var{true},
-turns the automatic beaming mechanism off for the current staff.
+its behavior. One of the variables is @code{noAutoBeaming}. Setting
+this @code{Staff}'s property to @code{##t}, which is the boolean value
+@var{true}, turns the automatic beaming mechanism off for the current
+staff.
@cindex GUILE
@cindex Scheme
@cindex accessing Scheme
@end example
MIDI (Musical Instrument Digital Interface) is a standard for
connecting and recording digital instruments. So a MIDI file is like a
-tape recording of an instrument. The @code{\midi} block causes makes the
+tape recording of an instrument. The @code{\midi} block makes the
music go to a MIDI file, so you can listen to the music you entered. It
is great for checking the music. Whenever you hear something weird, you
probably hear a typing error.
some calculations, a @file{.tex} is produced. The contents
of this file are very low-level instructions.
-For example, the following file (@file{miniatures.ly})
+For example, consider the following file (@file{miniatures.ly})
@example
-\version "1.3.124"
+\version "1.4.0"
\header @{
title = "Two miniatures"
tagline = "small is beautiful"
@end example
The titling in this manual was not generated by ly2dvi, so we can't
-exactly show it would look, but the result should resemble this:
+exactly show what it would look like, but the result should resemble this:
@center @strong{Two miniatures}
@flushright
@separate
@example
-\version "1.3.124"
+\version "1.4.0"
@end example
Lilypond and its language are still under development, and occasionally,
details of the syntax are changed. This fragment indicates for which
is too old.
This version number is also used by the @code{convert-ly} program (See
-@ref{convert-ly}), which uses it to update the file to the latest lily
+@ref{convert-ly}), which is used to update the file to the latest lily
version.
@separate
The @code{\score} blocks that follow in the file don't have
@code{\paper} sections, so the settings of this block are substituted: A
-paper block, at top-level, i.e. not in a @code{\score} block sets the
+paper block at top level, i.e. not in a @code{\score} block sets the
default page layout.
@separate
@end example
In previous examples, notes were specified in relative octaves,
-i.e. each note was put in the octave that would put it closest to its
+i.e. each note was put in the octave that is closest to its
predecessor. Besides relative, there is also absolute octave
specification, which you get when you don't specify @code{\relative}. In
this input mode, the central C is denoted by @code{c'}. Going down, you
When you're copying music from existing sheet music, relative octaves
are probably the easiest to use: it's less typing work and errors are
easily spotted. However, if you write LilyPond input directly, either by
-hand (i.e. composing) or by computer, absolute octaves are easier to use.
+hand (i.e. composing) or by computer, absolute octaves may be easier to use.
@separate
\context Voice = oboeTwo {
\stemDown
\grace {
- \property Grace.Stem \override #'direction = #-1
- [f,16 g] }
+ \property Voice.Stem \override #'direction = #-1
+ [f,16 g]
+ \property Voice.Stem \revert #'direction
+ }
f8 e e2
}
>
stemDown = \property Voice.Stem \override #'direction = #-1
@end example
-Set a proprerty for all Stem grobs in the current Voice:
+Set a property for all Stem grobs in the current Voice:
@code{direction} is set to @code{-1}, which encodes down. The setting
remains in effect until it is reverted.
@end example
Revert the to the previous setting. The effect of precisely one
-@code{\stemDown} or @code{\stemUp} is neutralised.
+@code{\stemDown} or @code{\stemUp} is neutralized.
LilyPond includes the identifiers @code{\stemUp}, @code{\stemDown} along
@end example
In this example, you can see multiple parts on a staff. Each part is
associated with one notation context. This notation context handles
-stems and dynamics (among others). The name of this context is
+stems and dynamics (among others). The type name of this context is
@code{Voice}. For each part we have to make sure that there is
-precisely one @code{Voice} context, so we give it an unique name
+precisely one @code{Voice} context, so we give it a unique name
(`@code{viola}').
@separate
@cindex @code{\grace}
@cindex ornaments
@cindex grace notes
-
@code{\grace} introduces grace notes. It takes one argument, in this
case a chord.
it from the other context. Stems go down in this voice.
@separate
@example
-\grace @{
+\grace
@end example
@cindex Grace context
When a grace section is processed, a @code{Grace} context is
@separate
@example
-\property Grace.Stem \override #'direction = #-1
-[f,16 g] @}
+ \property Voice.Stem \override #'direction = #-1
+ [f,16 g]
+ \property Voice.Stem \revert #'direction
@end example
Normally, grace notes are always stem up, but in this case, the upper
-voice interferes. We set the stems down here.
+voice interferes, so we set the stems down here.
As far as relative mode is concerned, the previous note is the
@code{c'''2} of the upper voice, so we have to go an octave down for
positioned as if it were single part music.
The bass has a little hoom-pah melody to demonstrate parts switching
-between staffs. Since it is repetitive, we use repeats:
+between staves. Since it is repetitive, we use repeats:
@separate
@example
hoomPah = \repeat unfold 8
@cindex transposing
@cindex relative mode and transposing
-Transposing can be done with @code{\transpose}. It takes two arguments
-the first specifies what central C should be transposed to. The second
+Transposing can be done with @code{\transpose}, which takes two arguments.
+The first specifies what central C should be transposed to. The second
is the to-be-transposed music. As you can see, in this case, the
transposition has no effect, as central C stays at central C.
@cindex cross staff voice, automatic
@cindex @code{\autochange}
-Voices can switch between staffs. The easiest way to get this, is to use
+Voices can switch between staves. The easiest way to get this, is to use
@code{\autochange}. This command looks at the pitch of each note, and if
necessary, will cross to the other staff. For this to work, the two
-staffs must be called @code{"up"} and @code{"down"}.
+staves must be called @code{"up"} and @code{"down"}.
@separate
@example
\translator Staff = down
Key = \notes \key as \major
@end example
Declare the key signature of the piece and assign it to the identifier
-@var{Key}. Lateron, we'll use @code{\Key} for all staffs except those
+@var{Key}. Later on, we'll use @code{\Key} for all staves except those
for transposing instruments.
@node The full score
indent = 15 * \staffspace
linewidth = 60 * \staffspace
textheight = 90 * \staffspace
- \translator@{
- \VoiceContext
- \consists "Multi_measure_rest_engraver"
- @}
\translator@{
\HaraKiriStaffContext
- \remove "Multi_measure_rest_engraver"
@}
@}
\midi @{
with a flat sign. LilyPond has a mechanism for font selection and
kerning called Scheme markup text (See @ref{Text markup}). The flat
sign is taken from the music font, and its name is @code{accidentals--1}
-(The sharp sign is called @code{accidentals-+1}). The default font is
+(The natural sign is called @code{accidentals-0}). The default font is
too big for text, so we select a relative size of @code{-2}.
@separate
<
\global
@end example
-Of course, all staffs are simultaneous and use the same global settings.
+Of course, all staves are simultaneous and use the same global settings.
@separate
@example
is the @var{padding}: the amount of extra space that is put between this
Grob and other Grobs. We set the padding to three staff spaces.
-You can find all this kind of information in LilyPond's automatically
-generated documentation in
+You can find information on all these kind of properties in LilyPond's
+automatically generated documentation in
@ifnottex
@ref{ (lilypond-internals)lilypond-internals, LilyPond Internals}.
@end ifnottex
\context StaffGroup = woodwind <
\context Staff = flauti <
@end example
-A new notation context: the StaffGroup. StaffGroup can hold one or more
-Staffs, and will print a big bracket at the left of the score. Start a
-new staff group for the woodwind section (just the flutes in this case).
-Immediately after that, we start the staff for the two flutes, that also
-play simultaneously.
+A new notation context: the @code{StaffGroup}. @code{StaffGroup} can
+hold one or more @code{Staff}'s, and will print a big bracket at the
+left of the score. Start a new staff group for the woodwind section
+(just the flutes in this case). Immediately after that, we start the
+staff for the two flutes, that also play simultaneously.
@separate
@example
(columns "(E" ,text-flat ")"))
@end example
The french horn has the most complex scheme markup name, made up of two
-lines of text. The second line has two elements (columns), the @code{E}
-and the flat sign @code{text-flat} that we defined before.
+lines of text. The second line has three elements (columns), the @code{(E},
+the flat sign @code{text-flat} that we defined before and a final @code{")"}.
+Note that we use a backquote instead of an ordinary quote at the
+beginning of the Scheme expression to be able to access the
+@code{text-flat} identifier, `unquoting' it with a @code{,}.
@separate
@example
transpose this staff by three steps.
Note how we can choose different tuning for entering, printing and
-playing, using @code{\transpose} and the MIDI Staff proprerty
+playing, using @code{\transpose} and the MIDI Staff property
@var{transposing}.
@separate
Voice, Staff, Staffgroup, Score) is just fine. But in this case, we
want a different type of Staff context.
+@example
+ \translator@{
+ \HaraKiriStaffContext
+ @}
+@end example
+
In orchestral scores, it often happens that one instrument has only
rests during one line of the score. The @code{HaraKiriStaffContext} can
be used as a regular @code{StaffContext} drop-in and will take care of
-the automatic removing of empty staffs.
+the automatic removing of empty staves.
@node Extracting an individual part
@subsection Extracting an individual part
Because we separated the music definitions from the @code{\score}
-instantiations, we can easily define a second score from the music of
+instantiations, we can easily define a second score with the music of
the second flute. This then is the part for the second flute player.
Of course, we make separate parts for all individual instruments.
Until now, you have been using @file{ly2dvi} to invoke LilyPond.
There are three other routes. Firstly, there is a script called
@code{lilypond-book}, that allows you to freely mix LilyPond input with
-Texinfo or LaTeX input. For example, this manual was written using
-@code{lilypond-book}. It is discussed in @ref{lilypond-book}.
+Texinfo or \LaTeX input. For example, this manual was written using
+@code{lilypond-book}. It is discussed below and in @ref{lilypond-book}.
Secondly, you can generate PostScript directly. This is useful if you
@example
lilypond -f ps test.ly
@end example
-You have to set some environment variables to view or print this
-output. More information can be found in @ref{Invoking
-LilyPond}.
+You have to set some environment variables to view or print this output.
+More information can be found in @ref{Invoking LilyPond}. Since the
+direct Postscript generation has some problems, it is recommended
+to use @file{ly2dvi}.
Thirdly, if you want to do special things with your output, you can run
@end example
Notice the @code{outdir} option to lilypond-book. Running lilypond-book
-and running latex creates a lot of temporary files, and you wouldn't
+and running latex creates a lot of temporary files, and you wouldn't want
those to clutter up your working directory. Hence, we have them created
in a separate subdirectory.
projects / lilypond.git / blobdiff