(define (pitch= pitch1 pitch2)
(and (= (ly:pitch-notename pitch1) (ly:pitch-notename pitch2))
(= (ly:pitch-alteration pitch1) (ly:pitch-alteration pitch2))))
- (let* ((pitches (ly:parser-lookup 'pitchnames))
- (result (rassoc ly-pitch pitches pitch=)))
+ (let* ((result (rassoc ly-pitch pitchnames pitch=)))
(and result (car result))))
(define-public (octave->lily-string pitch)
;;; post events
;;;
-(define (post-event? m)
- (music-is-of-type? m 'post-event))
+(define post-event? (music-type-predicate 'post-event))
(define* (event-direction->lily-string event #:optional (required #t))
(let ((direction (ly:music-property event 'direction)))
(music->lily-string music))
(ly:music-property sim 'elements)))))
-(define-extra-display-method SimultaneousMusic (expr)
- "If `sim' is an \afterGrace expression, return \"\\afterGrace ...\".
-Otherwise, return #f."
- ;; TODO: do something with afterGraceFraction?
- (with-music-match (expr (music 'SimultaneousMusic
- elements (?before-grace
- (music 'SequentialMusic
- elements ((music 'SkipMusic)
- (music 'GraceMusic
- element ?grace))))))
- (format #f "\\afterGrace ~a ~a"
- (music->lily-string ?before-grace)
- (music->lily-string ?grace))))
-
;;;
;;; Chords
;;;
(chord-repeat (ly:music-property chord 'duration)))
(call-with-values
(lambda ()
- (partition (lambda (m) (music-is-of-type? m 'rhythmic-event))
+ (partition (music-type-predicate 'rhythmic-event)
elements))
(lambda (chord-elements other-elements)
(cond ((pair? chord-elements)
(music->lily-string (ly:music-property chord 'element)))
(define-display-method MarkEvent (mark)
- (let ((label (ly:music-property mark 'label)))
- (if (null? label)
- "\\mark \\default"
- (format #f "\\mark ~a" (markup->lily-string label)))))
+ (let ((label (ly:music-property mark 'label #f)))
+ (string-append "\\mark "
+ (if label (value->lily-string label) "\\default"))))
(define-display-method KeyChangeEvent (key)
(let ((pitch-alist (ly:music-property key 'pitch-alist))
(format #f "~s" string)
string))
(markup->lily-string text)))
- (map-in-order (lambda (m) (music->lily-string m))
+ (map-in-order music->lily-string
(ly:music-property lyric 'articulations))))
(define-display-method BreathingEvent (event)
(define-display-method AutoChangeMusic (m)
(format #f "\\autochange ~a"
- (music->lily-string (ly:music-property m 'element))))
+ (music->lily-string
+ (ly:music-property (ly:music-property m 'element) 'element))))
(define-display-method ContextChange (m)
(format #f "\\change ~a = \"~a\""
(parameterize ((*current-context* ctype))
(music->lily-string music)))))
+;; \afterGrace
+(define-extra-display-method ContextSpeccedMusic (expr)
+ "If `sim' is an \afterGrace expression, return \"\\afterGrace ...\".
+Otherwise, return #f."
+ ;; TODO: do something with afterGraceFraction?
+ (with-music-match
+ (expr (music 'ContextSpeccedMusic
+ context-type 'Bottom
+ element
+ (music 'SimultaneousMusic
+ elements (?before-grace
+ (music 'SequentialMusic
+ elements ((music 'SkipMusic)
+ (music 'GraceMusic
+ element ?grace)))))))
+ (format #f "\\afterGrace ~a ~a"
+ (music->lily-string ?before-grace)
+ (music->lily-string ?grace))))
+
+
;; special cases: \figures \lyrics \drums
(define-extra-display-method ContextSpeccedMusic (expr)
(with-music-match (expr (music 'ContextSpeccedMusic
(define-public (value->lily-string arg)
(cond ((ly:music? arg)
(music->lily-string arg))
- ((string? arg)
- (format #f "#~s" arg))
((markup? arg)
(markup->lily-string arg))
((ly:duration? arg)
(if (and (not (null? once)))
"\\once "
"")
- (if (eqv? (*current-context*) 'Bottom)
+ (if (eq? (*current-context*) 'Bottom)
""
- (format #f "~a . " (*current-context*)))
+ (format #f "~a." (*current-context*)))
property
(value->lily-string value)
(new-line->lily-string))))
(define-display-method PropertyUnset (expr)
- (format #f "\\unset ~a~a~a"
- (if (eqv? (*current-context*) 'Bottom)
+ (format #f "~a\\unset ~a~a~a"
+ (if (ly:music-property expr 'once #f) "\\once " "")
+ (if (eq? (*current-context*) 'Bottom)
""
- (format #f "~a . " (*current-context*)))
+ (format #f "~a." (*current-context*)))
(ly:music-property expr 'symbol)
(new-line->lily-string)))
(define-display-method RevertProperty (expr)
(let* ((symbol (ly:music-property expr 'symbol))
(properties (ly:music-property expr 'grob-property-path
- (list (ly:music-property expr 'grob-property)))))
- (format #f "\\revert ~{~a~^.~}~a"
+ (list (ly:music-property expr
+ 'grob-property))))
+ (once (ly:music-property expr 'once #f)))
+ (format #f "~a\\revert ~{~a~^.~}~a"
+ (if once "\\once " "")
(if (eqv? (*current-context*) 'Bottom)
(cons symbol properties)
(cons* (*current-context*) symbol properties))
num den
(new-line->lily-string))
(format #f
- "\\time #'~a ~a/~a~a"
+ ;; This is silly but the latter will also work for #f
+ ;; and other
+ (if (key-list? structure)
+ "\\time ~{~a~^,~} ~a/~a~a"
+ "\\time #'~a ~a/~a~a")
structure num den
(new-line->lily-string)))))
(define-display-method ApplyOutputEvent (applyoutput)
(let ((proc (ly:music-property applyoutput 'procedure))
- (ctx (ly:music-property applyoutput 'context-type)))
- (format #f "\\applyOutput #'~a #~a"
+ (ctx (ly:music-property applyoutput 'context-type))
+ (grob (ly:music-property applyoutput 'symbol)))
+ (format #f "\\applyOutput ~a~@[.~a~] #~a"
ctx
+ (and (symbol? grob) grob)
(or (procedure-name proc)
(with-output-to-string
(lambda ()
;;; \partcombine
(define-display-method PartCombineMusic (expr)
- (format #f "\\partcombine ~{~a ~}"
- (map-in-order (lambda (music)
- (music->lily-string music))
- (ly:music-property expr 'elements))))
-
-(define-extra-display-method PartCombineMusic (expr)
- (with-music-match (expr (music 'PartCombineMusic
- direction ?dir
- elements ((music 'UnrelativableMusic
- element (music 'ContextSpeccedMusic
- context-id "one"
- context-type 'Voice
- element ?sequence1))
- (music 'UnrelativableMusic
- element (music 'ContextSpeccedMusic
- context-id "two"
- context-type 'Voice
- element ?sequence2)))))
- (format #f "\\partcombine~a ~a~a~a"
- (cond ((equal? ?dir UP) "Up")
- ((equal? ?dir DOWN) "Down")
- (else ""))
- (music->lily-string ?sequence1)
- (new-line->lily-string)
- (music->lily-string ?sequence2))))
+ (let ((dir (ly:music-property expr 'direction)))
+ (format #f "\\partcombine~a ~a~a~a"
+ (cond ((equal? dir UP) "Up")
+ ((equal? dir DOWN) "Down")
+ (else ""))
+ (music->lily-string (car (ly:music-property expr 'elements)))
+ (new-line->lily-string)
+ (music->lily-string (cadr (ly:music-property expr 'elements))))))
+
+(define-display-method PartCombinePartMusic (expr)
+ (with-music-match ((ly:music-property expr 'element)
+ (music 'ContextSpeccedMusic element ?part))
+ (format #f "~a" (music->lily-string ?part))))
(define-extra-display-method ContextSpeccedMusic (expr)
"If `expr' is a \\partcombine expression, return \"\\partcombine ...\".
(music 'ContextSpeccedMusic
context-id "null"
context-type 'NullVoice)
- ?pc-music))))
+ ?pc-music
+ ?pc-marks))))
(with-music-match
(?pc-music (music 'PartCombineMusic))
(format #f "~a" (music->lily-string ?pc-music)))))
(*omit-duration* #t))
(music->lily-string (ly:music-property expr 'element)))))
+;; \autochange
+(define-extra-display-method SimultaneousMusic (expr)
+ (with-music-match (expr (music 'SimultaneousMusic
+ elements ((music 'ContextSpeccedMusic
+ context-id "up"
+ context-type 'Staff
+ element ?ac-music)
+ (music 'ContextSpeccedMusic
+ context-id "up"
+ context-type 'Staff)
+ (music 'ContextSpeccedMusic
+ context-id "down"
+ context-type 'Staff))))
+ (with-music-match (?ac-music (music 'AutoChangeMusic))
+ (format #f "~a"
+ (music->lily-string ?ac-music)))))
+
;; \addlyrics
(define-extra-display-method SimultaneousMusic (expr)
(with-music-match (expr (music 'SimultaneousMusic
projects / lilypond.git / blobdiff