X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=ly%2Fmusic-functions-init.ly;h=f3210832186e5b4510fcec365b6c3f2ef4312d3b;hb=01df8ad908c92687d0c352e5ad5f067e52809423;hp=80c3020ac04b7a2574ad72b85e59cad45edffaac;hpb=9a73c67a79a21b889d67f8d28f2c106de830d936;p=lilypond.git diff --git a/ly/music-functions-init.ly b/ly/music-functions-init.ly index 80c3020ac0..f321083218 100644 --- a/ly/music-functions-init.ly +++ b/ly/music-functions-init.ly @@ -18,7 +18,7 @@ %%%% You should have received a copy of the GNU General Public License %%%% along with LilyPond. If not, see . -\version "2.15.18" +\version "2.17.6" %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -36,7 +36,7 @@ acciaccatura = (_i "Create an acciaccatura from the following music expression")) %% keep these two together -"instrument-definitions" = #'() +instrument-definitions = #'() addInstrumentDefinition = #(define-void-function (parser location name lst) (string? list?) @@ -85,6 +85,40 @@ markups), or inside a score.") 'elements (list (make-music 'PageTurnEvent 'break-permission 'allow)))) +alterBroken = +#(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) (symbol? ly:music? ly:music?) @@ -178,7 +212,7 @@ barNumberCheck = cbn n)))))) bendAfter = -#(define-music-function (parser location delta) (real?) +#(define-event-function (parser location delta) (real?) (_i "Create a fall or doit of pitch interval @var{delta}.") (make-music 'BendAfterEvent 'delta-step delta)) @@ -226,20 +260,31 @@ as @code{\\compoundMeter #'((3 2 8))} or shorter (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 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 \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") + #{ + \temporary \override Stem.cross-staff = #cross-staff-connect + \temporary \override Flag.style = #'no-flag + #notes + \revert Stem.cross-staff + \revert Flag.style +#}) cueClef = #(define-music-function (parser location type) (string?) (_i "Set the current cue clef to @var{type}.") (make-cue-clef-set type)) + cueClefUnset = #(define-music-function (parser location) () (_i "Unset the current cue clef.") @@ -293,27 +338,22 @@ endSpanners = #(define-music-function (parser location music) (ly:music?) (_i "Terminate the next spanner prematurely after exactly one note without the need of a specific end spanner.") - (if (memq (ly:music-property music 'name) '(EventChord NoteEvent)) - (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)))) - total) - - (begin - (ly:input-message location (_ "argument endSpanners is not an EventChord: ~a") music) - music))) + (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)))) + total)) eventChords = #(define-music-function (parser location music) (ly:music?) @@ -342,23 +382,35 @@ featherDurations= argument)) footnote = -#(define-music-function (parser location text offset grob-name footnote) - ((markup?) number-pair? (symbol? '()) markup?) - (_i "Attach @var{text} at @var{offset} with @var{text} referring to -@var{footnote}. If @var{text} is given as @code{\\default}, use -autonumbering instead. Note that, for this to take effect, -auto-numbering must be turned on in the paper block. Otherwise, no -number will appear. Footnotes are applied like articulations. If a -symbol @var{grob-name} is specified, all grobs of that kind at the -current time step are affected.") - (make-music - 'FootnoteEvent - 'X-offset (car offset) - 'Y-offset (cdr offset) - 'automatically-numbered (not text) - 'text (or text (make-null-markup)) - 'footnote-text footnote - 'symbol grob-name)) +#(define-music-function (parser location mark offset footnote item) + ((markup?) number-pair? markup? symbol-list-or-music?) + (_i "Make the markup @var{footnote} a footnote on @var{item}. The +footnote is marked with a markup @var{mark} moved by @var{offset} with +respect to the marked music. + +If @var{mark} is not given or specified as @var{\\default}, it is +replaced by an automatically generated sequence number. If @var{item} +is a symbol list of form @samp{Grob} or @samp{Context.Grob}, then +grobs of that type will be marked at the current time step in the +given context (default @code{Bottom}). + +If @var{item} is music, the music will get a footnote attached to a +grob immediately attached to the event, like @var{\\tweak} does. For +attaching a footnote to an @emph{indirectly} caused grob, write +@code{\\single\\footnote}, use @var{item} to specify the grob, and +follow it with the music to annotate. + +Like with @code{\\tweak}, if you use a footnote on a following +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))) + #{ \tweak footnote-music #mus #item #})) grace = #(def-grace-function startGraceMusic stopGraceMusic @@ -378,18 +430,18 @@ harmonicByFret = #(define-music-function (parser location fret music) (number? l 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 + \temporary \override TabNoteHead.stencil = #(tab-note-head::print-custom-fret-label (number->string fret)) + \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 (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?) @@ -398,20 +450,46 @@ harmonics played on a fretted instrument by touching the strings at the point 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 = +#(define-music-function (parser location item) (symbol-list-or-music?) + (_i "Set @var{item}'s @samp{transparent} property to @code{#t}, +making it invisible while still retaining its dimensions. + +If @var{item} is a symbol list of form @code{GrobName} or +@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 #})) + +inStaffSegno = +#(define-music-function (parser location) () + (_i "Put the segno variant 'varsegno' at this position into the staff, +compatible with the repeat command.") + (make-music 'ApplyContext + 'procedure + (lambda (ctx) + (let ((score-ctx (ly:context-find ctx 'Score))) + (if (ly:context? score-ctx) + (let ((old-rc (ly:context-property score-ctx 'repeatCommands '()))) + (if (eq? (memq 'segno-display old-rc) #f) + (ly:context-set-property! score-ctx 'repeatCommands (cons 'segno-display old-rc))))))))) + instrumentSwitch = #(define-music-function (parser location name) (string?) @@ -435,15 +513,21 @@ instrumentSwitch = 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 tag music) + (symbol-list-or-symbol? ly:music?) + (_i "Include only elements of @var{music} that are either untagged +or tagged with one of the tags in @var{tag}. @var{tag} 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))) - (or - (eq? tags '()) - res))) + (if (symbol? tag) + (lambda (m) + (let ((music-tags (ly:music-property m 'tags))) + (or (null? music-tags) + (memq tag music-tags)))) + (lambda (m) + (let ((music-tags (ly:music-property m 'tags))) + (or (null? music-tags) + (any (lambda (t) (memq t music-tags)) tag))))) music)) key = @@ -588,6 +672,19 @@ octaveCheck = (make-music 'RelativeOctaveCheck 'pitch pitch)) +omit = +#(define-music-function (parser location item) (symbol-list-or-music?) + (_i "Set @var{item}'s @samp{stencil} property to @code{#f}, +effectively omitting it without taking up space. + +If @var{item} is a symbol list of form @code{GrobName} or +@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 #})) + once = #(define-music-function (parser location music) (ly:music?) (_i "Set @code{once} to @code{#t} on all layout instruction events in @var{music}.") @@ -621,31 +718,30 @@ of @var{base-moment}, @var{beat-structure}, and @var{beam-exceptions}.") (override-time-signature-setting time-signature setting))) overrideProperty = -#(define-music-function (parser location name property value) - (string? symbol? scheme?) +#(define-music-function (parser location grob-property-path value) + (symbol-list? scheme?) - (_i "Set @var{property} to @var{value} in all grobs named @var{name}. -The @var{name} argument is a string of the form @code{\"Context.GrobName\"} -or @code{\"GrobName\"}.") + (_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)))) - (let ((name-components (string-split name #\.)) - (context-name 'Bottom) - (grob-name #f)) - (if (> 2 (length name-components)) - (set! grob-name (string->symbol (car name-components))) - (begin - (set! grob-name (string->symbol (list-ref name-components 1))) - (set! context-name (string->symbol (list-ref name-components 0))))) - (make-music 'ApplyOutputEvent - 'context-type context-name - 'procedure - (lambda (grob orig-context context) - (if (equal? - (cdr (assoc 'name (ly:grob-property grob 'meta))) - grob-name) - (set! (ly:grob-property grob property) value)))))) @@ -919,13 +1015,19 @@ relative = '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 tag music) + (symbol-list-or-symbol? ly:music?) + (_i "Remove elements of @var{music} that are tagged with one of the +tags in @var{tag}. @var{tag} 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))) + (if (symbol? tag) + (lambda (m) + (not (memq tag (ly:music-property m 'tags)))) + (lambda (m) + (let ((music-tags (ly:music-property m 'tags))) + (or (null? music-tags) + (not (any (lambda (t) (memq t music-tags)) tag)))))) music)) resetRelativeOctave = @@ -952,7 +1054,7 @@ for time signatures of @var{time-signature}.") (revert-time-signature-setting time-signature)) rightHandFinger = -#(define-music-function (parser location finger) (number-or-string?) +#(define-event-function (parser location finger) (number-or-string?) (_i "Apply @var{finger} as a fingering indication.") (make-music @@ -991,11 +1093,17 @@ a context modification duplicating their effect.") (cons* 'push (ly:music-property m 'symbol) (ly:music-property m 'grob-value) - (ly:music-property m 'grob-property-path))) + (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) - (ly:music-property m 'grob-property-path))))) + (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 @@ -1012,6 +1120,49 @@ a context modification duplicating their effect.") (musicop music) mods)) +shape = +#(define-music-function (parser location offsets item) + (list? symbol-list-or-music?) + (_i "Offset control-points of @var{item} by @var{offsets}. The +argument is a list of number pairs or list of such lists. Each +element of a pair represents an offset to one of the coordinates of a +control-point. If @var{item} is a string, the result is +@code{\\once\\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.") + (define (shape-curve grob) + (let* ((orig (ly:grob-original grob)) + (siblings (if (ly:spanner? grob) + (ly:spanner-broken-into orig) '())) + (total-found (length siblings)) + (function (assoc-get 'control-points + (reverse (ly:grob-basic-properties grob)))) + (coords (function grob))) + + (define (offset-control-points offsets) + (if (null? offsets) + coords + (map + (lambda (x y) (coord-translate x y)) + coords offsets))) + + (define (helper sibs offs) + (if (pair? offs) + (if (eq? (car sibs) grob) + (offset-control-points (car offs)) + (helper (cdr sibs) (cdr offs))) + coords)) + + ;; we work with lists of lists + (if (or (null? offsets) + (not (list? (car offsets)))) + (set! offsets (list offsets))) + + (if (>= total-found 2) + (helper siblings offsets) + (offset-control-points (car offsets))))) + #{ \tweak control-points #shape-curve #item #}) + shiftDurations = #(define-music-function (parser location dur dots arg) (integer? integer? ly:music?) @@ -1022,6 +1173,30 @@ shiftDurations = (lambda (x) (shift-one-duration-log x dur dots)) arg)) +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}.") + (set! (ly:music-property music 'tweaks) + (fold-some-music + (lambda (m) (eq? (ly:music-property m 'name) + 'OverrideProperty)) + (lambda (m tweaks) + (let ((p (cond + ((ly:music-property m 'grob-property #f) => list) + (else + (ly:music-property m 'grob-property-path))))) + (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) + skip = #(define-music-function (parser location dur) (ly:duration?) (_i "Skip forward by @var{dur}.") @@ -1039,28 +1214,70 @@ spacingTweaks = (_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)))) #}) styledNoteHeads = #(define-music-function (parser location style heads music) - (symbol? list-or-symbol? ly:music?) + (symbol? symbol-list-or-symbol? ly:music?) (_i "Set @var{heads} in @var{music} to @var{style}.") (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 tag music) (symbol-list-or-symbol? ly:music?) + (_i "Tag the following @var{music} with @var{tag} and return the +result, by adding the single symbol or symbol list @var{tag} 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? tag) cons append) + tag + (ly:music-property music 'tags))) + music) + +temporary = +#(define-music-function (parser location music) + (ly:music?) + (_i "Make any @code{\\override} in @var{music} replace an existing +grob property value only temporarily, restoring the old value when a +corresponding @code{\\revert} is executed. This is achieved by +clearing the @samp{pop-first} property normally set on +@code{\\override}s. + +An @code{\\override}/@/@code{\\revert} sequence created by using +@code{\\temporary} and @code{\\undo} on the same music containing +overrides will cancel out perfectly or cause a@tie{}warning. + +Non-property-related music is ignored, warnings are generated for any +property-changing music that isn't an @code{\\override}.") + (define warned #f) + (for-some-music + (lambda (m) + (and (or (music-is-of-type? m 'layout-instruction-event) + (music-is-of-type? m 'context-specification) + (music-is-of-type? m 'apply-context) + (music-is-of-type? m 'time-signature-music)) + (case (ly:music-property m 'name) + ((OverrideProperty) + (if (ly:music-property m 'pop-first #f) + (set! (ly:music-property m 'pop-first) '())) + (if (ly:music-property m 'once #f) + (set! (ly:music-property m 'once) '())) + #t) + ((ContextSpeccedMusic) + #f) + (else + (if (not warned) + (begin + (ly:input-warning location (_ "Cannot make ~a revertible") + (ly:music-property m 'name)) + (set! warned #t))) + #t)))) + music) + music) time = #(define-music-function (parser location beat-structure fraction) @@ -1119,21 +1336,102 @@ transposition = 'Staff)) tweak = -#(define-music-function (parser location sym val arg) - (symbol? scheme? ly:music?) - (_i "Add @code{sym . val} to the @code{tweaks} property of @var{arg}.") - - (if (equal? (object-property sym 'backend-type?) #f) - (begin - (ly:input-warning location (_ "cannot find property type-check for ~a") sym) - (ly:warning (_ "doing assignment anyway")))) - (set! - (ly:music-property arg 'tweaks) - (acons sym val - (ly:music-property arg 'tweaks))) - arg) - - +#(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. + +As a special case, @var{item} may be a symbol list specifying a grob +path, in which case @code{\\once\\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. + +@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 ((a (check-grob-path item parser location + #:default 'Bottom #:min 2 #:max 2)) + (b (check-grob-path prop parser location + #:start 2))) + (if (and a b) + #{ \once\override #(append a b) = #value #} + (make-music 'Music))))) + +undo = +#(define-music-function (parser location music) + (ly:music?) + (_i "Convert @code{\\override} and @code{\\set} in @var{music} to +@code{\\revert} and @code{\\unset}, respectively. Any reverts and +unsets already in @var{music} cause a warning. Non-property-related music is ignored.") + (define warned #f) + (let loop + ((music music)) + (let + ((lst + (fold-some-music + (lambda (m) (or (music-is-of-type? m 'layout-instruction-event) + (music-is-of-type? m 'context-specification) + (music-is-of-type? m 'apply-context) + (music-is-of-type? m 'time-signature-music))) + (lambda (m overrides) + (case (ly:music-property m 'name) + ((OverrideProperty) + (cons + (make-music 'RevertProperty + 'symbol (ly:music-property m 'symbol) + 'grob-property-path + (cond + ((ly:music-property m 'grob-property #f) => list) + (else + (ly:music-property m 'grob-property-path)))) + overrides)) + ((PropertySet) + (cons + (make-music 'PropertyUnset + 'symbol (ly:music-property m 'symbol)) + overrides)) + ((ContextSpeccedMusic) + (cons + (make-music 'ContextSpeccedMusic + 'element (loop (ly:music-property m 'element)) + 'context-type (ly:music-property m 'context-type)) + overrides)) + (else + (if (not warned) + (begin + (ly:input-warning location (_ "Cannot revert ~a") + (ly:music-property m 'name)) + (set! warned #t))) + overrides))) + '() + music))) + (cond + ((null? lst) (make-music 'Music)) + ((null? (cdr lst)) (car lst)) + (else (make-sequential-music lst)))))) unfoldRepeats = #(define-music-function (parser location music) (ly:music?)