[lilypond.git] / Documentation / user / refman.itely

@c Note: -*-texinfo-*-
@c
@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

@c FIXME: singular vs. plural:  Beams/Beam


@macro refbugs
@strong{BUGS}
@end macro


@c .{Reference Manual}

@node Reference Manual
@chapter Reference Manual

@html
<!--- @@WEB-TITLE@@=Reference Manual --->
@end html

This document describes GNU LilyPond and its input format. The last
revision of this document was made for LilyPond 1.6.2.  It assumes
that you already know a little bit about LilyPond input (how to
make an input file, how to create sheet music from that input file,
etc).  New users are encouraged to study the tutorial before reading
this manual.


@menu
* Note entry::                  
* Easier music entry::          
* Staff notation::              
* Polyphony::                   
* Beaming::                     
* Accidentals::                 
* Expressive marks::            
* Ornaments::                   
* Repeats::                     
* Rhythmic music::              
* Piano music::                 
* Tablatures::                  
* Chords::                      
* Writing parts::               
* Ancient notation ::           
* Tuning output::               
* Global layout::               
* Sound::                       
@end menu

@c FIXME: Note entry vs Music entry at top level menu is confusing.
@c . {Note entry}
@node Note entry
@section Note entry
@cindex Note entry

Notes constitute the most basic elements of LilyPond input, but they do
not form valid input on their own without a @code{\score} block.  However,
for the sake of brevity and simplicity we will generally omit
@code{\score} blocks and @code{\paper} declarations in this manual.


@menu
* Notes::                       
* Pitches::                     
* Chromatic alterations::       
* Rests::                       
* Skips::                       
* Durations::                   
* Ties::                        
* Automatic note splitting ::   
* Tuplets::                     
* Easy Notation note heads ::   
@end menu

@c . {Notes}
@node Notes
@subsection Notes


A note is printed by specifying its pitch and then its duration.
@lilypond[fragment,verbatim]
  cis'4 d'8 e'16 c'16
@end lilypond

@c .  {Pitches}
@node Pitches
@subsection Pitches

@cindex Pitch names
@cindex Note specification
@cindex pitches
@cindex entering notes

The verbose syntax for pitch specification is

@cindex @code{\pitch}
@example
  \pitch @var{scmpitch}
@end example

where @var{scmpitch} is a pitch scheme object.

In Note and Chord mode, pitches may be designated by names.  The default
names are the Dutch note names.  The notes are specified by the letters
@code{a} through @code{g}, while the octave is formed with notes ranging
from @code{c} to @code{b}.  The pitch @code{c} is an octave below
middle C and the letters span the octave above that C.  Here's an example
which should make things more clear:

@lilypond[fragment,verbatim]
\clef bass
  a,4 b, c d e f g a b c' d' e' \clef treble f' g' a' b' c''
@end lilypond

@cindex note names, Dutch

In Dutch, a sharp is formed by adding @code{-is} to the end of a pitch
name and a flat is formed by adding @code{-es}.  Double sharps and double
flats are obtained by adding @code{-isis} or @code{-eses}.  @code{aes}
and @code{ees} are contracted to @code{as} and @code{es} in Dutch, but
both forms are accepted.

LilyPond has predefined sets of note names for various other languages.
To use them, simply include the language specific init file.  For
example: @code{\include "english.ly"}.  The available language files and
the note names they define are:

@anchor{note name}
@anchor{note names}
@example 
                        Note Names               sharp       flat
nederlands.ly  c   d   e   f   g   a   bes b   -is         -es
english.ly     c   d   e   f   g   a   bf  b   -s/-sharp   -f/-flat
deutsch.ly     c   d   e   f   g   a   b   h   -is         -es
norsk.ly       c   d   e   f   g   a   b   h   -iss/-is    -ess/-es
svenska.ly     c   d   e   f   g   a   b   h   -iss        -ess
italiano.ly    do  re  mi  fa  sol la  sib si  -d          -b
catalan.ly     do  re  mi  fa  sol la  sib si  -d/-s       -b 
espanol.ly     do  re  mi  fa  sol la  sib si  -s          -b 

@end example 

@cindex @code{'}
@cindex @code{,}



The optional octave specification takes the form of a series of
single quote (`@code{'}') characters or a series of comma
(`@code{,}') characters.  Each @code{'} raises the pitch by one
octave; each @code{,} lowers the pitch by an octave.

@lilypond[fragment,verbatim,center]
  c' c'' es' g' as' gisis' ais'  
@end lilypond

@node Chromatic alterations
@subsection Chromatic alterations

Normally accidentals are printed automatically, but you may also
print them manually.  A reminder accidental
@cindex reminder accidental
@cindex @code{?}
can be forced by adding an exclamation mark @code{!}
after the pitch.  A cautionary accidental
@cindex cautionary accidental
@cindex parenthesized accidental
(an accidental within parentheses) can be obtained by adding the
question mark `@code{?}' after the pitch.

@lilypond[fragment,verbatim]
  cis' cis' cis'! cis'?
@end lilypond


The automatic production of accidentals can be tuned in many
ways. For more information, refer to @ref{Accidentals}.

@c .  {Rests}
@node  Rests
@subsection Rests
@cindex Rests

Rests are entered like notes, with a ``note name'' of `@code{r}':

@lilypond[singleline,verbatim]
r1 r2 r4 r8
@end lilypond

Whole bar rests, centered in middle of the bar, are specified using
@code{R} (capital R); see @ref{Multi measure rests}.  See also
@seeinternals{Rest}.

For some music, you may wish to explicitly specify the rest's vertical
position.  This can be achieved by entering a note with the @code{\rest}
keyword appended. Rest collision testing will leave these rests alone.

@lilypond[singleline,verbatim]
a'4\rest d'4\rest
@end lilypond


@c .  {Skips}
@c FIXME: naming.
@node Skips
@subsection Skips
@cindex Skip
@cindex Invisible rest
@cindex Space note

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]
a2 s4 a4 \skip 1 a4 
@end lilypond

@c FIXME: in Lyrics mode, we have " " and _

In Lyrics mode, invisible rests are entered using either `@code{" "}' 
or `@code{_}':
@lilypond[singleline,verbatim]
<
  \context Lyrics \lyrics { lah2 di4 " " dah2 _4 di }
  \notes\relative c'' { a2 a4 a a2 a4 a }
>
@end lilypond

Note that the @code{s} syntax is only available in Note mode and Chord
mode.  In other situations, you should use the @code{\skip} command,
which will work outside of those two modes:

@lilypond[singleline,verbatim]
\score {
  \context Staff <
    { \time 4/8 \skip 2 \time 4/4 } 
    \notes\relative c'' { a2 a1 }
  >
}
@end lilypond

The skip command is merely an empty musical placeholder.  It doesn't
produce any output, not even transparent output.



@c .  {Durations}
@node Durations
@subsection Durations


@cindex duration
@cindex @code{\duration}


