X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=scm%2Foutput-lib.scm;h=59f93e2e7ea3111cf4048409901273858ffed974;hb=410a5691ad4d90bac28ceccdc4d2458153b1ffd2;hp=739c581a14816bbccf0e92d33bed84ea3b60f0e8;hpb=324ff94afc62c7011b7377f24392f95391ed3b84;p=lilypond.git

diff --git a/scm/output-lib.scm b/scm/output-lib.scm
index 739c581a14..59f93e2e7e 100644
--- a/scm/output-lib.scm
+++ b/scm/output-lib.scm
@@ -404,8 +404,8 @@ and duration-log @var{log}."
                                 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
@@ -571,11 +571,12 @@ and duration-log @var{log}."
 ;; 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
@@ -620,10 +621,10 @@ and duration-log @var{log}."
 
     (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)
 
 
@@ -704,7 +705,7 @@ and duration-log @var{log}."
 ;; 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)
@@ -714,10 +715,10 @@ and duration-log @var{log}."
                 (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
@@ -1357,3 +1358,39 @@ parent or the parent has no setting."
               (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)))