@c
@c A menu is needed before every deeper *section nesting of @nodes
@c Run M-x texinfo-all-menus-update
-@c to automagically fill in these menus
+@c to automatically fill in these menus
@c before saving changes
Syntax: c4 \context \set #'padding =
- \property
+ \override
Objects: Music expressions Contexts Layout object
Engravers (aka. Grob)
These use mixed-caps naming: @code{autoBeamSettings},
@code{ignoreMelismata}. They are assigned as follows:
@example
- \property LyricsVoice.ignoreMelismata = ...
+ \set ignoreMelismata = ...
@end example
@item Layout properties
@code{break-align-symbol}. They most often assigned as follows:
@example
- \property Score.RehearsalMark \set #'break-align-symbol = ...
+ \override Score.RehearsalMark #'break-align-symbol = ...
@end example
@noindent
Scheme interpreter.
@menu
-* Interpretation context::
-* Scheme integration::
-* Music storage format::
-* Lexical details::
-* Output details::
+* Interpretation context::
+* Scheme integration::
+* Music storage format::
+* Lexical details::
+* Output details::
@end menu
@section Interpretation context
@menu
-* Creating contexts::
-* Default contexts::
-* Context properties::
-* Context evaluation::
-* Defining contexts::
-* Changing contexts locally::
-* Engravers and performers::
-* Defining new contexts::
+* Creating contexts::
+* Default contexts::
+* Context properties::
+* Context evaluation::
+* Defining contexts::
+* Changing contexts locally::
+* Engravers and performers::
+* Defining new contexts::
@end menu
of type @var{contexttype} (with name @var{contextname} if specified).
If no such context exists, it will be created:
-@lilypond[verbatim,singleline]
+@lilypond[verbatim,raggedright]
\score {
\notes \relative c'' {
c4 <<d4 \context Staff = "another" e4>> f
context. The notes contained therein inherit the @code{goUp} context
from the enclosing music expression.
-@lilypond[verbatim,singleline]
+@lilypond[verbatim,raggedright]
\notes \context Voice = goUp { c'4 d' e' }
@end lilypond
Second, contexts are created automatically to be able to interpret the
music expressions. Consider the following example:
-@lilypond[verbatim, singleline]
+@lilypond[verbatim,raggedright]
\score { \notes { c'4-( d' e'-) } }
@end lilypond
@noindent
The sequential music is interpreted by the Score context initially,
but when a note is encountered, contexts are setup to accept that
-note. In this case, a @code{Thread}, @code{Voice}, and @code{Staff}
+note. In this case, a @code{Voice}, and @code{Staff}
context are created. The rest of the sequential music is also
-interpreted with the same @code{Thread}, @code{Voice}, and
+interpreted with the same @code{Voice}, and
@code{Staff} context, putting the notes on the same staff, in the same
voice.
Contexts have properties. These properties are set from the @file{.ly}
file using the following expression:
-@cindex @code{\property}
@cindex context properties
@cindex properties, context
@example
-\property @var{contextname}.@var{propname} = @var{value}
+\set @var{contextname}.@var{propname} = @var{value}
@end example
@noindent
@internalsref{Voice} context can be set in the @internalsref{Score} context
(for example) and thus take effect in all @internalsref{Voice} contexts.
-@cindex @code{Current}
-If you do not wish to specify the name of the context in the
-@code{\property}-expression itself, you can refer to the abstract context
-name, @code{Current}. The @code{Current} context is the latest
-used context. This will typically mean the @internalsref{Thread} context,
-but you can force another context with the
-@code{\property}-command. Hence the expressions
-
-@example
-\property @var{contextname}.@var{propname} = @var{value}
-@end example
-
-@noindent
-and
-
-@example
-\context @var{contextname}
-\property Current.@var{propname} = @var{value}
-@end example
-
-@noindent
-do the same thing. The main use for this is in predefined variables.
-This construction allows the specification of a property-setting
-without restriction to a specific context.
-
Properties can be unset using the following statement.
@example
-\property @var{contextname}.@var{propname} \unset
+\unset @var{contextname}.@var{propname}
@end example
@cindex properties, unsetting
@var{propname} was not defined in @var{contextname} (but was inherited
from a higher context), then this has no effect.
-@refbugs
+If @var{contextname} is left out, then it defaults to the current
+``bottom'' context: this is a context like @internalsref{Voice} that
+cannot contain any other contexts.
-The syntax of @code{\unset} is asymmetric: @code{\property \unset} is not
-the inverse of @code{\property \set}.
@node Context evaluation
\applycontext
#(lambda (x)
(format #t "\nWe were called in barnumber ~a.\n"
- (ly:get-context-property x 'currentBarNumber)))
+ (ly:context-property x 'currentBarNumber)))
@end example
defaultBarType = #"||"
@}
@end example
-These assignments happen before interpretation starts, so a @code{\property}
+These assignments happen before interpretation starts, so a property
command will override any predefined settings.
@cindex engraver
<<
\new Staff { c4 es4 g2 }
\new Staff \with {
- StaffSymbol \set #'staff-space = #(magstep 1.5)
+ \override StaffSymbol #'staff-space = #(magstep 1.5)
fontSize = #1.5
\remove "Clef_engraver"
} {
@refbugs
The command @code{\with} has no effect on contexts that already
-exist. Neither can it be used for @internalsref{Score} contexts.
+exist.
@node Engravers and performers
\remove @var{engravername}
@end example
-@cindex \consists
-@cindex \remove
+@cindex @code{\consists}
+@cindex @code{\remove}
@noindent
Here @var{engravername} is a string, the name of an engraver in the
system. In the following example, the @code{Clef_engraver} is removed
from the Staff context. The result is a staff without a clef, where
-the central C is at its default position, the center line:
+the middle C is at its default position, the center line:
-@lilypond[verbatim,singleline]
+@lilypond[verbatim,raggedright]
\score {
\notes {
c'4 f'4
@end lilypond
A list of all engravers is in the internal documentation,
-see @internalsref{All engravers}.
+see @internalsref{Engravers}.
@node Defining new contexts
@subsection Defining new contexts
@itemize @bullet
@item @code{\alias} @var{alternate-name}:
This specifies a different name. In the above example,
-@code{\property Staff.X = Y} will also work on @code{SimpleStaff}s.
+@code{\set Staff.X = Y} will also work on @code{SimpleStaff}s.
@item @code{\consistsend} @var{engravername}:
Analogous to @code{\consists}, but makes sure that
@end ifinfo
@menu
-* Inline Scheme::
-* Input variables and Scheme::
-* Scheme datatypes::
-* Assignments::
+* Inline Scheme::
+* Input variables and Scheme::
+* Assignments::
@end menu
@node Inline Scheme
@code{#t} in Scheme, so for LilyPond @var{true} looks like @code{##t},
and can be used in property assignments:
@example
- \property Staff.autoBeaming = ##f
+ \set Staff.autoBeaming = ##f
@end example
-@node Scheme datatypes
-@subsection Scheme datatypes
-
-Scheme is used to glue together different program modules. To aid this
-glue function, many LilyPond specific object types can be passed as
-Scheme value.
-
-The following list are all LilyPond specific types, that
-can exist during parsing:
-@table @code
-@item Duration
-@item Input
-@item Moment
-@item Music
-@item Event
-In C++ terms, an @code{Event} is a subtype of @code{Music}. However,
-both have different functions in the syntax.
-@item Music_output_def
-@item Pitch
-@item Score
-@item Translator_def
-@end table
-
-
-During a run, transient objects are also created and destroyed.
-
-@table @code
-@item Grob: short for `Graphical object'.
-@item Scheme_hash_table
-@item Music_iterator
-
-@item Molecule: Device-independent page output object,
-including dimensions.
-
-@item Syllable_group
-
-@item Spring_smob
-
-@item Translator: An object that produces audio objects or Grobs.
-It may be accessed with @code{\applyoutput}.
-
-@item Font_metric: An object representing a font.
-@end table
-
-Many functions are defined to manipulate these data structures. They
-are all listed and documented in the internals manual, see
-@internalsref{All scheme functions}.
-
-
@node Assignments
@subsection Assignments
@cindex Assignments
@end example
When a variable is referenced in LilyPond syntax, the information it
-points to is copied. For this reason, an variable reference must
+points to is copied. For this reason, a variable reference must
always be the first item in a block.
@example
manipulated using Scheme functions.
@menu
-* Music expressions::
-* Internal music representation::
-* Manipulating music expressions::
+* Music expressions::
+* Internal music representation::
+* Manipulating music expressions::
@end menu
@node Music expressions
produce music is not relevant. In the following example, three chords
are expressed in two different ways:
-@lilypond[fragment,verbatim,center,quote]
+@lilypond[fragment,verbatim,center]
\notes \context Voice {
<<a c'>> <<b d'>> <<c' e'>>
<< { a b c' } { c' d' e' } >>
This means that the scheme function @var{func} is called with
@var{music} as its argument. The return value of @var{func} is the
result of the entire expression. @var{func} may read and write music
-properties using the functions @code{ly:get-mus-property} and
-@code{ly:set-mus-property!}.
+properties using the functions @code{ly:music-property} and
+@code{ly:music-set-property!}.
An example is a function that reverses the order of elements in
its argument:
-@lilypond[verbatim,singleline]
+@lilypond[verbatim,raggedright]
#(define (rev-music-1 m)
- (ly:set-mus-property! m 'elements (reverse
- (ly:get-mus-property m 'elements)))
+ (ly:music-set-property! m 'elements (reverse
+ (ly:music-property m 'elements)))
m)
\score { \notes \apply #rev-music-1 { c4 d4 } }
@end lilypond
children.
@example
#(define (reverse-music music)
- (let* ((elements (ly:get-mus-property music 'elements))
- (child (ly:get-mus-property music 'element))
+ (let* ((elements (ly:music-property music 'elements))
+ (child (ly:music-property music 'element))
(reversed (reverse elements)))
; set children
- (ly:set-mus-property! music 'elements reversed)
+ (ly:music-set-property! music 'elements reversed)
; recurse
(if (ly:music? child) (reverse-music child))
@node Output details
@section Output details
-LilyPond's default output format is @TeX{}. Using the option @option{-f}
+The default output format is La@TeX{}, which should be run
+through La@TeX{}. Using the option @option{-f}
(or @option{--format}) other output formats can be selected also, but
currently none of them work reliably.
-At the beginning of the output file, various global parameters are defined.
-It also contains a large @code{\special} call to define PostScript routines
-to draw items not representable with @TeX{}, mainly slurs and ties. A DVI
-driver must be able to understand such embedded PostScript, or the output
-will be rendered incompletely.
-
-Then the file @file{lilyponddefs.tex} is loaded to define the macros used
-in the code which follows. @file{lilyponddefs.tex} includes various other
-files, partially depending on the global parameters.
+At the beginning of the output file, various global parameters are
+defined. Then the file @file{lilyponddefs.tex} is loaded to define
+the macros used in the code which follows. @file{lilyponddefs.tex}
+includes various other files, partially depending on the global
+parameters.
Now the music is output system by system (a `system' consists of all
staves belonging together). From @TeX{}'s point of view, a system is an
The horizontal dimension of the @code{\hbox} is given by the
@code{linewidth} parameter from LilyPond's @code{\paper} block.
-
After the last system LilyPond emits a stronger variant of
@code{\interscoreline} only if the macro
@code{\lilypondpaperlastpagefill} is not defined (flushing the systems
@noindent
where @code{\baselineskip} is the distance from one text line to the next.
-The code produced by LilyPond should be run through La@TeX{}, not
-plain @TeX{}.
-
Here an example how to embed a small LilyPond file @code{foo.ly} into
running La@TeX{} text without using the @code{lilypond-book} script
(@pxref{lilypond-book manual}):
The file @file{foo.tex} has been simply produced with
@example
-lilypond foo.ly
+ lilypond-bin foo.ly
@end example
-It is important to set the @code{indent} parameter to zero in the
-@code{\paper} block of @file{foo.ly}.
-
The call to @code{\lineskip} assures that there is enough vertical space
between the LilyPond box and the surrounding text lines.
projects / lilypond.git / blobdiff