In Note, Chord, and Lyrics mode, durations are designated by numbers
and dots: durations are entered as their reciprocal values.  For example,
a quarter note is entered using a @code{4} (since it's a 1/4 note), while
a half note is entered using a @code{2} (since it's a 1/2 note).  For notes
longer than a whole you must use identifiers.
@c FIXME: what's an identifier?  I don't 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 
r\longa r\breve  
r1 r2 r4 r8 r16 r32 r64 r64 
@end example 

@lilypond[noindent,noquote]
\score {
  \notes \relative c'' {
    a\breve  \autoBeamOff
    a1 a2 a4 a8 a16 a32 a64 a64 
    r\longa r\breve  
    r1 r2 r4 r8 r16 r32 r64 r64 
  }
  \paper {
    \translator {
      \StaffContext
        \remove "Clef_engraver"
        \remove "Staff_symbol_engraver"
        \remove "Time_signature_engraver"
        \consists "Pitch_squash_engraver"
    }
  }
}
@end lilypond


If the duration is omitted then it is set to the previously entered
duration.  At the start of parsing, a quarter note is assumed.  The
duration can be followed by dots (`@code{.}') in order to obtain dotted
note lengths:
@cindex @code{.}

@lilypond[fragment,verbatim,center]
  a' b' c''8 b' a'4 a'4. b'4.. c'8.
@end lilypond
@cindex @code{r}
@cindex @code{s}

You can alter the length of duration by a fraction @var{N/M}
appending `@code{*}@var{N/M}' (or `@code{*}@var{N}' if @var{M=1}). This
won't affect the appearance of the notes or rests produced.

@lilypond[fragment,verbatim]
  a'2*2 b'4*2 a'8*4 a'4*3/2 gis'4*3/2 a'4*3/2 a'4
@end lilypond

Durations can also be produced through GUILE extension mechanism. 
@lilypond[verbatim,fragment]
 c'\duration #(ly:make-duration 2 1)
@end lilypond


@refbugs

Dot placement for chords is not perfect.  In some cases, dots overlap:
@lilypond[]
 <<f, c'' d e f>>4.
@end lilypond


@node Ties
@subsection Ties

@cindex Tie
@cindex ties
@cindex @code{~}

A tie connects two adjacent note heads of the same pitch.  The tie in
effect extends the length of a note.  Ties should not be confused with
slurs, which indicate articulation, or phrasing slurs, which indicate
musical phrasing.  A tie is entered using the tilde symbol `@code{~}'.

@lilypond[fragment,verbatim,center]
  e' ~ e' <<c' e' g'>> ~ <<c' e' g'>>
@end lilypond

When a tie is applied to a chord, all note heads (whose pitches match) are
connected.  If you try to tie together chords that have no common pitches,
no ties will be created.

If you want less ties created for a chord, you can set
@code{Voice.sparseTies} to true.  In this case, a single tie is used
for every tied chord.
@lilypond[fragment,verbatim,center]
  \property Voice.sparseTies = ##t
  <<c' e' g'>> ~ <<c' e' g'>>
@end lilypond

In its meaning a tie is just a way of extending a note duration, similar
to the augmentation dot: the following example are two ways of notating
exactly the same concept.
@c
@lilypond[fragment, singleline]
\time 3/4 c'2. c'2 ~ c'4
@end lilypond
If you need to tie notes over bars, it may be easier to use
@ref{Automatic note splitting}.

See also @seeinternals{Tie}.


@refbugs

At present, the tie is represented as a separate event, temporally
located in between the notes.  Tying only a subset of the note heads
of a chord is not supported in a simple way.  It can be achieved by
moving the tie-engraver into the Thread context and turning on and off
ties per Thread.

Switching staves when a tie is active will not work.

@node Automatic note splitting 
@subsection Automatic note splitting
@c FIXME: This subsection doesn't belong in @ref{Note entry}.

LilyPond can automatically converting long notes to tied notes.  This
is done by replacing the @code{Note_heads_engraver} by the
@code{Completion_heads_engraver}. 

@lilypond[verbatim,noindent,noquote]
\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
      \remove "Note_heads_engraver"
      \consists "Completion_heads_engraver"
  } } }
@end lilypond

This engraver splits all running notes at the bar line, and inserts
ties.  One of its uses is to debug complex scores: if the measures are
not entirely filled, then the ties exactly show how much each measure
is off.

@refbugs

Not all durations (especially those containing tuplets) can be
represented exactly; the engraver will not insert tuplets. 

@node Tuplets
@subsection Tuplets

@cindex tuplets
@cindex triplets
@cindex @code{\times}

Tuplets are made out of a music expression by multiplying all durations
with a fraction.

@cindex @code{\times}
@example
  \times @var{fraction} @var{musicexpr}
@end example

The duration of @var{musicexpr} will be multiplied by the fraction. 
In the sheet music, the fraction's denominator will be printed over
the notes, optionally with a bracket.  The most common tuplet is the
triplet in which 3 notes have the length of 2, so the notes are 2/3
of their written length:

@lilypond[fragment,verbatim,center]
  g'4 \times 2/3 {c'4 c' c'} d'4 d'4
@end lilypond

The property @code{tupletSpannerDuration} specifies how long each bracket
should last.  With this, you can make lots of tuplets while typing
@code{\times} only once, saving you lots of typing.

@lilypond[fragment,  relative, singleline, verbatim]
\property Voice.tupletSpannerDuration = #(ly:make-moment 1 4)
\times 2/3 { c'8 c c c c c }
@end lilypond

The format of the number is determined by the property
@code{tupletNumberFormatFunction}.  The default prints only the
denominator, but if you set it to the Scheme function
@code{fraction-tuplet-formatter}, Lilypond will print @var{num}:@var{den}
instead.


@cindex @code{tupletNumberFormatFunction}
@cindex tuplet formatting 

See also @seeinternals{TupletBracket}.

@refbugs

Nested tuplets are not formatted automatically.  In this case, outer
tuplet brackets should be moved automatically.

@node Easy Notation note heads 
@subsection Easy Notation note heads

@cindex easy notation
@cindex Hal Leonard

A entirely different type of note head is the "easyplay" note head: a
note head that includes a note name.  It is used in some publications by
Hal-Leonard Inc. music publishers.

@lilypond[singleline,verbatim,26pt]
\score {
  \notes { c'2 e'4 f' | g'1 }
  \paper { \translator { \EasyNotation } } 
}
@end lilypond

Note that @code{EasyNotation} 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
(with @file{ly2dvi}) and then enlarge it with something like @file{dvips -x
2000 file.dvi}.  See @file{man dvips} for details.  To print with a larger
font, see @ref{Font Size}.


@cindex Xdvi
@cindex ghostscript

If you view the result with Xdvi, then staff lines will show through
the letters.  Printing the PostScript file obtained with ly2dvi does
produce the correct result.


@node Easier music entry
@section Easier music entry
@cindex Music entry
@menu
* Graphical interfaces::        
* Relative octaves::            
* Bar check::                   
* Point and click::             
* Skipping corrected music::    
@end menu

When entering music with LilyPond, it is easy to introduce errors. This
section deals with tricks and features that help you enter music, and
find and correct mistakes.

@node Graphical interfaces
@subsection Graphical interfaces

@cindex GUI
@cindex graphical interface
@cindex sequencer
@cindex RoseGarden
@cindex Denemo
@cindex NoteEdit
@cindex MIDI

One way to avoid entering notes using the keyboard is to use a
graphical user interface.  The following programs are known to have
a lilypond export option:

@itemize @bullet
@item
Denemo was once intended as
a LilyPond graphical user interface.  It run on Gnome/GTK.

@quotation
@uref{http://denemo.sourceforge.net/}
@end  quotation

@item
 Noteedit, a graphical score editor that runs under KDE/Qt.
@quotation
@uref{http://rnvs.informatik.tu-chemnitz.de/~jan/noteedit/noteedit.html,}
@end quotation

@item
RoseGarden was once the inspiration for naming LilyPond.  Nowadays it
has been rewritten from scratch and supports LilyPond export as of
version 0.1.6.

@quotation
@uref{http://rosegarden.sf.net/}
@end quotation
@end itemize

Another option is to enter the music using your favorite MIDI
sequencer, and then import it using midi2ly. midi2ly is described in
@ref{Invoking midi2ly}.


@c .  {Relative}
@node Relative octaves
@subsection Relative octaves
@cindex Relative
@cindex relative octave specification

Octaves are specified by adding @code{'} and @code{,} to pitch names.
When you copy existing music, it is easy to accidentally put a pitch in
the wrong octave and hard to find such an error.  To prevent these
errors, LilyPond features octave entry.

@cindex @code{\relative}
@example
  \relative @var{startpitch} @var{musicexpr}
@end example

The octave of notes that appear in @var{musicexpr} are calculated as
follows: If no octave changing marks are used, the basic interval
between this and the last note is always taken to be a fourth or less
(This distance is determined without regarding alterations; a
@code{fisis} following a @code{ceses} will be put above the
@code{ceses})

The octave changing marks @code{'} and @code{,} can be added to raise or
lower the pitch by an extra octave.  Upon entering relative mode, an
absolute starting pitch must be specified that will act as the
predecessor of the first note of @var{musicexpr}.

Entering music that changes octave frequently  is easy in relative mode.
@lilypond[fragment,singleline,verbatim,center]
  \relative c'' {
    b c d c b c bes a 
  }
@end lilypond

And octave changing marks are used for intervals greater than a fourth.
@lilypond[fragment,verbatim,center]
  \relative c'' {
    c g c f, c' a, e'' }
@end lilypond

If the preceding item is a chord, the first note of the chord is used
to determine the first note of the next chord. However, other notes
within the second chord are determined by looking at the immediately
preceding note.

@lilypond[fragment,verbatim,center]
  \relative c' {
    c <<c e g>> 
    <<c' e g>>
    <<c, e' g>>
  }
@end lilypond 
@cindex @code{\notes}

The pitch after the @code{\relative} contains a note name.  To parse
the pitch as a note name, you have to be in note mode, so there must
be a surrounding @code{\notes} keyword (which is not
shown here).

The relative conversion will not affect @code{\transpose},
@code{\chords} or @code{\relative} sections in its argument.  If you
want to use relative within transposed music, you must place an
additional @code{\relative} inside the @code{\transpose}.


@c . {Bar check}
@node Bar check
@subsection Bar check
@cindex Bar check

@cindex bar check
@cindex @code{barCheckSynchronize}
@cindex @code{|}


Whenever a bar check is encountered during interpretation, a warning
message is issued if it doesn't fall at a measure boundary.  This can
help you find errors in the input.  Depending on the value of
@code{barCheckSynchronize}, the beginning of the measure will be
relocated, so this can also be used to shorten measures.

A bar check is entered using the bar symbol, @code{|}:
@example
  \time 3/4 c2 e4 | g2.
@end example



@cindex skipTypesetting

Failed bar checks are most often caused by entering incorrect
durations. Incorrect durations often completely garble up the score,
especially if it is polyphonic, so you should start correcting the score
by scanning for failed bar checks and incorrect durations.  To speed up
this process, you can use @code{skipTypesetting} (See @ref{Skipping
corrected music})). 

@c .  {Point and click}
@node Point and click
@subsection Point and click
@cindex poind and click

Point and click lets you find notes in the input by clicking on them in
the Xdvi window. This makes it very easy to find input that causes some
error in the sheet music.

To use it, you need the following software
@itemize @bullet
@item A dvi viewer that supports src specials.
@itemize @bullet
@item Xdvi, version 22.36 or newer.  Available from
@uref{ftp://ftp.math.berkeley.edu/pub/Software/TeX/xdvi.tar.gz,ftp.math.berkeley.edu}.

  Note that most @TeX{} distributions ship with xdvik, which is always
  a few versions behind the official Xdvi. To find out which xdvi you
  are running, try @code{xdvi -version} or @code{xdvi.bin -version}.
@item KDVI.  A dvi viewer for KDE.  You need KDVI from KDE 3.0 or
newer.  Enable option @emph{Inverse search} in the menu @emph{Settings}.

@cindex Xdvi
@cindex KDVI
@cindex KDE



@end itemize
@item An editor with a client/server interface (or a lightweight GUI
editor).

@cindex editor

@itemize @bullet
@item Emacs. Emacs is an extensible text-editor.  It is available from
@uref{http://www.gnu.org/software/emacs/}.  You need version 21 to use
column location.

@c move this elsewhere?

LilyPond also comes with support files for emacs: lilypond-mode for
emacs provides indentation, syntax coloring and handy compile
short-cuts. If lilypond-mode is not installed on your platform, then
refer to the installation instructions for more information

@cindex emacs
@cindex emacs mode
@cindex lilypond-mode for emacs
@cindex syntax coloring

@item XEmacs. Xemacs is very similar to emacs.

@cindex XEmacs

@item NEdit.  NEdit runs under Windows, and Unix.
  It is available from @uref{http://www.nedit.org}.

@cindex NEdit

@item GVim.  GVim is a GUI variant of VIM, the popular VI
clone.  It is available from @uref{http://www.vim.org}.

@cindex GVim
@cindex Vim

@end itemize
@end itemize


Xdvi must be configured to find the @TeX{} fonts and music
fonts. Refer to the Xdvi documentation for more information.

To use point-and-click, add one of these lines to the top of your .ly
file.
@example
#(ly:set-point-and-click 'line)
@end example
@cindex line-location

When viewing, Control-Mousebutton 1 will take you to the originating
spot in the @file{.ly} file.  Control-Mousebutton 2 will show all
clickable boxes.

If you correct large files with point-and-click, be sure to start
correcting at the end of the file. When you start at the top, and
insert one line, all following locations will be off by a line.

@cindex Emacs
For using point-and-click with emacs,  add the following
In your emacs startup file (usually @file{~/.emacs}), 
@example
(server-start)
@end example

Make sure that the environment variable @var{XEDITOR} is set to
@example
emacsclient --no-wait +%l %f
@end example
@cindex @var{XEDITOR}
If you use xemacs instead of emacs, you use @code{(gnuserve-start)} in
your @file{.emacs}, and set @code{XEDITOR} to @code{gnuclient -q +%l %f}

For using Vim, set @code{XEDITOR} to @code{gvim --remote +%l %f}, or
use this argument with xdvi's @code{-editor} option.

@cindex NEdit
For using NEdit, set @code{XEDITOR} to @code{nc -noask +%l %f}, or
use this argument with xdvi's @code{-editor} option.

If can also make your editor jump to the exact location of the note
you clicked. This is only supported on Emacs and VIM. Users of Emacs version
20 must apply the patch @file{emacsclient.patch}. Users of version 21
must apply @file{server.el.patch} (version 21.2 and earlier).  At the
top of the @code{ly} file, replace the @code{set-point-and-click} line
with the following line,
@example
#(ly:set-point-and-click 'line-column)
@end example
@cindex line-colomn-location
and set @code{XEDITOR} to @code{emacsclient --no-wait +%l:%c %f}.  Vim
users can set @var{XEDITOR} to @code{gvim --remote +:%l:norm%c| %f}.



@refbugs

When you convert the @TeX{} file to PostScript using @code{dvips}, it
will complain about not finding @code{src:X:Y} files. These complaints
are harmless, and can be ignored.

@node Skipping corrected music
@subsection Skipping corrected music

The property @code{Score.skipTypesetting} can be used to switch on and
off typesetting completely during the interpretation phase. When
typesetting is switched off, the music is processed much more quickly.
You can use this to skip over the parts of a score that you have already
checked for errors. 

@lilypond[fragment,singleline,verbatim]
\relative c'' { c8 d
\property Score.skipTypesetting = ##t
  e f g a g c, f e d
\property Score.skipTypesetting = ##f
c d b bes a g c2 } 
@end lilypond




@node Staff notation
@section Staff notation

This section deals with music notation that occurs on staff level,
such as keys, clefs and time signatures.

@cindex Staff notation

@menu
* Staff symbol::                
* Key signature::               
* Clef::                        
* Time signature::              
* Unmetered music::             
* Bar lines::                   
@end menu

@node Staff symbol
@subsection Staff symbol


@cindex adjusting staff symbol
@cindex StaffSymbol, using \property
@cindex staff lines, setting number of


The lines of the staff symbol are formed by the
@internalsref{StaffSymbol} object.  This object is created at the moment
that their context is created.  You can not change the appearance of
the staff symbol by using @code{\override} or @code{\set}.  At the
moment that @code{\property Staff} is interpreted, a Staff context is
made, and the StaffSymbol is created before any @code{\override} is
effective. You can deal with this either overriding properties in a
@code{\translator} definition, or by using @code{\outputproperty}.


@refbugs

If you end a staff half way a piece, the staff symbol may not end
exactly on the barline.


@c .  {Key}
@node Key signature
@subsection Key signature
@cindex Key

@cindex @code{\key}

Setting or changing the key signature is done with the @code{\key}
command.
@example
  @code{\key} @var{pitch} @var{type}
@end example

@cindex @code{\minor}
@cindex @code{\major}
@cindex @code{\minor}
@cindex @code{\ionian}
@cindex @code{\locrian}
@cindex @code{\aeolian}
@cindex @code{\mixolydian}
@cindex @code{\lydian}
@cindex @code{\phrygian}
@cindex @code{\dorian}

Here, @var{type} should be @code{\major} or @code{\minor} to get
@var{pitch}-major or @var{pitch}-minor, respectively.
The standard mode names @code{\ionian},
@code{\locrian}, @code{\aeolian}, @code{\mixolydian}, @code{\lydian},
@code{\phrygian}, and @code{\dorian} are also defined.

This command sets the context property @code{Staff.keySignature}. 
Non-standard key signatures can be specified by setting this property
directly.

The printed signature is a @internalsref{KeySignature} object, typically
created in @internalsref{Staff} context.

@cindex @code{keySignature}

@c .  {Clef}
@node Clef
@subsection Clef
@cindex @code{\clef}

The clef can be set or changed with the @code{\clef} command:
@lilypond[fragment,verbatim]
  \key f\major  c''2 \clef alto g'2
@end lilypond

Supported clef-names include 
@c Moved standard clefs to the top /MB
@table @code
@item treble, violin, G, G2
G clef on 2nd line
@item alto, C
 C clef on 3rd line
@item tenor
 C clef on 4th line
@item bass, F
 F clef on 4th line
@item french
 G clef on 1st line, so-called French violin clef
@item soprano
 C clef on 1st line
@item mezzosoprano
 C clef on 2nd line
@item baritone
 C clef on 5th line
@item varbaritone
 F clef on 3rd line
@item subbass
 F clef on 5th line
@item percussion
 percussion clef
@end table

By adding @code{_8} or @code{^8} to the clef name, the clef is
transposed one octave down or up, respectively.  Note that you have to
enclose @var{clefname} in quotes if you use underscores or digits in the
name. For example,
@example
        \clef "G_8"
@end example

The object for this symbol is @internalsref{Clef}. 


This command is equivalent to setting @code{clefGlyph},
@code{clefPosition} (which controls the Y position of the clef),
@code{centralCPosition} and @code{clefOctavation}. A clef is created
when any of these properties are changed.


@c .  {Time signature}
@node Time signature
@subsection Time signature
@cindex Time signature
@cindex meter
@cindex @code{\time}

The time signature is set or changed by the @code{\time}
command.
@lilypond[fragment,verbatim]
 \time 2/4 c'2 \time 3/4 c'2. 
@end lilypond

The actual symbol that's printed can be customized with the @code{style}
property. Setting it to @code{#'()} uses fraction style for 4/4 and
2/2 time.


The object for this symbol is @internalsref{TimeSignature}.  There are
many more options for its layout. They are selected through the
@code{style} object property. See @file{input/test/time.ly} for more
examples.

This command sets the property @code{timeSignatureFraction},
@code{beatLength} and @code{measureLength} in the @code{Timing}
context, which is normally aliased to @internalsref{Score}.  The property
@code{timeSignatureFraction} determine where bar lines should be
inserted, and how automatic beams should be generated.  Changing the
value of @code{timeSignatureFraction} also causes a time signature
symbol to be printed.

More options are available through the Scheme function
@code{set-time-signature}. In combination with the
@internalsref{Measure_grouping_engraver}, it will create
@internalsref{MeasureGrouping} signs. Such signs ease reading
rhythmically complex modern music.  In the following example, the 9/8
measure is subdivided in 2, 2, 2 and 3. This is passed to
@code{set-time-signature} as the third argument @code{(2 2 2 3)}.

@lilypond[verbatim]
\score { \notes \relative c'' {
   #(set-time-signature 9 8 '(2 2 2 3))
   g8 g d d g g a8-[-( bes g-]-) | 
   #(set-time-signature 5 8 '(3 2))
   a4. g4
   }
   \paper {
       linewidth = -1.0
       \translator { \StaffContext
         \consists "Measure_grouping_engraver"
   }}}
@end lilypond 

@c .   {Partial}
@subsection Partial
@cindex Partial
@cindex anacrusis
@cindex upbeat
@cindex partial measure
@cindex measure, partial
@cindex shorten measures
@cindex @code{\partial}

Partial measures, for example in upbeats, are entered using the
@code{\partial} command:
@lilypond[fragment,verbatim]
\partial 4* 5/16  c'16 c4 f16 a'2. ~ a'8. a'16 | g'1
@end lilypond

The syntax for this command is 
@example
  \partial @var{duration} 
@end example
This is  internally translated into
@example
  \property Timing.measurePosition = -@var{length of duration}
@end example
@cindex @code{|}
The property @code{measurePosition} contains a rational number
indicating how much of the measure has passed at this point.


@node Unmetered music
@subsection Unmetered music

Bar lines and bar numbers are calculated automatically. For unmetered
music (e.g. cadenzas), this is not desirable.  The commands
@code{\cadenzaOn} and @code{\cadenzaOff} can be used to switch off the
timing information:

@lilypond[fragment,relative,singleline,verbatim]
c'2.
\cadenzaOn
c2
\cadenzaOff
c4 c4 c4 
@end lilypond

The property @code{Score.timing} can be used to switch off this
automatic timing

@c .   {Bar lines}
@node Bar lines
@subsection Bar lines
@cindex Bar lines

@cindex @code{\bar}
@cindex measure lines
@cindex repeat bars

Bar lines are inserted automatically, but if you need a special type
of barline, you can force one using the @code{\bar} command:
@lilypond[fragment,verbatim] c4 \bar "|:" c4
@end lilypond

The following bar types are available
@lilypond[fragment,  relative, singleline, verbatim]
c4
\bar "|" c
\bar "" c
\bar "|:" c
\bar "||" c
\bar ":|" c
\bar ".|" c
\bar ".|." c
\bar "|." 
@end lilypond

You are encouraged to use @code{\repeat} for repetitions.  See
@ref{Repeats}.

In scores with many staves, the barlines are automatically placed at
top level, and they are connected between different staves of a
@internalsref{StaffGroup}:
@lilypond[fragment, verbatim]
< \context StaffGroup <
  \context Staff = up { e'4 d'
     \bar "||"
     f' e' }
  \context Staff = down { \clef bass c4 g e g } >
\context Staff = pedal { \clef bass c2 c2 } >
@end lilypond

The objects that are created at @internalsref{Staff} level. The name is
@internalsref{BarLine}.

The command @code{\bar @var{bartype}} is a short cut for
doing  @code{\property Score.whichBar = @var{bartype}}
Whenever @code{whichBar} is set to a string, a bar line of that type is
created.  @code{whichBar} is usually set automatically: at the start of
a measure it is set to @code{defaultBarType}. The contents of
@code{repeatCommands} is used to override default measure bars.

@code{whichBar} can also be set directly, using @code{\property} or
@code{\bar  }.  These settings take precedence over the automatic
@code{whichBar} settings. 


@cindex Bar_line_engraver
@cindex whichBar
@cindex repeatCommands
@cindex defaultBarType



@c .   {Polyphony}
@node Polyphony
@section Polyphony
@cindex polyphony

The easiest way to enter such fragments with more than one voice on a
staff is to split chords using the separator @code{\\}.  You can use
it for small, short-lived voices (make a chord of voices) or for
single chords:

@lilypond[verbatim,fragment]
\context Voice = VA \relative c'' {
 c4 < { f d e  } \\ { b c2 } > c4 < g' \\ b, \\  f \\ d >
}
@end lilypond

The separator causes @internalsref{Voice} contexts to be instantiated,
bearing the names @code{"1"}, @code{"2"}, etc.

Sometimes, it is necessary to instantiate these contexts by hand: For
Instantiate a separate Voice context for each part, and use
@code{\voiceOne}, up to @code{\voiceFour} to assign a stem directions
and horizontal shift for each part.
@c

@lilypond[singleline, verbatim]
\relative c''
\context Staff < \context Voice = VA { \voiceOne cis2 b  }
  \context Voice = VB { \voiceThree b4 ais ~ ais4 gis4 } 
  \context Voice = VC { \voiceTwo fis4~  fis4 f ~ f  } >
@end lilypond

The identifiers @code{\voiceOne} to @code{\voiceFour} set directions
ties, slurs and stems, and set shift directions.

If you want more than four voices, you can also manually set
horizontal shifts and stem directions, as is shown  in the following example:
@lilypond[fragment, verbatim]
  \context Staff \notes\relative c''<
       \context Voice=one {
       \shiftOff \stemUp e4
       }
       \context Voice=two {
          \shiftOn \stemUp cis
       }
       \context Voice=three {
         \shiftOnn \stemUp ais
       }
       \context Voice=four {
          \shiftOnnn \stemUp fis
       }
  >
@end lilypond


Normally, note heads with a different number of dots are not merged, but
if you set the object property @code{merge-differently-dotted}, they are:
@lilypond[verbatim,fragment,singleline]
\context Voice < {
     g'8 g'8 
     \property Staff.NoteCollision \override
        #'merge-differently-dotted = ##t
     g'8 g'8
  } \\ { [g'8. f16] [g'8. f'16] } 
  >
@end lilypond

Similarly, you can merge half note heads with eighth notes, by setting
@code{merge-differently-headed}:
@lilypond[fragment, relative=2,verbatim]
\context Voice < {
    c8 c4.
    \property Staff.NoteCollision
      \override #'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]
\context Voice < c''4 \\  r4 >
@end lilypond

See also @internalsref{NoteCollision} and @internalsref{RestCollision}

@refbugs

Resolving collisions is a very intricate subject, and LilyPond only
handles a few situations. When it can not cope, you are advised to use
@code{force-hshift} of the @internalsref{NoteColumn} object and pitched
rests to override typesetting decisions.

@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]
\time 2/4 c8 c c c \time 6/8 c c c c8. c16  c8
@end lilypond

If you're not satisfied with the automatic beaming, you can enter the
beams explicitly. If you have beaming patterns that differ from the
defaults, you can also set the patterns for automatic beamer.

See also @internalsref{Beam}.

@c .    {Manual beams}
@cindex Automatic beams
@subsection Manual beams
@cindex beams, manual
@cindex @code{]}
@cindex @code{[}

In some cases it may be necessary to override LilyPond's automatic
beaming algorithm.  For example, the auto beamer will not beam over
rests or bar lines, If you want that, specify the begin and end point
manually using a @code{[} before the first beamed note and a @code{]}
after the last note:

@lilypond[fragment,relative,verbatim]
  \context Staff {
    r4 [r8 g' a r8] r8 [g | a] r8
  }
@end lilypond

@cindex @code{stemLeftBeamCount}

Normally, beaming patterns within a beam are determined automatically.
When this mechanism fouls up, the properties
@code{Voice.stemLeftBeamCount} and @code{Voice.stemRightBeamCount} can
be used to control the beam subdivision on a stem.  If you set either
property, 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]
  }
@end lilypond
@cindex @code{stemRightBeamCount}


The property @code{subdivideBeams} can be set in order to subdivide
all 16th or shorter beams at beat positions.  This accomplishes the
same effect as twiddling with @code{stemLeftBeamCount} and
@code{stemRightBeamCount}, but it take less typing.


@example
[c16 c c c c c c c]
\property Voice.subdivideBeams = ##t
[c16 c c c c c c c]
[c32 c c c c c c c c c c c c c c c]
\property Score.beatLength = #(ly:make-moment 1 8)
[c32 c c c c c c c c c c c c c c c]
@end example
@lilypond[noindent,noquote]
\score {
    \notes \relative c' {
        [c16 c c c c c c c]
        \property Voice.subdivideBeams = ##t
        [c16 c c c c c c c]
        [c32 c c c c c c c c c c c c c c c]
        \property Score.beatLength = #(ly:make-moment 1 8)
        [c32 c c c c c c c c c c c c c c c]
    }
}
@end lilypond
@cindex subdivideBeams

Kneed beams are inserted automatically, when a large gap between two
adjacent beamed notes is detected. This behavior can be tuned through
the object property @code{auto-knee-gap}.

@cindex beams, kneed
@cindex kneed beams
@cindex auto-knee-gap
@cindex hara kiri


@c TODO -> why this ref? Document? 
@cindex @code{neutral-direction}

@refbugs

Auto knee beams can not be used together with hara kiri staves.

[TODO from bugs]

The Automatic beamer does not put @strong{unfinished} beams on the
last notes of a score.

Formatting of ties is a difficult subject. LilyPond often does not
give optimal results.

@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

@c .    {Automatic beams}
@node Setting automatic beam behavior 
@subsection Setting automatic beam behavior 

@cindex @code{autoBeamSettings}
@cindex @code{(end * * * *)}
@cindex @code{(begin * * * *)}
@cindex automatic beams, tuning
@cindex tuning automatic beaming

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}
are defined in @file{scm/auto-beam.scm}.

The value of @code{autoBeamSettings} is changed using
@code{\override} and unset using @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})
@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
signatures).

For example, if you want automatic beams to end on every quarter note,
you can use the following:
@example
\property Voice.autoBeamSettings \override
    #'(end * * * *) = #(ly:make-moment 1 4)
@end example
Since the duration of a quarter note is 1/4 of a whole note, it is
entered as @code{(ly:make-moment 1 4)}.

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
    #'(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).

You can also restrict rules 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
    #'(begin * * 6 8) =  ... 
@end example

If you want a rule to apply to certain types of beams, you can use the
first pair of asterisks. Beams are classified according to the shortest
note they contain. For a beam ending rule that only applies to beams
with 32nd notes (and no shorter notes), you would use @code{(end 1
32 * *)}.

@c not true
@c Automatic beams can not be put on the last note in a score.

If a score ends while an automatic beam has not been ended and is still
accepting notes, this last beam will not be typeset at all.

@cindex automatic beam generation
@cindex autobeam
@cindex @code{Voice.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
@code{#f}. 


@refbugs

It is not possible to specify beaming parameters for beams with mixed
durations, that differ from the beaming parameters of all separate
durations, i.e., you'll have to specify manual beams to get:

@lilypond[singleline,fragment,relative,noverbatim]
  \property Voice.autoBeamSettings
  \override #'(end * * * *) = #(ly:make-moment 3 8)
  \time 12/8 c'8 c c c16 c c c c c [c c c c] c8 c c4
@end lilypond
It is not possible to specify beaming parameters that act differently in
different parts of a measure. This means that it is not possible to use
automatic beaming in irregular meters such as @code{5/8}.

@node Accidentals
@section Accidentals
@cindex Accidentals
This section describes how to change the way that LilyPond automatically
inserts accidentals before the running notes.

@menu
* Using the predefined accidental macros::  
* Defining your own accidental typesettings::  
@end menu

@node Using the predefined accidental macros
@subsection Using the predefined accidental macros
The constructs for describing the accidental typesetting rules are
quite hairy, so non-experts should stick to the macros defined in
@file{ly/property-init.ly}.
@cindex @file{property-init.ly}

The macros operate on the ``Current'' context (see @ref{Context properties}). This
means that the macros shuold normally be invoked right after the
creation of the context in which the accidental typesetting described
by the macro is to take effect. I.e. if you want to use
piano-accidentals in a pianostaff then you issue
@code{\pianoAccidentals} first thing after the creation of the piano
staff:
@example
\score @{
    \notes \relative c'' <
        \context Staff = sa @{ cis4 d e2 @}
        \context GrandStaff <
            \pianoAccidentals
            \context Staff = sb @{ cis4 d e2 @}
            \context Staff = sc @{ es2 c @}
        >
        \context Staff = sd @{ es2 c @}
    >
@}
@end example
@lilypond[singleline]
\score {
    \notes \relative c'' <
        \context Staff = sa { cis4 d e2 }
        \context GrandStaff <
            \pianoAccidentals
            \context Staff = sb { cis4 d e2 }
            \context Staff = sc { es2 c }
        >
        \context Staff = sd { es2 c }
    >
    \paper {
        \translator {
            \StaffContext
            minimumVerticalExtent = #'(-4.0 . 4.0)
        }
    }
}
@end lilypond

The macros are:
@table @code
@item \defaultAccidentals
      @cindex @code{\defaultAccidentals}
      This is the default typesetting behaviour. It should correspond
      to 18th century common practice: Accidentals are
      remembered to the end of the measure in which they occur and
      only on their own octave.

@item \voiceAccidentals
      @cindex @code{\voiceAccidentals}
      The normal behaviour is to remember the accidentals on
      Staff-level.
      This macro, however, typesets accidentals individually for each
      voice.
      Apart from that the rule is similar to
      @code{\defaultAccidentals}.

      Warning: 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]
    \context Staff <
        \voiceAccidentals
        \context Voice=va { \voiceOne es g }
        \context Voice=vb { \voiceTwo c, e }
    >
@end lilypond
      Hence you should only use @code{\voiceAccidentals}
      if the voices are to be read solely by
      individual musicians. if the staff should be readable also
      by one musician/conductor then you should use
      @code{\modernVoiceAccidentals} or @code{\modernVoiceCautionaries}
      instead.

@item \modernAccidentals
      @cindex @code{\modernAccidentals}
      This rule should correspond to the common practice in the 20th
      century.
      The rule is a bit more complex than @code{\defaultAccidentals}:
      You get all the same accidentals, but temporary
      accidentals also get cancelled in other octaves. Further more,
      in the same octave, they also get cancelled in the following measure:
@lilypond[singleline,fragment,verbatim]
      \modernAccidentals
      cis' c'' cis'2 | c'' c'
@end lilypond

@item \modernCautionaries
      @cindex @code{\modernCautionaries}
     This rule is similar to @code{\modernAccidentals}, but the
     ``extra'' accidentals (the ones not typeset by
     @code{\defaultAccidentals}) are typeset as cautionary accidentals
     (i.e. in reduced size):
@lilypond[singleline,fragment,verbatim]
      \modernCautionaries
      cis' c'' cis'2 | c'' c'
@end lilypond

@item \modernVoiceAccidentals
      @cindex @code{\modernVoiceAccidentals}
      Multivoice accidentals to be read both by musicians playing one voice
      and musicians playing all voices.

      Accidentals are typeset for each voice, but they ARE cancelled
      across voices in the same @internalsref{Staff}.

@item \modernVoiceCautionaries
      @cindex @code{\modernVoiceCautionaries}
      The same as @code{\modernVoiceAccidentals}, but with the
      extra accidentals (the ones not typeset by
      @code{\voiceAccidentals}) typeset as cautionaries.
      Notice that even though all accidentals typeset by
      @code{\defaultAccidentals} ARE typeset by this macro then some
      of them are typeset as cautionaries.

@item \pianoAccidentals
      @cindex @code{\pianoAccidentals}
      20th century practice for piano notation. Very similar to
      @code{\modernAccidentals} but accidentals also get cancelled
      across the staves in the same @internalsref{GrandStaff} or
      @internalsref{PianoStaff}.

@item \pianoCautionaries
      @cindex @code{\pianoCautionaries}
      As @code{\pianoAccidentals} but with the extra accidentals
      typeset as cationaries.

@item \noResetKey
      @cindex @code{\noResetKey}
      Same as @code{\defaultAccidentals} but with accidentals lasting
      ``forever'' and not only until the next measure:
@lilypond[singleline,fragment,verbatim,relative]
      \noResetKey
      c1 cis cis c
@end lilypond

@item \forgetAccidentals
      @cindex @code{\forgetAccidentals}
      This is sort of the opposite of @code{\noResetKey}: Accidentals
      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]
      \forgetAccidentals
      \key d\major c4 c cis cis d d dis dis
@end lilypond
@end table

@node Defining your own accidental typesettings
@subsection Defining your own accidental typesettings

This section must be considered gurus-only, and hence it must be
sufficient with a short description of the system and a reference to
the internal documentation.

The idea of the algorithm is to try several different rules and then
use the rule that gives the highest number of accidentals.
Each rule cosists of
@table @asis
@item Context:
      In which context is the rule applied. I.e. if context is
      @internalsref{Score} then all staves share accidentals, and if
      context is @internalsref{Staff} then all voices in the same
      staff share accidentals, but staves don't - like normally.
@item Octavation:
      Whether the accidental changes all octaves or only the current
      octave.
@item Lazyness:
      Over how many barlines the accidental lasts.
      If lazyness is @code{-1} then the accidental is forget
      immidiately, and if lazyness is @code{#t} then the accidental
      lasts forever.
@end table

As described in the internal documentation of
@reng{Accidental_engraver}, the properties @code{autoAccidentals} and
@code{autoCautionaries} contain lists of rule descriptions. Notice
that the contexts must be listed from in to out - that is
@internalsref{Thread} before @internalsref{Voice},
@internalsref{Voice} before @internalsref{Staff}, etc. 
see the macros in @file{ly/property-init.ly} for examples of how the
properties are set.

@refbugs

Currently the simultaneous notes are considered to be entered in
sequential mode. This means that in a chord the accidentals are
typeset as if the notes in the chord happened one at a time - in the
order in which they appear in the input file.

Of course this is only a problem when you have simultainous notes
which accidentals should depend on each other.
Notice that the problem only occurs when using non-default accidentals
- as the default accidentals only depend on other accidentals on the
same staff and same pitch and hence cannot depend on other
simultainous notes.

This example shows two examples of the same music giving different
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) )
cis'4 <<c'' c'>> r2 | cis'4 <<c' c''>> r2 | <<cis' c''>> r | <<c'' cis'>> r | 
@end lilypond

The only solution is to manually insert the problematic
accidentals using @code{!} and @code{?}.

@node Expressive marks
@section Expressive marks

@c .   {Slurs}
@menu
* Slurs ::                      
* Phrasing slurs::              
* Breath marks::                
* Tempo::                       
* Text spanners::               
@end menu

@node Slurs 
@subsection Slurs
@cindex Slurs

A slur indicates that notes are to be played bound or @emph{legato}.
They are entered using parentheses:
@lilypond[fragment,verbatim,center]
  f'()g'()a' [a'8 b'(] a'4 g'2 )f'4
@end lilypond

See also @seeinternals{Slur}.

Slurs avoid crossing stems, and are generally attached to note heads.
However, in some situations with beams, slurs may be attached to stem
ends.  If you want to override this layout you can do this through the
object property @code{attachment} of @internalsref{Slur} in
@internalsref{Voice} context It's value is a pair of symbols, specifying
the attachment type of the left and right end points.

@lilypond[fragment,relative,verbatim]
  \slurUp
  \property Voice.Stem \set #'length = #5.5
  g'8(g)g4
  \property Voice.Slur \set #'attachment = #'(stem . stem)
  g8(g)g4
@end lilypond

If a slur would strike through a stem or beam, the slur will be moved
away upward or downward. If this happens, attaching the slur to the
stems might look better:

@lilypond[fragment,relative,verbatim]
  \stemUp \slurUp
  d32( d'4 )d8..
  \property Voice.Slur \set #'attachment = #'(stem . stem)
  d,32( d'4 )d8..
@end lilypond

@ignore
Similarly, the curvature of a slur is adjusted to stay clear of note
heads and stems.  When that would increase the curvature too much, the
slur is reverted to its default shape.  The threshold for this
decision is in @internalsref{Slur}'s object property @code{beautiful}.
It is loosely related to the enclosed area between the slur and the
notes.  Usually, the default setting works well, but in some cases you
may prefer a curved slur when LilyPond decides for a vertically moved
one.  You can indicate this preference by increasing the
@code{beautiful} value:

@lilyp ond[verbatim,singleline,relative]
  \stemDown \slurUp
  c16( a' f' a a f a, )c,
  c( a' f' a a f d, )c
  \property Voice.Slur \override #'beautiful = #5.0
  c( a' f' a a f d, )c
@end lilypond
@end ignore

@refbugs

Producing nice slurs is a difficult problem, and LilyPond currently
uses a simple, empiric method to produce slurs. In some cases, the
results of this method are ugly.

@ignore
This is reflected by the
@code{beautiful} property, which it is an arbitrary parameter in the
slur formatter.  Useful values can only be determined by trial and
error.
@end ignore

@cindex Adjusting slurs

@node Phrasing slurs
@subsection Phrasing slurs

@cindex phrasing slurs
@cindex phrasing marks

A phrasing slur (or phrasing mark) connects chords and is used to
indicate a musical sentence. It is started using @code{\(} and @code{\)}
respectively.

@lilypond[fragment,verbatim,center,relative]
  \time 6/4 c' \(  d () e f () e  \) d
@end lilypond

Typographically, the phrasing slur behaves almost exactly like a normal
slur.  See also @seeinternals{PhrasingSlur}.  But although they behave
similarily to normal slurs, phrasing slurs count as different objects.
A @code{\slurUp} will have no effect on a phrasing slur; instead, you
should use @code{\phrasingSlurUp}, @code{\phrasingSlurDown}, and
@code{\phrasingSlurBoth}.

Note that the commands
@code{\slurUp}, @code{\slurDown}, and @code{\slurBoth} will only affect
normal slurs and not phrasing slurs.

@node Breath marks
@subsection Breath marks

Breath marks are entered using @code{\breathe}.  See also
@seeinternals{BreathingSign}.

@lilypond[fragment,relative]
c'4 \breathe d4
@end lilypond


@c .  {Tempo}
@node Tempo
@subsection Tempo
@cindex Tempo
@cindex beats per minute
@cindex metronome marking

Metronome settings can be entered as follows:

@cindex @code{\tempo}
@example
  \tempo @var{duration} = @var{perminute} 
@end example

For example, @code{\tempo 4 = 76} requests output with 76 quarter notes
per minute.
  
@refbugs
  
The tempo setting is not printed, but is only used in the MIDI
output. You can trick lily into producing a metronome mark,
though. Details are in @ref{Text markup}.
  


@node Text spanners
@subsection Text spanners
@cindex Text spanners

Some textual indications, e.g. rallentando or accelerando, often extend
over many measures. This is indicated by following the text with a
dotted line.  You can create such texts using text spanners. The syntax
is as follows:
@example
 \startTextSpan
 \stopTextSpan
@end example
LilyPond will respond by creating a @internalsref{TextSpanner} object (typically
in @internalsref{Voice} context).  The string to be printed, as well as the
style is set through object properties.

An application---or rather, a hack---is to fake octavation indications.
@lilypond[fragment,relative,verbatim]
 \relative c' {  a''' b c a
  \property Voice.TextSpanner \set #'type = #'dotted-line
  \property Voice.TextSpanner \set #'edge-height = #'(0 . 1.5)
  \property Voice.TextSpanner \set #'edge-text = #'("8va " . "")
  \property Staff.centralCPosition = #-13
  a\startTextSpan b c a \stopTextSpan }
@end lilypond


@c .  {Ornaments}
@node Ornaments
@section Ornaments
@cindex Ornaments
@menu
* Articulations::               
* Text scripts::                
* Grace notes::                 
* Glissando ::                  
* Dynamics::                    
@end menu

@c .   {Articulation}
@node Articulations
@subsection Articulations
@cindex Articulations

@cindex articulations
@cindex scripts
@cindex ornaments

A variety of symbols can appear above and below notes to indicate
different characteristics of the performance. They are added to a note
by adding a dash and the the character signifying the
articulation. They are demonstrated here.
@lilypond[singleline]
  \score {
    \notes \context Voice {
      \property Voice.TextScript \set #'font-family = #'typewriter
      \property Voice.TextScript \set #'font-shape = #'upright
      c''4-._"c-."      s4
      c''4--_"c-{}-"    s4
      c''4-+_"c-+"      s4
      c''4-|_"c-|"      s4
      c''4->_"c->"      s4
      c''4-^_"c-\\^{ }" s4
      c''4-__"c-\_" s4      
    }
  }
@end lilypond

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]
  c''4^^ c''4_^
@end lilypond


Other symbols can be added using the syntax
@var{note}@code{-\}@var{name}. Again, they can be forced up or down
using @code{^} and @code{_}.

@cindex accent      
@cindex marcato      
@cindex staccatissimo
@cindex fermata 
@cindex stopped     
@cindex staccato
@cindex portato
@cindex tenuto        
@cindex upbow
@cindex downbow
@cindex foot marks
@cindex organ pedal marks
@cindex turn         
@cindex open          
@cindex flageolet
@cindex reverseturn 
@cindex trill        
@cindex prall         
@cindex mordent
@cindex prallprall  
@cindex prallmordent 
@cindex prall, up
@cindex prall, down
@cindex mordent
@cindex thumb marking
@cindex segno         
@cindex coda

@lilypond[]
  \score {
    <
      \property Score.LyricText \override #'font-family =#'typewriter
      \property Score.LyricText \override #'font-shape = #'upright
      \context Staff \notes {
        c''-\accent      c''-\marcato      c''-\staccatissimo c''^\fermata 
        c''-\stopped     c''-\staccato     c''-\tenuto         c''-\portato
        c''-\upbow
        c''-\downbow     c''^\lheel        c''-\rheel         c''^\ltoe
        c''-\rtoe        c''-\turn         c''-\open          c''-\flageolet
        c''-\reverseturn c''-\trill        c''-\prall         c''-\mordent
        c''-\prallprall  c''-\prallmordent c''-\upprall       c''-\downprall
        c''-\upmordent   c''-\downmordent  c''-\pralldown     c''-\prallup
        c''-\lineprall   c''-\thumb        c''-\segno         c''-\coda
      }
      \context Lyrics \lyrics {
        accent__      marcato__      staccatissimo__ fermata
        stopped__     staccato__     tenuto__        portato
        upbow
        downbow__     lheel__        rheel__         ltoe
        rtoe__        turn__         open__          flageolet
        reverseturn__ trill__        prall__         mordent
        prallprall__  prallmordent__ uprall__        downprall
        upmordent__   downmordent__  pralldown__  prallup__
        lineprall__   thumb__       segno__        coda
      }
    >
    \paper {
      linewidth = 5.1\in
      indent    = 0.0\mm
    }
  }
@end lilypond


@cindex fingering

Fingering instructions can also be entered in this shorthand. For
finger changes, use markup texts:
@c
@lilypond[verbatim, singleline, fragment]
      c'4-1 c'4-2 c'4-3 c'4-4
      c^#'(finger "2-3")
@end lilypond


@cindex scripts
@cindex superscript
@cindex subscript

See also @seeinternals{Script} and @seeinternals{Fingering}.

@refbugs

All of these note ornaments appear in the printed output but have no
effect on the MIDI rendering of the music.

Unfortunately, there is no support for adding fingering instructions or 
ornaments to individual note heads. Some hacks exist, though. See
@file{input/test/script-horizontal.ly}.


@c .  {Text scripts}
@node Text scripts
@subsection Text scripts
@cindex Text scripts

In addition, 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' {
c4^"longtext" \fatText c4_"longlongtext" c4 }
@end lilypond

It is possible to use @TeX{} commands in the strings, but this should be
avoided because it makes it impossible for LilyPond to compute the
exact length of the string, which may lead to collisions.  Also, @TeX{}
commands won't work with direct PostScript output.
@c (see @ref{PostScript output}).

Text scripts are created in form of @internalsref{TextScript} objects, in
@internalsref{Voice} context. 

@ref{Text markup} describes how to change the font or access
special symbols in text scripts.


@c .   {Grace notes}
@node Grace notes
@subsection Grace notes



@cindex @code{\grace}
@cindex ornaments
@cindex grace notes

Grace notes are ornaments that are written out
@lilypond[relative=2,verbatim,ifragment] c4 \grace c16 c4 \grace {
[c16 d16] } c4
@end lilypond

In normal notation, grace notes are supposed to take up no logical
time in a measure. Such an idea is practical for normal notation, but
is not strict enough to put it into a program. The model that LilyPond
uses for grace notes internally is that all timing is done in two
steps:

Every point in musical time consists of two rational numbers: one
denotes the logical time, one denotes the grace timing. The above
example is shown here with timing tuples.

@lilypond[]
\score { \notes \relative c''{ 
  c4^"(0,0)"  \grace c16_" "_"(1/4,-1/16)"  c4^"(1/4,0)"  \grace {
  [c16_"(2/4,-1/8)"  d16^"(2/4,-1/16)" ] } c4_" "_"(2/4,0)"
  }
\paper {  linewidth = 8.\cm }
}
@end lilypond

The advantage of this approach is that you can use almost any lilypond
construction together with grace notes, for example slurs and clef
changes may appear halfway in between grace notes:

@lilypond[relative=2,verbatim,fragment] 
  c4  \grace { [ c16 c, \clef bass c, b(] }  )c4 
@end lilypond

The placement of these grace notes is synchronized between different
staves, using this grace timing.

@lilypond[relative=2,verbatim,fragment] 
< \context Staff = SA { e4 \grace { c16 d e f } e4 }
  \context Staff = SB { c4 \grace { g8 b } c4 } >
@end lilypond


Unbeamed eighth notes and shorter by default have a slash through the
stem. This can be controlled with object property @code{stroke-style} of
@internalsref{Stem}. The change in formatting is accomplished by
inserting @code{\startGraceMusic} before handling the grace notes, and
@code{\stopGraceMusic} after finishing the grace notes.
You can add to these definitions to globally change grace note
formatting. The standard definitions are in @file{ly/grace-init.ly}.

[TODO discuss Scheme functionality.]


Notice how the @code{\override} is carefully matched with a @code{\revert}.

@cindex slash
@cindex grace slash

@lilypond[fragment,verbatim]
\relative c'' \context Voice {
  \grace c8 c4 \grace { [c16 c16] } c4
  \grace { 
    \property Voice.Stem \override #'stroke-style = #'() 
    c16 
    \property Voice.Stem \revert #'stroke-style
  } c4
}
@end lilypond



If you want to end a note with a grace note, then the standard trick
is to put the grace notes before a phantom ``space note'', e.g.
@lilypond[fragment,verbatim, relative=2]
\context Voice {
    < { d1^\trill ( }
     { s2 \grace { [c16 d] } } >
   )c4
}
@end lilypond

A @code{\grace} section has some default values, and LilyPond will
use those default values unless you specify otherwise inside the
@code{\grace} section.  For example, if you specify \slurUp
@emph{before} your @code{\grace} section, a slur which starts inside
the @code{\grace} won't be forced up, even if the slur ends outside
of the @code{\grace}.  Note the difference between the first and
second bars in this example:

@lilypond[fragment,verbatim]
\relative c'' \context Voice {
    \slurUp
    \grace {
        a4 ( }
    ) a4 a4 () a2
    \slurBoth

    \grace {
        \slurUp
        a4 ( }
    ) a4 a4 () a2
    \slurBoth

}
@end lilypond


@refbugs

Grace notes can not be used in the smallest size (@file{paper11.ly}).

Grace note synchronization can also lead to surprises. Staff notation,
such as key signatures, barlines, etc. are also synchronized. Take
care when you mix staves with grace notes and staves without.

@lilypond[relative=2,verbatim,fragment]
< \context Staff = SA { e4 \bar "|:" \grace c16 d4 }
  \context Staff = SB { c4 \bar "|:"  d4 } >
@end lilypond

Grace sections should only be used within sequential music
expressions.  Nesting, juxtaposing, or ending sequential music with a
grace section is not supported, and might produce crashes or other
errors.


@node Glissando 
@subsection Glissando
@cindex Glissando 

@cindex @code{\glissando}

A glissando line can be requested by attaching a @code{\glissando} to
a note:

@lilypond[fragment,relative,verbatim]
  c'-\glissando c'
@end lilypond

@refbugs

Printing of an additional text (such as @emph{gliss.}) must be done
manually. See also @seeinternals{Glissando}.



@c .   {Dynamics}
@node Dynamics
@subsection Dynamics
@cindex Dynamics



@cindex @code{\ppp}
@cindex @code{\pp}
@cindex @code{\p}
@cindex @code{\mp}
@cindex @code{\mf}
@cindex @code{\f}
@cindex @code{\ff}
@cindex @code{\fff}
@cindex @code{\ffff}
@cindex @code{\fp}
@cindex @code{\sf}
@cindex @code{\sff}
@cindex @code{\sp}
@cindex @code{\spp}
@cindex @code{\sfz}
@cindex @code{\rfz}


Absolute dynamic marks are specified using an identifier after a
note: @code{c4-\ff}.  The available dynamic marks are: @code{\ppp},
@code{\pp}, @code{\p}, @code{\mp}, @code{\mf}, @code{\f}, @code{\ff},
@code{\fff}, @code{\fff}, @code{\fp}, @code{\sf}, @code{\sff},
@code{\sp}, @code{\spp}, @code{\sfz}, and @code{\rfz}.

@lilypond[verbatim,singleline,fragment,relative]
  c'\ppp c\pp c \p c\mp c\mf c\f c\ff c\fff
  c2\sf c\rfz
@end lilypond

@cindex @code{\cr}
@cindex @code{\rc}
@cindex @code{\decr}
@cindex @code{\rced}
@cindex @code{\<}
@cindex @code{\>}
@cindex @code{\"!}


A crescendo mark is started with @code{\cr} and terminated with
@code{\rc} (the textual reverse of @code{cr}).  A decrescendo mark is
started with @code{\decr} and terminated with @code{\rced}.  There are
also shorthands for these marks.  A crescendo can be started with
@code{\<} and a decrescendo can be started with @code{\>}.  Either one
can be terminated with @code{\!}.  Note that @code{\!}  must go before
the last note of the dynamic mark whereas @code{\rc} and @code{\rced} go
after the last note.  Because these marks are bound to notes, if you
want several marks during one note, you have to use spacer notes.

@lilypond[fragment,verbatim,center]
  c'' \< \! c''   d'' \decr e'' \rced 
  < f''1 { s4 s4 \< \! s4 \> \! s4 } >
@end lilypond

You can also use a text saying @emph{cresc.} instead of hairpins. Here
is an example how to do it:

@lilypond[fragment,relative=2,verbatim]
  c4 \cresc c4 \endcresc c4
@end lilypond


@cindex crescendo
@cindex decrescendo

You can also supply your own texts:
@lilypond[fragment,relative,verbatim]
  \context Voice {
    \property Voice.crescendoText = "cresc. poco"
    \property Voice.crescendoSpanner = #'dashed-line
    a'2\mf\< a a \!a 
  }
@end lilypond

@cindex diminuendo

Dynamics are objects of @internalsref{DynamicText} and
@internalsref{Hairpin}. Vertical positioning of these symbols is
handled by the @internalsref{DynamicLineSpanner} object.  If you want to
adjust padding or vertical direction of the dynamics, you must set
properties for the @internalsref{DynamicLineSpanner} object. Predefined
identifiers to set the vertical direction are \dynamicUp and
\dynamicDown.

@cindex direction, of dynamics
@cindex @code{\dynamicDown}
@cindex @code{\dynamicUp}

@c .  {Repeats}
@node Repeats
@section Repeats


@cindex repeats
@cindex @code{\repeat}

To specify repeats, use the @code{\repeat} keyword.  Since repeats
should work differently when played or printed, there are a few
different variants of repeats.

@table @code
@item unfold
Repeated music is fully written (played) out.  Useful for MIDI
output, and entering repetitive music.

@item volta
This is the normal notation: Repeats are not written out, but
alternative endings (voltas) are printed, left to right.

@item fold
Alternative endings are written stacked. This has limited use but may be
used to typeset two lines of lyrics in songs with repeats, see
@file{input/star-spangled-banner.ly}.

@item tremolo
Make tremolo beams.

@item percent
Make beat or measure repeats. These look like percent signs.

@end table  

@menu
* Repeat syntax::               
* Repeats and MIDI::            
* Manual repeat commands::      
* Tremolo repeats::             
* Tremolo subdivisions::        
* Measure repeats::             
@end menu

@node Repeat syntax
@subsection Repeat syntax

The syntax for repeats is

@example
  \repeat @var{variant} @var{repeatcount} @var{repeatbody}
@end example

If you have alternative endings, you may add
@cindex @code{\alternative}
@example
 \alternative @code{@{} @var{alternative1}
            @var{alternative2}
            @var{alternative3} @dots{} @code{@}}
@end example
where each @var{alternative} is a music expression.

Normal notation repeats are used like this:
@lilypond[fragment,verbatim]
  c'1
  \repeat volta 2 { c'4 d' e' f' }
  \repeat volta 2 { f' e' d' c' }
@end lilypond

With alternative endings:
@lilypond[fragment,verbatim]
  c'1
  \repeat volta 2 {c'4 d' e' f'} 
  \alternative { {d'2 d'} {f' f} }
@end lilypond

Folded repeats look like this:


@lilypond[fragment,verbatim]
  c'1
  \repeat fold 2 {c'4 d' e' f'} 
  \alternative { {d'2 d'} {f' f} }

@end lilypond

If you don't give enough alternatives for all of the repeats, then
the first alternative is assumed to be repeated often enough to equal
the specified number of repeats.

@lilypond[fragment,verbatim]
\context Staff {
  \relative c' {
    \partial 4
    \repeat volta 4 { e | c2 d2 | e2 f2 | }
    \alternative { { g4 g g } { a | a a a a | b2. } }
  }
}
@end lilypond

@node Repeats and MIDI
@subsection Repeats and MIDI

@cindex expanding repeats

For instructions on how to unfoldi repeats for MIDI output, see
the example file @file{input/test/unfold-all-repeats.ly}.


@refbugs

Notice that timing information is not remembered at the start of an
alternative, so you have to reset timing information after a repeat,
e.g. using a bar-check (See @ref{Bar check}), setting
@code{Score.measurePosition} or entering @code{\partial}.  Slurs or ties
are also not repeated.

It is possible to nest @code{\repeat}s, although this probably is only
meaningful for unfolded repeats.

Folded repeats offer little more over simultaneous music.

@node Manual repeat commands
@subsection Manual repeat commands

@cindex @code{repeatCommands}

The property @code{repeatCommands} can be used to control the layout of
repeats. Its value is a Scheme list of repeat commands, where each repeat
command can be

@table @code
@item 'start-repeat
 Print a |: bar line
@item 'end-repeat
 Print a :| bar line
@item (volta . @var{text})
 Print a volta bracket saying @var{text}.
@item (volta . #f)
 Stop a running volta bracket
@end table

@lilypond[verbatim, fragment]
 c''4
    \property Score.repeatCommands = #'((volta "93") end-repeat)
 c''4 c''4
    \property Score.repeatCommands = #'((volta #f))
 c''4 c''4
@end lilypond


Repeats brackets are @internalsref{VoltaBracket} objects.

@node Tremolo repeats
@subsection Tremolo repeats
@cindex tremolo beams

To place tremolo marks between notes, use @code{\repeat} with tremolo
style.  
@lilypond[verbatim,center,singleline]
\score { 
  \context Voice \notes\relative c' {
    \repeat "tremolo" 8 { c16 d16 }
    \repeat "tremolo" 4 { c16 d16 }    
    \repeat "tremolo" 2 { c16 d16 }
    \repeat "tremolo" 4 c16
  }
}
@end lilypond

Tremolo beams are @internalsref{Beam} objects. Single stem tremolos are
@internalsref{StemTremolo}. The single stem tremolo @emph{must} be
entered without @code{@{} and @code{@}}.  

@refbugs

Only powers of two and undotted notes are supported repeat counts.

@node Tremolo subdivisions
@subsection Tremolo subdivisions
@cindex tremolo marks
@cindex @code{tremoloFlags}

Tremolo marks can be printed on a single note by adding
`@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.

@lilypond[verbatim,fragment,center]
  c'2:8 c':32 | c': c': |
@end lilypond

@refbugs


Tremolos in this style do not carry over into the MIDI output.


@node Measure repeats
@subsection Measure repeats

@cindex percent repeats
@cindex measure repeats

In the @code{percent} style, a note pattern can be repeated. It is
printed once, and then the pattern is replaced with a special sign.
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]
 \context Voice { \repeat  "percent" 4  { c'4 }
    \repeat "percent" 2 { c'2 es'2 f'4 fis'4 g'4 c''4 }
}
@end lilypond   

The signs are represented by these objects: @internalsref{RepeatSlash} and
@internalsref{PercentRepeat} and @internalsref{DoublePercentRepeat}.

@refbugs

You can not nest percent repeats, e.g. by filling in the first measure
with slashes, and repeating that measure with percents.

@node Rhythmic music
@section Rhythmic music

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  looks has  a single staff line:

@lilypond[fragment,relative,verbatim]
  \context RhythmicStaff {
      \time 4/4
      c4 e8 f  g2 | r4 g r2 | g1:32 | r1 |
  }
@end lilypond

@menu
* Percussion staves::           
@end menu

@node Percussion staves
@subsection Percussion staves
@cindex percussion
@cindex drums
To typeset more than one piece of percussion to be played by the same
musician one typically uses a multiline staff where each staff
position refers to a specific piece of percussion.

LilyPond is shipped with a bunch of scheme functions which allows you
to do this fairly easily.

The system is based on the general midi drum-pitches.
In order to use the drum pitches you include
@file{ly/drumpitch-init.ly}. This file defines the pitches from the scheme
variable @code{drum-pitch-names} - which definition can be read in
@file{scm/drums.scm}. You see that each piece of percussion has a full
name and an abbreviated name - and you may freely select whether to
refer to the full name or the abbreviation in your music definition.

To typeset the music on a staff you apply the scheme 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 uses this to
transform the input music by moving the pitch, changing the notehead
and (optionally) adding a script:
@lilypond[singleline,verbatim]
\include "drumpitch-init.ly"
up = \notes { crashcymbal4 hihat8 halfopenhihat hh hh hh openhihat }
down = \notes { bassdrum4 snare8 bd r bd sn4 }
\score {
    \apply #(drums->paper 'drums) \context Staff <
        \clef percussion
        \context Voice = up { \voiceOne \up }
        \context Voice = down { \voiceTwo \down }
    >
}

@end lilypond
In the above example the music was transformed using the list @code{'drums}.
Currently the following lists are defined in @file{scm/drums.scm}:
@table @code
@item 'drums
To typeset 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
    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
            \remove Bar_engraver
            \remove Time_signature_engraver
            minimumVerticalExtent = #'(-4.0 . 5.0)
        }
        \translator {
            \VoiceContext
            \remove Stem_engraver
        }
   }   
}
@end lilypond

Notice that the scheme supports six different toms.
If you are using fewer toms then you simply select the toms that produce
the desired result - i.e. to get toms on the three middle lines you
use @code{tommh}, @code{tomml} and @code{tomfh}.

Because the general midi contain no rimshots we use the sidestick for
this purpose instead.
@item 'timbales
To typeset timbales on a two line staff.
@lilypond[singleline]
\include "drumpitch-init.ly"
nam = \lyrics { timh ssh timl ssl cb }
mus = \notes  { timh ssh timl ssl cb s16 }
\score {
    <
        \apply #(drums->paper 'timbales) \context Staff <
            \clef percussion
            \mus
        >
        \context Lyrics \nam 
    >
    \paper {
        \translator {
            \StaffContext
            \remove Bar_engraver
            \remove Time_signature_engraver
            StaffSymbol \override #'line-count = #2
            StaffSymbol \override #'staff-space = #2
            minimumVerticalExtent = #'(-3.0 . 4.0)
        }
        \translator {
            \VoiceContext
            \remove Stem_engraver
        }

    }   
}
@end lilypond
@item 'congas
To typeset congas on a two line staff.
@lilypond[singleline]
\include "drumpitch-init.ly"
nam = \lyrics { cgh cgho cghm ssh cgl cglo cglm ssl }
mus = \notes  { 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
            \remove Bar_engraver
            \remove Time_signature_engraver
            StaffSymbol \override #'line-count = #2
            StaffSymbol \override #'staff-space = #2
            minimumVerticalExtent = #'(-3.0 . 4.0)
        }
        \translator {
            \VoiceContext
            \remove Stem_engraver
        }
    }   
}
@end lilypond
@item 'bongos
To typeset bongos on a two line staff.
@lilypond[singleline]
\include "drumpitch-init.ly"
nam = \lyrics { boh boho bohm ssh bol bolo bolm ssl }
mus = \notes  { 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
            \remove Bar_engraver
            \remove Time_signature_engraver
            StaffSymbol \override #'line-count = #2
            StaffSymbol \override #'staff-space = #2
            minimumVerticalExtent = #'(-3.0 . 4.0)
        }
        \translator {
            \VoiceContext
            \remove Stem_engraver
        }
    }   
}
@end lilypond
@item 'percussion
To typeset all kinds of simple percussion on one line staves.
@lilypond[singleline]
\include "drumpitch-init.ly"
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 }
\score {
    <
        \apply #(drums->paper 'percussion) \context Staff <
            \clef percussion
            \mus
        >
        \context Lyrics \nam 
    >
    \paper {
        \translator {
            \StaffContext
            \remove Bar_engraver
            \remove Time_signature_engraver
            StaffSymbol \override #'line-count = #1
            minimumVerticalExtent = #'(-2.0 . 3.0)
        }
        \translator {
            \VoiceContext
            \remove Stem_engraver
        }
    }   
}
@end lilypond
@end table

