+mailto(gnu-music-discuss@gnu.org)
COMMENT(-*-text-*-)
redef(var)(1)(whenlatex(latexcommand({\normalfont\scshape )ARG1+latexcommand(}))\
redef(code)(1)(tt(ARG1))
+
COMMENT(
+questions:
+ long lyrics don't get any space at the end
+ lyrics and scripts collide
+ \key b; \time 4/4; looks bad---no space between key sig and clef
+ \portato still DOES NOT WORK!
+ \cadenza vs. barNonAuto ?
+ not enough space for \key b;
+ I noticed that ledger lines in the previewer looked like they had
+ a double line (of different lengths). On printed output, I think
+ I can see a slight thickening of the ledger lines in the middle.
+ Is this supposed to happen?
+ restStyle=mensural doesn't seem to work (lots of characters not found
+ for rests.fly)
+ what happened to the Staff.textalignment and Lyrics.textalignment
+ properties?
+
+
TODO:
- the use of semicolons needs to be documented once it settles down
- \times needs documentation with examples somewhere once it works (?)
+ autobeamer
paper size?
+ paper variables
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
+ Is there a simple way to explain this, or is the behavior
+ too complicated for a reasonable explanation?
accordion symbols
- extender* (see extender.ly)
- \repeat & \alternative -> probably should have an example
+ interstaff beams (beam-interstaff.ly)
+ interstaff slurs (see preludes-1.ly)
+
+ Current list of undocumented properties:
+
+ "alignmentReference" to do with minVerticalAlign, etc?
+ "beamAuto"
+ "beamAutoBegin"
+ "beamAutoBegin" + type_str
+ "beamAutoEnd"
+ "beamAutoEnd" + type_str
+ "createInitdefaultClef"
+ "dynamicStyle"
+ "postBreakPadding"
+ "staffLineLeading"
+ "stemLeftBeamCount"
+ "stemRightBeamCount"
+ time_str + "beamAutoBegin"
+ time_str + "beamAutoBegin" + type_str
+ time_str + "beamAutoEnd"
+ time_str + "beamAutoEnd" + type_str
+ type_ + "Direction"
+ type_ + "HangOnClef"
+ type_ + "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.1.8 Reference Manual)
+article(Mudela 1.0.14 / LilyPond 1.1.40 Reference Manual)
(Adrian Mariano, Han-Wen Nienhuys and Jan Nieuwenhuizen)
(nop()PIPETHROUGH(date "+%B %d, %Y")()()nop())
A Mudela file consists of keywords with arguments and identifier
assignments separated by spaces, tabs or newlines. Semicolons are
-used by some keywords but are not generally required. A one line
-comment is introduced by a code(%) character. Block comments are
-started by code(%{) and ended by code(%}). They cannot be nested.
+used by some keywords and are inconsistantly required in other
+circumstances. A one line comment is introduced by a code(%)
+character. Block comments are started by code(%{) and ended by
+code(%}). They cannot be nested.
Mudela supports several types:
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).
)
-COMMENT(
-Compound types are built up from the simple types. The compound types
-are: arglist, assignlist and musiclist. An arglist is a
-white space separated list of integers, reals and or strings surrounded
-by braces code({) and code(}). An assignlist is a list of
-identifier assignments, which have the form var(key)code(=)var(value).
-A statement in Mudela has one of three forms:
-verb(\keyword argument
-\keyword argument1 argument2 ... ;
-string=value)
-)
subsect(Identifiers)
name with a backslash: code(\)var(name). It is legal to redefine an
identifier in terms of its old value: code(foo = \foo * 2.0).
Identifier assignments must appear at the top level in the Mudela
-file.
+file. Note that semicolons are forbidden after assignments appearing
+at the top level but they are obligatory after assignments appearing
+elsewhere.
An identifier can be created with any string for its name, but you
will only be able to refer to identifiers whose names begin with 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 grouping mm relative symboltables
-accepts header musicalpitch remove table
-alternative in name repeat tempo
-bar include notenames scm time
-cadenza key notes scmfile times
-clef keysignature paper score translator
-cm lyrics partial script transpose
-consists maininput penalty shape type
-duration mark property skip version
-font midi pt spandynamic)
+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
+chordmodifiers 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
Section ref(translators) for more information.
-COMMENT(
-subsect(Hierarchical structures)
-
-The general structure consists of declarations:
-verb(IDENTIFIER = \TYPE{
- <type specific data>
-})
-and instantiations:
-
-verb(\TYPE{ <type specific data> })
-
-(Currently, code(\score) is the only type that can be instantiated
-at top level.)
-
-Most instantiations that use an IDENTIFIER are specified as follows:
-
-verb(\TYPE{ \IDENTIFIER [...] })
-
-Some exceptions on this rule have been made to prevent inputting
-Mudela becoming tedious
-)
-
subsect(Modes)
label(modes)
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
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)(
+\context 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']
-)
-If you want to put beams over chords, you will find that the obvious
-construction does not work. You must do the following:
-mudela(fragment,verbatim,center)(<[a'8 c''> b' <c'' e''> <a' c'']>)
-The bracket characters must appear immediately adjacent to a note.
-
-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.
+A tie connects two adjacent note heads of the same pitch.
+When used with chords, it
+connects all of the note heads whose pitches match.
+Ties are indicated using the tilde symbol
+code(~) by analogy with TeX()'s tie which connects words.
+Note that if you try to tie together chords which have no common
+pitches, then a warning message will appear and no tie will be created.
+(Note that ties between different pitches can be enabled using the
+property Voice.oldTieBehavior.)
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)(
+<
+\context Staff=one \notes\relative c'{
+ \stemup
+ [c8 c \translator Staff=two \stemup c c]
+ \translator Staff=one
+ d4( \translator Staff=two )a4
+ }
+\context Staff=two \notes{ \clef bass;}
+>
)
subsect(Note Ornaments)
A variety of symbols can appear above and below notes to indicate
-different characteristics of the performance.
-These symbols can be
-added to a note with `var(note)code(-\)var(name)'. Numerous different
-symbols are defined in file(script.ly). Each symbol is defined using
-the code(\script) keyword which specifies where symbols appear.
-Symbols can be forced to appear above the note by writing
+different characteristics of the performance. These symbols can be
+added to a note with `var(note)code(-\)var(name)'. Numerous symbols
+are defined in file(script.ly) and file(script.scm). Symbols can be
+forced to appear above the note by writing
`var(note)code(^\)var(name)', and they can be forced to appear below
by writing `var(note)code(_\)var(name)'. Here is a chart showing
symbols above notes, with the name of the corresponding symbol
-appearing underneath.
+appearing underneath.
mudela()(
\score{
c''-\open c''-\flageolet c''-\reverseturn
c''-\trill
c''-\prall c''-\mordent c''-\prallprall c''-\prallmordent
- 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 thumb}>
- \paper{linewidth = 5.875\in;
- indent = 0.0;
- }
-}
+ c''-\upprall c''-\downprall c''-\thumb }
+ \context 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 thumb }
+ >
+ \paper{ linewidth = 5.875\in;
+ indent = 0.0; }
+ }
)
-COMMENT( The following are defined in script.ly but do not work:
-
-portato lbheel rbheel lbtoe rbtoe lfheel rfheel lftoe rftoe )
-
In addition, it is possible to place arbitrary strings of text or
TeX() above or below notes by using a string instead of an identifier:
`code(c^"text")'. Fingerings can be placed by simply using digits.
single characters:
mudela()(
\score{ \notes {
- \property Voice.textstyle = typewriter
+ \property Voice.textStyle = typewriter
c''4-._"c-." s4
c''4--_"c-{}-" s4
c''4-+_"c-+" s4
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
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
of 8 gives one line across the note stem.
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]
-)
+))
)
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 sid si -d -b)
+italiano.ly do re mi fa sol la sid si -d -b
+catalan.ly do re mi fa sol la sid si -d/-s -b)
subsect(Relative Pitch Specification)
label(relative)
above. Also note that if the music passed to a code(\relative) keyword
contains a code(\transpose) keyword, the tranposed music will not be
processed in relative mode. An additional code(\relative) must be placed
-inside the code(\transpose).
+inside the code(\transpose). If code(\relative) will be used several
+times, or if it will be used in the same music with code(\transpose),
+then you may get bizarre effects. This can be fixed by using an
+explicit code(Staff) context.
subsect(Tranposition of Pitches)
If you want to use both code(\transpose) and code(\relative), then you must use
code(\transpose) first. Any code(\relative) keywords that are outside the
code(\transpose) have no effect on notes that appear inside the
-code(\transpose).
+code(\transpose). As with code(\relative), using code(\transpose)
+repeatedly can cause bizarre effects. An explicit code(Staff) context
+will eliminate the problems.
+
+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)(
+<
+ \context ChordNames { \chords{ a b c} \notes{ < d f g > < e g b > } }
+ \context 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)(
+<
+ \context ChordNames {
+ \notes{ < e' g' c'' > } }
+ \context 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
+ \context ChordNames {
+ \notes{ < e' g' c'' > } }
+ \context Staff \notes{ c' }
+>)
+
+
sect(Lyrics)
See Section ref(modes) for a description of what is interpreted as a lyric.
In order to instruct LilyPond to write lyrics underneath the
-staff, you must enter the lyrics context with code(\type Lyrics).
+staff, you must enter the lyrics context with code(\context Lyrics).
Lyrics should be entered in lyrics mode which is entered with code(\lyrics).
Spaces can be introduced into a lyric either by using quotes (code("))
mudela(verbatim)(\score{
< \notes \transpose c'' {c d e c | c d e c | e f g'2 |
e'4 f g'2 \bar "|."; }
- \type Lyrics \lyrics {
+ \context Lyrics \lyrics {
DOEXPAND(Fr\)`e-4 re Ja- que DOEXPAND(Fr\)`e- re Ja- que
Dor- mez vous?2 Dor-4 mez vous?2 }
>
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 as a separate word
+after the lyric to be extended.
+This will create
+an extender, a line that extends over the entire duration of
+the lyric. This line will run all the way to the start of the next
+lyric, so you may want to shorten it by using a blank lyric.
+mudela(verbatim)(\score{
+< \notes \relative c''{
+ a4()b()c()d c()d()b()a c()d()b()a }
+ \context Lyrics \lyrics {
+ foo1 __ bar2. __ _4 baz1 __ }
+> })
+
-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 }
->
-)
-
-)
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
row(cell()cell(code(|) code({) em(MusicList) code(})))
row(cell()cell(code(|) code(<) em(MusicList) code(>)))
row(cell()cell(code(|) em(Command)))
- row(cell()cell(code(|) code(\type) em(string) code(=) em(string) em(Music)))
+ row(cell()cell(code(|) code(\context) em(string) code(=) em(string) em(Music)))
row(cell()cell(;))
row(cell(em(MusicList))cell(: em(empty)))
row(cell()cell(code(|) em(MusicList) em(Music)))
d % from c to the d that's almost one octave down
{ e4 f4 } % the horizontal music
)
-it()verb(\type)
+it()verb(\context)
it()verb(\property)
it()verb(\translator)
it()verb(\relative)
{ c <c e> <c e g> <c e g \transpose d' dis > } % 4 increasing chords
)
-)
+END OF COMMENT )
+
+
+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 in a somewhat unexpected way
+to indicate some measure lengths.
+mudela(fragment,verbatim)(
+\context Staff { \relative c'{
+ \repeat 2 { \partial 4; e | c2 d2 | e2 f2 | }
+ \alternative { { g4 g g } {\partial 1; a a a a | b1 } }
+}})
+Repeats can be unfolded by setting the property Staff.unfoldRepeats.
+Note also that if your music begins with code(\repeat), you must place
+it in an explicit code(Staff) context or you will get bizarre results.
+
+If you don't give enough alternatives for all of the repeats, then the
+first alternative is assumed to be repeated enough to equal to
+specified number of repeats.
+mudela(fragment,verbatim)(
+\context Staff { \relative c'{
+ \repeat 3 { \partial 4; e | c2 d2 | e2 f2 | }
+ \alternative { { g4 g g } {\partial 1; e4 e e }
+ {\partial 1; a a a a | b1 } }
+}})
sect(Keywords)
mudela(center)(
\score{
\notes{ \cadenza 1;
- %\property Voice.textstyle = typewriter
+ %\property Voice.textStyle = typewriter
\clef subbass; c'4-"\kern-10mm subbass"
\clef bass; c'4^"\kern -8mm bass"
\clef baritone; c'4_"\kern -10mm baritone"
\clef varbaritone; c'4^"\kern -10mm varbaritone"
\clef tenor; c'4_"\kern -10mm tenor"
- \clef "G_8"; c'4^"\kern -6mm G\_8" }
+ \clef "G_8"; c'4^"\kern -6mm G\_8"
+ }
\paper{ linewidth= 4.5 \in; }
}
)
mudela(center)(
\score{
\notes{\cadenza 1; \clef alto; c'4_"\kern -10mm alto"
- \clef scarlatti; c'4_"\kern -4mm scarlatti"
+ % \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"
The treble clef can also be obtained using the names code(G) or
code(violin). The bass clef is also available by code(\clef F).
+dit(code(\chord) var(chordlist)) Parse var(chordlist) in chords mode.
+
+dit(code(\chordmodifiers) var(modifierlist)) Specify the text chord
+modifiers that may appear after chord names. These are specified in
+the file file(chord-modifiers.ly).
+
dit(code(\cm)) Specify a dimension in centimeters.
dit(code(\consists) var(string)code(;)) This keyword can appear only within a
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.
each score block describing its contents. Tools like code(ly2dvi) can
use this information for generating titles. Key values that are used
by ly2dvi are: title, subtitle, composer, opus, poet, instrument,
-metre, arranger, and piece.
+metre, arranger, piece and tagline.
dit(code(\in)) Specify a dimension in inches.
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 var(\context) 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.
+e.g. code(\minor) is defined as 3. The standard mode names
+code(\ionian), code(\locrian), code(\aeolian), code(\mixolydian),
+code(\lydian), code(\phrygian), and code(\dorian) are also defined.
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
output. See Section ref(paper).
dit(code(\partial) var(duration)code(;)) Specify that the first measure of
-the music lasts only for the specified duration.
+the music lasts only for the specified duration. Use also to specify
+the duration of the first measure of the argument to
+code(\alternative).
dit(code(\penalty) code(=) var(int)code(;)) Allowed only in music.
Discourage or encourage line breaks. See identifiers code(\break) and
is the top level notation context.
COMMENT(this still needs work)
-dit(code(\script) code({) var(name) var(instaff) var(withstem)
-var(location) var(invertible) var(priority) code(})) This keyword is
-used the initialization file(script.ly) to define the various symbols
-that can appear above and below notes. The first argument is the name
-of the symbol. The second argument var(instaff) is 1 if the symbol
-follows the notehead into the staff and 0 if the symbol stays above or
-below the staff lines. The third parameter var(withstem) is 0 if the
-symbol's placement does not depend on the stem direction; it is 1 if
-the symbol should be at the stem end of the note and it is -1 if the
-symbol should be at the note head end of the note. The argument
-var(location) is set to 1 for symbols that always appear above the
-staff; it is -1 for symbols that appear below the staff. If
-var(invertible) is set to 1 then the symbol can be inverted; otherwise
-it cannot. The last argument var(priority) sets a priority for the
-order of placement of several symbols on a single note.
+dit(code(\script) var(alias)) Prints a symbol above or below a note.
+The argument is a string which points into the script-alias table
+defined in file(script.scm). The scheme definitions specify whether
+the symbol follows notes into the staff, dependence of symbol
+placement on staff direction, and a priority for placing several
+symbols over one note. Usually the code(\script) keyword is not used
+directly. Various helpful identifier definitions appear in
+file(script.ly).
dit(code(\shape) code(=) var(indent1) var(width1) var(indent2)
var(width2) ... code(;)) Allowed only within code(\paper). Each pair
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
var(context) = var(name)) The first variant appears only within
code(\paper) and specifies a translator for
converting music to notation. The translator is specified with a
-single code(\type) statement and a series of code(\accepts), and
+single code(\context) statement and a series of code(\accepts), and
code(\consists) statements. See Section ref(translators).
The second variant appears in
music. It specifies that the current the contexts
transposition should be specified inside another code(\relative). See Section
ref(transpose).
-dit(code(\type) var(contexttype) [code(=) var(contextname)]
-var(music) or code(\type) var(translatortype)code(;)) The first
+dit(code(\context) var(contexttype) [code(=) var(contextname)]
+var(music) or code(\context) var(translatortype)code(;)) The first
variant is used only within music to create an instance of a
context. The new context can optionally be given a name. The
specified var(music) is processed in the new context. The second
Notation contexts provide information that appears in printed music
but not in the music itself. A new musical context is created using
-the code(\type) keyword: `code(\type) var(contexttype) [code(=)
+the code(\context) keyword: `code(\context) var(contexttype) [code(=)
var(contextname)] var(music)'. The following context types are
allowed.
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.
contained staffs are not connected vertically.
dit(code(Score)) This is the top level notation context. It is specified with
-the code(\score) keyword rather than the code(\type) command. No
+the code(\score) keyword rather than the code(\context) command. No
other context can contain a code(Score) context. This context handles
the administration of time signatures. It also makes sure that items
such as clefs, time signatures, and key-signatures are aligned across
description(
-dit(code(textstyle)) Set the font for lyrics. The available font
+dit(code(textStyle)) Set the font for lyrics. The available font
choices are code(roman), code(italic), code(bold), code(large),
code(Large), code(typewriter), and code(finger). The code(finger)
font can only display numbers. Note also that you must be careful
are parsed, either put quotes around the arguments to code(\property)
or be sure to leave a space on both sides of the dot.
-dit(code(textalignment)) Controls alignment of lyrics. Set to code(\left)
+GONE dit(code(textalignment)) Controls alignment of lyrics. Set to code(\left)
to align the left end of the lyric with the note; set to code(\right) to
align the right end of the lyric with the note. Set to code(\center) to
align the center of the lyric with the note.
description(
+dit(code(textEmptyDimension)) If set to 1 then text placed above or
+below the staff is assumed to have zero width.
+
+dit(code(noteheadStyle)) Selects type of note head. Choices are
+code(cross), code(diamond), code(harmonic), code(transparent), and
+code(""). They are shown in that order below.
+mudela(center)(
+\score{
+ \notes{
+ \property Staff.barNonAuto = 1
+ \property Voice.noteHeadStyle = cross
+ a'
+ \property Voice.noteHeadStyle = diamond
+ a'
+ \property Voice.noteHeadStyle = harmonic
+ a'
+ \property Voice.noteHeadStyle = transparent
+ a'
+ \property Voice.noteHeadStyle = ""
+ a'
+ }
+ \paper{ linewidth = -1.;}
+}
+)
+
dit(code("midi_instrument")) Sets the instrument for MIDI output. This
property name must be quoted because of the embedded underscore. If
this property is not set then LilyPond will use the code(instrument)
dit(code(transposing)) Tranpose the MIDI output. Set this property to
the number of half-steps to transpose by.
+dit(code(oldTieBehavior)) Set to 1 in order to get old tie behavior
+where ties would connect unequal pitches.
+
dit(code(ydirection)) Determines the direction of stems, subscripts,
beams, slurs, and ties. Set to code(\down) to force them down,
code(\up) to force them up, or code(\free) to let LilyPond decide.
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
+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.
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.
-dit(code(textalignment)) Controls alignment of superscripted and
+GONE dit(code(textalignment)) Controls alignment of superscripted and
subscripted text. Set to \left to align the left end of the text with
the note; set to \right to align the right end of the text with the
note. Set to \center to align the center of the text with the note.
-dit(code(textstyle)) Set the text style for superscripts and
+dit(code(textStyle)) Set the text style for superscripts and
subscripts. See above for list of text styles.
+dit(code(textScriptPadding)) Determines the extra space added between
+super-/subscripted text and the closest staff line or note.
+
dit(code(fontsize)) Can be used to select smaller font sizes for
music. The normal font size is 0, and the two smaller sizes are -1
and -2.
-dit(code(pletvisibility)) Determines whether tuplets of notes are
-labelled. Setting to 0 shows nothing; setting to 1 shows a number;
-setting to 2 shows a number and a bracket if there is no beam; setting
-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.
+GONE dit(code(markScriptPadding)) Determines the extra space added between
+the mark and the closest staff line or note.
+
+GONE 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)
description(
+
+dit(code(barAtLineStart)) Set to 1 to produce a bar line after the
+clef at the start of each line (but not at the beginning of the
+music).
+
+dit(code(voltaVisibility)) Set to 0 to suppress the printing
+of brackets over alternate endings specified by code(\alternative).
+
+dit(code(voltaSpannerDuration)) Set to an integer to control the size
+of the brackets printed by code(\alternative). The integer specifies
+the number of whole notes duration to use for the brackets. It seems
+to be rounded to the nearest measure. This can be used to shrink the
+length of brackets in the situation where one alternative is very
+large. It may have odd effects if the specified duration is longer
+than the music given in an code(\alternative).
+
+dit(code(barNonAuto)) If set to 1 then bar lines will not be printed
+automatically; they must be explicitly created with code(\bar) keywords.
+
+dit(code(unfoldRepeats)) If set to 1 then repeats will be unfolded.
+Otherwise, they will be printed using repeat symbols.
dit(code(defaultClef)) Determines the default clef. See code(\clef)
keyword.
-dit(code(nolines)) Sets the number of lines that the staff has.
+dit(code(nuberOfStaffLines)) Sets the number of lines that the staff has.
dit(code(barAlways)) If set to 1 a bar line is drawn after each note.
description(
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
- old-style mensuration marks. All other time signatures are
+ dit(code(old)) 2/2, 3/2, 3/4, 4/4, 6/4, 9/4, 6/8 and 9/8 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
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
- signature.
+ code(old3/4), code(old4/4), code(old6/4), code(old9/4),
+ code(old6/8) or code(old9/8))Tells Lilypond to use a
+ specific symbol as time signature.
)
The different time signature characters are shown below with
their names:
-mudela(fragment,center)(
-\relative c'' {
-\property Voice.textstyle = typewriter
+mudela(center)(
+\score{
+ \notes\relative c'' {
+\property Voice.textStyle = typewriter
\property Staff.timeSignatureStyle = "C2/2"
\time 2/2; a2^"C2/2" a2
\property Staff.timeSignatureStyle = "C4/4"
\time 2/2; a2^"old6/4" a2
\property Staff.timeSignatureStyle = "old9/4"
\time 2/2; a2^"old9/4" a2
+\property Staff.timeSignatureStyle = "old6/8"
+\time 2/2; a2^"old6/8" a2
+\property Staff.timeSignatureStyle = "old9/8"
+\time 2/2; a2^"old9/8" a2
+}
+ \paper{ linewidth= 4.5 \in; }
}
)
+dit(code(restStyle)) Change the layout of rests shorter than quarter notes.
+Currently, the standard layout code(restStyle="") and mensural notation
+code(restStyle="mensural") are available.
+
+dit(code(clefStyle)) Determines how clefs are typeset. When set to
+code(transparent), the clefs are not printed at all, when set to
+code(fullSizeChanges), clef changes in the middle of a line are
+typeset with a full size clef. By default, clef changes are typeset in
+smaller size.
)
-
-
subsubsubsect(GrandStaff properties)
description(
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)
label(ident)
provide shorthands for some settings.
description(
+dit(code(\aeolian)) Used as the second argument of the code(\key)
+keyword to get an aeolian mode.
dit(code(\break)) Force a line break in music by using a large
argument for the keyword code(\penalty).
dit(code(\center)) Used for setting textalignment property. Is set to 0.
dit(code(\cr)) Start a crescendo.
dit(code(\decr)) Start a decrescendo.
+dit(code(\dorian)) Used as the second argument of the code(\key)
+keyword to get a dorian mode.
dit(code(\down)) Used for setting direction setting properties. Is
equal to -1.
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.
code(castingalgorithm). Is equal to 1.0.
dit(code(\infinity)) Used for setting the Score.beamslopedamping
property. Is actually equal to 10000.
+dit(code(\ionian)) Used as the second argument of the code(\key)
+keyword to get an ionian mode.
dit(code(\left)) Used for setting textalignment property. Is equal to -1.
+dit(code(\locrian)) Used as the second argument of the code(\key)
+keyword to get a locrian mode.
+dit(code(\lydian)) Used as the second argument of the code(\key)
+keyword to get a lydian mode.
dit(code(\major)) Used as the second argument of the code(\key)
-command to get a major key.
+keyword to get a major key.
dit(code(\minor)) Used as the second argument of the code(\key)
-command to get a minor key.
+keyword to get a minor key.
+dit(code(\mixolydian)) Used as the second argument of the code(\key)
+keyword to get a mixolydian mode.
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(\normalkey)) Select normal key signatures where each octave
has the same key signature. This sets the Staff.keyoctaviation property.
dit(code(\p)) Print a piano symbol on preceeding note.
+dit(code(\phrygian)) Used as the second argument of the code(\key)
+keyword to get a phrygian mode.
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).
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(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).
projects / lilypond.git / blobdiff