%%%% This file is part of LilyPond, the GNU music typesetter.
%%%%
-%%%% Copyright (C) 2003--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
+%%%% Copyright (C) 2003--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
%%%% Jan Nieuwenhuizen <janneke@gnu.org>
%%%%
%%%% LilyPond is free software: you can redistribute it and/or modify
%%%% You should have received a copy of the GNU General Public License
%%%% along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
-\version "2.17.6"
+\version "2.17.11"
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% need SRFI-1 for filter; optargs for lambda*
#(use-modules (srfi srfi-1)
- (ice-9 optargs))
+ (ice-9 optargs))
%% TODO: using define-music-function in a .scm causes crash.
+absolute =
+#(define-music-function (parser location music)
+ (ly:music?)
+ (_i "Make @var{music} absolute. This does not actually change the
+music itself but rather hides it from surrounding @code{\\relative}
+commands.")
+ (make-music 'RelativeOctaveMusic 'element music))
+
acciaccatura =
#(def-grace-function startAcciaccaturaMusic stopAcciaccaturaMusic
(_i "Create an acciaccatura from the following music expression"))
#(define-music-function (parser location main grace) (ly:music? ly:music?)
(_i "Create @var{grace} note(s) after a @var{main} music expression.")
(let ((main-length (ly:music-length main))
- (fraction (ly:parser-lookup parser 'afterGraceFraction)))
+ (fraction (ly:parser-lookup parser 'afterGraceFraction)))
(make-simultaneous-music
(list
main
(make-sequential-music
- (list
+ (list
- (make-music 'SkipMusic
- 'duration (ly:make-duration
- 0 0
- (* (ly:moment-main-numerator main-length)
- (car fraction))
- (* (ly:moment-main-denominator main-length)
- (cdr fraction))))
- (make-music 'GraceMusic
- 'element grace)))))))
+ (make-music 'SkipMusic
+ 'duration (ly:make-duration
+ 0 0
+ (* (ly:moment-main-numerator main-length)
+ (car fraction))
+ (* (ly:moment-main-denominator main-length)
+ (cdr fraction))))
+ (make-music 'GraceMusic
+ 'element grace)))))))
%% music identifiers not allowed at top-level,
(_i "Allow a page turn. May be used at toplevel (ie between scores or
markups), or inside a score.")
(make-music 'EventChord
- 'page-marker #t
- 'page-turn-permission 'allow
- 'elements (list (make-music 'PageTurnEvent
- 'break-permission 'allow))))
+ 'page-marker #t
+ 'page-turn-permission 'allow
+ 'elements (list (make-music 'PageTurnEvent
+ 'break-permission 'allow))))
alterBroken =
-#(define-music-function (parser location name property arg)
- (symbol-list? symbol? list?)
- (_i "Override @var{property} for pieces of broken spanner @var{name} with
-values @var{arg}.")
- ;; only apply override if grob is a spanner
- (let ((description
- (assoc-get (last name) all-grob-descriptions)))
- (if (and description
- (member 'spanner-interface
- (assoc-get 'interfaces
- (assoc-get 'meta description))))
- #{
- \override $name $property =
- #(value-for-spanner-piece arg)
- #}
- (begin
- (ly:input-warning location (_ "not a spanner name, `~a'") name)
- (make-music 'SequentialMusic 'void #t)))))
+#(define-music-function (parser location property arg item)
+ (symbol-list-or-symbol? list? symbol-list-or-music?)
+ (_i "Override @var{property} for pieces of broken spanner @var{item}
+with values @var{arg}. @var{item} may either be music in the form of
+a starting spanner event, or a symbol list in the form
+@samp{Context.Grob} or just @samp{Grob}. Iff @var{item} is in the
+form of a spanner event, @var{property} may also have the form
+@samp{Grob.property} for specifying a directed tweak.")
+ (if (ly:music? item)
+ (if (eq? (ly:music-property item 'span-direction) START)
+ #{ \tweak #property #(value-for-spanner-piece arg) #item #}
+ (begin
+ (ly:music-warning item (_ "not a spanner"))
+ item))
+ (let* ((p (check-grob-path item parser location
+ #:default 'Bottom
+ #:min 2
+ #:max 2))
+ (name (and p (second p)))
+ (description
+ (and name (assoc-get name all-grob-descriptions))))
+ (if (and description
+ (member 'spanner-interface
+ (assoc-get 'interfaces
+ (assoc-get 'meta description))))
+ #{
+ \override #item . #property =
+ #(value-for-spanner-piece arg)
+ #}
+ (begin
+ (ly:input-warning location (_ "not a spanner name, `~a'") name)
+ (make-music 'Music))))))
appendToTag =
#(define-music-function (parser location tag more music)
(_i "Append @var{more} to the @code{elements} of all music
expressions in @var{music} that are tagged with @var{tag}.")
(music-map (lambda (m)
- (if (memq tag (ly:music-property m 'tags))
- (set! (ly:music-property m 'elements)
- (append (ly:music-property m 'elements)
- (list more))))
- m)
- music))
+ (if (memq tag (ly:music-property m 'tags))
+ (set! (ly:music-property m 'elements)
+ (append (ly:music-property m 'elements)
+ (list more))))
+ m)
+ music))
applyContext =
#(define-music-function (parser location proc) (procedure?)
(_i "Modify context properties with Scheme procedure @var{proc}.")
(make-music 'ApplyContext
- 'procedure proc))
+ 'procedure proc))
applyMusic =
#(define-music-function (parser location func music) (procedure? ly:music?)
#(define-music-function (parser location ctx proc) (symbol? procedure?)
(_i "Apply function @code{proc} to every layout object in context @code{ctx}")
(make-music 'ApplyOutputEvent
- 'procedure proc
- 'context-type ctx))
+ 'procedure proc
+ 'context-type ctx))
appoggiatura =
#(def-grace-function startAppoggiaturaMusic stopAppoggiaturaMusic
(symbol? number-pair? markup?)
(_i "Attach @var{text} to @var{grob-name} at offset @var{offset}
(use like @code{\\once})")
- (make-music 'AnnotateOutputEvent
- 'symbol grob-name
- 'X-offset (car offset)
- 'Y-offset (cdr offset)
- 'text text))
+ (make-event-chord
+ (list
+ (make-music 'AnnotateOutputEvent
+ 'symbol grob-name
+ 'X-offset (car offset)
+ 'Y-offset (cdr offset)
+ 'text text))))
balloonText =
-#(define-music-function (parser location offset text) (number-pair? markup?)
+#(define-event-function (parser location offset text) (number-pair? markup?)
(_i "Attach @var{text} at @var{offset} (use like @code{\\tweak})")
(make-music 'AnnotateOutputEvent
- 'X-offset (car offset)
- 'Y-offset (cdr offset)
- 'text text))
+ 'X-offset (car offset)
+ 'Y-offset (cdr offset)
+ 'text text))
bar =
#(define-music-function (parser location type) (string?)
#(define-music-function (parser location n) (integer?)
(_i "Print a warning if the current bar number is not @var{n}.")
(make-music 'ApplyContext
- 'procedure
- (lambda (c)
- (let ((cbn (ly:context-property c 'currentBarNumber)))
- (if (and (number? cbn) (not (= cbn n)))
- (ly:input-warning location
- "Barcheck failed got ~a expect ~a"
- cbn n))))))
+ 'procedure
+ (lambda (c)
+ (let ((cbn (ly:context-property c 'currentBarNumber)))
+ (if (and (number? cbn) (not (= cbn n)))
+ (ly:input-warning location
+ "Barcheck failed got ~a expect ~a"
+ cbn n))))))
+
+beamExceptions =
+#(define-scheme-function (parser location music) (ly:music?)
+ (_i "Extract a value suitable for setting
+@code{Timing.beamExceptions} from the given pattern with explicit
+beams in @var{music}. A bar check @code{|} has to be used between
+bars of patterns in order to reset the timing.")
+ (extract-beam-exceptions music))
bendAfter =
#(define-event-function (parser location delta) (real?)
(_i "Create a fall or doit of pitch interval @var{delta}.")
(make-music 'BendAfterEvent
- 'delta-step delta))
+ 'delta-step delta))
bookOutputName =
#(define-void-function (parser location newfilename) (string?)
(timesig (cons (ly:moment-main-numerator mlen)
(ly:moment-main-denominator mlen))))
#{
- \once \override Staff.TimeSignature #'stencil = #(lambda (grob)
- (grob-interpret-markup grob (format-compound-time args)))
- \set Timing.timeSignatureFraction = $timesig
- \set Timing.baseMoment = $beat
- \set Timing.beatStructure = $beatGrouping
+ \once \override Timing.TimeSignature.stencil = #(lambda (grob)
+ (grob-interpret-markup grob (make-compound-meter-markup args)))
+ \set Timing.timeSignatureFraction = #timesig
+ \set Timing.baseMoment = #beat
+ \set Timing.beatStructure = #beatGrouping
\set Timing.beamExceptions = #'()
- \set Timing.measureLength = $mlen
+ \set Timing.measureLength = #mlen
#} ))
crossStaff =
#(define-music-function (parser location notes) (ly:music?)
(_i "Create cross-staff stems")
#{
- \override Stem #'cross-staff = #cross-staff-connect
- \override Flag #'style = #'no-flag
- $notes
- \revert Stem #'cross-staff
- \revert Flag #'style
+ \temporary \override Stem.cross-staff = #cross-staff-connect
+ \temporary \override Flag.style = #'no-flag
+ #notes
+ \revert Stem.cross-staff
+ \revert Flag.style
#})
cueClef =
(_i "Insert contents of quote @var{what} corresponding to @var{main-music},
in a CueVoice oriented by @var{dir}.")
(make-music 'QuoteMusic
- 'element main-music
- 'quoted-context-type 'Voice
- 'quoted-context-id "cue"
- 'quoted-music-name what
- 'quoted-voice-direction dir))
+ 'element main-music
+ 'quoted-context-type 'CueVoice
+ 'quoted-context-id "cue"
+ 'quoted-music-name what
+ 'quoted-voice-direction dir))
cueDuringWithClef =
#(define-music-function
(_i "Insert contents of quote @var{what} corresponding to @var{main-music},
in a CueVoice oriented by @var{dir}.")
(make-music 'QuoteMusic
- 'element main-music
- 'quoted-context-type 'Voice
- 'quoted-context-id "cue"
- 'quoted-music-name what
- 'quoted-music-clef clef
- 'quoted-voice-direction dir))
+ 'element main-music
+ 'quoted-context-type 'CueVoice
+ 'quoted-context-id "cue"
+ 'quoted-music-name what
+ 'quoted-music-clef clef
+ 'quoted-voice-direction dir))
displayLilyMusic =
-#(define-music-function (parser location music) (ly:music?)
+#(define-music-function (parser location port music) ((output-port?) ly:music?)
(_i "Display the LilyPond input representation of @var{music}
-to the console.")
- (newline)
- (display-lily-music music parser)
+to @var{port}, defaulting to the console.")
+ (let ((port (or port (current-output-port))))
+ (newline port)
+ (display-lily-music music parser port))
music)
displayMusic =
-#(define-music-function (parser location music) (ly:music?)
- (_i "Display the internal representation of @var{music} to the console.")
- (newline)
- (display-scheme-music music)
+#(define-music-function (parser location port music) ((output-port?) ly:music?)
+ (_i "Display the internal representation of @var{music} to
+@var{port}, default to the console.")
+ (let ((port (or port (current-output-port))))
+ (newline port)
+ (display-scheme-music music port))
music)
+displayScheme =
+#(define-scheme-function (parser location port expr) ((output-port?) scheme?)
+ (_i "Display the internal representation of @var{expr} to
+@var{port}, default to the console.")
+ (let ((port (or port (current-output-port))))
+ (newline port)
+ (display-scheme-music expr port))
+ expr)
+
endSpanners =
(_i "Terminate the next spanner prematurely after exactly one note
without the need of a specific end spanner.")
(let* ((start-span-evs (filter (lambda (ev)
- (equal? (ly:music-property ev 'span-direction)
- START))
- (extract-typed-music music 'span-event)))
- (stop-span-evs
- (map (lambda (m)
- (let ((c (music-clone m)))
- (set! (ly:music-property c 'span-direction) STOP)
- c))
- start-span-evs))
- (end-ev-chord (make-music 'EventChord
- 'elements stop-span-evs))
- (total (make-music 'SequentialMusic
- 'elements (list music
- end-ev-chord))))
+ (equal? (ly:music-property ev 'span-direction)
+ START))
+ (extract-typed-music music 'span-event)))
+ (stop-span-evs
+ (map (lambda (m)
+ (music-clone m 'span-direction STOP))
+ start-span-evs))
+ (end-ev-chord (make-music 'EventChord
+ 'elements stop-span-evs))
+ (total (make-music 'SequentialMusic
+ 'elements (list music
+ end-ev-chord))))
total))
eventChords =
#(define-music-function (parser location factor argument) (ly:moment? ly:music?)
(_i "Adjust durations of music in @var{argument} by rational @var{factor}.")
(let ((orig-duration (ly:music-length argument))
- (multiplier (ly:make-moment 1 1)))
+ (multiplier (ly:make-moment 1 1)))
(for-each
(lambda (mus)
- (if (< 0 (ly:moment-main-denominator (ly:music-length mus)))
- (begin
- (ly:music-compress mus multiplier)
- (set! multiplier (ly:moment-mul factor multiplier)))))
+ (if (< 0 (ly:moment-main-denominator (ly:music-length mus)))
+ (begin
+ (ly:music-compress mus multiplier)
+ (set! multiplier (ly:moment-mul factor multiplier)))))
(extract-named-music argument '(EventChord NoteEvent RestEvent SkipEvent)))
(ly:music-compress
argument
argument))
+finger =
+#(define-event-function (parser location finger) (number-or-markup?)
+ (_i "Apply @var{finger} as a fingering indication.")
+
+ (make-music
+ 'FingeringEvent
+ (if (number? finger) 'digit 'text)
+ finger))
+
footnote =
#(define-music-function (parser location mark offset footnote item)
((markup?) number-pair? markup? symbol-list-or-music?)
post-event, the @code{\\footnote} command itself needs to be attached
to the preceding note or rest as a post-event with @code{-}.")
(let ((mus (make-music
- 'FootnoteEvent
- 'X-offset (car offset)
- 'Y-offset (cdr offset)
- 'automatically-numbered (not mark)
- 'text (or mark (make-null-markup))
- 'footnote-text footnote)))
- (if (ly:music? item)
- #{ \tweak #'footnote-music #mus #item #}
- #{ \once\override $item #'footnote-music = #mus #})))
+ 'FootnoteEvent
+ 'X-offset (car offset)
+ 'Y-offset (cdr offset)
+ 'automatically-numbered (not mark)
+ 'text (or mark (make-null-markup))
+ 'footnote-text footnote)))
+ #{ \once \tweak footnote-music #mus #item #}))
grace =
#(def-grace-function startGraceMusic stopGraceMusic
in the format of @code{all-grob-descriptions}.")
(ly:make-context-mod
(map (lambda (p)
- (list 'assign (car p) (list (cdr p))))
- descriptions)))
+ (list 'assign (car p) (ly:make-grob-properties (cdr p))))
+ descriptions)))
harmonicByFret = #(define-music-function (parser location fret music) (number? ly:music?)
(_i "Convert @var{music} into mixed harmonics; the resulting notes resemble
harmonics played on a fretted instrument by touching the strings at @var{fret}.")
#{
\set harmonicDots = ##t
- \override TabNoteHead #'stencil = #(tab-note-head::print-custom-fret-label (number->string fret))
- \override NoteHead #'Y-extent = #(ly:make-unpure-pure-container ly:grob::stencil-height
- (lambda (grob start end)
- (ly:grob::stencil-height grob)))
- \override NoteHead #'stencil = #(lambda (grob) (ly:grob-set-property! grob 'style 'harmonic-mixed)
+ \temporary \override TabNoteHead.stencil = #(tab-note-head::print-custom-fret-label (number->string fret))
+ \temporary \override NoteHead.Y-extent = #grob::always-Y-extent-from-stencil
+ \temporary \override NoteHead.stencil = #(lambda (grob) (ly:grob-set-property! grob 'style 'harmonic-mixed)
(ly:note-head::print grob))
- $(make-harmonic
+ #(make-harmonic
(calc-harmonic-pitch (fret->pitch (number->string fret)) music))
\unset harmonicDots
- \revert TabNoteHead #'stencil
- \revert NoteHead #'Y-extent
- \revert NoteHead #'stencil
+ \revert TabNoteHead.stencil
+ \revert NoteHead.Y-extent
+ \revert NoteHead.stencil
#})
harmonicByRatio = #(define-music-function (parser location ratio music) (number? ly:music?)
given through @var{ratio}.")
#{
\set harmonicDots = ##t
- \override TabNoteHead #'stencil = #(tab-note-head::print-custom-fret-label (ratio->fret ratio))
- \override NoteHead #'Y-extent = #(ly:make-unpure-pure-container ly:grob::stencil-height
+ \temporary \override TabNoteHead.stencil = #(tab-note-head::print-custom-fret-label (ratio->fret ratio))
+ \temporary \override NoteHead.Y-extent = #(ly:make-unpure-pure-container ly:grob::stencil-height
(lambda (grob start end)
(ly:grob::stencil-height grob)))
- \override NoteHead #'stencil = #(lambda (grob) (ly:grob-set-property! grob 'style 'harmonic-mixed)
+ \temporary \override NoteHead.stencil = #(lambda (grob) (ly:grob-set-property! grob 'style 'harmonic-mixed)
(ly:note-head::print grob))
- $(make-harmonic
+ #(make-harmonic
(calc-harmonic-pitch (ratio->pitch ratio) music))
\unset harmonicDots
- \revert TabNoteHead #'stencil
- \revert NoteHead #'Y-extent
- \revert NoteHead #'stencil
+ \revert TabNoteHead.stencil
+ \revert NoteHead.Y-extent
+ \revert NoteHead.stencil
#})
hide =
@code{Context.GrobName}, the result is an override for the grob name
specified by it. If @var{item} is a music expression, the result is
the same music expression with an appropriate tweak applied to it.")
- (if (ly:music? item)
- #{ \tweak #'transparent ##t $item #}
- #{ \override $item #'transparent = ##t #}))
+ #{ \tweak transparent ##t #item #})
inStaffSegno =
#(define-music-function (parser location) ()
(_i "Switch instrument to @var{name}, which must be predefined with
@code{\\addInstrumentDefinition}.")
(let* ((handle (assoc name instrument-definitions))
- (instrument-def (if handle (cdr handle) '())))
+ (instrument-def (if handle (cdr handle) '())))
(if (not handle)
- (ly:input-warning location "No such instrument: ~a" name))
+ (ly:input-warning location "No such instrument: ~a" name))
(context-spec-music
(make-music 'SimultaneousMusic
- 'elements
- (map (lambda (kv)
- (make-property-set
- (car kv)
- (cdr kv)))
- instrument-def))
+ 'elements
+ (map (lambda (kv)
+ (make-property-set
+ (car kv)
+ (cdr kv)))
+ instrument-def))
'Staff)))
keepWithTag =
-#(define-music-function (parser location tag music) (symbol? ly:music?)
- (_i "Include only elements of @var{music} that are tagged with @var{tag}.")
+#(define-music-function (parser location tags music)
+ (symbol-list-or-symbol? ly:music?)
+ (_i "Include only elements of @var{music} that are tagged with one
+of the tags in @var{tags}. @var{tags} may be either a single symbol
+or a list of symbols.
+
+Each tag may be declared as a member of at most one tag group (defined
+with @code{\\tagGroup}). If none of a @var{music} element's tags
+share a tag group with one of the specified @var{tags}, the element is
+retained.")
(music-filter
- (lambda (m)
- (let* ((tags (ly:music-property m 'tags))
- (res (memq tag tags)))
- (or
- (eq? tags '())
- res)))
+ (tags-keep-predicate tags)
music))
key =
(_i "Set key to @var{tonic} and scale @var{pitch-alist}.
If both are null, just generate @code{KeyChangeEvent}.")
(cond ((null? tonic) (make-music 'KeyChangeEvent))
- ((null? pitch-alist)
- (ly:parser-error parser (_ "second argument must be pitch list")
- location)
- (make-music 'SequentialMusic 'void #t))
- (else
- (ly:music-transpose
- (make-music 'KeyChangeEvent
- 'tonic (ly:make-pitch 0 0 0)
- 'pitch-alist pitch-alist)
- tonic))))
+ ((null? pitch-alist)
+ (ly:parser-error parser (_ "second argument must be pitch list")
+ location)
+ (make-music 'SequentialMusic 'void #t))
+ (else
+ (ly:music-transpose
+ (make-music 'KeyChangeEvent
+ 'tonic (ly:make-pitch 0 0 0)
+ 'pitch-alist pitch-alist)
+ tonic))))
killCues =
#(define-music-function (parser location music) (ly:music?)
(music-map
(lambda (mus)
(if (and (string? (ly:music-property mus 'quoted-music-name))
- (string=? (ly:music-property mus 'quoted-context-id "") "cue"))
- (ly:music-property mus 'element)
- mus))
+ (string=? (ly:music-property mus 'quoted-context-id "") "cue"))
+ (ly:music-property mus 'element)
+ mus))
music))
#(define-music-function (parser location label) (symbol?)
(_i "Create @var{label} as a bookmarking label.")
(make-music 'EventChord
- 'page-marker #t
- 'page-label label
- 'elements (list (make-music 'LabelEvent
- 'page-label label))))
+ 'page-marker #t
+ 'page-label label
+ 'elements (list (make-music 'LabelEvent
+ 'page-label label))))
language =
(ly:input-warning location (_ "No other language was defined previously. Ignoring."))))
+magnifyMusic =
+#(define-music-function (parser location mag music) (positive? ly:music?)
+ (_i "Magnify the notation of @var{music} without changing the
+staff-size, using @var{mag} as a size factor. Stems, beams,
+slurs, ties, and horizontal spacing are adjusted automatically.")
+
+ ;; these props are NOT allowed to shrink below default size
+ (define unshrinkable-props
+ '(
+ ;; stems
+ (Stem thickness)
+
+ ;; slurs
+ (Slur line-thickness)
+ (Slur thickness)
+ (PhrasingSlur line-thickness)
+ (PhrasingSlur thickness)
+
+ ;; ties
+ (Tie line-thickness)
+ (Tie thickness)
+ (LaissezVibrerTie line-thickness)
+ (LaissezVibrerTie thickness)
+ (RepeatTie line-thickness)
+ (RepeatTie thickness)
+ ))
+
+ ;; these props ARE allowed to shrink below default size
+ (define shrinkable-props
+ (let ((baseline-skip-props
+ (find-named-props 'baseline-skip all-grob-descriptions))
+ (word-space-props
+ (find-named-props 'word-space all-grob-descriptions)))
+ (append
+ baseline-skip-props
+ word-space-props
+ '(
+ ;; TODO: uncomment spacing-increment here once Issue 3987 is fixed
+ ;; override at the 'Score level
+ ;(SpacingSpanner spacing-increment)
+
+ ;; lengths and heights
+ (Beam length-fraction)
+ (Stem length-fraction)
+ (Stem beamlet-default-length)
+ (Stem double-stem-separation)
+ (Slur height-limit)
+ (Slur minimum-length)
+ (PhrasingSlur height-limit)
+ (PhrasingSlur minimum-length)
+
+ ;; Beam.beam-thickness is dealt with separately below
+ ))))
+ #{
+ \context Bottom {
+ %% TODO: uncomment \newSpacingSection once Issue 3990 is fixed
+ %\newSpacingSection
+ #(scale-fontSize 'magnifyMusic mag)
+ #(scale-props 'magnifyMusic mag #f unshrinkable-props)
+ #(scale-props 'magnifyMusic mag #t shrinkable-props)
+ #(scale-beam-thickness mag)
+
+ #music
+
+ %% TODO: uncomment \newSpacingSection once Issue 3990 is fixed
+ %\newSpacingSection
+ %% reverse engineer the former fontSize value instead of using \unset
+ #(revert-fontSize 'magnifyMusic mag)
+ #(revert-props 'magnifyMusic mag (append unshrinkable-props
+ shrinkable-props
+ '((Beam beam-thickness))))
+ }
+ #})
+
+magnifyStaff =
+#(define-music-function (parser location mag) (positive?)
+ (_i "Change the size of the staff, adjusting notation size and
+horizontal spacing automatically, using @var{mag} as a size factor.")
+
+ ;; these props are NOT allowed to shrink below default size
+ (define unshrinkable-props
+ '((StaffSymbol thickness)))
+
+ ;; these props ARE allowed to shrink below default size
+ (define shrinkable-props
+ (let* ((baseline-skip-props
+ (find-named-props 'baseline-skip all-grob-descriptions))
+ (word-space-props
+ (find-named-props 'word-space all-grob-descriptions))
+ (space-alist-props
+ (find-named-props 'space-alist all-grob-descriptions)))
+ (append
+ baseline-skip-props
+ word-space-props
+ space-alist-props
+ '(
+ ;; override at the 'Score level
+ (SpacingSpanner spacing-increment)
+
+ (StaffSymbol staff-space)
+ (BarLine kern)
+ (BarLine segno-kern)
+ (BarLine hair-thickness)
+ (BarLine thick-thickness)
+ (Stem beamlet-default-length)
+ (Stem double-stem-separation)
+ ))))
+
+ #{
+ \stopStaff
+
+ %% revert settings from last time
+ %% (but only if \magnifyStaff has already been used
+ %% and the staff magnification is changing)
+ #(revert-fontSize 'magnifyStaff mag)
+ #(revert-props 'magnifyStaff mag (append unshrinkable-props
+ shrinkable-props))
+
+ %% scale settings
+ %% (but only if staff magnification is changing
+ %% and does not equal 1)
+ #(scale-fontSize 'magnifyStaff mag)
+ #(scale-props 'magnifyStaff mag #f unshrinkable-props)
+ #(scale-props 'magnifyStaff mag #t shrinkable-props)
+
+ %% this might cause problems until Issue 3990 is fixed
+ \newSpacingSection
+
+ \startStaff
+ \set Staff.magnifyStaffValue = #mag
+ #})
+
makeClusters =
#(define-music-function (parser location arg) (ly:music?)
(_i "Display chords in @var{arg} as clusters.")
(parser location label) ((scheme? '()))
"Make the music for the \\mark command."
(let* ((set (and (integer? label)
- (context-spec-music (make-property-set 'rehearsalMark label)
- 'Score)))
- (ev (make-music 'MarkEvent
- 'origin location)))
+ (context-spec-music (make-property-set 'rehearsalMark label)
+ 'Score)))
+ (ev (make-music 'MarkEvent
+ 'origin location)))
(if set
- (make-sequential-music (list set ev))
- (begin
- (set! (ly:music-property ev 'label) label)
- ev))))
+ (make-sequential-music (list set ev))
+ (begin
+ (set! (ly:music-property ev 'label) label)
+ ev))))
musicMap =
#(define-music-function (parser location proc mus) (procedure? ly:music?)
(_i "Forbid a page break. May be used at toplevel (i.e., between scores or
markups), or inside a score.")
(make-music 'EventChord
- 'page-marker #t
- 'page-break-permission 'forbid
- 'elements (list (make-music 'PageBreakEvent
- 'break-permission '()))))
+ 'page-marker #t
+ 'page-break-permission 'forbid
+ 'elements (list (make-music 'PageBreakEvent
+ 'break-permission '()))))
noPageTurn =
#(define-music-function (location parser) ()
(_i "Forbid a page turn. May be used at toplevel (i.e., between scores or
markups), or inside a score.")
(make-music 'EventChord
- 'page-marker #t
- 'page-turn-permission 'forbid
- 'elements (list (make-music 'PageTurnEvent
- 'break-permission '()))))
+ 'page-marker #t
+ 'page-turn-permission 'forbid
+ 'elements (list (make-music 'PageTurnEvent
+ 'break-permission '()))))
(make-music 'RelativeOctaveCheck
'pitch pitch))
+offset =
+#(define-music-function (parser location property offsets item)
+ (symbol-list-or-symbol? scheme? symbol-list-or-music?)
+ (_i "Offset the default value of @var{property} of @var{item} by
+@var{offsets}. If @var{item} is a string, the result is
+@code{\\override} for the specified grob type. If @var{item} is
+a music expression, the result is the same music expression with an
+appropriate tweak applied.")
+ (if (ly:music? item)
+ ; In case of a tweak, grob property path is Grob.property
+ (let ((prop-path (check-grob-path
+ (if (symbol? property)
+ (list property)
+ property)
+ parser location
+ #:start 1 #:default #t #:min 2 #:max 2)))
+ (if prop-path
+ ; If the head of the grob property path is a symbol--i.e.,
+ ; a grob name, produce a directed tweak. Otherwise, create
+ ; an ordinary tweak.
+ (if (symbol? (car prop-path))
+ #{
+ \tweak #prop-path #(offsetter (second prop-path) offsets) #item
+ #}
+ #{
+ \tweak #(second prop-path) #(offsetter (second prop-path) offsets) #item
+ #})
+ item))
+ ; In case of an override, grob property path is Context.Grob.property.
+ (let ((prop-path (check-grob-path
+ (append item
+ (if (symbol? property)
+ (list property)
+ property))
+ parser location
+ #:default 'Bottom #:min 3 #:max 3)))
+ (if prop-path
+ #{
+ \override #prop-path = #(offsetter (third prop-path) offsets)
+ #}
+ (make-music 'Music)))))
+
omit =
#(define-music-function (parser location item) (symbol-list-or-music?)
(_i "Set @var{item}'s @samp{stencil} property to @code{#f},
@code{Context.GrobName}, the result is an override for the grob name
specified by it. If @var{item} is a music expression, the result is
the same music expression with an appropriate tweak applied to it.")
- (if (ly:music? item)
- #{ \tweak #'stencil ##f $item #}
- #{ \override $item #'stencil = ##f #}))
+ #{ \tweak stencil ##f #item #})
once =
#(define-music-function (parser location music) (ly:music?)
- (_i "Set @code{once} to @code{#t} on all layout instruction events in @var{music}.")
- (music-map
- (lambda (m)
- (cond ((music-is-of-type? m 'layout-instruction-event)
- (set! (ly:music-property m 'once) #t))
- ((ly:duration? (ly:music-property m 'duration))
- (ly:music-warning m (_ "Cannot apply \\once to timed music"))))
- m)
- music))
+ (_i "Set @code{once} to @code{#t} on all layout instruction events
+in @var{music}. This will complain about music with an actual
+duration. As a special exception, if @var{music} contains
+@samp{tweaks} it will be silently ignored in order to allow for
+@code{\\once \\tweak} to work as both one-time override and proper
+tweak.")
+ (if (not (pair? (ly:music-property music 'tweaks)))
+ (for-some-music
+ (lambda (m)
+ (cond ((music-is-of-type? m 'layout-instruction-event)
+ (set! (ly:music-property m 'once) #t)
+ #t)
+ ((ly:duration? (ly:music-property m 'duration))
+ (ly:music-warning m (_ "Cannot apply \\once to timed music"))
+ #t)
+ (else #f)))
+ music))
+ music)
ottava =
#(define-music-function (parser location octave) (integer?)
(_i "Set the octavation.")
(make-music 'OttavaMusic
- 'ottava-number octave))
+ 'ottava-number octave))
overrideTimeSignatureSettings =
#(define-music-function
(parser location time-signature base-moment beat-structure beam-exceptions)
- (pair? pair? cheap-list? cheap-list?)
+ (fraction? fraction? list? list?)
(_i "Override @code{timeSignatureSettings}
for time signatures of @var{time-signature} to have settings
of @var{base-moment}, @var{beat-structure}, and @var{beam-exceptions}.")
;; TODO -- add warning if largest value of grouping is
- ;; greater than time-signature.
+ ;; greater than time-signature.
(let ((setting (make-setting base-moment beat-structure beam-exceptions)))
(override-time-signature-setting time-signature setting)))
overrideProperty =
-#(define-music-function (parser location name property-path value)
- (symbol-list? symbol-list-or-symbol? scheme?)
-
- (_i "Set @var{property-path} to @var{value} in all grobs named @var{name}.
-The @var{name} argument is a symbol list of the form @code{Context.GrobName}
-or @code{GrobName}.")
- (if (<= 1 (length name) 2)
- (make-music 'ApplyOutputEvent
- 'context-type (if (null? (cdr name)) 'Bottom
- (car name))
- 'procedure
- (lambda (grob orig-context context)
- (if (equal?
- (cdr (assoc 'name (ly:grob-property grob 'meta)))
- (last name))
- (if (symbol? property-path)
- (ly:grob-set-property! grob property-path value)
- (case (length property-path)
- ((0) *unspecified*)
- ((1)
- (ly:grob-set-property!
- grob (car property-path) value))
- (else
- (ly:grob-set-nested-property!
- grob property-path value)))))))
- (begin
- (ly:parser-error parser (_ "bad grob name") location)
+#(define-music-function (parser location grob-property-path value)
+ (symbol-list? scheme?)
+
+ (_i "Set the grob property specified by @var{grob-property-path} to
+@var{value}. @var{grob-property-path} is a symbol list of the form
+@code{Context.GrobName.property} or @code{GrobName.property}, possibly
+with subproperties given as well.")
+ (let ((p (check-grob-path grob-property-path parser location
+ #:default 'Bottom
+ #:min 3)))
+ (if p
+ (make-music 'ApplyOutputEvent
+ 'context-type (first p)
+ 'procedure
+ (lambda (grob orig-context context)
+ (if (equal?
+ (cdr (assoc 'name (ly:grob-property grob 'meta)))
+ (second p))
+ (ly:grob-set-nested-property!
+ grob (cddr p) value))))
(make-music 'Music))))
(_i "Force a page break. May be used at toplevel (i.e., between scores or
markups), or inside a score.")
(make-music 'EventChord
- 'page-marker #t
- 'line-break-permission 'force
- 'page-break-permission 'force
- 'elements (list (make-music 'LineBreakEvent
- 'break-permission 'force)
- (make-music 'PageBreakEvent
- 'break-permission 'force))))
+ 'page-marker #t
+ 'line-break-permission 'force
+ 'page-break-permission 'force
+ 'elements (list (make-music 'LineBreakEvent
+ 'break-permission 'force)
+ (make-music 'PageBreakEvent
+ 'break-permission 'force))))
pageTurn =
#(define-music-function (location parser) ()
(_i "Force a page turn between two scores or top-level markups.")
(make-music 'EventChord
- 'page-marker #t
- 'line-break-permission 'force
- 'page-break-permission 'force
- 'page-turn-permission 'force
- 'elements (list (make-music 'LineBreakEvent
- 'break-permission 'force)
- (make-music 'PageBreakEvent
- 'break-permission 'force)
- (make-music 'PageTurnEvent
- 'break-permission 'force))))
+ 'page-marker #t
+ 'line-break-permission 'force
+ 'page-break-permission 'force
+ 'page-turn-permission 'force
+ 'elements (list (make-music 'LineBreakEvent
+ 'break-permission 'force)
+ (make-music 'PageBreakEvent
+ 'break-permission 'force)
+ (make-music 'PageTurnEvent
+ 'break-permission 'force))))
parallelMusic =
#(define-void-function (parser location voice-ids music) (list? ly:music?)
C = { e e | f f | }
@end verbatim
")
- (let* ((voices (apply circular-list (make-list (length voice-ids) (list))))
- (current-voices voices)
- (current-sequence (list))
- (original music)
- (wrapper #f))
- ;;
- ;; utilities
- (define (push-music m)
- "Push the music expression into the current sequence"
- (set! current-sequence (cons m current-sequence)))
- (define (change-voice)
- "Stores the previously built sequence into the current voice and
- change to the following voice."
- (list-set! current-voices 0 (cons (make-music 'SequentialMusic
- 'elements (reverse! current-sequence))
- (car current-voices)))
- (set! current-sequence (list))
- (set! current-voices (cdr current-voices)))
- (define (bar-check? m)
- "Checks whether m is a bar check."
- (eq? (ly:music-property m 'name) 'BarCheck))
- (define (music-origin music)
- "Recursively search an origin location stored in music."
- (cond ((null? music) #f)
- ((not (null? (ly:music-property music 'origin)))
- (ly:music-property music 'origin))
- (else (or (music-origin (ly:music-property music 'element))
- (let ((origins (remove not (map music-origin
- (ly:music-property music 'elements)))))
- (and (not (null? origins)) (car origins)))))))
- (while (music-is-of-type? music 'music-wrapper-music)
- (set! wrapper music)
- (set! music (ly:music-property wrapper 'element)))
- (if wrapper
- (set! (ly:music-property wrapper 'element)
- (make-music 'SequentialMusic
- 'origin location))
- (set! original
- (make-music 'SequentialMusic
- 'origin location)))
- ;;
- ;; first, split the music and fill in voices
- ;; We flatten direct layers of SequentialMusic since they are
- ;; pretty much impossible to avoid when writing music functions.
- (let rec ((music music))
- (for-each (lambda (m)
- (if (eq? (ly:music-property m 'name) 'SequentialMusic)
- (rec m)
- (begin
- (push-music m)
- (if (bar-check? m) (change-voice)))))
- (ly:music-property music 'elements)))
- (if (not (null? current-sequence)) (change-voice))
- ;; un-circularize `voices' and reorder the voices
- (set! voices (map-in-order (lambda (dummy seqs)
- (reverse! seqs))
- voice-ids voices))
- ;;
- ;; set origin location of each sequence in each voice
- ;; for better type error tracking
- (for-each (lambda (voice)
- (for-each (lambda (seq)
- (set! (ly:music-property seq 'origin)
- (or (music-origin seq) location)))
- voice))
- voices)
- ;;
- ;; check sequence length
- (apply for-each (lambda* (#:rest seqs)
- (let ((moment-reference (ly:music-length (car seqs))))
- (for-each (lambda (seq moment)
- (if (not (equal? moment moment-reference))
- (ly:music-warning seq
- "Bars in parallel music don't have the same length")))
- seqs (map-in-order ly:music-length seqs))))
- voices)
- ;;
- ;; bind voice identifiers to the voices
- (for-each (lambda (voice-id voice)
- (ly:parser-define! parser voice-id
- (let ((v (ly:music-deep-copy original)))
- (set! (ly:music-property
- (car (extract-named-music
- v 'SequentialMusic))
- 'elements) voice)
- v)))
- voice-ids voices)))
+ (define voice-count (length voice-ids))
+ (define (bar-check? m)
+ "Checks whether m is a bar check."
+ (eq? (ly:music-property m 'name) 'BarCheck))
+ (define (recurse-and-split-list lst)
+ "Return either a list of music lists split along barchecks, or @code{#f}."
+ (if (any bar-check? lst)
+ (let* ((voices (apply circular-list (make-list voice-count '())))
+ (current-voices voices)
+ (current-sequence '()))
+ ;;
+ ;; utilities
+ (define (push-music m)
+ "Push the music expression into the current sequence"
+ (set! current-sequence (cons m current-sequence)))
+ (define (change-voice)
+ "Store the previously built sequence into the current voice and
+change to the following voice."
+ (set-car! current-voices
+ (cons (reverse! current-sequence)
+ (car current-voices)))
+ (set! current-sequence '())
+ (set! current-voices (cdr current-voices)))
+ (for-each (lambda (m)
+ (let ((split? (recurse-and-split m)))
+ (if split?
+ (for-each
+ (lambda (m)
+ (push-music m)
+ (change-voice))
+ split?)
+ (begin
+ (push-music m)
+ (if (bar-check? m) (change-voice))))))
+ lst)
+ (if (pair? current-sequence) (change-voice))
+ ;; un-circularize `voices' and reorder the voices
+ (set! voices (map reverse!
+ (list-head voices voice-count)))
+ ;; check sequence length
+ (apply for-each (lambda seqs
+ (define (seq-len seq)
+ (reduce ly:moment-add
+ (ly:make-moment 0)
+ (map ly:music-length seq)))
+ (let ((moment-reference (seq-len (car seqs))))
+ (for-each (lambda (seq)
+ (if (not (equal? (seq-len seq)
+ moment-reference))
+ (ly:music-warning
+ (if (pair? seq)
+ (last seq)
+ (caar seqs))
+ (_ "Bars in parallel music don't have the same length"))))
+ seqs)))
+ voices)
+ (map concatenate! voices))
+ (let ((deeper (map recurse-and-split lst)))
+ (and (any pair? deeper)
+ (apply zip (map
+ (lambda (m split)
+ (or split
+ (ly:music-deep-copy (make-list voice-count m))))
+ lst deeper))))))
+ (define (recurse-and-split music)
+ "This returns either a list of music split along barchecks, or
+@code{#f}."
+ (let* ((elt (ly:music-property music 'element))
+ (elts (ly:music-property music 'elements))
+ (split-elt (and (ly:music? elt) (recurse-and-split elt)))
+ (split-elts (and (pair? elts) (recurse-and-split-list elts))))
+ (and (or split-elt split-elts)
+ (map
+ (lambda (e es)
+ (apply music-clone music
+ (append
+ ;; reassigning the origin of the parent only
+ ;; makes sense if the first expression in the
+ ;; result is from a distributed origin
+ (let ((origin
+ (if (ly:music? elt)
+ (and (ly:music? e) (ly:music-property e 'origin #f))
+ (and (pair? es) (ly:music-property (car es) 'origin #f)))))
+ (if origin (list 'origin origin) '()))
+ (if (ly:music? e) (list 'element e) '())
+ (if (pair? es) (list 'elements es) '()))))
+ (or split-elt (circular-list #f))
+ (or split-elts (circular-list #f))))))
+ (let ((voices (recurse-and-split music)))
+ (if voices
+ ;;
+ ;; bind voice identifiers to the voices
+ (for-each (lambda (voice-id voice)
+ (ly:parser-define! parser voice-id voice))
+ voice-ids voices)
+ (ly:music-warning music
+ (_ "ignoring parallel music without barchecks")))))
parenthesize =
#(define-music-function (parser loc arg) (ly:music?)
;; arg is an EventChord -> set the parenthesize property
;; on all child notes and rests
(for-each
- (lambda (ev)
- (if (or (memq 'note-event (ly:music-property ev 'types))
- (memq 'rest-event (ly:music-property ev 'types)))
- (set! (ly:music-property ev 'parenthesize) #t)))
- (ly:music-property arg 'elements))
+ (lambda (ev)
+ (if (or (memq 'note-event (ly:music-property ev 'types))
+ (memq 'rest-event (ly:music-property ev 'types)))
+ (set! (ly:music-property ev 'parenthesize) #t)))
+ (ly:music-property arg 'elements))
;; No chord, simply set property for this expression:
(set! (ly:music-property arg 'parenthesize) #t))
arg)
partcombine =
-#(define-music-function (parser location part1 part2) (ly:music? ly:music?)
- (_i "Take the music in @var{part1} and @var{part2} and typeset so
-that they share a staff.")
+#(define-music-function (parser location chord-range part1 part2)
+ ((number-pair? '(0 . 8)) ly:music? ly:music?)
+ (_i "Take the music in @var{part1} and @var{part2} and return
+a music expression containing simultaneous voices, where @var{part1}
+and @var{part2} are combined into one voice where appropriate.
+Optional @var{chord-range} sets the distance in steps between notes
+that may be combined into a chord or unison.")
(make-part-combine-music parser
- (list part1 part2) #f))
+ (list part1 part2) #f chord-range))
partcombineUp =
-#(define-music-function (parser location part1 part2) (ly:music? ly:music?)
+#(define-music-function (parser location chord-range part1 part2)
+ ((number-pair? '(0 . 8)) ly:music? ly:music?)
(_i "Take the music in @var{part1} and @var{part2} and typeset so
that they share a staff with stems directed upward.")
(make-part-combine-music parser
- (list part1 part2) UP))
+ (list part1 part2) UP chord-range))
partcombineDown =
-#(define-music-function (parser location part1 part2) (ly:music? ly:music?)
+#(define-music-function (parser location chord-range part1 part2)
+ ((number-pair? '(0 . 8)) ly:music? ly:music?)
(_i "Take the music in @var{part1} and @var{part2} and typeset so
that they share a staff with stems directed downward.")
(make-part-combine-music parser
- (list part1 part2) DOWN))
+ (list part1 part2) DOWN chord-range))
partcombineForce =
-#(define-music-function (location parser type once) (symbol-or-boolean? boolean?)
+#(define-music-function (location parser type once) (boolean-or-symbol? boolean?)
(_i "Override the part-combiner.")
(make-music 'EventChord
- 'elements (list (make-music 'PartCombineForceEvent
- 'forced-type type
- 'once once))))
+ 'elements (list (make-music 'PartCombineForceEvent
+ 'forced-type type
+ 'once once))))
partcombineApart = \partcombineForce #'apart ##f
partcombineApartOnce = \partcombineForce #'apart ##t
partcombineChords = \partcombineForce #'chords ##f
;; ensure \partial still works if the Timing_translator is moved
(descend-to-context
(context-spec-music (make-music 'PartialSet
- 'origin location
- 'partial-duration dur)
- 'Timing)
+ 'origin location
+ 'duration dur)
+ 'Timing)
'Score))
pitchedTrill =
(_i "Print a trill with @var{main-note} as the main note of the trill and
print @var{secondary-note} as a stemless note head in parentheses.")
(let* ((get-notes (lambda (ev-chord)
- (extract-named-music ev-chord 'NoteEvent)))
+ (extract-named-music ev-chord 'NoteEvent)))
(sec-note-events (get-notes secondary-note))
(trill-events (extract-named-music main-note 'TrillSpanEvent)))
(if (pair? sec-note-events)
(_i "Add @var{more} to the front of @code{elements} of all music
expressions in @var{music} that are tagged with @var{tag}.")
(music-map (lambda (m)
- (if (memq tag (ly:music-property m 'tags))
- (set! (ly:music-property m 'elements)
- (cons more (ly:music-property m 'elements))))
- m)
- music))
+ (if (memq tag (ly:music-property m 'tags))
+ (set! (ly:music-property m 'elements)
+ (cons more (ly:music-property m 'elements))))
+ m)
+ music))
quoteDuring =
#(define-music-function (parser location what main-music) (string? ly:music?)
relative =
#(define-music-function (parser location pitch music)
- ((ly:pitch? (ly:make-pitch 0 0 0)) ly:music?)
- (_i "Make @var{music} relative to @var{pitch} (default @code{c'}).")
- (ly:make-music-relative! music pitch)
+ ((ly:pitch?) ly:music?)
+ (_i "Make @var{music} relative to @var{pitch}. If @var{pitch} is
+omitted, the first note in @var{music} is given in absolute pitch.")
+ ;; When \relative has no clear decision (can only happen with
+ ;; scales with an even number of steps), it goes down (see
+ ;; pitch.cc). The following formula puts out f for both the normal
+ ;; 7-step scale as well as for a "shortened" scale missing the
+ ;; final b. In either case, a first note of c will end up as c,
+ ;; namely pitch (-1, 0, 0).
+ (ly:make-music-relative! music
+ (or pitch
+ (ly:make-pitch
+ -1
+ (quotient
+ ;; size of current scale:
+ (ly:pitch-steps (ly:make-pitch 1 0))
+ 2))))
(make-music 'RelativeOctaveMusic
- 'element music))
+ 'element music))
removeWithTag =
-#(define-music-function (parser location tag music) (symbol? ly:music?)
- (_i "Remove elements of @var{music} that are tagged with @var{tag}.")
+#(define-music-function (parser location tags music)
+ (symbol-list-or-symbol? ly:music?)
+ (_i "Remove elements of @var{music} that are tagged with one of the
+tags in @var{tags}. @var{tags} may be either a single symbol or a list
+of symbols.")
(music-filter
- (lambda (m)
- (let* ((tags (ly:music-property m 'tags))
- (res (memq tag tags)))
- (not res)))
+ (tags-remove-predicate tags)
music))
resetRelativeOctave =
(revert-time-signature-setting time-signature))
rightHandFinger =
-#(define-event-function (parser location finger) (number-or-string?)
+#(define-event-function (parser location finger) (number-or-markup?)
(_i "Apply @var{finger} as a fingering indication.")
(make-music
'StrokeFingerEvent
- 'origin location
- (if (string? finger) 'text 'digit)
+ (if (number? finger) 'digit 'text)
finger))
scaleDurations =
(fraction? ly:music?)
(_i "Multiply the duration of events in @var{music} by @var{fraction}.")
(ly:music-compress music
- (ly:make-moment (car fraction) (cdr fraction))))
+ (ly:make-moment (car fraction) (cdr fraction))))
settingsFrom =
#(define-scheme-function (parser location ctx music)
(let ((mods (ly:make-context-mod)))
(define (musicop m)
(if (music-is-of-type? m 'layout-instruction-event)
- (ly:add-context-mod
- mods
- (case (ly:music-property m 'name)
- ((PropertySet)
- (list 'assign
- (ly:music-property m 'symbol)
- (ly:music-property m 'value)))
- ((PropertyUnset)
- (list 'unset
- (ly:music-property m 'symbol)))
- ((OverrideProperty)
- (cons* 'push
- (ly:music-property m 'symbol)
- (ly:music-property m 'grob-value)
+ (ly:add-context-mod
+ mods
+ (case (ly:music-property m 'name)
+ ((PropertySet)
+ (list 'assign
+ (ly:music-property m 'symbol)
+ (ly:music-property m 'value)))
+ ((PropertyUnset)
+ (list 'unset
+ (ly:music-property m 'symbol)))
+ ((OverrideProperty)
+ (cons* 'push
+ (ly:music-property m 'symbol)
+ (ly:music-property m 'grob-value)
(cond
((ly:music-property m 'grob-property #f) => list)
(else
(ly:music-property m 'grob-property-path)))))
- ((RevertProperty)
- (cons* 'pop
- (ly:music-property m 'symbol)
+ ((RevertProperty)
+ (cons* 'pop
+ (ly:music-property m 'symbol)
(cond
((ly:music-property m 'grob-property #f) => list)
(else
(ly:music-property m 'grob-property-path)))))))
- (case (ly:music-property m 'name)
- ((ApplyContext)
- (ly:add-context-mod mods
- (list 'apply
- (ly:music-property m 'procedure))))
- ((ContextSpeccedMusic)
- (if (or (not ctx)
- (eq? ctx (ly:music-property m 'context-type)))
- (musicop (ly:music-property m 'element))))
- (else
- (let ((callback (ly:music-property m 'elements-callback)))
- (if (procedure? callback)
- (for-each musicop (callback m))))))))
+ (case (ly:music-property m 'name)
+ ((ApplyContext)
+ (ly:add-context-mod mods
+ (list 'apply
+ (ly:music-property m 'procedure))))
+ ((ContextSpeccedMusic)
+ (if (or (not ctx)
+ (eq? ctx (ly:music-property m 'context-type)))
+ (musicop (ly:music-property m 'element))))
+ (else
+ (let ((callback (ly:music-property m 'elements-callback)))
+ (if (procedure? callback)
+ (for-each musicop (callback m))))))))
(musicop music)
mods))
(if (>= total-found 2)
(helper siblings offsets)
(offset-control-points (car offsets)))))
- (if (ly:music? item)
- #{
- \tweak #'control-points #shape-curve $item
- #}
- #{
- \once \override $item #'control-points = #shape-curve
- #}))
+ #{ \once \tweak control-points #shape-curve #item #})
shiftDurations =
#(define-music-function (parser location dur dots arg)
(_i "Change the duration of @var{arg} by adding @var{dur} to the
@code{durlog} of @var{arg} and @var{dots} to the @code{dots} of @var{arg}.")
- (music-map
- (lambda (x)
- (shift-one-duration-log x dur dots)) arg))
+ (shift-duration-log arg dur dots))
single =
#(define-music-function (parser location overrides music)
(ly:music? ly:music?)
(_i "Convert @var{overrides} to tweaks and apply them to @var{music}.
-This does not convert @code{\\revert}, @code{\\set} or @code{\\unset}
-and ignores nested overrides.")
+This does not convert @code{\\revert}, @code{\\set} or @code{\\unset}.")
(set! (ly:music-property music 'tweaks)
(fold-some-music
(lambda (m) (eq? (ly:music-property m 'name)
((ly:music-property m 'grob-property #f) => list)
(else
(ly:music-property m 'grob-property-path)))))
- (if (pair? (cdr p))
- tweaks ;ignore nested properties
- (acons (cons (ly:music-property m 'symbol) ;grob name
- (car p)) ;grob property
- (ly:music-property m 'grob-value)
- tweaks))))
+ (acons (cons (ly:music-property m 'symbol) ;grob name
+ (if (pair? (cdr p))
+ p ;grob property path
+ (car p))) ;grob property
+ (ly:music-property m 'grob-value)
+ tweaks)))
(ly:music-property music 'tweaks)
overrides))
music)
#(define-music-function (parser location dur) (ly:duration?)
(_i "Skip forward by @var{dur}.")
(make-music 'SkipMusic
- 'duration dur))
+ 'duration dur))
slashedGrace =
(_i "Set the system stretch, by reading the 'system-stretch property of
the `parameters' assoc list.")
#{
- \overrideProperty Score.NonMusicalPaperColumn
- #'line-break-system-details
+ \overrideProperty Score.NonMusicalPaperColumn.line-break-system-details
#(list (cons 'alignment-extra-space (cdr (assoc 'system-stretch parameters)))
- (cons 'system-Y-extent (cdr (assoc 'system-Y-extent parameters))))
+ (cons 'system-Y-extent (cdr (assoc 'system-Y-extent parameters))))
#})
styledNoteHeads =
(style-note-heads heads style music))
tag =
-#(define-music-function (parser location tag arg) (symbol? ly:music?)
-
- (_i "Add @var{tag} to the @code{tags} property of @var{arg}.")
+#(define-music-function (parser location tags music) (symbol-list-or-symbol? ly:music?)
+ (_i "Tag the following @var{music} with @var{tags} and return the
+result, by adding the single symbol or symbol list @var{tags} to the
+@code{tags} property of @var{music}.")
(set!
- (ly:music-property arg 'tags)
- (cons tag
- (ly:music-property arg 'tags)))
- arg)
+ (ly:music-property music 'tags)
+ ((if (symbol? tags) cons append)
+ tags
+ (ly:music-property music 'tags)))
+ music)
+
+tagGroup =
+#(define-void-function (parser location tags) (symbol-list?)
+ (_i "Define a tag group comprising the symbols in the symbol list
+@var{tags}. Tag groups must not overlap.")
+ (let ((err (define-tag-group tags)))
+ (if err (ly:parser-error parser err location))))
temporary =
#(define-music-function (parser location music)
(fraction? ly:music?)
(_i "Scale @var{music} in time by @var{fraction}.")
(make-music 'TimeScaledMusic
- 'element (ly:music-compress music (ly:make-moment (car fraction) (cdr fraction)))
- 'numerator (car fraction)
- 'denominator (cdr fraction)))
+ 'element (ly:music-compress music (ly:make-moment (car fraction) (cdr fraction)))
+ 'numerator (car fraction)
+ 'denominator (cdr fraction)))
transpose =
#(define-music-function
(_i "Insert notes from the part @var{what} into a voice called @code{cue},
using the transposition defined by @var{pitch}. This happens
-simultaneously with @var{main-music}, which is usually a rest. The
+simultaneously with @var{main-music}, which is usually a rest. The
argument @var{dir} determines whether the cue notes should be notated
as a first or second voice.")
(make-music 'QuoteMusic
- 'element main-music
- 'quoted-context-type 'Voice
- 'quoted-context-id "cue"
- 'quoted-music-name what
- 'quoted-voice-direction dir
- 'quoted-transposition pitch))
+ 'element main-music
+ 'quoted-context-type 'CueVoice
+ 'quoted-context-id "cue"
+ 'quoted-music-name what
+ 'quoted-voice-direction dir
+ ;; following is inverse of instrumentTransposition for
+ ;; historical reasons
+ 'quoted-transposition pitch))
transposition =
#(define-music-function (parser location pitch) (ly:pitch?)
(_i "Set instrument transposition")
(context-spec-music
- (make-property-set 'instrumentTransposition
- (ly:pitch-negate pitch))
+ (make-property-set 'instrumentTransposition pitch)
'Staff))
+tuplet =
+#(define-music-function (parser location ratio tuplet-span music)
+ (fraction? (ly:duration? '()) ly:music?)
+ (_i "Scale the given @var{music} to tuplets. @var{ratio} is a
+fraction that specifies how many notes are played in place of the
+nominal value: it will be @samp{3/2} for triplets, namely three notes
+being played in place of two. If the optional duration
+@var{tuplet-span} is specified, it is used instead of
+@code{tupletSpannerDuration} for grouping the tuplets.
+For example,
+@example
+\\tuplet 3/2 4 @{ c8 c c c c c @}
+@end example
+will result in two groups of three tuplets, each group lasting for a
+quarter note.")
+ (make-music 'TimeScaledMusic
+ 'element (ly:music-compress
+ music
+ (ly:make-moment (cdr ratio) (car ratio)))
+ 'numerator (cdr ratio)
+ 'denominator (car ratio)
+ 'duration tuplet-span))
+
+tupletSpan =
+#(define-music-function (parser location tuplet-span)
+ ((ly:duration?))
+ (_i "Set @code{tupletSpannerDuration}, the length into which
+@code{\\tuplet} without an explicit @samp{tuplet-span} argument of its
+own will group its tuplets, to the duration @var{tuplet-span}. To
+revert to the default of not subdividing the contents of a @code{\\tuplet}
+command without explicit @samp{tuplet-span}, use
+@example
+\\tupletSpan \\default
+@end example
+")
+ (if tuplet-span
+ #{ \set tupletSpannerDuration = #(ly:duration-length tuplet-span) #}
+ #{ \unset tupletSpannerDuration #}))
+
tweak =
-#(define-music-function (parser location prop value music)
- (symbol-list-or-symbol? scheme? ly:music?)
- (_i "Add a tweak to the following @var{music}.
-Layout objects created by @var{music} get their property @var{prop}
+#(define-music-function (parser location prop value item)
+ (symbol-list-or-symbol? scheme? symbol-list-or-music?)
+ (_i "Add a tweak to the following @var{item}, usually music.
+Layout objects created by @var{item} get their property @var{prop}
set to @var{value}. If @var{prop} has the form @samp{Grob.property}, like with
@example
\\tweak Accidental.color #red cis'
@end example
an indirectly created grob (@samp{Accidental} is caused by
@samp{NoteHead}) can be tweaked; otherwise only directly created grobs
-are affected.")
- (if (symbol? prop)
- (set! prop (list prop)))
- (if (and (<= 1 (length prop) 2)
- (object-property (last prop) 'backend-type?))
- (set! (ly:music-property music 'tweaks)
- (acons (apply cons* prop)
- value
- (ly:music-property music 'tweaks)))
- (ly:input-warning location (_ "cannot find property type-check for ~a") prop))
- music)
+are affected.
+
+As a special case, @var{item} may be a symbol list specifying a grob
+path, in which case @code{\\override} is called on it instead of
+creating tweaked music. This is mainly useful when using
+@code{\\tweak} as as a component for building other functions.
+
+If this use case would call for @code{\\once \\override} rather than a
+plain @code{\\override}, writing @code{\\once \\tweak @dots{}} can be
+convenient.
+
+@var{prop} can contain additional elements in which case a nested
+property (inside of an alist) is tweaked.")
+ (if (ly:music? item)
+ (let ((p (check-grob-path prop parser location
+ #:start 1
+ #:default #t
+ #:min 2)))
+ (if p
+ (set! (ly:music-property item 'tweaks)
+ (acons (cond ((pair? (cddr p)) p)
+ ((symbol? (car p))
+ (cons (car p) (cadr p)))
+ (else (cadr p)))
+ value
+ (ly:music-property item 'tweaks))))
+ item)
+ ;; We could just throw this at \override and let it sort this
+ ;; out on its own, but this way we should get better error
+ ;; diagnostics.
+ (let ((p (check-grob-path
+ (append item (if (symbol? prop) (list prop) prop))
+ parser location
+ #:default 'Bottom #:min 3)))
+ (if p
+ #{ \override #p = #value #}
+ (make-music 'Music)))))
undo =
#(define-music-function (parser location music)