If you don't like any of the predefined lists you can define your own
list at the top of your file:

@lilypond[singleline, verbatim]
#(define 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))
))
\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
        \context Voice = up { \voiceOne \up }
        \context Voice = down { \voiceTwo \down }
    >
}
@end lilypond

To use a modified existing list instead of building your own from
scratch you can append your modifications to the start of the existing
list:

@example
#(define mydrums (append `(
   (bassdrum default #f ,(ly:make-pitch -1 2 0))
   (lowtom   diamond #f ,(ly:make-pitch -1 6 0))
) drums ))
@end example

@c FIXME: Too many levels of headers when using subsubsections.
@c Perhaps junk subsection ``Percussion staves''
@subsubsection Percussion staves with normal staves
When you include @file{drumpitch-init.ly} then the default pitches
are overridden so that you after the inclusion cannot use the common
dutch pitch names anymore. Hence you might wan't to reinclude
@file{nederlands.ly} after the drum-pattern-definitions:
@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 }
\score {
    <
        \apply #(drums->paper 'drums) \context Staff = drums <
            \clef percussion
            \context Voice = up { \voiceOne \up }
            \context Voice = down { \voiceTwo \down }
        >
        \context Staff = bass { \clef "F_8" \bass }
    >
}
@end lilypond

@subsubsection 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.
To use the percussion channel you set the property @code{instrument}
to @code{'drums}. Because the drum-pitches themself 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:

@example
\score @{    
    \apply #(drums->paper 'mydrums) \context Staff <
        \clef percussion
        \context Voice = up @{ \voiceOne \up @}
        \context Voice = down @{ \voiceTwo \down @}
    >
    \paper@{@}
@}
\score @{    
    \context Staff <
        \property Staff.instrument = #'drums
        \up \down
    >
    \midi@{@}
@}
@end example

@refbugs

This scheme is to be considered a temporary implementation. Even
though the scheme will probably keep on working then the future might
bring some other way of typesetting drums, and probably
there will be made no great efforts in keeping things downwards
compatible.

@c . {Piano music}
@node Piano music
@section Piano music

Piano music is an odd type of notation. Piano staves are two normal
staves coupled with a brace.  The staves are largely independent, but
sometimes voices can cross between the two staves.  The
@internalsref{PianoStaff} is especially built to handle this cross-staffing
behavior.  In this section we discuss the @internalsref{PianoStaff} and some
other pianistic peculiarities.


@menu
* Automatic staff changes::     
* Manual staff switches::       
* Pedals::                      
* Arpeggio::                    
* Voice follower lines::        
@end menu 

@refbugs

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 @file{input/test/stem-cross-staff.ly}.

@cindex cross staff stem
@cindex stem, cross staff


@c fixme: should have hyperlinks as well.




@c .   {Automatic staff changes}
@node Automatic staff changes
@subsection Automatic staff changes
@cindex Automatic staff changes

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{} @}
@end example        
The autochanger switches on basis of pitch (central C is the turning
point), and it looks ahead skipping over rests to switch rests in
advance. Here is a practical example:
        
