+mailto(gnu-music-discuss@gnu.org)
COMMENT(-*-text-*-)
redef(var)(1)(whenlatex(latexcommand({\normalfont\scshape )ARG1+latexcommand(}))\
redef(code)(1)(tt(ARG1))
+
COMMENT(
TODO:
the use of semicolons needs to be documented once it settles down
- \times needs documentation with examples somewhere once it works (?)
paper size?
the explanation of how lyrics mode parses words seems ridiculous.
Is there a simple way to explain this, or is the behavior
too complicated for a reasonable explanation?
+ \relative and \tranpose and \times make it necessary to specify
+ an explicit \type staff, or bizarre things happen.
+ catalan.ly
+ accordion symbols
+ extender* (see extender.ly)
+ \repeat & \alternative -> probably should have an example
+ properties:
+ unfoldRepeats
+ voltaVisibility
+ property: stemLeftBeamCount stemRightBeamCount
+ interstaff beams (beam-interstaff.ly)
+ interstaff slurs (see preludes-1.ly)
+ boolean property barAuto
+ property: noteheadStyle
+ harmonics: test/harmonics.fly
+ autobeamer
+ properties: beamAutoEndx ??? rational string "1/2"
+ beamAutoBegin
+ beamAutoEnd
+ beamAuto
+ ScriptPadding
+ Direction
+ chordNameStyle (banter)
+ chordInversionPreserve
+ createInitdefaultClef
+ dynamicStyle
+ singleStaffBracket
+ numberOfStaffLines
+
+
+ {Mark,BarNumber,Margin}{Direction,ScriptPadding}
+
+
)
-COMMENT( This document contains Mudela fragments. You need at least
+COMMENT(
+This document contains Mudela fragments. You need at least
Yodl-1.30.18 to convert this to tex or html.
-
-TODO
-
-in stead <-> instead
)
htmlbodyopt(bgcolor)(white)
whentexinfo(notableofcontents())
-article(Mudela 1.0.7 / LilyPond 1.0.15 Reference Manual)
+article(Mudela 1.0.14 / LilyPond 1.1.27 Reference Manual)
(Adrian Mariano, Han-Wen Nienhuys and Jan Nieuwenhuizen)
(nop()PIPETHROUGH(date "+%B %d, %Y")()()nop())
file(init.)var(ext) must contain the code(\maininput) keyword or LilyPond
will not read the user specified file.
+When LilyPond processes file(filename.ly) it will produce file(filename.tex) as
+output. If file(filename.ly) contains a second code(\paper) keyword, then
+LilyPond will produce file(filename-1.tex) as well. Subsequent code(\paper)
+keywords will produces sequentially numbered file names. Several files can be
+specified; they will each be processed independently.
sect(Syntax)
are converted immediately to a real which gives the dimension in
points, so they can be mixed with reals, but the result is no longer
of type dimension. The keywords that require a dimension
-(code(\shape) and code(\symboltables)) will not accept this.
+(code(\shape)).
dit(pitch)
A pitch is a string which is the name of a pitch. Example: code(a).
letter and are entirely alphanumeric. It is also impossible to refer
to an identifier whose name is the same as the name of a keyword. The
following words are keywords:
-verb(absdynamic header musicalpitch remove times
-accepts in name score translator
-bar include notenames script transpose
-cadenza key notes shape type
-clef keysignature paper skip version
-cm lyrics partial spandynamic
-consists maininput penalty symboltables
-duration mark property table
-font midi pt tempo
-grouping mm relative time)
+verb(absdynamic duration mark property skip
+accepts font midi pt spandynamic
+alternative grouping mm relative tempo
+bar header musicalpitch remove time
+cadenza in name repeat times
+chordmodifier include notenames scm translator
+chords key notes scmfile transpose
+clef keysignature paper score type
+cm lyrics partial script version
+consists maininput penalty shape)
The right hand side of an identifier assignment is parsed completely
when the assignment is made. It therefore must have any context
treated as a string. If you mistype a notename, the parser will most
likely complain that you should be in code(\lyrics) mode to do lyrics.
+dit(Chord mode) Chord mode is instroduced by the keyword code(\chords).
+Very similar to Note mode.
+COMMENT(I'm not sure how it differs)
+
dit(Lyric mode) Lyrics mode is introduced by the keyword
code(\lyrics). This mode is has rules that make it easy to include
punctuation and diacritical marks in words. A word in Lyrics mode
_ _ _ _ % 4 words, each one a space
))
+It is possible to create words that break the rules by prefixing them with the
+dollar sign code($). Regardless of the context, a word beginning with code($)
+extends until the next white space character. Such words can contain numbers
+(even in Note mode), or other forbidden characters. The dollar sign can be
+used to create and access identifiers that could not otherwise be used.
COMMENT(
These modes are of a lexical nature. Normal and Note mode largely
subsect(Basic Note Specification)
A note specification has the form
-var(pitch)[var(octavespec)][code(!)][var(duration)].
+var(pitch)[var(octavespec)][code(!)][code(?)][var(duration)].
The pitch of the note is specified by the note's name.
LilyPond has predefined note names for various languages. The default
context.
A reminder accidental can be forced by
using the optional exclamation mark `code(!)'
-on a pitch.
+on the pitch.
+A cautionary accidental, i.e., an accidental within paranthesis
+can be obtained using the optional question mark `code(?)' on the pitch.
mudela(fragment,verbatim,center)(
-cis' d' e' cis' c'! d' e' c'
+cis' d' e' cis' c'? d' e' c'!
)
a'4. b'4.
)
-In addition, the duration can be followed by a multiplier which is
-introduced with the asterisk code(*) and can be an integer or a
-fraction. The multiplier changes the duration that LilyPond uses
-internally for the note, but for notes it
-does not change the symbol that is printed.
+Extra long notes can be obtained using the code(\breve) and
+code(longa) durations:
mudela(fragment,verbatim,center)(
-c'4*2 c'4*2 d'8*2/3 d'8*2/3
+c'\breve gis'\longa
)
+
+In order to get triplets and other tuplets, you must use the
+code(\times) keyword which multiplies the duration by a fraction. The
+syntax is code(\times) var(fraction) var(music). The length of all of
+the specified music will be multiplied by the fraction and the
+fraction's denominator will be printed over the notes. The most
+common tuplet is the triplet in which 3 notes have the length of 2, so
+the notes are 2/3 their written length:
+mudela(fragment,verbatim,center)( b'4 \times 2/3 {c'4 c' c'} d'4 d'4 )
+If you try to use code(\times) as the first thing in your music, you
+may encounter the warning ``No one to print a tuplet start bracket''.
+This happens because the Tuplet-engraver is in Voice and no Voice has
+been created yet. You must explicitly specify the Voice context in
+this situation
+mudela(fragment,verbatim,center)(
+\type Voice { \times 2/3 {c'4 d' e'}}
+)
+
+A shorthand for code(\times) is to write code(*)var(fraction) after a
+duration. This shorthand will not label triplets correctly, but
+it is convenient for long rests.
For long rests with durations equal to an integer number of whole notes,
LilyPond produces output that indicates the duration of the rest. If you use
code(r) then one rest symbol will be printed and several measures left blank.
If you use code(R) then all of the measure will be filled with whole rests.
+mudela(fragment,verbatim,center)(
+r1 r1*3 R1*3
+)
If you set the code(Score.SkipBars) property, then only one measure will be
printed; with code(R), a number indicating the length of the rest will be
displayed.
mudela(fragment,verbatim,center)(
-r1*3 R1*3
\property Score.SkipBars=1
-r1*3 R1*3)
-
-Extra long notes can be obtained using the code(\breve) and
-code(longa) durations:
+r1 r1*3 R1*3
+)
+Even though the code(\times) command is not explicit, it is still
+necessary to specify a code(Voice) context if the music begins with
+rests lengthened using code(*).
+Otherwise, the following will result:
mudela(fragment,verbatim,center)(
-c'\breve gis'\longa
+R1*3 c'1 d'
)
-
-subsect(Note Spanners: Beams, Tuplets, Slurs and Ties)
+subsect(Note Spanners: Beams, Slurs and Ties)
A beam is specified by surrounding the beamed notes with brackets
code([) and code(]).
mudela(fragment,verbatim,center)(
-[a'8 a'] [a'16 a' a' a']
-)
-
-In order to create triplets, you must use a length multiplier after
-the brackets. An open bracket code([) followed by a fraction
-instructs LilyPond to print a number over the beam, and it also
-starts multiplying all note lengths by the fraction. The closing
-bracket code(]) should be followed by the fraction code(1/1) in order
-to restore normal note lengths. To create a triplet without a beam,
-place a backslace code(\) before the opening and closing brackets.
-
-For example, in an ordinary triplet, the notes have duration 2/3 as
-long as normal.
-mudela(fragment,verbatim,center)(
-[2/3 a'8 a' a' ]1/1 \[2/3 b'4 b' b'\]1/1
+[a'8 a'] [a'16 a' a' a']
)
-
-There is a shorthand that can be used when you
-want notes lengths multiplied by 2/n.
-The 2 can be omitted after the open bracket
-and the first 1 can be omitted after the closing bracket.
+Some more elaborate constructions:
mudela(fragment,verbatim,center)(
-[/3 b'8 b' b' ]/1 \[/3 a'4 a'8\]/1
-)
-
-COMMENT(This next bit needs to be fixed...or the language needs to be
-fixed.)
-
-Here is a combination
-mudela(fragment,verbatim,center)(
-[/3 a'8 a'16 a'] a'8 \]
+[a'16 <a' c''> c'' <a' c''>]
+\times 2/3 { [e'8 f' g'] }
)
Another type of spanner is the slur. Slurs connects chords and try to
note in the slur. This makes it possible to put a note in slurs from
both sides:
mudela(fragment,verbatim,center)(
-f'()g'()a' [a'8 b']( a'4 g' )f'
+f'()g'()a' [a'8 b'(] a'4 g' )f'
)
A tie connects two adjacent note heads. When used with chords, it
connects all of the note heads. Ties are indicated using the tilde symbol
-code(~) by analogy with TeX()'s tie which connects words. For ties
-between chords, the input convention is somewhat peculiar. You cannot
-write code(<c g>~<c g>), but rather must put the tilde after
-a note within the first chord.
+code(~) by analogy with TeX()'s tie which connects words.
mudela(fragment,verbatim,center)(
-e' ~ e' <c'~ e' g'><c' e' g'>
+e' ~ e' <c' e' g'> ~ <c' e' g'>
+)
+
+It is possible to create beams and slurs that cross staffs by switching the
+context:
+mudela(fragment,verbatim,center)(
+<
+\type Staff=one \notes\relative c'{
+ \stemup
+ [c8 c \translator Staff=two \stemup c c]
+ \translator Staff=one
+ d4( \translator Staff=two )a4
+ }
+\type Staff=two \notes{ \clef bass;}
+>
)
+COMMENT(!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
+
subsect(Note Ornaments)
A variety of symbols can appear above and below notes to indicate
c''-\open c''-\flageolet c''-\reverseturn
c''-\trill
c''-\prall c''-\mordent c''-\prallprall c''-\prallmordent
- c''-\upprall c''-\downprall }
+ c''-\upprall c''-\downprall c''-\thumb }
\type Lyrics \lyrics{
accent marcato staccatissimo fermata stopped
staccato tenuto upbow downbow lheel rheel ltoe rtoe turn
open flageolet reverseturn
trill prall
- mordent prallprall prallmordent uprall downprall }>
- \paper{linewidth = 5.875\in;
- indent = 0.0;
- }
-}
+ mordent prallprall prallmordent uprall downprall thumb }
+ >
+ \paper{ linewidth = 5.875\in;
+ indent = 0.0; }
+ }
)
COMMENT( The following are defined in script.ly but do not work:
Dynamic marks are specified by using an identifier after a note
without a dash: code(c4 \ff). Note that this syntax is inconsistent
with the syntax for other types of ornaments. The available dynamic
-marks are: code(\ppp), code(\pp), code(\p), code(\mp), code(\mf),
-code(\f), code(\ff), code(\fff), code(\fp), code(sf), and code(\sfz).
+marks are: code(\pppppp), code(\ppppp), code (\pppp), code(\ppp), code(\pp),
+code(\p), code(\mp), code(\mf), code(\f), code(\ff), code(\fff),
+code(\ffff), code(\fffff), code(\ffffff),
+code(\fp), code(sf), code(\sff), code(\sp), code(\spp), (\sfz) and code (\rfz).
A crescendo mark is started with code(\cr) and terminated with
code(\rc). 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 to get several marks during one note, you must use
+spacer notes.
+mudela(fragment,verbatim,center)(
+c'' \< \! c'' d'' \decr e'' \rced
+< f''1 {s4 \< \! s4 \> \! s2 } >)
+
+
+COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
Tremolo marks can be printed by a note by adding code(:)[var(length)]
after the note. The length must be at least 8. A var(length) value
between two notes, begin with code([:)var(length) and end with code(]).
The tremolo marks will appear instead of beams. Putting more than two
notes in such a construction will produce odd effects.
-mudela(fragment,verbatim,center)(
+
+[TREMOLO BEAMS TEMPORARILY OUT OF ORDER]
+
+COMMENT(mudela (fragment,verbatim,center)(
c'2:8 c':32 [:16 e'1 g'] [:8 e'4 f']
-)
+))
COMMENT(
Is the last paragraph correct? Is it called "tremolo"? Why is
"abbreviation" used? (What is the unabreviated form?)
-
-mudela(fragment,verbatim,center)(
+COMMENT(
+mudela (fragment,verbatim,center)(
c'4:32 [:16 c'8 d'8]
-)
+))
)
code(\transpose) have no effect on notes that appear inside the
code(\transpose).
+sect(Chords)
+
+Chords can be entered either by name or by listing the notes in angle brackets.
+Chords can be displayed either as notes or by name. To enter chords by name,
+either place them inside the code(\chords) keyword, or use
+code(\notes) and surround them with
+code(@) characters.
+Chord names have the form
+var(tonic)[var(duration)][code(-)var(modifier)][code(^)var(subtractions)][code(/)var(inversion)]
+The var(tonic) should be the tonic note of the chord, and the var(duration) is
+the chord duration in the usual notation. There are two kinds of modifiers.
+One type is chord additions, which 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. A chord additions has
+two effects: it adds the specified interval and all lower odd numbered
+intervals to the chord, and it may lower or raise the specified interval.
+Intervals can be separated by a dot (code(.)) if you need to list
+several unmodified intervals.
+Repeating a code(-) character will remove a half step from the preceeding
+interval.
+mudela(fragment,verbatim,center)(
+\transpose c''{
+\chords{
+ c1 c-3- c-7 c-8 c-9
+ c-9-5+7+ c-3-5- c-4.6.8
+}})
+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.
+mudela(fragment,verbatim,center)(
+\transpose c''{
+\chords{
+ c1-m c-min c-maj c-aug c-dim c-sus
+}})
+
+Chord subtractions are used to eliminate notes from a chord. The notes to be
+subtracted are listed after a code(^) character, separated by dots.
+mudela(fragment,verbatim,center)(
+\transpose c''{
+\chords{
+ c1^3 c-7^5.3 c-8^7
+}})
+
+Chord inversions can be specified by appending code(/) and the name of a
+single note to a chord. This has the effect of lowering the specified note by
+an octave so it becomes the lowest note in the chord. If the
+specified note is not in the chord then a warning will be printed.
+mudela(fragment,verbatim,center)(
+\transpose c'''{
+ @c1@ @c/e@ @c/g@ @c-7/e@
+})
+Throughout these examples, chords have been shifted around the staff
+using code(\transpose). The code(\relative) keyword has odd effects
+when combined with named chords.
+
+For displaying printed chord names, use the code(ChordNames) context.
+The chords may be entered either using the notation described above,
+or directly using angle brackets.
+mudela(fragment,verbatim)(
+<
+ \type ChordNames { \chords{ a b c} \notes{ < d f g > < e g b > } }
+ \type Staff \notes{ a b c' d' e' }
+>
+)
+Lilypond examines chords specified as lists of notes to determine a
+name to give the chord. By default, LilyPond will not try to identify
+chord inversions:
+mudela(fragment,verbatim,center)(
+<
+ \type ChordNames {
+ \notes{ < e' g' c'' > } }
+ \type Staff \notes{ c' }
+>)
+If you want inversions to be recognized, you must set the property
+code(Score.chordInversion):
+mudela(fragment,verbatim,center)(
+<
+ \property Score.chordInversion = 1
+ \type ChordNames {
+ \notes{ < e' g' c'' > } }
+ \type Staff \notes{ c' }
+>)
+
+COMMENT(
+ Two other properties
+ chordInversionPreserve
+ and chordNameStyle = Banter
+ exist. What do these do?
+)
+
+
sect(Lyrics)
Lyrics are entered like notes, with pitches replaced
Why does this warrant an URG?
)
+When one word is attached to many notes, you may
+want a continuous line after the lyric to show this. To achieve
+this effect, add a code(__) lyric after the lyric to be extended.
+This will create
+an extender, a line that extends over the entire duration of
+the lyric. There must be a lyric after the code(__), so if you want
+to extend the final lyric, you will have to end with a blank lyric.
+mudela(verbatim,center)(
+\score{
+< \notes \relative c''{
+ a4()b()c()d c()d()b()a }
+ \type Lyrics \lyrics {
+ foo1 __ bar2. __ _ }
+> })
+
-COMMENT(
-
-sect(Chords and Voices)
-
-Here's a simple chord
-mudela(fragment,verbatim,center)(
-<c e g>
-)
-
-here are a few
-mudela(fragment,verbatim,center)(
-<
- { c'()d'()c' }
- { e'()f'()e' }
- { g'()a'()g' }
->
-)
-
-and similarly voices
-mudela(fragment,verbatim)(
-<
- { \voiceone c'4 g' c' g' }
- { \voicetwo c2 g2 }
->
-)
+COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
-)
sect(Time)
LilyPond aligns all musical objects according to the amount of time
-they occupy. All of these objects have a duration. When music is
+they occupy. All musical objects have a duration. When music is
written sequentially using braces the duration is the sum of the
durations of the elements. When music is stacked into simultaneous music
using angle
)
+sect(Repeats)
+
+In order to specify repeats, use the code(\repeat) keyword. By
+default, repeats are printed with repeat symbols.
+mudela(fragment,verbatim,center)(
+c'1
+\repeat 2 { c'4 d' e' f' }
+\repeat 2 { f' e' d' c' })
+In order to specify alternate endings, use the code(\alternative)
+keyword.
+mudela(fragment,verbatim,center)(
+c'1
+\repeat 2 {c'4 d' e' f'}
+\alternative { {d'2 d'} {f' f} })
+When the repeats involve partial measures, it will be necessary to use
+code(\partial) keywords to indicate which measures are short.
+mudela(fragment,verbatim)(
+\type Staff { \relative c'{
+ \repeat 2 { \partial 4; e | c2 d2 | e2 f2 | }
+ \alternative { { g4 g g } {\partial 2.; a a a a | b1 } }
+}})
+Repeats can be unfolded by setting the unfoldRepeats
+
+
sect(Keywords)
Keywords sometimes appear alone, but usually they require arguments.
code(\translator) block. It specifies what contexts are allowed with the
context that is being defined. See Section ref(translators).
+dit(code(\alternative) code({) var(music1) var(music2) ... code(}))
+Specifies alternative endings. Must come after a code(\repeat) keyword.
+
dit(code(\bar) var(bartype)code(;)) Prints a special bar symbol, or at
measure boundaries, replaces the regular bar symbol with a special
symbol. The argument var(bartype) is a string which specifies the
mudela(center)(
\score{
\notes{\cadenza 1; \clef alto; c'4_"\kern -10mm alto"
+ % \clef scarlatti; c'4_"\kern -4mm scarlatti"
\clef mezzosoprano; c'4^"\kern -10mm mezzosoprano"
\clef soprano; c'4_"\kern -10mm soprano"
\clef treble; c'4^"\kern -6mm treble"
var(dotcount).
dit(code(\font) var(string)) Internal keyword. Used within
-code(\symboltables) to specify the font.
+code(\paper) to specify the font.
dit(code(\grouping) var(durationseq)code(;)) Sets the metric structure of
the measure. Each argument specifies the duration of one metric unit.
top of the file describing the file's contents. If a file has
multiple code(\score) blocks, then a header should appear in
each score block describing its contents. Tools like code(ly2dvi) can
-use this information for generating titles. Some possible key values
-are: title, opus, description, composer, enteredby, and copyright.
+use this information for generating titles. Key values that are used
+by ly2dvi are: title, subtitle, composer, opus, poet, instrument,
+metre, arranger, and piece.
dit(code(\in)) Specify a dimension in inches.
file(.ly) extension must be given, and the filename must be quoted.
(An unquoted string will not work here.)
-dit(code(\key) var(pitch)code(;)) Change key signature to that of
-var(pitch)-major.
+dit(code(\key) var(pitch) var(type) code(;)) Change the key signature.
+var(type) should be code(\major) or code(\minor) to get
+var(pitch)-major or var(pitch)-minor, respectively. The second
+argument is optional, the default is major keys.
+The var(\type) argument can also be given as an integer, which tells
+the number of semitones that should be added to the pitch given in the
+subsequent code(\key) commands to get the corresponding major key,
+e.g. code(\minor) is defined as 3.
dit(code(\keysignature) var(pitchseq)code(;))
Specify an arbitrary key signature. The pitches from var(pitch) will
dit(code(\maininput)) Internal command. This command is used for creating init
files like file(init.fly) that read the user file into the middle of another
-file. Using it in a user file will lead to an infinite loop.
+file. It is illegal to use this command in a user file.
dit(code(\mark) var(unsigned)code(;) or code(\mark) var(string)code(;))
-Allowed in music only. Prints a mark over or under (?) the staff.
-You must add code(Mark_engraver) to the Score context and it only
-seems to work if the mark appears at the beginning of a line.
+Allowed in music only. Prints a mark over or under (depending on the
+code(markDirection) property) the staff.
+You must add code(Mark_engraver) to the Score context.
dit(code(\midi) var(statementlist)) Appears in a score block to
indicate that musical output should be produced and to set output
dit(code(\notes) var(music)) Enter note mode and process the
specified music.
-dit(code(\)code(output) var(string)code(;)) Generate a parse error.
-
dit(code(\paper) var(statmentlist))
Appears in a score block to indicate that the music should be printed
or to set output parameters. Can also appear at the top level to set
code(\translator) block. Specifies that a performer or engraver named
var(string) should be removed. See Section ref(translators).
+dit(code(\repeat) var(count) code({) var(music) code(}))
+Repeats the specified
+music var(count) times. Alternative endings can be specified by adding a
+code(\alternative) keyword after the code(\repeat).
+
+dit(code(\scm) var(scheme)code(;)) Embeds specified Scheme code.
+
+dit(code(\scmfile) var(filename)code(;)) Reads Scheme code from the specified
+file.
+
dit(code(\score) var(statementlist)) Create a Score context. This
is the top level notation context.
COMMENT(this still needs work)
Users should use the abbreviations which are defined in the
initialization file file(dynamic.ly).
-dit(code(\symboltables)) Internal keyword. Used to create symbol
-tables. See initialization files file(paper*.ly), file(feta*.ly), and
-file(table*.ly).
-
-dit(code(\table)) Internal keyword. Used within code(\symboltables)
-to specify the tables. See initialization files.
-
dit(code(\tempo) var(duration) = var(perminute)code(;)) Used within
code(\midi) or within music to specify the tempo. For example,
`code(\midi { \tempo 4 = 76;})' requests output with 76 quarter notes
This context handles the conversion of noteheads,
dynamic signs, stems, beams, super- and subscripts, slurs, ties and rests.
+dit(code(ChordNamesVoice)) A voice with chord names. Handles printing
+of a line of chord names.
+
+dit(code(ChordNames)) Typesets chord names. Can contain
+code(ChordNamesVoice) contexts.
+
dit(code(Lyrics)) Typesets lyrics. It can contain code(LyricVoice) contexts.
dit(code(Staff)) Handles clefs, bar lines, keys,
together. The bar lines of the contained staffs are connected vertically.
It can contain code(Staff) contexts.
+dit(code(PianoStaff)) Just like code(GrandStaff) but with
+code(minVerticalAlign) set equal to code(maxVerticalAlign) so that
+interstaff beaming and slurring can be used.
+
dit(code(StaffGroup)) Contains code(Staff) or code(RhythmicStaff)
contexsts. Adds a bracket on the left side, grouping the staffs
together. The bar lines of the contained staffs are connected vertically.
force slurs down. The shorthands code(\slurup), code(\slurdown), and
code(\slurboth) are available.
+dit(code(tieydirection)) Set to code(\free) for free choice of tie
+direction, set to code(\up) to force ties up, set to code(\down) to
+force ties down.
+
dit(code(slurdash)) Set to 0 for normal slurs, 1 for dotted slurs, and
a larger value for dashed slurs. Identifiers code(\slurnormal) and
code(\slurdotted) are predefined to set the first two settings.
typesetting many voices on one staff. The identifier code(\shift) is
defined to enable this.
-dit(code(dynamicdir)) Determines location of dynamic marks. Set to
+dit(code(dynamicDir)) Determines location of dynamic marks. Set to
code(\up) to print marks above the staff; set to code(\down) to print
marks below the staff.
to 3 shows a number, and if there is no beam it adds a bracket;
setting to 4 shows both a number and a bracket unconditionally.
+dit(code(markScriptPadding)) Determines the extra space added between
+the mark and the closest staff line or note.
+
+dit(code(markDirection)) Determines if marks should be printed above
+or below the staff. Set to code(\up) to print marks above the staff;
+set to code(\down) to print marks below the staff.
+
)
subsubsubsect(Staff properties)
dit(code(defaultBarType)) Sets the default type of bar line. See
code(\bar) keyword.
-
-
-
dit(code(keyoctaviation)) If set to 1, then keys are the same in all
octaves. If set to 0 then the key signature for different octaves can
be different and is specified independently: code(\keysignature bes
dit(code(timeSignatureStyle)) Changes the default two-digit layout
for time signatures. The following values are recognized:
description(
- dit(code(C)): 4/4 and 2/2 are typeset as C and struck C,
+ dit(code(C)) 4/4 and 2/2 are typeset as C and struck C,
respectively. All other time signatures are written with two digits.
- dit(code(old)): 2/2, 3/2, 3/4, 4/4, 6/4 and 9/4 are typeset with
+ dit(code(old)) 2/2, 3/2, 3/4, 4/4, 6/4 and 9/4 are typeset with
old-style mensuration marks. All other time signatures are
written with two digits.
- dit(code(1)): All time signatures are typeset with a single
+ dit(code(1)) All time signatures are typeset with a single
digit, e.g. 3/2 is written as 3.
dit(code(C2/2), code(C4/4), code(old2/2), code(old3/2),
code(old3/4), code(old4/4), code(old6/4) or
- code(old9/4)): Tells Lilypond to use a specific symbol as time
+ code(old9/4)) Tells Lilypond to use a specific symbol as time
signature.
)
The different time signature characters are shown below with
}
)
+COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)
+
)
code(\beamslopedamped), and code(\beamslopezero) each set the
corresponding value.
+dit(code(chordInversion)) Determines whether LilyPond should look for
+chord inversions when translating from notes to chord names. Set to 1
+to find inversions. The default is 0 which does not look for inversions.
+
)
-
+
COMMENT(
Mystery properties:
bar-number-engraver.cc: "barScriptPadding" vertical space for numbers
-mark-engraver.cc: "markScriptPadding" vertical space for marks
span-bar-engraver.cc: "singleStaffBracket" do single staffs get a bracket?
-bar-column-engraver.cc: "barColumnPriority"
-bar-number-engraver.cc: "barNumberBreakPriority" Control horizontal ordering
-mark-engraver.cc: "markBreakPriority" of bars, clefs, keysig
-staff-margin-engraver.cc:"marginBreakPriority" etc. Slated for revision
)
sect(Pre-defined Identifiers)
dit(code(\f)) Print forte symbol on the preceeding note.
dit(code(\ff)) Print fortissimo symbol on the preceeding note.
dit(code(\fff)) Print fortississimo symbol on preceeding note.
+dit(code(\ffff)) Print fortissississimo symbol on preceeding note.
+dit(code(\fffff)) Print fffff symbol on preceeding note.
+dit(code(\ffffff)) Print ffffff symbol on preceeding note.
dit(code(\fp)) Print fortepiano symbol on preceeding note.
dit(code(\free)) Used for setting direction setting properties. Is
equal to 0.
dit(code(\infinity)) Used for setting the Score.beamslopedamping
property. Is actually equal to 10000.
dit(code(\left)) Used for setting textalignment property. Is equal to -1.
+dit(code(\major)) Used as the second argument of the code(\key)
+command to get a major key.
+dit(code(\minor)) Used as the second argument of the code(\key)
+command to get a minor key.
dit(code(\mf)) Print mezzoforte symbol on preceeding note.
dit(code(\mp)) Print mezzopiano symbol on preceeding note.
dit(code(\nobreak)) Prevent a line break in music by using a large
dit(code(\p)) Print a piano symbol on preceeding note.
dit(code(\pp)) Print pianissimo symbol on preceeding note.
dit(code(\ppp)) Print pianississimo symbol on preceeding note.
+dit(code(\pppp)) Print pianissississimo symbol on preceeding note.
+dit(code(\ppppp)) Print ppppp symbol on preceeding note.
+dir(code(\pppppp)) Print pppppp symbol on preceeding note.
dit(code(\rc)) Terminate a crescendo.
dit(code(\rced)) Terminate a decrescendo
+dit(code(\rfz)) Print a rinforzato symbol on preceeding note.
dit(code(\right)) Used for setting textalignment property. Is set to 1.
-dit(code(\sf)) Print a ?? symbol on preceeding note.
-dit(code(\sfz)) Print a ?? symbol on preceeding note.
+dit(code(\sf)) Print a subito-forte symbol on preceeding note.
+dit(code(\sff)) Print a subito-fortissimo symbol on preceeding note.
+dit(code(\sfz)) Print a sforzato symbol on preceeding note.
dit(code(\shiftoff)) Disable horizontal shifting of note heads that collide.
Sets the Voice.hshift property.
dit(code(\shifton)) Enable note heads that collide with other note heads
Voice.slurydirection property.
dit(code(\slurup)) Force slurs to be above notes. This sets the
Voice.slurydirection property.
+dit(code(\sp)) Print a subito-piano symbol on preceeding note.
+dit(code(\spp)) Print a subito-forte symbol on preceeding note.
dit(code(\specialkey)) Allow keys signatures do differ in different
octaves. This sets the Staff.keyoctaviation property.
dit(code(\stemboth)) Allow stems, beams, and slurs to point either
subsect(Paper variables)
+Warning: this section is outdated and inaccurate.
+
There are a large number of paper variables that are used to control
details of the layout. Usually you will not want to change these
variables; they are set by default to vaules that depend on the font
description(
dit(var(integer)) If an integer appears on the left side of an
-assignment then a code(\symboltables) keyword must appear on the right
+assignment then a code(\font) keyword must appear on the right
side. This defines a music font at a particular size. See Voice
property code(\fontsize).
dit(code(arithmetic_basicspace) and code(arithmetic_multiplier))
The space taken by a note is determined by the formula
-verb(arithmetic_multiplier * ( c + time ))
-where code(time) is the amount of time a note occupies. The value of
-code(c) is affected by code(arithmetic_basicspace). Increasing
-code(arithmetic_basicspace) will increase code(c).
+COMMENT(
+
+)verb(arithmetic_multiplier * ( c + log2 (time) ))COMMENT(
+
+) where code(time) is the amount of time a note occupies. The value
+of code(c) is chosen such that the smallest space within a measure is
+arithmetic_basicspace. The smallest space is the one following the
+shortest note in the measure. Typically arithmetic_basicspace is set
+to the width of a quarter note head.
+
dit(code(barsize)) Specify height of bars. This value may need to be
adjusted if you change the number of lines in the staff.
dit(code(beam_dir_algorithm)) Specify algorithm for determining
majority selection is used. If set to 3.0, then mean selection is
used based on the mean center distance. If set to 4.0 then median
selection is used, based on the median center distance.
-dit(code(beam_ideal_stem1))
-dit(code(beam_ideal_stem2))
-dit(code(beam_minimum_stem1))
-dit(code(beam_minimum_stem2))
-dit(code(beam_multiple_break))
-dit(code(beam_slope_damp_correct_factor))
-dit(code(beam_thickness)) Specify the thickness of beams.
dit(code(castingalgorithm))
dit(code(forced_stem_shorten)) Stems that have been forced to go the
unnatural direction are shortened by this amount. Equal to
-code(\interline) by default.
+dit(code(forced_stem_shorten0))
dit(code(gourlay_energybound))
dit(code(gourlay_maxmeasures)) Maximum number of measures per line
when using Gourlay method.
description(
dit(code(Abbreviation_beam_engraver))
-dit(code(Bar_column_engraver))
dit(code(Bar_engraver)) Engraves bar lines. Normally in code(Staff) and
code(RhythmicStaff).
dit(code(Bar_number_engraver)) Engrave bar numbers. These numbers
dit(code(Beam_req_swallow_translator)) Swallows beam requests. In
code(LyricVoice).
+dit(code(Chord_name_engraver)) Engraves chord names. Normally in
+code(ChordNameVoice)
dit(code(Clef_engraver)) Engraves the clef symbol. Normally in code(Staff).
dit(code(Collision_engraver))
dit(code(Dot_column_engraver)) Engraves dots on dotted notes shifted to the
dit(code(Lyric_engraver)) Engraves lyrics. Normally in code(LyricVoice).
dit(code(Multi_measure_rest_engraver)) Engraves multi-measure rests that are
produced with code(R). Normally in code(Voice).
-dit(code(Note_heads_engraver)) Engraves note heads. Normally in code(Voice).
-Removing this gives a fatal error.
-COMMENT(Perhaps should be Note_head_engraver)
dit(code(Piano_bar_engraver))
dit(code(Pitch_squash_engraver)) Treat all pitches as middle C. Used in
code(RhythmicStaff). Note that the notes move, but the locations of
accidentals stay the same.
-dit(code(Plet_engraver)) Engraves brackets and the number over tuplets. In
-code(Voice).
-dit(code(Plet_swallow_engraver)) Swallows tuplet requests without any output.
-In code(LyricVoice).
-COMMENT( Should this be named Plet_req_swallow_translator? )
dit(code(Priority_horizontal_align_engraver))
+dit(code(Repeat_engraver)) Handles repeats? In code(Staff) and
+ code(RhythmicStaff).
dit(code(Rest_collision_engraver)) Handles collisions of rests. In code(Staff).
dit(code(Rest_engraver)) Engraves rests. Normally in code(Voice).
dit(code(Rhythmic_column_engraver))
dit(code(Timing_engraver)) Responsible for synchronizing timing information
from staffs. Normally in code(Score). In order to create polyrhythmic music,
this engraver should be removed from code(Score) and placed in code(Staff).
+dit(code(Tuplet_engraver)) Engraves tuplet brackets? In code(Staff).
dit(code(Vertical_align_engraver))
)