;;; define-music-display-methods.scm -- data for displaying music
;;; expressions using LilyPond notation.
;;;
-;;; (c) 2005--2009 Nicolas Sceaux <nicolas.sceaux@free.fr>
+;;; Copyright (C) 2005--2010 Nicolas Sceaux <nicolas.sceaux@free.fr>
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(if (and (car alist) (test item (cdar alist)))
(set! result (car alist)))))
-(define (note-name->lily-string ly-pitch parser)
+(define-public (note-name->lily-string ly-pitch parser)
;; here we define a custom pitch= function, since we do not want to
;; test whether octaves are also equal. (otherwise, we would be using equal?)
(define (pitch= pitch1 pitch2)
(car result)
#f)))
-(define (octave->lily-string pitch)
+(define-public (octave->lily-string pitch)
(let ((octave (ly:pitch-octave pitch)))
(cond ((>= octave 0)
(make-string (1+ octave) #\'))
;;;
;;; durations
;;;
-(define* (duration->lily-string ly-duration #:key (prev-duration (*previous-duration*))
+(define*-public (duration->lily-string ly-duration #:key (prev-duration (*previous-duration*))
(force-duration (*force-duration*))
(time-factor-numerator (*time-factor-numerator*))
(time-factor-denominator (*time-factor-denominator*)))
'ArticulationEvent
'BeamEvent
'BeamForbidEvent
+ 'BendAfterEvent
'CrescendoEvent
'DecrescendoEvent
+ 'EpisemaEvent
'ExtenderEvent
'FingeringEvent
'GlissandoEvent
(define-post-event-display-method MultiMeasureTextEvent (event parser) #t
(markup->lily-string (ly:music-property event 'text)))
+(define-post-event-display-method BendAfterEvent (event parser) #t
+ (format #f "\\bendAfter #~a" (ly:music-property event 'delta-step)))
+
(define-post-event-display-method HarmonicEvent (event parser) #f "\\harmonic")
(define-post-event-display-method GlissandoEvent (event parser) #t "\\glissando")
(define-post-event-display-method ArpeggioEvent (event parser) #t "\\arpeggio")
(define-span-event-display-method SlurEvent (event parser) #f "(" ")")
(define-span-event-display-method CrescendoEvent (event parser) #f "\\<" "\\!")
(define-span-event-display-method DecrescendoEvent (event parser) #f "\\>" "\\!")
+(define-span-event-display-method EpisemaEvent (event parser) #f "\\episemInitium" "\\episemFinis")
(define-span-event-display-method PhrasingSlurEvent (event parser) #f "\\(" "\\)")
(define-span-event-display-method SustainEvent (event parser) #f "\\sustainOn" "\\sustainOff")
(define-span-event-display-method SostenutoEvent (event parser) #f "\\sostenutoOn" "\\sostenutoOff")
(define-display-method SkipMusic (skip parser)
(format #f "\\skip ~a" (duration->lily-string (ly:music-property skip 'duration) #:force-duration #t)))
+(define-display-method OttavaMusic (ottava parser)
+ (format #f "\\ottava #~a" (ly:music-property ottava 'ottava-number)))
+
;;;
;;; Notes, rests, skips...
;;;
(define-display-method SkipEvent (rest parser)
"s")
+(define-display-method RepeatedChord (chord parser)
+ (music->lily-string (ly:music-property chord 'element) parser))
+
(define-display-method MarkEvent (mark parser)
(let ((label (ly:music-property mark 'label)))
(if (null? label)
(*indent*)
(first op)
(second op)))
- (reverse operations)))
+ operations))
(*indent*)))
(parameterize ((*current-context* ctype))
(music->lily-string music parser)))))
properties)
(new-line->lily-string))))
+(define-display-method TimeSignatureMusic (expr parser)
+ (let* ((num (ly:music-property expr 'numerator))
+ (den (ly:music-property expr 'denominator))
+ (structure (ly:music-property expr 'beat-structure)))
+ (if (null? structure)
+ (format #f
+ "\\time ~a/~a~a"
+ num den
+ (new-line->lily-string))
+ (format #f
+ "#(set-time-signature ~a ~a '~a)~a"
+ num den structure
+ (new-line->lily-string)))))
+
;;; \melisma and \melismaEnd
(define-extra-display-method ContextSpeccedMusic (expr parser)
"If expr is a melisma, return \"\\melisma\", otherwise, return #f."
symbol 'clefOctavation)
(music 'ApplyContext
procedure ly:set-middle-C!)))))
- (let ((clef-prop+name (assoc (list ?clef-glyph ?clef-position 0)
+ (let ((clef-name (assoc-get (list ?clef-glyph ?clef-position 0)
clef-name-alist)))
- (if clef-prop+name
+ (if clef-name
(format #f "\\clef \"~a~{~a~a~}\"~a"
- (cdr clef-prop+name)
+ clef-name
(cond ((= 0 ?clef-octavation)
(list "" ""))
((> ?clef-octavation 0)
(new-line->lily-string))
#f))))
-;;; \time
-(define-extra-display-method ContextSpeccedMusic (expr parser)
- "If `expr' is a time signature set, return \"\\time ...\".
-Otherwise, return #f."
- (with-music-match (expr (music
- 'ContextSpeccedMusic
- element (music
- 'ContextSpeccedMusic
- context-type 'Timing
- element (music
- 'SequentialMusic
- elements ((music
- 'PropertySet
- value ?num+den
- symbol 'timeSignatureFraction)
- (music
- 'PropertySet
- symbol 'beatLength)
- (music
- 'PropertySet
- symbol 'measureLength)
- (music
- 'PropertySet
- value ?grouping
- symbol 'beatGrouping))))))
- (if (null? ?grouping)
- (format #f "\\time ~a/~a~a" (car ?num+den) (cdr ?num+den) (new-line->lily-string))
- (format #f "#(set-time-signature ~a ~a '~s)~a"
- (car ?num+den) (cdr ?num+den) ?grouping (new-line->lily-string)))))
-
;;; \bar
(define-extra-display-method ContextSpeccedMusic (expr parser)
"If `expr' is a bar, return \"\\bar ...\".
(format #f "\\bar \"~a\"~a" ?bar-type (new-line->lily-string))))
;;; \partial
-(define (duration->moment ly-duration)
- (let ((log2 (ly:duration-log ly-duration))
- (dots (ly:duration-dot-count ly-duration))
- (num+den (ly:duration-factor ly-duration)))
- (let* ((m (expt 2 (- log2)))
- (factor (/ (car num+den) (cdr num+den))))
- (/ (do ((i 0 (1+ i))
- (delta (/ m 2) (/ delta 2)))
- ((= i dots) m)
- (set! m (+ m delta)))
- factor))))
-(define moment-duration-alist (map (lambda (duration)
- (cons (duration->moment duration)
- duration))
- (append-map (lambda (log2)
- (map (lambda (dots)
- (ly:make-duration log2 dots 1 1))
- (list 0 1 2 3)))
- (list 0 1 2 3 4))))
-
-(define (moment->duration moment)
- (let ((result (assoc (- moment) moment-duration-alist =)))
- (and result
- (cdr result))))
(define-extra-display-method ContextSpeccedMusic (expr parser)
"If `expr' is a partial measure, return \"\\partial ...\".
'ContextSpeccedMusic
context-type 'Timing
element (music
- 'PropertySet
- value ?moment
- symbol 'measurePosition))))
- (let ((duration (moment->duration (/ (ly:moment-main-numerator ?moment)
- (ly:moment-main-denominator ?moment)))))
- (and duration (format #f "\\partial ~a" (duration->lily-string duration
- #:force-duration #t))))))
+ 'PartialSet
+ partial-duration ?duration))))
+
+ (and ?duration
+ (format #f "\\partial ~a"
+ (duration->lily-string ?duration #:force-duration #t)))))
;;;
;;;
(music->lily-string ?lyric-sequence parser)))
#f)))
-
+;; Silence internal event sent at end of each lyrics block
+(define-display-method CompletizeExtenderEvent (expr parser)
+ "")