@lilypond[verbatim,singleline]
\score { \notes \context PianoStaff <
  \context Staff = "up" {
    \autochange Staff \context Voice = VA < \relative c' {
       g4 a  b c d r4 a g } > }
  \context Staff = "down" {
       \clef bass
       s1*2
} > }
@end lilypond
Spacer rests are used to prevent the bottom staff from
terminating too soon.


@node Manual staff switches
@subsection Manual staff switches

@cindex manual staff switches
@cindex staff switch, manual

Voices can be switched between staves manually, using the following command:
@example
  \translator Staff = @var{staffname} @var{music}
@end example
The string @var{staffname} is the name of the staff. It switches the
current voice from its current staff to the Staff called
@var{staffname}. Typically @var{staffname} is @code{"up"} or
@code{"down"}.

@c .   {Pedals}
@node Pedals
@subsection Pedals
@cindex Pedals

Piano pedal instruction can be expressed using 
@code{\sustainDown}, @code{\sustainUp}, @code{\unaCorda},
@code{\treCorde}, @code{\sostenutoDown} and @code{\sostenutoUp}.

The symbols that are printed can be modified by setting
@code{pedal@var{X}Strings}, where @var{X} is one of the pedal types:
Sustain, Sostenuto or UnaCorda.  Refer to the generated documentation of
@rgrob{SustainPedal}, for example, for more information.

