%%%% This file is part of LilyPond, the GNU music typesetter.
%%%%
-%%%% Copyright (C) 2003--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+%%%% Copyright (C) 2003--2012 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.14.0"
+\version "2.16.0"
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
(_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?)
'elements (list (make-music 'PageTurnEvent
'break-permission 'allow))))
+alterBroken =
+#(define-music-function (parser location name property arg)
+ (string? scheme? list?)
+ (_i "Override @var{property} for pieces of broken spanner @var{name} with
+values @var{arg}.")
+ (let* ((name (string-delete name char-set:blank)) ; remove any spaces
+ (name-components (string-split name #\.))
+ (context-name "Bottom")
+ (grob-name #f))
+
+ (if (> 2 (length name-components))
+ (set! grob-name (car name-components))
+ (begin
+ (set! grob-name (cadr name-components))
+ (set! context-name (car name-components))))
+
+ ;; only apply override if grob is a spanner
+ (let ((description
+ (assoc-get (string->symbol grob-name) all-grob-descriptions)))
+ (if (and description
+ (member 'spanner-interface
+ (assoc-get 'interfaces
+ (assoc-get 'meta description))))
+ #{
+ \override $context-name . $grob-name $property =
+ #(value-for-spanner-piece arg)
+ #}
+ (begin
+ (ly:input-warning location (_ "not a spanner name, `~a'") grob-name)
+ (make-music 'SequentialMusic 'void #t))))))
+
appendToTag =
#(define-music-function (parser location tag more music)
(symbol? ly:music? ly:music?)
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))
bookOutputName =
#(define-void-function (parser location newfilename) (string?)
(_i "Direct output for the current book block to @var{newfilename}.")
- (set! book-filename newfilename))
+ (set! (paper-variable parser #f 'output-filename) newfilename))
bookOutputSuffix =
#(define-void-function (parser location newsuffix) (string?)
(_i "Set the output filename suffix for the current book block to
@var{newsuffix}.")
- (set! book-output-suffix newsuffix))
+ (set! (paper-variable parser #f 'output-suffix) newsuffix))
%% \breathe is defined as a music function rather than an event identifier to
%% ensure it gets useful input location information: as an event identifier,
(ly:moment-main-denominator mlen))))
#{
\once \override Staff.TimeSignature #'stencil = #(lambda (grob)
- (grob-interpret-markup grob (format-compound-time $args)))
+ (grob-interpret-markup grob (format-compound-time args)))
\set Timing.timeSignatureFraction = $timesig
\set Timing.baseMoment = $beat
\set Timing.beatStructure = $beatGrouping
\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
+#})
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.")
#(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 (eq? (ly:music-property music 'name) 'EventChord)
- (let* ((elts (ly:music-property music 'elements))
- (start-span-evs (filter (lambda (ev)
- (and (music-has-type ev 'span-event)
- (equal? (ly:music-property ev 'span-direction)
- START)))
- elts))
- (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?)
+ (_i "Compatibility function wrapping @code{EventChord} around
+isolated rhythmic events occuring since version 2.15.28, after
+expanding repeat chords @samp{q}.")
+ (event-chord-wrap! music parser))
featherDurations=
#(define-music-function (parser location factor argument) (ly:moment? ly:music?)
(let ((orig-duration (ly:music-length argument))
(multiplier (ly:make-moment 1 1)))
- (music-map
+ (for-each
(lambda (mus)
- (if (and (eq? (ly:music-property mus 'name) 'EventChord)
- (< 0 (ly:moment-main-denominator (ly:music-length mus))))
+ (if (< 0 (ly:moment-main-denominator (ly:music-length mus)))
(begin
(ly:music-compress mus multiplier)
- (set! multiplier (ly:moment-mul factor multiplier))))
- mus)
- argument)
-
+ (set! multiplier (ly:moment-mul factor multiplier)))))
+ (extract-named-music argument '(EventChord NoteEvent RestEvent SkipEvent)))
(ly:music-compress
argument
(ly:moment-div orig-duration (ly:music-length argument)))
argument))
-footnoteGrob =
-#(define-music-function (parser location grob-name offset text footnote)
- (symbol? number-pair? markup? markup?)
- (_i "Attach @var{text} to @var{grob-name} at offset @var{offset},
-with @var{text} referring to @var{footnote} (use like @code{\\once})")
- (make-music 'FootnoteEvent
- 'automatically-numbered #f
- 'symbol grob-name
- 'X-offset (car offset)
- 'Y-offset (cdr offset)
- 'text text
- 'footnote-text footnote))
-
-autoFootnoteGrob =
-#(define-music-function (parser location grob-name offset footnote)
- (symbol? number-pair? markup?)
- (_i "Footnote @var{grob-name} with the text in @var{footnote}
-allowing for the footnote to be automatically numbered such that
-the number appears at @var{offset}. Note that, for this to take effect,
-auto-numbering must be turned on in the paper block. Otherwise, no
-number will appear. Use like @code{\\once})")
- (make-music 'FootnoteEvent
- 'automatically-numbered #t
- 'symbol grob-name
- 'X-offset (car offset)
- 'Y-offset (cdr offset)
- 'text (make-null-markup)
- 'footnote-text footnote))
-
-
footnote =
-#(define-music-function (parser location offset text footnote)
- (number-pair? markup? markup?)
- (_i "Attach @var{text} at @var{offset} with @var{text} referring
-to @var{footnote} (use like @code{\\tweak})")
- (make-music 'FootnoteEvent
- 'automatically-numbered #f
- 'X-offset (car offset)
- 'Y-offset (cdr offset)
- 'text text
- 'footnote-text footnote))
-
-autoFootnote =
-#(define-music-function (parser location offset footnote)
- (number-pair? markup?)
- (_i "Footnote the item after which this comes with the text in
-@var{footnote} allowing for the footnote to be automatically numbered
-such that the number appears at @var{offset}. Note that, for this to
-take effect, auto-numbering must be turned on in the paper block.
-Otherwise, no number will appear. Use like @code{\\tweak})")
- (make-music 'FootnoteEvent
- 'automatically-numbered #t
+#(define-music-function (parser location mark offset grob-name footnote music)
+ ((markup?) number-pair? (symbol?) markup? (ly:music?))
+ (_i "Make the markup @var{footnote} a footnote on @var{music}. 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 a symbol
+@var{grob-name} is specified, then grobs of that type will be marked
+if they have @var{music} as their ultimate cause; by default all grobs
+having @var{music} as their @emph{direct} cause will be marked,
+similar to the way @code{\\tweak} works.
+
+If @var{music} is given as @code{\\default}, a footnote event
+affecting @emph{all} grobs matching @var{grob-name} at a given time
+step is generated. This may be required for creating footnotes on
+time signatures, clefs, and other items not cooperating with
+@code{\\tweak}.
+
+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)
- 'text (make-null-markup)
- 'footnote-text footnote))
+ 'automatically-numbered (not mark)
+ 'text (or mark (make-null-markup))
+ 'footnote-text footnote
+ 'symbol (or grob-name '()))))
+ (cond (music
+ (set! (ly:music-property music 'tweaks)
+ (acons (if grob-name
+ (cons grob-name 'footnote-music)
+ 'footnote-music)
+ mus
+ (ly:music-property music 'tweaks)))
+ music)
+ (grob-name mus)
+ (else
+ (ly:input-warning location
+ (_ "\\footnote requires music or grob-name"))
+ (make-music 'Music)))))
grace =
#(def-grace-function startGraceMusic stopGraceMusic
(_i "Insert @var{music} as grace notes."))
+grobdescriptions =
+#(define-scheme-function (parser location descriptions) (list?)
+ (_i "Create a context modification from @var{descriptions}, a list
+in the format of @code{all-grob-descriptions}.")
+ (ly:make-context-mod
+ (map (lambda (p)
+ (list 'assign (car p) (list (cdr p))))
+ descriptions)))
+
harmonicByFret = #(define-music-function (parser location fret music) (number? ly:music?)
- (_i "Convert @var{music} into harmonics; the resulting notes resemble
-harmonics played on a fretted instrument by touching the strings above @var{fret}.")
- (let* ((fret (number->string fret))
- (pitch (fret->pitch fret)))
- (make-sequential-music
- (list
- #{
- \override TabNoteHead #'stencil = #(tab-note-head::print-custom-fret-label $fret)
- #}
- (make-harmonic
- (calc-harmonic-pitch pitch music))
- #{
- \revert TabNoteHead #'stencil
- #}))))
+ (_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)
+ (ly:note-head::print grob))
+ $(make-harmonic
+ (calc-harmonic-pitch (fret->pitch (number->string fret)) music))
+ \unset harmonicDots
+ \revert TabNoteHead #'stencil
+ \revert NoteHead #'Y-extent
+ \revert NoteHead #'stencil
+ #})
harmonicByRatio = #(define-music-function (parser location ratio music) (number? ly:music?)
- (_i "Convert @var{music} into harmonics; the resulting notes resemble
-harmonics played on a fretted instrument by touching the strings above the point
+ (_i "Convert @var{music} into mixed harmonics; the resulting notes resemble
+harmonics played on a fretted instrument by touching the strings at the point
given through @var{ratio}.")
- (let ((pitch (ratio->pitch ratio))
- (fret (ratio->fret ratio)))
- (make-sequential-music
- (list
- #{
- \override TabNoteHead #'stencil = #(tab-note-head::print-custom-fret-label $fret)
- #}
- (make-harmonic
- (calc-harmonic-pitch pitch music))
- #{
- \revert TabNoteHead #'stencil
- #}))))
+ #{
+ \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
+ (lambda (grob start end)
+ (ly:grob::stencil-height grob)))
+ \override NoteHead #'stencil = #(lambda (grob) (ly:grob-set-property! grob 'style 'harmonic-mixed)
+ (ly:note-head::print grob))
+ $(make-harmonic
+ (calc-harmonic-pitch (ratio->pitch ratio) music))
+ \unset harmonicDots
+ \revert TabNoteHead #'stencil
+ \revert NoteHead #'Y-extent
+ \revert NoteHead #'stencil
+ #})
+
+hide =
+#(define-music-function (parser location item) (string-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 string, 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 (string? item)
+ #{ \override $item #'transparent = ##t #}
+ #{ \tweak #'transparent ##t $item #}))
+
+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
res)))
music))
+key =
+#(define-music-function (parser location tonic pitch-alist)
+ ((ly:pitch? '()) (list? '()))
+ (_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))))
+
killCues =
#(define-music-function (parser location music) (ly:music?)
(_i "Remove cue notes from @var{music}.")
transpose from @var{around} to @var{to}.")
(music-invert around to music))
+mark =
+#(define-music-function
+ (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)))
+
+ (if set
+ (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 "Apply @var{proc} to @var{mus} and all of the music it contains.")
(make-music 'RelativeOctaveCheck
'pitch pitch))
+omit =
+#(define-music-function (parser location item) (string-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 string, 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 (string? 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))
+
ottava =
#(define-music-function (parser location octave) (integer?)
(_i "Set the octavation.")
")
(let* ((voices (apply circular-list (make-list (length voice-ids) (list))))
(current-voices voices)
- (current-sequence (list)))
+ (current-sequence (list))
+ (original music)
+ (wrapper #f))
;;
;; utilities
(define (push-music m)
(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
- (for-each (lambda (m)
- (push-music m)
- (if (bar-check? m) (change-voice)))
- (ly:music-property music 'elements))
+ ;; 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)
;; bind voice identifiers to the voices
(for-each (lambda (voice-id voice)
(ly:parser-define! parser voice-id
- (make-music 'SequentialMusic
- 'origin location
- 'elements voice)))
+ (let ((v (ly:music-deep-copy original)))
+ (set! (ly:music-property
+ (car (extract-named-music
+ v 'SequentialMusic))
+ 'elements) voice)
+ v)))
voice-ids voices)))
parenthesize =
(_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)
- (filter
- (lambda (m) (eq? 'NoteEvent (ly:music-property m 'name)))
- (ly:music-property ev-chord 'elements))))
+ (extract-named-music ev-chord 'NoteEvent)))
(sec-note-events (get-notes secondary-note))
- (trill-events (filter (lambda (m) (music-has-type m 'trill-span-event))
- (ly:music-property main-note 'elements))))
-
+ (trill-events (extract-named-music main-note 'TrillSpanEvent)))
(if (pair? sec-note-events)
(begin
(let* ((trill-pitch (ly:music-property (car sec-note-events) 'pitch))
(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
scaleDurations =
#(define-music-function (parser location fraction music)
- (number-pair? ly:music?)
+ (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))))
+settingsFrom =
+#(define-scheme-function (parser location ctx music)
+ ((symbol?) ly:music?)
+ (_i "Take the layout instruction events from @var{music}, optionally
+restricted to those applying to context type @var{ctx}, and return
+a context modification duplicating their effect.")
+ (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)
+ (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)
+ (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))))))))
+ (musicop music)
+ mods))
+
+shape =
+#(define-music-function (parser location offsets item)
+ (list? string-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)))))
+ (if (ly:music? item)
+ #{
+ \tweak #'control-points #shape-curve $item
+ #}
+ #{
+ \once \override $item #'control-points = #shape-curve
+ #}))
+
shiftDurations =
#(define-music-function (parser location dur dots arg)
(integer? integer? ly:music?)
- (_i "Scale @var{arg} up by a factor of 2^@var{dur}*(2-(1/2)^@var{dots}).")
+ (_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))
+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.")
+ (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)))))
+ (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))))
+ (ly:music-property music 'tweaks)
+ overrides))
+ music)
+
skip =
#(define-music-function (parser location dur) (ly:duration?)
(_i "Skip forward by @var{dur}.")
#{
\overrideProperty #"Score.NonMusicalPaperColumn"
#'line-break-system-details
- #$(list (cons 'alignment-extra-space (cdr (assoc 'system-stretch parameters)))
+ #(list (cons 'alignment-extra-space (cdr (assoc 'system-stretch parameters)))
(cons 'system-Y-extent (cdr (assoc 'system-Y-extent parameters))))
#})
(_i "Set @var{heads} in @var{music} to @var{style}.")
(style-note-heads heads style music))
-
-
-tabChordRepetition =
-#(define-music-function (parser location) ()
- (_i "Include the string information in a chord repetition.")
- (ly:parser-set-repetition-function parser tab-repeat-chord)
- (make-music 'SequentialMusic 'void #t))
-
tag =
#(define-music-function (parser location tag arg) (symbol? ly:music?)
(ly:music-property arg 'tags)))
arg)
+time =
+#(define-music-function (parser location beat-structure fraction)
+ ((number-list? '()) fraction?)
+ (_i "Set @var{fraction} as time signature, with optional
+number list @var{beat-structure} before it.")
+ (make-music 'TimeSignatureMusic
+ 'numerator (car fraction)
+ 'denominator (cdr fraction)
+ 'beat-structure beat-structure))
+
+times =
+#(define-music-function (parser location fraction 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)))
+
transpose =
#(define-music-function
(parser location from to music)
'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)
+#(define-music-function (parser location grob prop value music)
+ ((string?) symbol? scheme? ly:music?)
+ (_i "Add a tweak to the following @var{music}.
+Layout objects created by @var{music} get their property @var{prop}
+set to @var{value}. If @var{grob} is specified, 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 (not (object-property prop 'backend-type?))
(begin
- (ly:input-warning location (_ "cannot find property type-check for ~a") sym)
+ (ly:input-warning location (_ "cannot find property type-check for ~a") prop)
(ly:warning (_ "doing assignment anyway"))))
(set!
- (ly:music-property arg 'tweaks)
- (acons sym val
- (ly:music-property arg 'tweaks)))
- arg)
-
+ (ly:music-property music 'tweaks)
+ (acons (if grob (cons (string->symbol grob) prop) prop)
+ value
+ (ly:music-property music 'tweaks)))
+ 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} are ignored and not converted.")
+ (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)))
+ (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 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?)
Use this if you want to have a scheme expression evaluated
because of its side-effects, but its value ignored."))
-
withMusicProperty =
#(define-music-function (parser location sym val music)
(symbol? scheme? ly:music?)