in the notes at different heights'', but as you learn more of it, the
opposite turns out to be true. One has to master two difficult
tasks. First, one has to master music notation: the science of knowing
-which symbols to use when what. Second, one has to master music
+which symbols to use for what. Second, one has to master music
engraving: the art of placing symbols such that the result looks
pleasing.
+
+
+@lilypondfile[notexidoc]{puer-fragment.ly}
+
+@center A fragment of neume notation
+
+
Common music notation has its roots in the medieval time. In this
time, monks started to write down hints that indicated how their
sacred music was sung. These hints, neumes, gradually became simpler,
notation is still under development; the innovations of contemporary
music require still newer and more complex notations.
+
+
The term music engraving derives from the traditional process of music
printing. Only a few decades ago, sheet music was made by cutting and
stamping the music into zinc or pewter plates, in mirror image. The plate
automatically. In these cases, a user must be able to override
formatting decisions. A way to accomplish this, is to store decisions
in generic variables, and let the user manipulate these variables.
-For example, consider the following fragment of notation.
+For example, consider the following fragment of notation:
@lilypond
\score { \notes \relative c'' {
\stemUp
- c4-\f f4
+ a4^\f f8
}
\paper { raggedright = ##t }
}
The position of the forte symbol is slightly awkward, because it is
next to the low note, whereas dynamics should be below notes in
general. This may be remedied by inserting extra space between the
-high note and the `f', as shown in this example
+high note and the `f', as shown in this example:
@lilypond
\score { \notes \relative c'' {
\stemUp
\once\property Voice. DynamicLineSpanner \override #'padding = #4.0
- c4-\f f4
+ a4^\f f8
}
\paper { raggedright = ##t }
}
@end lilypond
-This was achieved with the following input statement.
+This was achieved with the following input statement:
@example
\once \property Voice. DynamicLineSpanner \override #'padding = #4.0
@end example
@end example
@lilypond
-\score { \notes {
+\score { \notes \relative c'' {
\property Score.Stem \override #'thickness = #2.0
\once\property Voice. DynamicLineSpanner \override #'padding = #4.0
- g'4-\f g4
+\stemUp
+ a4^\f f8
}
\paper { raggedright = ##t }
}
have to be touched up. Consequently, an interactive display of the
output, where it is possible to reposition notation elements, is
superfluous. This implies that the program should be a batch program:
-the input is entered in a file, which is @emph{compiled}, i.e. then
+the input is entered in a file, which then is @emph{compiled}, i.e.
put through the program. The final output is produced as a file ready
to view or print. The compiler fills in all the details of the
notation, those details should be left out of the input file. In other
@code{r8.} signifies a dotted eighth rest. Notes and rests form the
simplest musical expressions in the input syntax. More complex
constructs are produced by combining them into compound
-structures. This is done s in much the same way that complex
+structures. This is done in much the same way that complex
mathematical formulas are built from simple expressions such as
numbers and operators.
In effect, the input format is a language, and the rules of that
language can be specified succinctly with a so-called context-free
grammar. The grammar formally specificies what types of input form
-valid `sentences.' Reading such languages, and splitting them into
+valid `sentences'. Reading such languages, and splitting them into
grammatical structures is a problem with standard solutions.
-Moreover, they make the format easier to understand: a a concise
+Moreover, they make the format easier to understand: a concise
formal definition permits a simple informal description.
The user-interface of LilyPond is its syntax. That part is what users
a very important or interesting problem. In reality, less than 10% of
the source code of the program handles reading and representing the
input, and they form the easy bits of the program. In our opinion,
-producing music notation, and formatting it prettily are the
-interesting and important parts: they take up most of the bulk of the
-code, and are the most difficult things to get right.
+producing music notation, and formatting it prettily are much more
+interesting and important than music representation: solving
+these problems takes up most of the bulk of the code, and they are the
+most difficult things to get right.
@node Example applications
@section Example applications
We have written LilyPond as an experiment of how to condense the art
of music engraving into a computer program. Thanks to all that hard
work, the program can now be used to perform useful tasks. The
-simplest application is printing notes.
+simplest application is printing notes:
@lilypond[relative=1]
\time 2/4 c4 c g'4 g a4 a g2
@end lilypond
Polyphonic notation and piano music can also be printed. The following
-example combines some more exotic constructs.
+example combines some more exotic constructs:
@lilypondfile{screech-boink.ly}
@node About this manual
@section About this manual
-The manual is divided into the following chapters
+The manual is divided into the following chapters:
@itemize @bullet
@item
@ifhtml The
advisable to consult the glossary as well. The glossary explains
musical terms, and includes translations to various languages. It is a
@ifhtml
-@uref{../glossary.html,separate document}
+@uref{../music-glossary.html,separate document}.
@end ifhtml
@ifnothtml
separate document, available in HTML and PDF.
This manual is not complete without a number of other documents. They
are not available in print, but should be included with the
-documentation package for your platform
+documentation package for your platform:
@itemize @bullet
@item
-Generated internal documentation.
+Program reference
@ifhtml
-available @uref{../lilypond-internals/lilypond-internals.html,here}
+(available @uref{../lilypond-internals/lilypond-internals.html,here})
@end ifhtml
-The generated internal documentation is a set of heavily crosslinked
-HTML pages, which documents the nit-gritty details of each and every
-LilyPond class, object and function. It is produced directly from the
+The program reference is a set of heavily crosslinked HTML pages,
+which documents the nit-gritty details of each and every LilyPond
+class, object and function. It is produced directly from the
formatting definitions used.
Almost all formatting functionality that is used internally, is
@item
Templates
@ifhtml
-(available @uref{../../../input/templates/out-www/collated-files.html,here})
+(available @uref{../../../input/template/out-www/collated-files.html,here})
@end ifhtml
After you have gone through the tutorial, in theory you should be able
@item
Various input examples
@ifhtml
-available @uref{../../../input/test/out-www/collated-files.html,here}
+(available @uref{../../../../input/test/out-www/collated-files.html,here})
@end ifhtml
@cindex snippets
@item
The regression test
@ifhtml
-available @uref{../../../input/regression/out-www/collated-files.html,here}
+(available @uref{../../../input/regression/out-www/collated-files.html,here})
@end ifhtml
This collection of files tests each notation and engraving feature of
projects / lilypond.git / blobdiff