Pedals can also be indicated by a sequence of brackets, by setting the 
@code{pedal-type} property of SustainPedal objects: 

@lilypond[fragment,verbatim]
\property Staff.SustainPedal \override #'pedal-type = #'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}:

@lilypond[fragment,verbatim]
\property Staff.SustainPedal \override #'pedal-type = #'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:

@lilypond[fragment,verbatim]
c''4 \sostenutoDown d''4 e''4 c'4 f'4 g'4 a'4 \sostenutoUp
@end lilypond

For fine-tuning of the appearance of a pedal bracket, the properties
@code{edge-width}, @code{edge-height}, and @code{shorten-pair} of
@code{PianoPedalBracket} objects (see the detailed documentation of
@rgrob{PianoPedalBracket}) can be modified.  For example, the bracket
may be extended to the end of the note head.

@lilypond[fragment,verbatim]
\property Staff.PianoPedalBracket \override
   #'shorten-pair = #'(0 . -1.0)
c''4 \sostenutoDown d''4 e''4 c'4
f'4 g'4 a'4 \sostenutoUp
@end lilypond

@node Arpeggio
@subsection Arpeggio
@cindex Arpeggio

@cindex broken arpeggio
@cindex @code{\arpeggio}

You can specify an arpeggio sign on a chord by attaching an
@code{\arpeggio} to a chord.


@lilypond[fragment,relative,verbatim]
  <<c e g c>>-\arpeggio
@end lilypond

When an arpeggio crosses staves in piano music, you attach an arpeggio
to the chords in both staves, and set
@code{PianoStaff.connectArpeggios}.

@lilypond[fragment,relative,verbatim]
  \context PianoStaff <
    \property PianoStaff.connectArpeggios = ##t
    \context Voice = one  { <<c' e g c>>-\arpeggio }
    \context Voice = other { \clef bass  <<c,, e g>>-\arpeggio}
  >  
@end lilypond

This command creates @internalsref{Arpeggio} objects.  Cross staff arpeggios
are @code{PianoStaff.Arpeggio}.

To add an arrow head to explicitly specify the direction of the
arpeggio, you should set the arpeggio object property
@code{arpeggio-direction}.

@lilypond[fragment,relative,verbatim]
  \context Voice {
     \property Voice.Arpeggio \set #'arpeggio-direction = #1
     <<c e g c>>-\arpeggio
     \property Voice.Arpeggio \set #'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{PianoStaff.Arpeggio} objects to @code{\arpeggioBracket}, and use
@code{\arpeggio} statements within the chords as before.

@lilypond[fragment,relative,verbatim]
  \context PianoStaff <
    \property PianoStaff.connectArpeggios = ##t
    \property PianoStaff.Arpeggio \override
        #'molecule-callback = \arpeggioBracket
    \context Voice = one  { <<c' e g c>>-\arpeggio }
    \context Voice = other { \clef bass  <<c,, e g>>-\arpeggio }
  >  
@end lilypond


@refbugs

It is not possible to mix connected arpeggios and unconnected
arpeggios in one PianoStaff at the same time.



@node  Voice follower lines
@subsection Voice follower lines

@cindex follow voice
@cindex staff switching
@cindex cross staff

@cindex @code{followVoice}

Whenever a voice switches to another staff a line connecting the notes
can be printed automatically. This is enabled if the property
@code{PianoStaff.followVoice} is set to true:

@lilypond[fragment,relative,verbatim]
  \context PianoStaff <
    \property PianoStaff.followVoice = ##t
    \context Staff \context Voice {
      c1
      \translator Staff=two
      b2 a
    }
    \context Staff=two {\clef bass \skip 1*2 }
  >  
@end lilypond

The associated object is @internalsref{VoiceFollower}.


@node Tablatures
@section Tablatures

Tablature notation is used for notating music for plucked string
instruments.  It notates pitches not by using note heads, but by
indicating on which string and fret a note must be played.  LilyPond
offers limited support for tablature.

@menu
* Tablatures basic::            
* Non-guitar tablatures::       
* Tablature in addition to normal staff::  
@end menu

@node Tablatures basic
@subsection Tablatures basic
@cindex Tablatures basic

Tablature can be typeset with Lilypond by using the
@internalsref{TabStaff} and @internalsref{TabVoice} contexts. As
tablature is a recent feature in Lilypond, most of the guitar special
effects such as bend are not yet supported.

With the @internalsref{TabStaff}, the string number associated to a note
is given as a backslash followed by the string number, e.g. @code{c4\3} for a C
quarter on the third string. By default, string 1 is the highest one, and the
tuning defaults to the standard guitar tuning (with 6 strings).

@lilypond[fragment,verbatim]
  \context TabStaff <
    \notes {
      a,4\5 c'\2 a\3 e'\1
      e\4 c'\2 a\3 e'\1
    }
  >  
@end lilypond

If you do not specify a string number then lilypond automatically selects one.
The selection is controlled by the translator property @code{minimumFret}. -- LilyPond
simply selects the first string that does not give a fret number less than
@code{minimumFret}. Default is 0.

Notice that LilyPond does not handle chords in any special way, and hence
the automatic string selector may easily select the same string to two notes in a chord.

@example
e8 fis gis a b cis' dis' e'
\property TabStaff.minimumFret = #8
e8 fis gis a b cis' dis' e'
@end example
@lilypond[noindent,noquote]
frag = \notes {
    \key e \major
    e8 fis gis a b cis' dis' e'
    \property TabStaff.minimumFret = #8
    e8 fis gis a b cis' dis' e'
}
\score {
  \context StaffGroup <
    \context Staff { \clef "G_8" \frag }
    \context TabStaff { \frag }
  >
}
@end lilypond

@node Non-guitar tablatures
@subsection Non-guitar tablatures
@cindex Non-guitar tablatures

There are many ways to customize Lilypond tablatures.

First you can change the number of strings, by setting the number of
lines in the @internalsref{TabStaff} (the @code{line-count} property
of TabStaff can only be changed using @code{\outputproperty}, for more
information, see @ref{Tuning per object}.  You can change the strings
tuning. A string tuning is given as a Scheme list with one integer
number for each string, the number being the pitch of an open string.

(The numbers specified for stringTuning are the numbers of semitons
to subtract --- or add --- starting the specified pitch by default
middle C, in string order: thus the notes are e, a, d & g)

@lilypond[fragment,verbatim]
  \context TabStaff <

    \outputproperty #(make-type-checker 'staff-symbol-interface)
                    #'line-count = #4
    \property TabStaff.stringTunings =  #'(-5 -10 -15 -20)
    
    \notes {
      a,4 c' a e' e c' a e'
    }
  > 
@end lilypond

Finally, it is possible to change the Scheme function to format the
tablature note text. The default is @var{fret-number-tablature-format},
which uses the fret number, but for some instruments that may not use
this notation, just create your own tablature-format function. This
function takes three argument: the string number, the string tuning and
the note pitch.


@node Tablature in addition to normal staff
@subsection Tablature in addition to normal staff
@cindex Tablature in addition to normal staff

It is possible to typeset both tablature and a "normal" staff, as
commonly done in many parts.

A common trick for that is to put the notes in a variables, and to hide
the fingering information (which correspond to the string number) for
the standard staff.

@c FIXME
@c @lily pond[verbatim]
@example
  part = \notes @{
    a,4-2 c'-5 a-4 e'-6
    e-3 c'-5 a-4 e'-6
  @}
  \score @{
    \context StaffGroup <
      \context Staff <
        % Hide fingering number
        \property Staff.Fingering \override #'transparent = ##t

        \part
      >
      \context TabStaff <
        \property Staff.Stem \override #'direction = #1

        \part
      >
    >
  @}
@end example
@c @end lilypond

@c . {Chords}
@node Chords
@section Chords
@cindex Chords

LilyPond has support for both entering and printing chords. 
@lilypond[verbatim,singleline]
twoWays = \notes \transpose c c' {
  \chords {
    c1 f:sus4 bes/f
  }
  <<c e g>>
  <<f bes c'>>
  <<f bes d'>>
  }

\score {
   < \context ChordNames \twoWays
     \context Voice \twoWays > }
@end lilypond

This example also shows that the chord printing routines do not try to
be intelligent. If you enter @code{f bes d}, it does not interpret
this as an inversion.

As you can see chords really are a set of pitches. They are internally
stored as simultaneous music expressions. This means you can enter
chords by name and print them as notes, enter them as notes and print
them as chord names, or (the most common case) enter them by name, and
print them as name.

@menu
* Chords mode::                 
* Printing named chords::       
@end menu

@c .  {Chords mode}
@node Chords mode
@subsection Chords mode
@cindex Chords mode

Chord mode is a mode where you can input sets of pitches using common
names.  It is introduced by the keyword @code{\chords}.  It is similar
to note mode, but words are also looked up in a chord modifier table
(containing @code{maj}, @code{dim}, etc). Dashes and carets are used
to indicate chord additions and subtractions, so articulation scripts
can not be entered in Chord mode.

Throughout these examples, chords have been shifted around the staff
using @code{\transpose}.

@lilypond[fragment,verbatim]
\transpose c c' {
  \chords {
    c1  c:3-       c:7     c:8
    c:9 c:9-.5+.7+ c:3-.5- 
  }
}
@end lilypond

@cindex @code{aug}
@cindex @code{dim}
@cindex @code{maj}
@cindex @code{sus}

The second type of modifier that may appear after the @code{:} is a
named modifier.  Named modifiers are listed in the file
@file{chord-modifiers.ly}.  The available modifiers are @code{m} and
@code{min} which lower the 3rd half a step, `@code{aug}' which
raises the 5th, `@code{dim}' which lowers the 5th,
`@code{maj}' which adds a raised 7th, and `@code{sus}'
which replaces the 5th with a 4th.

@lilypond[fragment,verbatim]
\transpose c c' {
  \chords {
    c1:m c:min7 c:maj c:aug c:dim c:sus
  }
}
@end lilypond
 

Chord subtractions are used to eliminate notes from a chord.  The
notes to be subtracted are listed after a @code{^} character,
separated by dots.

@lilypond[fragment,verbatim,center]
  \transpose c c' {
    \chords {
      c1^3 c:7^5.3 c:8^7
    }
  }
