1.3)
line-thickness))
(radius (/ (+ staff-space line-thickness) 2))
- (letter (markup #:center-align #:vcenter pitch-string))
- (filled-circle (markup #:draw-circle radius 0 #t)))
+ (letter (make-center-align-markup (make-vcenter-markup pitch-string)))
+ (filled-circle (make-draw-circle-markup radius 0 #t)))
(ly:stencil-translate-axis
(grob-interpret-markup
;; tuplet formatter function. It takes the value returned by the given
;; function and appends a note of given length.
(define ((tuplet-number::append-note-wrapper function note) grob)
- (let ((txt (if function (function grob) #f)))
+ (let ((txt (and function (function grob))))
(if txt
- (markup txt #:fontsize -5 #:note note UP)
- (markup #:fontsize -5 #:note note UP))))
+ (make-line-markup
+ (list txt (make-fontsize-markup -5 (make-note-markup note UP))))
+ (make-fontsize-markup -5 (make-note-markup note UP)))))
(export tuplet-number::append-note-wrapper)
;; Print a tuplet denominator with a different number than the one derived from
(make-concat-markup (list
(make-simple-markup (format #f "~a" den))
- (markup #:fontsize -5 #:note denominatornote UP)
+ (make-fontsize-markup -5 (make-note-markup denominatornote UP))
(make-simple-markup " : ")
(make-simple-markup (format #f "~a" num))
- (markup #:fontsize -5 #:note numeratornote UP)))))
+ (make-fontsize-markup -5 (make-note-markup numeratornote UP))))))
(export tuplet-number::non-default-fraction-with-notes)
;; annotations
(define-public (numbered-footnotes int)
- (markup #:tiny (number->string (+ 1 int))))
+ (make-tiny-markup (number->string (+ 1 int))))
(define-public (symbol-footnotes int)
(define (helper symbols out idx n)
(string-append out (list-ref symbols idx))
idx
(- n 1))))
- (markup #:tiny (helper '("*" "†" "‡" "§" "¶")
- ""
- (remainder int 5)
- (+ 1 (quotient int 5)))))
+ (make-tiny-markup (helper '("*" "†" "‡" "§" "¶")
+ ""
+ (remainder int 5)
+ (+ 1 (quotient int 5)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; accidentals
(define-public (string-number::calc-text grob)
(let ((event (event-cause grob)))
(or (ly:event-property event 'text #f)
- (number->string (ly:event-property event 'string-number) 10))))
+ (number-format
+ (ly:grob-property grob 'number-type)
+ (ly:event-property event 'string-number)))))
(define-public (stroke-finger::calc-text grob)
(let ((event (event-cause grob)))
(larger (max (car edge-height) (cdr edge-height))))
(interval-union '(0 . 0) (cons smaller larger)))
'(0 . 0))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; make-engraver helper macro
+
+(defmacro-public make-engraver forms
+ "Helper macro for creating Scheme engravers.
+
+The usual form for an engraver is an association list (or alist)
+mapping symbols to either anonymous functions or to another such
+alist.
+
+@code{make-engraver} accepts forms where the first element is either
+an argument list starting with the respective symbol, followed by the
+function body (comparable to the way @code{define} is used for
+defining functions), or a single symbol followed by subordinate forms
+in the same manner. You can also just make an alist pair
+literally (the @samp{car} is quoted automatically) as long as the
+unevaluated @samp{cdr} is not a pair. This is useful if you already
+have defined your engraver functions separately.
+
+Symbols mapping to a function would be @code{initialize},
+@code{start-translation-timestep}, @code{process-music},
+@code{process-acknowledged}, @code{stop-translation-timestep}, and
+@code{finalize}. Symbols mapping to another alist specified in the
+same manner are @code{listeners} with the subordinate symbols being
+event classes, and @code{acknowledgers} and @code{end-acknowledgers}
+with the subordinate symbols being interfaces."
+ (let loop ((forms forms))
+ (if (or (null? forms) (pair? forms))
+ `(list
+ ,@(map (lambda (form)
+ (if (pair? (car form))
+ `(cons ',(caar form) (lambda ,(cdar form) ,@(cdr form)))
+ `(cons ',(car form) ,(loop (cdr form)))))
+ forms))
+ forms)))