@end lilypond 
@cindex @code{/}

Chord inversions can be specified by appending `@code{/}' and the name
of a single note to a chord.  In a chord inversion, the inverted note is
transposed down until it is the lowest note in the chord.  If the note
is not in the chord, a warning will be printed.

@lilypond[fragment,verbatim,center]
  \transpose c c'' {
    \chords {
      c1 c/e c/g c:7/e
    }
  }

@end lilypond 
@cindex @code{/+}

Bass notes can be added by `@code{/+}' and
the name of a single note to a chord.  This has the effect of
adding the specified note to the chord, lowered by an octave,
so it becomes the lowest note in the chord.

@lilypond[fragment,verbatim,center]
  \transpose c c'' {
    \chords {
      c1 c/+c c/+g c:7/+b
    }
  }

@end lilypond 

The formal syntax for named chords is as follows:
@example
  @var{tonic}[@var{duration}][@code{-}@var{modifiers}][@code{^}@var{subtractions}][@code{/}@var{inversion}][@code{/+}@var{bass}].
@end example

@var{tonic} should be the tonic note of the chord, and @var{duration} is
the chord duration in the usual notation.  There are two kinds of
modifiers.  One type is formed by @emph{chord additions}. Additions are
obtained by listing intervals separated by dots.  An interval is written
by its number with an optional @code{+} or @code{-} to indicate raising
or lowering by half a step.  Chord additions have two effects: they adds
the specified interval and all lower odd numbered intervals to the
chord, and they may lower or raise the specified interval.


@refbugs

Implementation details are gory. For example @code{c:4} not only adds
a fourth, but also removes the third.


@c .  {Printing named chords}
@node Printing named chords
@subsection Printing named chords

@cindex printing chord names
@cindex chord names
@cindex chords

For displaying printed chord names, use the @internalsref{ChordNames} context.
The chords may be entered either using the notation described above, or
directly using simultaneous music.

@lilypond[verbatim,singleline]
scheme = \notes {
  \chords {a1 b c} <<d f g>>  <<e g b>>
}
\score {
  \notes<
    \context ChordNames \scheme
    \context Staff \transpose c c' \scheme
  >
}
@end lilypond

You can make the chord changes stand out by setting
@code{ChordNames.chordChanges} to true.  This will only display chord
names when there's a change in the chords scheme and at the start of a
new line.

@lilypond[verbatim]
scheme = \chords {
  c1:m c:m \break c:m c:m d
}
\score {
  \notes <
    \context ChordNames {
        \property ChordNames.chordChanges = ##t
        \scheme }
    \context Staff \transpose c c' \scheme
  >
\paper{linewidth= 9.\cm}
}
@end lilypond

LilyPond examines chords specified as lists of notes to determine a name
to give the chord. LilyPond will not try to identify chord inversions or
an added bass note, which may result in strange chord names when chords
are entered as a list of pitches:

@lilypond[verbatim,center,singleline]
scheme = \notes {
  <<c' e' g'>>1
  <<e' g' c''>>
  <<e e' g' c''>>
}

\score {
  <
    \context ChordNames \scheme
    \context Staff \scheme
  >
}
@end lilypond


By default, a chord name system proposed by Harald Banter (See
@ref{Literature}) is used. The system is very regular and predictable.
Typical American style chord names may be selected by setting the
@code{style} property of the @code{ChordNames.ChordName} object to
@code{'american}. Similarly @code{'jazz} selects Jazz chordnames.

Routines that determine the names to be printed are written in Scheme,
and may be customized by the user.  The code can be found in
@file{scm/chord-name.scm}.  Here's an example showing the differences in
chord name styles:

@c too long?
@c maybe just junk verbatim option?
@lilypond[verbatim,singleline,noquote]
scheme = \chords {
  c1 c:5^3 c:4^3 c:5+
  c:m7+ c:m5-.7
  c:5-.7 c:5+.7
  c:9^7
}

\score {
  \notes <
    \context ChordNames = banter \scheme
    \context ChordNames = american {
      \property ChordNames.ChordName \override
        #'style = #'american \scheme }
    \context ChordNames = jazz {
      \property ChordNames.ChordName \override
        #'style = #'jazz \scheme }
    \context Staff \transpose c c' \scheme
  >
}
@end lilypond


@node Writing parts
@section Writing parts

Orchestral music involves some special notation, both in the full score,
as in the individual parts. This section explains how to tackle common
problems in orchestral music.


@c .  {Transpose}
@menu
* Rehearsal marks::             
* Bar numbers::                 
* Instrument names::            
* Transpose::                   
* Multi measure rests::         
* Automatic part combining::    
* Hara kiri staves::            
* Sound output for transposing instruments::  
@end menu

@c .   {Rehearsal marks}
@node Rehearsal marks
@subsection Rehearsal marks
@cindex Rehearsal marks
@cindex mark
@cindex @code{\mark}

To print a  rehearsal mark, use the @code{\mark} command. 
@lilypond[fragment,verbatim]
\relative c'' {
  c1 \mark "A"
  c1 \mark \default
  c1 \mark \default 
  c1 \mark "12"
  c1 \mark \default
  c1
}
@end lilypond

As you can see, 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.  The object
is @internalsref{RehearsalMark} in @internalsref{Score} context. See
@code{input/test/boxed-molecule.ly} if you need boxes around the
marks.

The @code{\mark} command can also be used to put signs like coda,
segno and fermatas on a barline.  The trick is to use the text markup
mechanism to access the fermata symbol.
@lilypond[fragment,verbatim,relative=1]
  c1 \mark #'(music "scripts-ufermata") 
  c1
@end lilypond

The problem is that marks that occur at a line break are typeset only
at the beginning of the next line, opposite to what you want for the
fermata. This can be corrected by the following property setting
@example
\property Score.RehearsalMark \override
  #'visibility-lambda = #begin-of-line-invisible
@end example

@cindex fermatas
@cindex coda
@cindex segno
@cindex barlines, putting symbols on 


@node Bar numbers
@subsection Bar numbers


@cindex bar numbers
@cindex measure numbers
@cindex currentBarNumber

Bar numbers are printed by default at the start of the line.  The
number itself is a property that can be set by modifying the
@code{currentBarNumber} property, although that is usually not
necessary, i.e.
@example
  \property Score.currentBarNumber = #217
@end example

To typeset Bar Numbers at regular intervals instead of at the beginning of each line,
you need to change the grob property @code{break-visibility} as well as the translator
property @code{barNumberVisibility}, as illustrated in the following example which also
adds a box around the bar numbers:
@example
\property Score.BarNumber \override #'break-visibility =
  #end-of-line-invisible
\property Score.barNumberVisibility = #(every-nth-bar-number-visible 5)
\property Score.BarNumber \override #'molecule-callback =
  #(make-molecule-boxer 0.1 0.25 0.25 Text_item::brew_molecule)
\property Score.BarNumber \override #'font-relative-size = #0
@end example
@lilypond[noindent,noquote]
\score {
    \context Staff \notes \transpose c c'' {
        \property Score.BarNumber \override #'break-visibility = #end-of-line-invisible
        \property Score.barNumberVisibility = #(every-nth-bar-number-visible 5)
        \property Score.BarNumber \override #'molecule-callback =
        #(make-molecule-boxer 0.1 0.25 0.25 Text_item::brew_molecule)
        \property Score.BarNumber \override #'font-relative-size = #0
        
        \repeat unfold 16 c1 \bar "|."
    }
}
@end lilypond

See also @seeinternals{BarNumber}.

@refbugs

Barnumbers can collide with the StaffGroup, if there is one at the
top. To solve this, You have to twiddle with the
@internalsref{padding} property of @internalsref{BarNumber} if your
score starts with a @internalsref{StaffGroup}.

@node Instrument names
@subsection Instrument names

In scores, the instrument name is printed before the staff. This can
be done by setting @code{Staff.instrument} and
@code{Staff.instr}. This will print a string before the start of the
staff. For the first start, @code{instrument} is used, for the next
ones @code{instr} is used.

@lilypond[verbatim,singleline]
  \property Staff.instrument = "ploink " { c''4 }  
@end lilypond

You can also use markup texts to construct more complicated instrument
names:


@lilypond[verbatim,singleline]
#(define text-flat
  '((font-relative-size . -2 ) (music "accidentals--1")))

\score { \notes {
  \property Staff.instrument = #`((kern . 0.5) (lines
    "2 Clarinetti" (columns "     (B" ,text-flat ")")))
    c'' 4 }
}
@end lilypond


@refbugs

When you put a name on a grand staff or piano staff the width of the
brace is not taken into account. You must add extra spaces to the end of
the name to avoid a collision.

@node Transpose
@subsection Transpose
@cindex Transpose
@cindex transposition of pitches
@cindex @code{\transpose}

A music expression can be transposed with @code{\transpose}.  The syntax
is
@example
  \transpose @var{from} @var{to} @var{musicexpr}
@end example

This means that @var{musicexpr} is transposed to by the interval
between @var{from} is @var{to}.

@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]
mus =\notes { \key d \major cis d fis g }
\score { \notes \context Staff {
  \clef "F" \mus
  \clef "G"
  \transpose c g' \mus
  \transpose c f' \mus
}}
@end lilypond

If you want to use both @code{\transpose} and @code{\relative}, then
you must use @code{\transpose} first.  @code{\relative} will have no
effect music that appears inside a @code{\transpose}.

@c .  {Multi measure rests}
@node  Multi measure rests
@subsection Multi measure rests
@cindex Multi measure rests

@cindex @code{R}

Multi measure rests are entered using `@code{R}'. It is specifically
meant for full bar rests and for entering parts: the rest can expand to
fill a score with 
rests, or it can be printed as a single multimeasure rest This expansion
is controlled by the property @code{Score.skipBars}. If this is set to true,
Lily will not expand empty measures, and the appropriate number is added
automatically.

@lilypond[fragment,verbatim]
 \time 4/4 r1 | R1 | R1*2
 \property Score.skipBars = ##t R1*17  R1*4
@end lilypond

The @code{1} in @code{R1} is similar to the duration notation used for
notes. Hence, for time signatures other than 4/4, you must enter other
durations.  This can be done with augmentation dots, or with
fractions:

@lilypond[fragment,verbatim]
 \property Score.skipBars = ##t
 \time 3/4
  R2. | R2.*2
 \time 13/8
 R1*13/8
 R1*13/8*12
@end lilypond
Notice that a @code{R} spanning a single measure is printed as a whole
rest centered in the measure, regardless of the time signature.

[ add note about breves.]
 

@cindex whole rests for a full measure 

The object for this object is @internalsref{MultiMeasureRest}.

@refbugs

Currently, there is no way to automatically condense multiple rests
into a single multimeasure rest. Multi measure rests do not take part
in rest collisions. There is no way to put texts centered on
multi-measure rests.

@cindex condensing rests

@node Automatic part combining
@subsection Automatic part combining
@cindex automatic part combining
@cindex part combiner


Automatic part combining is used to merge two parts of music onto a
staff in an intelligent way.  It is aimed primarily at typesetting
orchestral scores.  When the two parts are identical for a period of
time, only one is shown.  In places where the two parts differ, they
are typeset as separate voices, and stem directions are set
automatically.  Also, solo and @emph{a due} parts can be identified
and marked.

The syntax for part combining is

@example
  \partcombine @var{context} @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 most useful function of the part combiner is to combine parts into
one voice, as common for wind parts in orchestral scores:

@lilypond[verbatim,singleline,fragment]
  \context Staff <
    \context Voice=one \partcombine Voice
      \context Thread=one \relative c'' {
        g a () b r
      }
      \context Thread=two \relative c'' {
        g r4 r f
      }
  >
@end lilypond

Notice that the first @code{g} appears only once, although it was
specified twice (once in each part).  Stem, slur and tie directions are
set automatically, depending whether there is a solo or unisono. The
first part (with context called @code{one}) always gets up stems, and
`solo', while the second (called @code{two}) always gets down stems and
`Solo II'.

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'
      }
  >
@end lilypond

There are a number of other properties that you can use to tweak the
behavior of part combining, refer to the automatically generated
documentation of @reng{Thread_devnull_engraver} and
@reng{Voice_devnull_engraver}. Look at the documentation of the
responsible engravers, @code{Thread_devnull_engraver},
@code{Voice_devnull_engraver} and @code{A2_engraver}.

@refbugs

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.

@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

@cindex @code{Thread_devnull_engraver}
@cindex @code{Voice_engraver}
@cindex @code{A2_engraver}

@node Hara kiri staves
@subsection Hara kiri staves

In orchestral scores, staff lines that only have rests are usually removed.
This saves some space.  LilyPond also supports this through the hara
kiri@footnote{Hara kiri, also called Seppuku, is the ritual suicide of
the Japanese Samourai warriors.} staff. This staff commits suicide when
it finds itself to be empty after the line-breaking process.  It will
not disappear when it contains normal rests, you must use multi measure
rests.

The hara kiri staff is specialized version of the @internalsref{Staff}
context. It is available as the context identifier
@code{\HaraKiriStaffContext}.  Observe how the second staff in this
example disappears in the second line.

@lilypond[verbatim]
\score  {
  \notes \relative c' <
    \context Staff = SA { e4 f g a \break c1 }
    \context Staff = SB { c4 d e f \break R1 }
  >
  \paper {
    linewidth = 6.\cm 
    \translator { \HaraKiriStaffContext }
  }
}
@end lilypond


@node Sound output for transposing instruments
@subsection Sound output for transposing instruments

When you want to make a MIDI file from a score containing transposed
and untransposed instruments, you have to instruct LilyPond the pitch
offset (in semitones) for the transposed instruments. This is done
using the @code{transposing} property. It does not affect printed
output.

@cindex @code{transposing}

@example
        \property Staff.instrument = #"Cl. in B-flat"
        \property Staff.transposing = #-2
@end example



@c . {Custodes}
@node Ancient notation 
@section Ancient notation

@cindex Vaticana, Editio
@cindex Medicaea, Editio
@cindex hufnagel
@cindex Petrucci
@cindex mensural

@menu
* Ancient note heads::          
* Ancient clefs ::              
* Custodes::                    
* Ligatures::                   
* Figured bass::                
@end menu


@node Ancient note heads
@subsection Ancient note heads

To get a longa note head, you have to use mensural note heads. This
is accomplished by setting the @code{style} property of the
NoteHead object to @code{mensural}. There is also a note head style
@code{baroque} which gives mensural note heads for @code{\longa} and
@code{\breve} but standard note heads for shorter notes.

@lilypond[fragment,singleline,verbatim]
 \property Voice.NoteHead \set #'style = #'mensural
 a'\longa
@end lilypond

@node Ancient clefs 
@subsection Ancient clefs

LilyPond supports a variety of clefs, many of them ancient.

For modern clefs, see section @ref{Clef}.  For the percussion clef, see
section @ref{Percussion staves}.  For the @code{TAB} clef, see section
@ref{Tablatures}.

The following table shows all ancient clefs that are supported via the
@code{\clef} command.  Some of the clefs use the same glyph, but differ
only with respect to the line they are printed on.  In such cases, a
trailing number in the name is used to enumerate these clefs.  Still,
you can manually force a clef glyph to be typeset on an arbitrary line,
as described in section @ref{Clef}.  The note printed to the right side
of each clef denotes the @code{c'} with respect to the clef.

@table @code

@c --- This should go somewhere else: ---
@c @item modern style G clef (glyph: @code{clefs-G})
@c
@c Supported clefs:
@c @code{treble}, @code{violin}, @code{G}, @code{G2}, @code{french}
@c
@c @lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "G" c'}
@c
@c @item modern style F clef (glyph: @code{clefs-F})
@c
@c Supported clefs:
@c @code{varbaritone}, @code{bass}, @code{F}, @code{subbass}
@c
@c @lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "F" c'}
@c
@c @item modern style C clef (glyph: @code{clefs-C})
@c
@c Supported clefs:
@c @code{soprano}, @code{mezzosoprano}, @code{alto}, @code{C},
@c @code{tenor}, @code{baritone}
@c
@c @lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "C" c'}

@item modern style mensural C clef (glyph: @code{clefs-neo_mensural_c'})

Supported clefs:
@code{neo_mensural_c1}, @code{neo_mensural_c2},
@code{neo_mensural_c3}, @code{neo_mensural_c4}

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "neo_mensural_c2" c'}

@item petrucci style mensural C clef (glyph: @code{clefs-petrucci_c1})

Supported clefs:
@code{petrucci_c1}
for 1st staffline

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "petrucci_c1" c'}

@item petrucci style mensural C clef (glyph: @code{clefs-petrucci_c2})

Supported clefs:
@code{petrucci_c2}
for 2nd staffline

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "petrucci_c2" c'}

@item petrucci style mensural C clef (glyph: @code{clefs-petrucci_c3})

Supported clefs:
@code{petrucci_c3}
for 3rd staffline

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "petrucci_c3" c'}

@item petrucci style mensural C clef (glyph: @code{clefs-petrucci_c4})

Supported clefs:
@code{petrucci_c4}
for 4th staffline

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "petrucci_c4" c'}

@item petrucci style mensural C clef (glyph: @code{clefs-petrucci_c5})

Supported clefs:
@code{petrucci_c5}
for 5th staffline

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "petrucci_c5" c'}

@item petrucci style mensural F clef (glyph: @code{clefs-petrucci_f})

Supported clefs:
@code{petrucci_f}

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "petrucci_f" c'}

@item petrucci style mensural G clef (glyph: @code{clefs-petrucci_g})

Supported clefs:
@code{petrucci_g}

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "petrucci_g" c'}

@item historic style mensural C clef (glyph: @code{clefs-mensural_c'})

Supported clefs:
@code{mensural_c1}, @code{mensural_c2}, @code{mensural_c3},
@code{mensural_c4}

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "mensural_c2" c'}

@item historic style mensural F clef (glyph: @code{clefs-mensural_f})

Supported clefs:
@code{mensural_f}

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "mensural_f" c'}

@item historic style mensural G clef (glyph: @code{clefs-mensural_g})

Supported clefs:
@code{mensural_g}

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "mensural_g" c'}

@item Editio Vaticana style do clef (glyph: @code{clefs-vaticana_do})

Supported clefs:
@code{vaticana_do1}, @code{vaticana_do2}, @code{vaticana_do3}

@lilypond[26pt]{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4 \property Staff.TimeSignature \set #'transparent = ##t \clef "vaticana_do2" c'}

@item Editio Vaticana style fa clef (glyph: @code{clefs-vaticana_fa})

Supported clefs:
@code{vaticana_fa1}, @code{vaticana_fa2}

@lilypond[26pt]{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4 \property Staff.TimeSignature \set #'transparent = ##t \clef "vaticana_fa2" c'}

@item Editio Medicaea style do clef (glyph: @code{clefs-medicaea_do})

Supported clefs:
@code{medicaea_do1}, @code{medicaea_do2}, @code{medicaea_do3}

@lilypond[26pt]{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4 \property Staff.TimeSignature \set #'transparent = ##t \clef "medicaea_do2" c'}

@item Editio Medicaea style fa clef (glyph: @code{clefs-medicaea_fa})

Supported clefs:
@code{medicaea_fa1}, @code{medicaea_fa2}

@lilypond[26pt]{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4 \property Staff.TimeSignature \set #'transparent = ##t \clef "medicaea_fa2" c'}

@item historic style hufnagel do clef (glyph: @code{clefs-hufnagel_do})

Supported clefs:
@code{hufnagel_do1}, @code{hufnagel_do2}, @code{hufnagel_do3}

@lilypond[26pt]{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4 \property Staff.TimeSignature \set #'transparent = ##t \clef "hufnagel_do2" c'}

@item historic style hufnagel fa clef (glyph: @code{clefs-hufnagel_fa})

Supported clefs:
@code{hufnagel_fa1}, @code{hufnagel_fa2}

@lilypond[26pt]{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #4 \property Staff.TimeSignature \set #'transparent = ##t \clef "hufnagel_fa2" c'}

@item historic style hufnagel combined do/fa clef (glyph: @code{clefs-hufnagel_do_fa})

Supported clefs:
@code{hufnagel_do_fa}

@lilypond[26pt]{\property Staff.TimeSignature \set #'transparent = ##t \clef "hufnagel_do_fa" c'}

@c --- This should go somewhere else: ---
@c @item modern style percussion clef (glyph: @code{clefs-percussion})
@c
@c Supported clefs:
@c @code{percussion}
@c
@c @lilypond[26pt]{\property Staff.TimeSignature \set #'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[26pt]{\context Staff \outputproperty #(make-type-checker 'staff-symbol-interface) #'line-count = #6 \property Staff.TimeSignature \set #'transparent = ##t \clef "tab" c'}

@end table

@emph{Modern style} means ``as is typeset in current editions of
transcribed mensural music''.

@emph{Petrucci style} means ``inspired by printings published by the
famous engraver Petrucci (1466-1539)''.

@emph{Historic style} means ``as was typeset or written in contemporary
historic editions (other than those of Petrucci)''.

@emph{Editio XXX style} means ``as is/was printed in Editio XXX''.

Petrucci used C clefs with differently balanced left-side vertical
beams, depending on which staffline it was printed.

@node Custodes
@subsection Custodes

@cindex Custos
@cindex Custodes

A @emph{custos} (plural: @emph{custodes}; latin word for `guard') is a
staff context symbol that appears at the end of a staff line.  It
anticipates the pitch of the first note(s) of the following line and
thus helps the player or singer to manage line breaks during
performance, thus enhancing readability of a score.

@lilypond[verbatim,noquote]
\score {
  \notes { c'1 \break
        \property Staff.Custos \set #'style = #'mensural
        d' }
  \paper {
    \translator {
      \StaffContext
      \consists Custos_engraver
    }
  }
}
@end lilypond

Custodes were frequently used in music notation until the 17th century.
There were different appearances for different notation styles.
Nowadays, they have survived only in special forms of musical notation
such as via the @emph{editio vaticana} dating back to the beginning of
the 20th century.

For typesetting custodes, just put a @code{Custos_engraver} into the
@internalsref{Staff} context when declaring the @code{\paper} block.  In this
block, you can also globally control the appearance of the custos symbol
by setting the custos @code{style} property.  Currently supported styles
are @code{vaticana}, @code{medicaea}, @code{hufnagel} and
@code{mensural}.

@example
\paper @{
  \translator @{
      \StaffContext
      \consists Custos_engraver
      Custos \override #'style = #'mensural
  @}
@}
@end example

The property can also be set locally, for example in a @code{\notes}
block:

@example
\notes @{
  \property Staff.Custos \override #'style = #'vaticana
  c'1 d' e' d' \break c' d' e' d'
@}
@end example

@node Ligatures
@subsection Ligatures

@cindex Ligatures

@c TODO: Should double check if I recalled things correctly when I wrote
@c down the following paragraph by heart.
In musical terminology, a ligature is a coherent graphical symbol that
represents at least two different notes.  Ligatures originally appeared
in the manuscripts of Gregorian chant notation roughly since the 9th
century as an allusion to the accent symbols of greek lyric poetry to
denote ascending or descending sequences of notes.  Both, the shape and
the exact meaning of ligatures changed tremendously during the following
centuries: In early notation, ligatures where used for monophonic tunes
(Gregorian chant) and very soon denoted also the way of performance in
the sense of articulation.  With upcoming multiphony, the need for a
metric system arised, since multiple voices of a piece have to be
synchronized some way.  New notation systems were invented, that used
the manifold shapes of ligatures to now denote rhythmical patterns
(e.g. black mensural notation, mannered notation, ars nova).  With the
invention of the metric system of the white mensural notation, the need
for ligatures to denote such patterns disappeared.  Nevertheless,
ligatures were still in use in the mensural system for a couple of
decades until they finally disappeared during the late 16th / early 17th
century.  Still, ligatures have survived in contemporary editions of
Gregorian chant such as the Editio Vaticana from 1905/08.

Syntactically, ligatures are simply enclosed by @code{\[} and @code{\]}.
Some ligature styles (such as Editio Vaticana) may need additional input
syntax specific for this particular type of ligature.  By default, the
@internalsref{LigatureBracket} engraver just marks the start and end of
a ligature by small square angles:

@lilypond[singleline,verbatim]
\score {
    \notes \transpose c c' {
        \[ g c a f d' \]
        a g f
        \[ e f a g \]
    }
}
@end lilypond

To select a specific style of ligatures, a proper ligature engraver has
to be added to the @internalsref{Voice} context, as explained in the
following subsections.  Currently, Lilypond only supports white mensural
ligatures with certain limitations.  Support for Editio Vaticana will be
added in the future.

@menu
* White mensural ligatures::    
@end menu

@node White mensural ligatures
@subsubsection White mensural ligatures

@cindex Mensural ligatures
@cindex White mensural ligatures

Lilypond has limited support for white mensural ligatures.  The
implementation is still experimental; it currently may output strange
warnings or even crash in some cases or produce weird results on more
complex ligatures.  To engrave white mensural ligatures, in the paper
block the @internalsref{MensuralLigature} engraver has to be put into
the @internalsref{Voice} context (and you probably want to remove the
@internalsref{LigatureBracket} engraver).  There is no additional input
language to describe the shape of a white mensural ligature.  The shape
is rather determined solely from the pitch and duration of the enclosed
notes.  While this approach may take a new user quite a while to get
accustomed, it has a great advantage: this way, lily has full musical
information about the ligature.  This is not only required for correct
MIDI output, but also allows for automatic transcription of the
ligatures.

Example:

@lilypond[singleline,verbatim]
\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
        \clef "petrucci_g"
        \[ g\longa c\breve a\breve f\breve d'\longa \]
        s4
        \[ e1 f1 a\breve g\longa \]
    }
    \paper {
        \translator {
            \VoiceContext
            \remove Ligature_bracket_engraver
            \consists Mensural_ligature_engraver
        }
    }
}
@end lilypond

Without replacing @code{Ligature_bracket_engraver} with
@code{Mensural_ligature_engraver}, the same music transcribes to the
following:

@lilypond[singleline,verbatim]
\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
        \clef "petrucci_g"
        \[ g\longa c\breve a\breve f\breve d'\longa \]
        s4
        \[ e1 f1 a\breve g\longa \]
    }
}
@end lilypond

@node Figured bass
@subsection Figured bass

@cindex Basso continuo

LilyPond has limited support for figured bass:

@lilypond[verbatim,fragment]
<
 \context FiguredBass
   \figures {
        <_! 3+ 5- >4
        < [4 6] 8 >
   }
 \context Voice { c4 g8 }
>
@end lilypond

The support for figured bass consists of two parts: there is an input
mode, introduced by @code{\figures}, where you can enter bass figures
as numbers, and there is a context called @internalsref{FiguredBass}
that takes care of making @internalsref{BassFigure} objects.

In figures input mode, a group of bass figures is delimited by
@code{<} and @code{>}. The duration is entered after the @code{>}.
@example
        <4 6>
@end example
@lilypond[fragment]
\context FiguredBass
\figures { <4 6> }
@end lilypond

Accidentals are added to the numbers if you alterate them by
appending @code{-}, @code{!}  and @code{+}.

@example
  <4- 6+ 7!>
@end example
@lilypond[fragment]
  \context FiguredBass
\figures { <4- 6+ 7!> }
@end lilypond

Spaces or dashes may be inserted by using @code{_}. Brackets are
introduced with @code{[} and @code{]}.

@example
        < [4 6] 8 [_ 12]>
@end example
@lilypond[fragment]
 \context FiguredBass
\figures { < [4 6] 8 [_ 12]> }
@end lilypond

Although the support for figured bass may superficially resemble chord
support, it works much simpler: in figured bass simply stores the
numbers, and then prints the numbers you entered. There is no
conversion to pitches, and no realizations of the bass are played in
the MIDI file.


@c . {Tuning output}
@node Tuning output
@section Tuning output

LilyPond tries to take as much formatting as possible out of your
hands. Nevertheless, there are situations where it needs some help, or
where you want to override its decisions. In this section we discuss
ways to do just that.

Formatting is internally done by manipulating so called objects (graphic
objects). Each object carries with it a set of properties (object
properties) specific to that object.  For example, a stem object has
properties that specify its direction, length and thickness.

The most direct way of tuning the output is by altering the values of
these properties. There are two ways of doing that: first, you can
temporarily change the definition of a certain type of object, thus
affecting a whole set of objects.  Second, you can select one specific
object, and set a object property in that object.

@menu
* Tuning groups of objects ::   
* Tuning per object ::          
* Font selection::              
* Text markup::                 
@end menu

@node Tuning groups of objects 
@subsection Tuning groups of objects 

@cindex object description

A object definition is a Scheme association list, that is stored in a
context property.  By assigning to that property (using plain
@code{\property}), you can change the resulting objects.

@lilypond[verbatim, fragment]
c'4 \property Voice.Stem  = #'()
@end lilypond

The @code{\property} assignment effectively empties the definition of
the Stem object. One of the effects is that the recipe of how it should be
printed is erased, with the effect of rendering it invisible.  The above
assignment is available as a standard identifier, for the case that you
find this useful:

@example
  \property Voice.Stem = \turnOff
@end example

@cindex \override
@cindex \revert
@cindex \set

This mechanism is fairly crude, since you can only set, but not modify,
the definition of a object. For this reason, there is a more advanced
mechanism.

The definition of a object is actually a list of default object
properties. For example, the definition of the Stem object (available in
@file{scm/grob-description.scm}), defines the following values for
@internalsref{Stem}

@example
        (thickness . 0.8)
        (beamed-lengths . (0.0 2.5 2.0 1.5))
        (Y-extent-callback . ,Stem::height)
        @var{...}
@end example

You can add a property on top of the existing definition, or remove a
property, thus overriding the system defaults:
@lilypond[verbatim]
c'4 \property Voice.Stem \override #'thickness = #4.0
c'4 \property Voice.Stem \revert #'thickness
c'4
@end lilypond
You should balance @code{\override} and @code{\revert}. If that's too
much work, you can use the @code{\set} shorthand. It performs a revert
followed by an override. The following example gives exactly the same
result as the previous one. 
@lilypond[verbatim]
c'4 \property Voice.Stem \set #'thickness = #4.0
c'4 \property Voice.Stem \set #'thickness = #0.8
c'4
@end lilypond
If you use @code{\set}, you must explicitly restore the default.


Formally the syntax for these constructions is
@example
\property @var{context}.@var{grobname} \override @var{symbol} = @var{value}
\property @var{context}.@var{grobname} \set @var{symbol} = @var{value}
\property @var{context}.@var{grobname} \revert @var{symbol}
@end example
Here @var{symbol} is a Scheme expression of symbol type, @var{context}
and @var{grobname} are strings and @var{value} is a Scheme expression.


If you revert a setting which was not set in the first place, then it
has no effect. However, if the setting was set as a system default, it
may remove the default value, and this may give surprising results,
including crashes.  In other words, @code{\override} and @code{\revert},
must be carefully balanced.

These are examples of correct nesting of @code{\override}, @code{\set},
@code{\revert}. 

A clumsy but correct form:
@example
  \override \revert \override \revert \override \revert
@end example

Shorter version of the same:
@example 
  \override \set \set  \revert
@end example

A short form, using only @code{\set}. This requires you to know the
default value:
@example
  \set \set \set \set @var{to default value}
@end example

If there is no default (i.e. by default, the object property is unset),
then you can use
@example
  \set \set \set \revert
@end example

For the digirati, the object description is an Scheme association
list. Since a Scheme list is a singly linked list, we can treat it as a
stack, and @code{\override} and @code{\revert} are just push and pop
operations. This pushing and popping is also used for overriding
automatic beaming settings.

@refbugs

LilyPond will hang or crash if @var{value} contains cyclic references.
The backend is not very strict in type-checking object properties. If you
@code{\revert} properties that are expected to be set by default,
LilyPond may crash.




@node Tuning per object 
@subsection Tuning per object 

@cindex \once
Tuning a single object is most often done with @code{\property}. The
form,
@example
        \once \property @dots{}
@end example
@c
applies a setting only during one moment in the score: notice how the
original setting for stem thickness is restored automatically in the
following example
@c
@lilypond[verbatim, fragment, relative=1]
  c4 
  \once \property Voice.Stem \set #'thickness = #4
  c4
  c4
@end lilypond

@cindex \once
@cindex \outputproperty

A second way of tuning objects is the more arcane @code{\outputproperty}
feature.  The syntax is as follows:
@example
\outputproperty @var{predicate} @var{symbol} = @var{value}
@end example
Here @code{predicate} is a Scheme function taking a object argument, and
returning a boolean.  This statement is processed by the
@code{Output_property_engraver}.  It instructs the engraver to feed all
objects that it sees to @var{predicate}. Whenever the predicate returns
true, the object property @var{symbol} will be set to @var{value}.

This command is only single shot, in contrast to @code{\override} and
@code{\set}.

You will need to combine this statement with @code{\context} to select
the appropriate context to apply this to.

In the following example, all note heads occurring at current staff
level, are shifted up and right by setting their @code{extra-offset}
property.

@lilypond[fragment,verbatim,singleline]
\relative c'' { c4
  \context Staff \outputproperty
  #(make-type-checker 'note-head-interface)
  #'extra-offset = #'(0.5 . 0.75)
  <<c e g>>8 }
@end lilypond

@cindex @code{extra-offset}

In this example, the predicate checks the @code{text} object property, to
shift only the `m.d.' text,  but not the fingering instruction "2".
@lilypond[verbatim,singleline]
#(define (make-text-checker text)
   (lambda (grob) (equal? text (ly:get-grob-property grob 'text))))

\score {    
  \notes\relative c''' {
    \property Voice.Stem \set #'direction = #1
    \outputproperty #(make-text-checker "m.d.")
      #'extra-offset = #'(-3.5 . -4.5)
    a^2^"m.d."    
  }
}
@end lilypond

@refbugs

If possible, avoid this feature: the semantics are not very clean, and
the syntax and semantics are up for rewrite.




@node Font selection
@subsection Font selection

The most common thing to change about the appearance of fonts is
their size. The font size of a @internalsref{Voice},
@internalsref{Staff} or @internalsref{Thread} context, can be easily
changed by setting the @code{fontSize} property for that context:
@lilypond[fragment,relative=1]
  c4 c4 \property Voice.fontSize = #-1
  f4 g4
@end lilypond
 This command will not change the size of variable symbols, such as
beams or slurs.  You can use this command to get smaller symbol for
cue notes, but that involves some more subtleties. An elaborate
example of those is in @file{input/test/cue-notes.ly}.

@cindex cue notes
@cindex font size
@cindex size
@cindex symbol size
@cindex glyph size

The font used for printing a object can be selected by setting
@code{font-name}, e.g.
@example
  \property Staff.TimeSignature
    \set #'font-name = #"cmr17"
@end example
You may use any font which is available to @TeX{}, such as foreign
fonts or fonts that do not belong to the Computer Modern font family.
Font selection for the standard fonts, @TeX{}'s Computer Modern fonts,
can also be adjusted with a more fine-grained mechanism.  By setting
the object properties described below, you can select a different font.
All three mechanisms work for every object that supports
@code{font-interface}.

@table @code
@item font-family
 A symbol indicating the general class of the typeface.  Supported are
@code{roman} (Computer Modern), @code{braces} (for piano staff
braces), @code{music} (the standard music font), @code{ancient} (the
ancient notation font) @code{dynamic} (font for dynamic signs) and
@code{typewriter}. 
  
@item font-shape
  A symbol indicating the shape of the font, there are typically several
  font shapes available for each font family. Choices are @code{italic},
  @code{caps} and @code{upright} 

@item font-series
A  symbol indicating the series of the font. There are typically several
font series for each font family and shape. Choices are @code{medium}
and @code{bold}. 

@item font-relative-size
  A number indicating the size relative the standard size.  For example,
  with 20pt staff height, relative size -1  corresponds to 16pt staff
  height, and relative size +1 corresponds to 23 pt staff height.

@item font-design-size
A number indicating  the design size of the font. 

This is a feature of the Computer Modern Font: each point size has a
slightly different design. Smaller design sizes are relatively wider,
which enhances readability.
@end table

For any of these properties, the value @code{*} (i.e. the @emph{symbol},
@code{*}, entered as @code{#'*}), acts as a wildcard. This can be used
to override default setting, which are always present. For example:
@example
  \property Lyrics.LyricText \override #'font-series = #'bold
  \property Lyrics.LyricText \override #'font-family = #'typewriter
  \property Lyrics.LyricText \override #'font-shape  = #'*
@end example

@cindex @code{font-style}

There are also pre-cooked font selection qualifiers. These are
selected through the object property @code{font-style}.  For example,
the style @code{finger} selects family @code{number} and relative size
@code{-3}.  Styles available include @code{volta}, @code{finger},
@code{tuplet}, @code{timesig}, @code{mmrest}, @code{script},
@code{large}, @code{Large} and @code{dynamic}. The style sheets and
tables for selecting fonts are located in @file{scm/font.scm}. Refer
to this file for more information.

@cindex magnification

The size of the font may be scaled with the object property
@code{font-magnification}.  For example, @code{2.0} blows up all
letters by a factor 2 in both directions.

@refbugs

Relative size is not linked to any real size.

There is no style sheet provided for other fonts besides the @TeX{}
family, and the style sheet can not be modified easiyl.

@cindex font selection
@cindex font magnification
@cindex @code{font-interface}


@node Text markup
@subsection Text markup
@cindex text markup
@cindex markup text

LilyPond has an internal mechanism to typeset texts. You can
form text markup expressions by composing scheme expressions
in the following way.

@lilypond[verbatim, singleline]
 \relative c' {
    \fatText
    a^#"upright"
    b_#'(bold "bold")
    c^#'(italic "italic")
    d_#'((bold italic) "ff")
    e^#'(dynamic "ff")
    f_#'(lines "one" (bold "two"))
    g^#'(music "noteheads-2" ((raise . 2.4) "flags-u3"))
  }
@end lilypond

Normally, the Scheme markup text is stored in the @code{text} property
of a object.  Formally, it is defined as follows:

@example
text: string | (head? text+)
head: markup | (markup+)
markup-item: property | abbrev
property: (@var{key} . @var{value})
abbrev: @code{columns lines roman music bold italic named super sub}
        @code{overstrike text finger volta timesig mmrest mark script}
        @code{large Large dynamic}
@end example

The markup is broken down and converted into a list of object properties,
which are prepended to the property list.  The @var{key}-@var{value}
pair is a object property. A list of properties available is included in
the generated documentation for @internalsref{text-interface}.

The following abbreviations are defined:
@table @code
@item columns
 horizontal mode: set all text on one line (default)
@item lines
 vertical mode: set every text on a new line
@item roman
 select roman font
@item music
 selects the Feta font (the standard font for music notation glyphs),
and uses named lookup

@item bold
 select bold series
@item italic
 select italic shape
@item named
 lookup by character name
@item text
 plain text lookup (by character value)
@item super
 superscript
@item sub
 subscript
@item overstrike
 the next text or character overstrikes this one
@item finger
 select fingering number fontstyle
@item volta
 select volta number fontstyle
@item timesig
 select time signature number fontstyle
@item mmrest
 select multi measure rest number fontstyle
@item mark
 select mark number fontstyle
@item script
 select scriptsize roman fontstyle
@item large
 select large roman fontstyle
@item Large
 select Large roman fontstyle
@item dynamic
 select dynamics fontstyle
@end table


@cindex metronome mark

One practical application of complicated markup is to fake a metronome
marking:

@lilypond[verbatim]
#(define note '(columns
  (music "noteheads-2" ((kern . -0.1) "flags-stem"))))
#(define eight-note `(columns ,note ((kern . -0.1)
  (music ((raise . 3.5) "flags-u3")))))
#(define dotted-eight-note
  `(columns ,eight-note (music "dots-dot")))

\score {
  \notes\relative c'' {
    a1^#`((columns (font-relative-size . -1))
           ,dotted-eight-note " = 64")
  }
  \paper {
    linewidth = -1.
    \translator{
      \ScoreContext
      TextScript \override #'font-shape = #'upright
    }
  }
}
@end lilypond

@refbugs

The syntax and semantics of markup texts are not clean, and both
syntax and semantics are slated for a rewrite.

LilyPond does not do kerning, and there generally spaces texts
slightly too wide.



@node Global layout
@section Global layout

The global layout determined by three factors: the page layout, the
line breaks and the spacing. These all influence each other: The
choice of spacing determines how densely each system of music is set,
where line breaks breaks are chosen, and thus ultimately how many
pages a piece of music takes. In this section we will explain how the
lilypond spacing engine works, and how you can tune its results.

Globally spoken, this procedure happens in three steps: first,
flexible distances (``springs'') are chosen, based on durations. All
possible line breaking combination are tried, and the one with the
best results---a layout that has uniform density and requires as
little stretching or cramping as possible---is chosen. When the score
is processed by @TeX{}, page are filled with systems, and page breaks
are chosen whenever the page gets full.

@menu
* Vertical spacing::            
* Horizontal spacing::          
* Font Size::                   
* Line breaking::               
* Page layout::                 
@end menu


@node Vertical spacing
@subsection Vertical spacing

@cindex vertical spacing
@cindex distance between staves
@cindex staff distance
@cindex between staves, distance
@cindex staffs per page


The height of each system is determined automatically by lilypond, to
keep systems from bumping into each other, some minimum distances are
set.  By changing these, you can put staves closer together, and thus
put more  systems onto one page.

Normally staves are stacked vertically. To make
staves maintain a distance, their vertical size is padded. This is
done with the property @code{minimumVerticalExtent}. It takes a pair
of numbers, so if you want to make it smaller from its, then you could
set
@example
  \property Staff.minimumVerticalExtent = #'(-4 . 4)
@end example
This sets the vertical size of the current staff to 4 staff-space on
either side of the center staff line.  The argument of
@code{minimumVerticalExtent} is interpreted as an interval, where the
center line is the 0, so the first number is generally negative.  you
could also make the staff larger at the bottom by setting it to
@code{(-6 . 4)}. The default value is @code{(-6 . 6)}.

Vertical aligment of staves is handled by the
@internalsref{VerticalAlignment} object, which lives at
@internalsref{Score} level.

The piano staves are handled a little differently: to make cross-staff
beaming work correctly, it necessary that the distance between staves
is fixed.  This is also done with a @internalsref{VerticalAlignment}
object, created in @internalsref{PianoStaff}, but a forced distance is
set. This is done with the object property #'forced-distance. If you
want to override this, use a @code{\translator} block as follows:
@example
  \translator @{
    \PianoStaffContext
    VerticalAlignment \override #'forced-distance = #9
  @}
@end example
This would bring the staves together at a distance of 9 staff spaces,
and again this is measured from the center line of each staff.



@node Horizontal spacing
@subsection Horizontal Spacing

The spacing engine translates differences in durations into
stretchable distances (``springs'') of differing lengths. Longer
durations get more space, shorter durations get less.  The basis for
assigning spaces to durations, is that the shortest durations get a
fixed amount of space, and the longer durations get more: doubling a
duration adds a fixed amount 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. The 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 c8 c4 c4 c4
@end lilypond

These two amounts of space are @code{shortest-duration-space}
@code{spacing-increment}, object properties of
@internalsref{SpacingSpanner}. Normally @code{spacing-increment} 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 noteheads of space. For normal notes, this space
is always counted from the left edge of the symbol, so the short notes
in a score is generally followed by one note head width of space.

If one would follow the above procedure exactly, then adding a single
32th note to a score that uses 8th and 16th notes, would widen up the
entire score a lot. The shortest note is no longer a 16th, but a 64th,
thus adding 2 noteheads of space to every note. To prevent this, the
shortest duration for spacing is not the shortest note in the score,
but the most commonly found shortest note.  Notes that are even
shorter this are followed by a space that is proportonial to their
duration relative to the common shortest note.  So if we were to add
only a few 16th notes to the example above, they would be followed by
half a NHW:

@lilypond[fragment, verbatim, relative=1]
 c2 c4. c8 c4. [c16 c] c4. c8 c8 c8 c4 c4 c4
@end lilypond

The most common shortest duration is determined as follows: in every
measure, the shortest duration is determined. The most common short
duration, is taken as the basis for the spacing, with the stipulation
that this shortest duration should always be equal to or shorter than
1/8th note. The shortest duration is printed when you run lilypond
with @code{--verbose}.  These durations may also be customized. If you
set the @code{common-shortest-duration} in
@internalsref{SpacingSpanner}, then this sets the base duration for
spacing. The maximum duration for this base (normally 1/8th), is set
through @code{base-shortest-duration}.

@cindex @code{common-shortest-duration}
@cindex @code{base-shortest-duration}
@cindex @code{stem-spacing-correction}
@cindex @code{spacing}

In the introduction it was explained that stem directions influence
spacing. This is controlled with @code{stem-spacing-correction} in
@internalsref{NoteSpacing}. The @code{StaffSpacing} object contains the
same property for controlling the stem/barline spacing. In the
following example shows these corrections, once with default settings,
and once with exaggerated corrections.  

@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
      = #1.5
      \property Staff.StaffSpacing \override #'stem-spacing-correction
      = #1.5
      c'4 e''4 e'4 b'4 |
      b'4 e''4 b'4 e''4|      
    }
    \paper { linewidth = -1. } }
@end lilypond



@refbugs

Spacing is determined on a score wide basis. If you have a score that
changes its character (measured in durations) half way during the
score, the part containing the longer durations will be spaced too
widely.

Generating optically pleasing spacing is black magic. LilyPond tries
to deal with a number of frequent cases. Here is an example that is
not handled correctly, due to the combination of chord collisions and
kneed stems.

@lilypond
\score {
     \context PianoStaff \notes \transpose c c'' <
     \context Staff = up { s1 }
     \context Staff = down { [c8 c \translator Staff=up <<c d>> c 
\translator Staff=down c c c] }
     >
     \paper { linewidth = -1 }
}
@end lilypond


@c .  {Font size}
@node Font Size
@subsection Font size
@cindex font size, setting
@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, 19 pt, 20 point, 23
point, and 26 point.  The point size of a font is the height of the
five lines in a staff when displayed in the font.

Definitions for these sizes are the files @file{paperSZ.ly}, where
@code{SZ} is one of 11, 13, 16, 19, 20, 23 and 26.  If you include any
of these files, the identifiers @code{paperEleven},
@code{paperThirteen}, @code{paperSixteen}, @code{paperNineteen},
@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.
@example
        \include "paper26.ly"
        \score @{  ... @}
@end example

The font definitions are generated using a Scheme function. For more
details, see the file @file{scm/font.scm}.


@c .  {Line break}
@node Line breaking
@subsection Line breaking

@cindex line breaks
@cindex breaking lines

Line breaks are normally computed automatically. They are chosen such
that it looks neither cramped nor loose, and that consecutive lines have
similar density.

Occasionally you might want to override the automatic breaks; you can
do this by specifying @code{\break}. This will force a line break at
this point.  Line breaks can only occur at places where there are bar
lines.  If you want to have a line break where there is no bar line,
you can force an invisible bar line by entering @code{\bar
""}. Similarly, @code{\noBreak} forbids a line break at a certain
point.


@cindex regular line breaks
@cindex four bar music. 

If you want linebreaks at regular intervals, you can use the following:
@example
<  \repeat 7 unfold @{ s1 * 4 \break  @}
   @emph{real music}
> 
@end  example
This makes the following 28 measures (assuming 4/4 time) be broken every
4 measures.

@node Page layout
@subsection Page layout

@cindex page breaks
@cindex breaking pages

@cindex @code{indent}
@cindex @code{linewidth}

The most basic settings influencing the spacing are @code{indent} and
@code{linewidth}. They are set in the @code{\paper} block. They
control the indentation of the first line of music, and the lengths of
the lines.  If @code{linewidth} set to a negative value, a single
unjustified line is produced.  A similar effect for scores that are
longer than one line, can be produced by setting @code{raggedright} to
true in the @code{\paper} block.

@cindex page layout

The page layout process happens outside lilypond. Ly2dvi sets page
layout instructions. Ly2dvi responds to the following variables in the
@code{\paper} block.  The variable @code{textheight} sets the total
height of the music on each page.  The spacing between systems is
controlled with @code{interscoreline}, its default is 16pt.
The distance between the score lines will stretch in order to fill the
full page @code{interscorelinefill} is set to a positive number.  In
that case @code{interscoreline} specifies the minimum spacing.

@cindex @code{textheight}
@cindex @code{interscoreline}
@cindex @code{interscorelinefill}

If the variable @code{lastpagefill} is defined (that is, it gets any
value assigned in the @code{\paper} block), 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.  Note
that @command{lilypond-book} ignores @code{lastpagefill}.  See
@ref{Integrating text and music with lilypond-book} for
more information.

@cindex @code{lastpagefill}

Page breaks are normally computed by @TeX{}, so they are not under
direct control of LilyPond.  However, you can insert a commands into
the @file{.tex} output to instruct @TeX{} where to break pages. You
can insert a @code{\newpage} from within lilypond. This is done by
setting the @code{between-systems-strings} on the
@internalsref{NonMusicalPaperColumn} where the system is broken.

@cindex paper size
@cindex page size
@cindex @code{papersize}

To change the paper size, you must first set the
@code{papersize} paper variable variable.  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.

@example
        \paper@{ papersize = "a4" @}
        \include "paper16.ly"
@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
Lilypond and @code{ly2dvi})




@c . {Sound}
@node Sound
@section Sound
@cindex Sound

LilyPond can produce MIDI output.  The performance lacks lots of
interesting effects, such as swing, articulation, slurring, etc., but it
is good enough for proof-hearing the music you have entered.  Ties,
dynamics and tempo changes are interpreted.

Dynamic marks, crescendi and decrescendi translate into MIDI volume
levels.  Dynamic marks translate to a fixed fraction of the available
MIDI volume range, crescendi and decrescendi make the the volume vary
linearly between their two extremities.  The fractions be adjusted by
overriding the @code{absolute-volume-alist} defined in
@file{scm/midi.scm}.

For each type of musical instrument (that MIDI supports), a volume range
can be defined.  This gives you basic equalizer control, which can
enhance the quality of the MIDI output remarkably.  You can add
instruments and ranges or change the default settings by overriding the
@code{instrument-equalizer-alist} defined in @file{scm/midi.scm}.

Both loudness controls are combined to produce the final  MIDI volume. 

@menu
* MIDI block::                  
* MIDI instrument names::       
@end menu

@c .  {MIDI block}
@node MIDI block
@subsection MIDI block
@cindex MIDI block


The MIDI block is analogous to the paper block, but it is somewhat
simpler.  The @code{\midi} block can contain:
@cindex MIDI block

@itemize @bullet
  @item  a @code{\tempo} definition
  @item  context definitions
@end itemize

Assignments in the @code{\midi} block are not allowed.



@cindex context definition

Context definitions follow precisely the same syntax as within the
\paper block.  Translation modules for sound are called performers.
The contexts for MIDI output are defined in @file{ly/performer-init.ly}.


@node MIDI instrument names
@subsection MIDI instrument names

@cindex instrument names
@cindex @code{Staff.midiInstrument}
@cindex @code{Staff.instrument}

The MIDI instrument name is set by the @code{Staff.midiInstrument}
property or, if that property is not set, the @code{Staff.instrument}
property.  The instrument name should be chosen from the list in
@ref{MIDI instruments}.

@refbugs

If the selected string does not exactly match, then LilyPond uses the
default (Grand Piano). It is not possible to select an instrument by
number.