Merge http://git.sv.gnu.org/r/lilypond

[lilypond.git] / scm / define-markup-commands.scm

diff --git a/scm/define-markup-commands.scm b/scm/define-markup-commands.scm
index 1a940b13834e8c2dd79b0b60a367b82c9a1b28f2..956bd817bfa2a15e39ab68c965e54fb24957c8bb 100644 (file)
--- a/scm/define-markup-commands.scm
+++ b/scm/define-markup-commands.scm
@@ -2,7 +2,7 @@
 ;;;;
 ;;;;  source file of the GNU LilyPond music typesetter
 ;;;; 
 ;;;;
 ;;;;  source file of the GNU LilyPond music typesetter
 ;;;; 

-;;;; (c) 2000--2006  Han-Wen Nienhuys <hanwen@cs.uu.nl>
+;;;; (c) 2000--2006  Han-Wen Nienhuys <hanwen@xs4all.nl>

 ;;;;                  Jan Nieuwenhuizen <janneke@gnu.org>
 
 
 ;;;;                  Jan Nieuwenhuizen <janneke@gnu.org>
 
 


@@ -24,14 +24,32 @@
 ;; geometric shapes
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; geometric shapes
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(define-markup-command (draw-circle layout props radius thickness fill)
+(define-builtin-markup-command (draw-line layout props dest)
+  (number-pair?)
+  "A simple line.  Uses the @code{thickness} property."
+  (let*
+      ((th (chain-assoc-get 'thickness props  0.1))
+       (x (car dest))
+       (y (cdr dest))
+       (s (ly:make-stencil
+          `(draw-line
+            ,th
+            0 0
+            ,x ,y)
+
+          (cons (min x 0) (max x 0))
+          (cons (min y 0) (max y 0)))))
+
+    s))
+
+(define-builtin-markup-command (draw-circle layout props radius thickness fill)

   (number? number? boolean?)
   "A circle of radius @var{radius}, thickness @var{thickness} and
 optionally filled."
   (make-circle-stencil radius thickness fill))
 
   (number? number? boolean?)
   "A circle of radius @var{radius}, thickness @var{thickness} and
 optionally filled."
   (make-circle-stencil radius thickness fill))
 

-(define-markup-command (triangle layout props filled) (boolean?)
-  "A triangle, filled or not"
+(define-builtin-markup-command (triangle layout props filled) (boolean?)
+  "A triangle, either filled or empty."

   (let*
       ((th (chain-assoc-get 'thickness props  0.1))
        (size (chain-assoc-get 'font-size props 0))
   (let*
       ((th (chain-assoc-get 'thickness props  0.1))
        (size (chain-assoc-get 'font-size props 0))


@@ -51,10 +69,11 @@ optionally filled."
      (cons 0 (* .86 ex))
      )))
 
      (cons 0 (* .86 ex))
      )))
 

-(define-markup-command (circle layout props arg) (markup?)
+(define-builtin-markup-command (circle layout props arg) (markup?)

   "Draw a circle around @var{arg}.  Use @code{thickness},
 @code{circle-padding} and @code{font-size} properties to determine line
 thickness and padding around the markup."
   "Draw a circle around @var{arg}.  Use @code{thickness},
 @code{circle-padding} and @code{font-size} properties to determine line
 thickness and padding around the markup."

+  

   (let* ((th (chain-assoc-get 'thickness props  0.1))
         (size (chain-assoc-get 'font-size props 0))
         (pad
   (let* ((th (chain-assoc-get 'thickness props  0.1))
         (size (chain-assoc-get 'font-size props 0))
         (pad


@@ -63,18 +82,19 @@ thickness and padding around the markup."
         (m (interpret-markup layout props arg)))
     (circle-stencil m th pad)))
 
         (m (interpret-markup layout props arg)))
     (circle-stencil m th pad)))
 

-(define-markup-command (with-url layout props url arg) (string? markup?)
-  "Add a link to URL @var{url} around @var{arg}. This only works in
+(define-builtin-markup-command (with-url layout props url arg) (string? markup?)
+  "Add a link to URL @var{url} around @var{arg}.  This only works in

 the PDF backend."
   (let* ((stil (interpret-markup layout props arg))
         (xextent (ly:stencil-extent stil X))
         (yextent (ly:stencil-extent stil Y))
         (old-expr (ly:stencil-expr stil))
         (url-expr (list 'url-link url `(quote ,xextent) `(quote ,yextent))))
 the PDF backend."
   (let* ((stil (interpret-markup layout props arg))
         (xextent (ly:stencil-extent stil X))
         (yextent (ly:stencil-extent stil Y))
         (old-expr (ly:stencil-expr stil))
         (url-expr (list 'url-link url `(quote ,xextent) `(quote ,yextent))))

+

     (ly:stencil-add (ly:make-stencil url-expr xextent yextent) stil)))
 
 
     (ly:stencil-add (ly:make-stencil url-expr xextent yextent) stil)))
 
 

-(define-markup-command (beam layout props width slope thickness)
+(define-builtin-markup-command (beam layout props width slope thickness)

   (number? number? number?)
   "Create a beam with the specified parameters."
   (let* ((y (* slope width))
   (number? number? number?)
   "Create a beam with the specified parameters."
   (let* ((y (* slope width))


@@ -93,7 +113,7 @@ the PDF backend."
      (cons (+ (- half) (car yext))
           (+ half (cdr yext))))))
 
      (cons (+ (- half) (car yext))
           (+ half (cdr yext))))))
 

-(define-markup-command (box layout props arg) (markup?)
+(define-builtin-markup-command (box layout props arg) (markup?)

   "Draw a box round @var{arg}.  Looks at @code{thickness},
 @code{box-padding} and @code{font-size} properties to determine line
 thickness and padding around the markup."
   "Draw a box round @var{arg}.  Looks at @code{thickness},
 @code{box-padding} and @code{font-size} properties to determine line
 thickness and padding around the markup."


@@ -105,41 +125,30 @@ thickness and padding around the markup."
         (m (interpret-markup layout props arg)))
     (box-stencil m th pad)))
 
         (m (interpret-markup layout props arg)))
     (box-stencil m th pad)))
 

-(define-markup-command (filled-box layout props xext yext blot)
+(define-builtin-markup-command (filled-box layout props xext yext blot)

   (number-pair? number-pair? number?)
   "Draw a box with rounded corners of dimensions @var{xext} and
 @var{yext}.  For example,
 @verbatim
 \\filled-box #'(-.3 . 1.8) #'(-.3 . 1.8) #0
 @end verbatim
   (number-pair? number-pair? number?)
   "Draw a box with rounded corners of dimensions @var{xext} and
 @var{yext}.  For example,
 @verbatim
 \\filled-box #'(-.3 . 1.8) #'(-.3 . 1.8) #0
 @end verbatim

-create a box extending horizontally from -0.3 to 1.8 and
+creates a box extending horizontally from -0.3 to 1.8 and

 vertically from -0.3 up to 1.8, with corners formed from a
 vertically from -0.3 up to 1.8, with corners formed from a

-circle of diameter 0 (ie sharp corners)."
+circle of diameter@tie{}0 (i.e. sharp corners)."

   (ly:round-filled-box
    xext yext blot))
 
   (ly:round-filled-box
    xext yext blot))
 

-(define-markup-command (rotate layout props ang arg) (number? markup?)
+(define-builtin-markup-command (rotate layout props ang arg) (number? markup?)

   "Rotate object with @var{ang} degrees around its center."
   (let* ((stil (interpret-markup layout props arg)))
     (ly:stencil-rotate stil ang 0 0)))
 
 
   "Rotate object with @var{ang} degrees around its center."
   (let* ((stil (interpret-markup layout props arg)))
     (ly:stencil-rotate stil ang 0 0)))
 
 

-(define-markup-command (whiteout layout props arg) (markup?)
-  "Provide a white underground for @var{arg}"
-  (let* ((stil (interpret-markup layout props
-                                (make-with-color-markup black arg)))
-        (white
-         (interpret-markup layout props
-                           (make-with-color-markup
-                            white
-                            (make-filled-box-markup
-                             (ly:stencil-extent stil X)
-                             (ly:stencil-extent stil Y)
-                             0.0)))))
-
-    (ly:stencil-add white stil)))
+(define-builtin-markup-command (whiteout layout props arg) (markup?)
+  "Provide a white underground for @var{arg}."
+  (stencil-whiteout (interpret-markup layout props arg)))

 
 

-(define-markup-command (pad-markup layout props padding arg) (number? markup?)
+(define-builtin-markup-command (pad-markup layout props padding arg) (number? markup?)

   "Add space around a markup object."
 
   (let*
   "Add space around a markup object."
 
   (let*


@@ -157,7 +166,7 @@ circle of diameter 0 (ie sharp corners)."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;FIXME: is this working? 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;FIXME: is this working? 

-(define-markup-command (strut layout props) ()
+(define-builtin-markup-command (strut layout props) ()

   "Create a box of the same height as the space in the current font."
   (let ((m (ly:text-interface::interpret-markup layout props " ")))
     (ly:make-stencil (ly:stencil-expr m)
   "Create a box of the same height as the space in the current font."
   (let ((m (ly:text-interface::interpret-markup layout props " ")))
     (ly:make-stencil (ly:stencil-expr m)


@@ -167,14 +176,16 @@ circle of diameter 0 (ie sharp corners)."
 
 
 ;; todo: fix negative space
 
 
 ;; todo: fix negative space

-(define-markup-command (hspace layout props amount) (number?)
-  "This produces a invisible object taking horizontal space.
+(define-builtin-markup-command (hspace layout props amount) (number?)
+  "This produces a invisible object taking horizontal space.  For example,
+

 @example 
 \\markup @{ A \\hspace #2.0 B @} 
 @end example
 @example 
 \\markup @{ A \\hspace #2.0 B @} 
 @end example

-will put extra space between A and B, on top of the space that is
-normally inserted before elements on a line.
-"
+
+@noindent
+puts extra space between A and@tie{}B, on top of the space that is
+normally inserted before elements on a line."

   (if (> amount 0)
       (ly:make-stencil "" (cons 0 amount) '(-1 . 1))
       (ly:make-stencil "" (cons amount amount) '(-1 . 1))))
   (if (> amount 0)
       (ly:make-stencil "" (cons 0 amount) '(-1 . 1))
       (ly:make-stencil "" (cons amount amount) '(-1 . 1))))


@@ -184,8 +195,8 @@ normally inserted before elements on a line.
 ;; importing graphics.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; importing graphics.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(define-markup-command (stencil layout props stil) (ly:stencil?)
-  "Stencil as markup"
+(define-builtin-markup-command (stencil layout props stil) (ly:stencil?)
+  "Use a stencil as markup."

   stil)
 
 (define bbox-regexp
   stil)
 
 (define bbox-regexp


@@ -203,8 +214,8 @@ normally inserted before elements on a line.
             
        #f)))
 
             
        #f)))
 

-(define-markup-command (epsfile layout props axis size file-name) (number? number? string?)
-  "Inline an EPS image. The image is scaled along @var{axis} to
+(define-builtin-markup-command (epsfile layout props axis size file-name) (number? number? string?)
+  "Inline an EPS image.  The image is scaled along @var{axis} to

 @var{size}."
 
   (if (ly:get-option 'safe)
 @var{size}."
 
   (if (ly:get-option 'safe)


@@ -212,41 +223,47 @@ normally inserted before elements on a line.
       (eps-file->stencil axis size file-name)
       ))
 
       (eps-file->stencil axis size file-name)
       ))
 

-(define-markup-command (postscript layout props str) (string?)
+(define-builtin-markup-command (postscript layout props str) (string?)

   "This inserts @var{str} directly into the output as a PostScript
 command string.  Due to technicalities of the output backends,
 different scales should be used for the @TeX{} and PostScript backend,
 selected with @code{-f}. 
 
   "This inserts @var{str} directly into the output as a PostScript
 command string.  Due to technicalities of the output backends,
 different scales should be used for the @TeX{} and PostScript backend,
 selected with @code{-f}. 
 

-
-For the TeX backend, the following string prints a rotated text
+For the @TeX{} backend, the following string prints a rotated text

 
 @cindex rotated text
 
 
 @cindex rotated text
 

-@verbatim
+@example

 0 0 moveto /ecrm10 findfont 
 1.75 scalefont setfont 90 rotate (hello) show
 0 0 moveto /ecrm10 findfont 
 1.75 scalefont setfont 90 rotate (hello) show

-@end verbatim
+@end example

 
 @noindent
 The magical constant 1.75 scales from LilyPond units (staff spaces) to
 
 @noindent
 The magical constant 1.75 scales from LilyPond units (staff spaces) to

-TeX dimensions.
+@TeX{} dimensions.

 
 For the postscript backend, use the following
 
 
 For the postscript backend, use the following
 

-@verbatim
+@example

 gsave /ecrm10 findfont 
  10.0 output-scale div 
  scalefont setfont 90 rotate (hello) show grestore 
 gsave /ecrm10 findfont 
  10.0 output-scale div 
  scalefont setfont 90 rotate (hello) show grestore 

-@end verbatim
-"
+@end example"
+

   ;; FIXME
   (ly:make-stencil
   ;; FIXME
   (ly:make-stencil

-   (list 'embedded-ps str)
+   (list 'embedded-ps
+        (format "
+gsave currentpoint translate
+0.1 setlinewidth
+ ~a
+grestore
+"
+                str))

    '(0 . 0) '(0 . 0)))
 
 
    '(0 . 0) '(0 . 0)))
 
 

-(define-markup-command (score layout props score) (ly:score?)
+(define-builtin-markup-command (score layout props score) (ly:score?)

   "Inline an image of music."
   (let* ((output (ly:score-embedded-format score layout)))
 
   "Inline an image of music."
   (let* ((output (ly:score-embedded-format score layout)))
 


@@ -257,8 +274,8 @@ gsave /ecrm10 findfont
          (ly:warning (_"no systems found in \\score markup, does it have a \\layout block?"))
          empty-stencil))))
 
          (ly:warning (_"no systems found in \\score markup, does it have a \\layout block?"))
          empty-stencil))))
 

-(define-markup-command (null layout props) ()
-  "An empty markup with extents of a single point"
+(define-builtin-markup-command (null layout props) ()
+  "An empty markup with extents of a single point."

 
   point-stencil)
 
 
   point-stencil)
 


@@ -266,15 +283,31 @@ gsave /ecrm10 findfont
 ;; basic formatting.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; basic formatting.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(define-markup-command (simple layout props str) (string?)
+
+
+(define-builtin-markup-command (simple layout props str) (string?)

   "A simple text string; @code{\\markup @{ foo @}} is equivalent with
 @code{\\markup @{ \\simple #\"foo\" @}}."
   (interpret-markup layout props str))
 
   "A simple text string; @code{\\markup @{ foo @}} is equivalent with
 @code{\\markup @{ \\simple #\"foo\" @}}."
   (interpret-markup layout props str))
 

-
-;; TODO: use font recoding.
-;;                   (make-line-markup
-;;                    (map make-word-markup (string-tokenize str)))))
+(define-builtin-markup-command (tied-lyric layout props str) (string?)
+  "Like simple-markup, but use tie characters for @q{~} tilde symbols."
+  (if (string-contains str "~")
+      (let*
+         ((parts (string-split str #\~))
+          (tie-str (ly:wide-char->utf-8 #x203f))
+          (joined  (list-join parts tie-str))
+          (join-stencil (interpret-markup layout props tie-str))
+          )
+
+       (interpret-markup layout 
+                         (prepend-alist-chain
+                          'word-space
+                          (/ (interval-length (ly:stencil-extent join-stencil X)) -3.5)
+                          props)
+                         (make-line-markup joined)))
+                          ;(map (lambda (s) (interpret-markup layout props s)) parts))
+      (interpret-markup layout props str)))

 
 (define-public empty-markup
   (make-simple-markup ""))
 
 (define-public empty-markup
   (make-simple-markup ""))


@@ -308,15 +341,13 @@ gsave /ecrm10 findfont
        (/ (+ (car text-widths) (car (cdr text-widths))) 2))
      (get-fill-space word-count line-width (cdr text-widths))))))
 
        (/ (+ (car text-widths) (car (cdr text-widths))) 2))
      (get-fill-space word-count line-width (cdr text-widths))))))
 

-(define-markup-command (fill-line layout props markups)
+(define-builtin-markup-command (fill-line layout props markups)

   (markup-list?)
   "Put @var{markups} in a horizontal line of width @var{line-width}.
   (markup-list?)
   "Put @var{markups} in a horizontal line of width @var{line-width}.

-   The markups are spaced/flushed to fill the entire line.
-   If there are no arguments, return an empty stencil."
+The markups are spaced or flushed to fill the entire line.
+If there are no arguments, return an empty stencil."

  
  

-  (let* ((orig-stencils
-         (map (lambda (x) (interpret-markup layout props x))
-              markups))
+  (let* ((orig-stencils (interpret-markup-list layout props markups))

         (stencils
          (map (lambda (stc)
                 (if (ly:stencil-empty? stc)
         (stencils
          (map (lambda (stc)
                 (if (ly:stencil-empty? stc)


@@ -331,8 +362,10 @@ gsave /ecrm10 findfont
         (text-width (apply + text-widths))
         (text-dir (chain-assoc-get 'text-direction props RIGHT))
         (word-count (length stencils))
         (text-width (apply + text-widths))
         (text-dir (chain-assoc-get 'text-direction props RIGHT))
         (word-count (length stencils))

-        (word-space (chain-assoc-get 'word-space props))
-        (line-width (chain-assoc-get 'line-width props))
+        (word-space (chain-assoc-get 'word-space props 1))
+        (prop-line-width (chain-assoc-get 'line-width props #f))
+        (line-width (if prop-line-width prop-line-width
+                        (ly:output-def-lookup layout 'line-width)))

         (fill-space
                (cond
                        ((= word-count 1) 
         (fill-space
                (cond
                        ((= word-count 1) 


@@ -366,11 +399,11 @@ gsave /ecrm10 findfont
        (stack-stencils-padding-list X
                                     RIGHT fill-space-normal line-stencils))))
        
        (stack-stencils-padding-list X
                                     RIGHT fill-space-normal line-stencils))))
        

-(define-markup-command (line layout props args) (markup-list?)
+(define-builtin-markup-command (line layout props args) (markup-list?)

   "Put @var{args} in a horizontal line.  The property @code{word-space}
 determines the space between each markup in @var{args}."
   (let*
   "Put @var{args} in a horizontal line.  The property @code{word-space}
 determines the space between each markup in @var{args}."
   (let*

-      ((stencils (map (lambda (m) (interpret-markup layout props m)) args))
+      ((stencils (interpret-markup-list layout props args))

        (space    (chain-assoc-get 'word-space props))
        (text-dir (chain-assoc-get 'text-direction props RIGHT)) 
        )
        (space    (chain-assoc-get 'word-space props))
        (text-dir (chain-assoc-get 'text-direction props RIGHT)) 
        )


@@ -383,6 +416,30 @@ determines the space between each markup in @var{args}."
      space
      (remove ly:stencil-empty? stencils))))
 
      space
      (remove ly:stencil-empty? stencils))))
 

+(define-builtin-markup-command (concat layout props args) (markup-list?)
+  "Concatenate @var{args} in a horizontal line, without spaces inbetween.
+Strings and simple markups are concatenated on the input level, allowing
+ligatures.  For example, @code{\\concat @{ \"f\" \\simple #\"i\" @}} is
+equivalent to @code{\"fi\"}."
+
+  (define (concat-string-args arg-list)
+    (fold-right (lambda (arg result-list)
+                  (let ((result (if (pair? result-list)
+                                    (car result-list)
+                                  '())))
+                    (if (and (pair? arg) (eqv? (car arg) simple-markup))
+                      (set! arg (cadr arg)))
+                    (if (and (string? result) (string? arg))
+                        (cons (string-append arg result) (cdr result-list))
+                      (cons arg result-list))))
+                '()
+                arg-list))
+
+  (interpret-markup layout
+                    (prepend-alist-chain 'word-space 0 props)
+                    (make-line-markup (if (markup-command-list? args)
+                                         args
+                                         (concat-string-args args)))))

 
 (define (wordwrap-stencils stencils
                           justify base-space line-width text-dir)
 
 (define (wordwrap-stencils stencils
                           justify base-space line-width text-dir)


@@ -464,31 +521,28 @@ determines the space between each markup in @var{args}."
 
 (define (wordwrap-markups layout props args justify)
   (let*
 
 (define (wordwrap-markups layout props args justify)
   (let*

-      ((baseline-skip (chain-assoc-get 'baseline-skip props))
-       (line-width (chain-assoc-get 'line-width props))
+      ((prop-line-width (chain-assoc-get 'line-width props #f))
+       (line-width (if prop-line-width prop-line-width
+                      (ly:output-def-lookup layout 'line-width)))

        (word-space (chain-assoc-get 'word-space props))
        (word-space (chain-assoc-get 'word-space props))

-       (text-dir (chain-assoc-get 'text-direction props RIGHT)) 
-       (lines (wordwrap-stencils
-              (remove ly:stencil-empty?
-                      (map (lambda (m) (interpret-markup layout props m)) args))
-              justify word-space line-width
-              text-dir)
-              ))
+       (text-dir (chain-assoc-get 'text-direction props RIGHT)))
+    (wordwrap-stencils (remove ly:stencil-empty?
+                               (interpret-markup-list layout props args))
+                       justify word-space line-width
+                       text-dir)))

 
 

-    (stack-lines DOWN 0.0 baseline-skip lines)))
-
-(define-markup-command (justify layout props args) (markup-list?)
+(define-builtin-markup-command (justify layout props args) (markup-list?)

   "Like wordwrap, but with lines stretched to justify the margins.
   "Like wordwrap, but with lines stretched to justify the margins.

-Use @code{\\override #'(line-width . X)} to set line-width, where X
-is the number of staff spaces."
-
-  (wordwrap-markups layout props args #t))
+Use @code{\\override #'(line-width . @var{X})} to set the line width;
+@var{X}@tie{}is the number of staff spaces."
+  (stack-lines DOWN 0.0 (chain-assoc-get 'baseline-skip props)
+              (wordwrap-markups layout props args #t)))

 
 

-(define-markup-command (wordwrap layout props args) (markup-list?)
-  "Simple wordwrap.  Use @code{\\override #'(line-width . X)} to set
-line-width, where X is the number of staff spaces."
-
-  (wordwrap-markups layout props args #f))
+(define-builtin-markup-command (wordwrap layout props args) (markup-list?)
+  "Simple wordwrap.  Use @code{\\override #'(line-width . @var{X})} to set
+the line width, where @var{X} is the number of staff spaces."
+  (stack-lines DOWN 0.0 (chain-assoc-get 'baseline-skip props)
+              (wordwrap-markups layout props args #f)))

 
 (define (wordwrap-string layout props justify arg) 
   (let*
 
 (define (wordwrap-string layout props justify arg) 
   (let*


@@ -525,32 +579,34 @@ line-width, where X is the number of staff spaces."
     (stack-lines DOWN 0.0 baseline-skip (apply append para-lines))))
 
 
     (stack-lines DOWN 0.0 baseline-skip (apply append para-lines))))
 
 

-(define-markup-command (wordwrap-string layout props arg) (string?)
-  "Wordwrap a string. Paragraphs may be separated with double newlines"
+(define-builtin-markup-command (wordwrap-string layout props arg) (string?)
+  "Wordwrap a string.  Paragraphs may be separated with double newlines."

   (wordwrap-string layout props  #f arg))
   
   (wordwrap-string layout props  #f arg))
   

-(define-markup-command (justify-string layout props arg) (string?)
-  "Justify a string. Paragraphs may be separated with double newlines"
+(define-builtin-markup-command (justify-string layout props arg) (string?)
+  "Justify a string.  Paragraphs may be separated with double newlines"

   (wordwrap-string layout props #t arg))
 
 
   (wordwrap-string layout props #t arg))
 
 

-(define-markup-command (wordwrap-field layout props symbol) (symbol?)
-   (let* ((m (chain-assoc-get symbol props)))
-     (if (string? m)
-      (interpret-markup layout props
-       (list wordwrap-string-markup m))
-      (ly:make-stencil '()  '(1 . -1) '(1 . -1)))))
+(define-builtin-markup-command (wordwrap-field layout props symbol) (symbol?)
+  "Wordwrap the data which has been assigned to @var{symbol}."
+  (let* ((m (chain-assoc-get symbol props)))
+    (if (string? m)
+     (interpret-markup layout props
+      (list wordwrap-string-markup m))
+     (ly:make-stencil '()  '(1 . -1) '(1 . -1)))))

 
 

-(define-markup-command (justify-field layout props symbol) (symbol?)
--   (let* ((m (chain-assoc-get symbol props)))
-     (if (string? m)
-      (interpret-markup layout props
-       (list justify-string-markup m))
-      (ly:make-stencil '()  '(1 . -1) '(1 . -1)))))
+(define-builtin-markup-command (justify-field layout props symbol) (symbol?)
+  "Justify the data which has been assigned to @var{symbol}."
+  (let* ((m (chain-assoc-get symbol props)))
+    (if (string? m)
+     (interpret-markup layout props
+      (list justify-string-markup m))
+     (ly:make-stencil '()  '(1 . -1) '(1 . -1)))))

 
 
 
 
 
 

-(define-markup-command (combine layout props m1 m2) (markup? markup?)
+(define-builtin-markup-command (combine layout props m1 m2) (markup? markup?)

   "Print two markups on top of each other."
   (let* ((s1 (interpret-markup layout props m1))
         (s2 (interpret-markup layout props m2)))
   "Print two markups on top of each other."
   (let* ((s1 (interpret-markup layout props m1))
         (s2 (interpret-markup layout props m2)))


@@ -559,12 +615,12 @@ line-width, where X is the number of staff spaces."
 ;;
 ;; TODO: should extract baseline-skip from each argument somehow..
 ;; 
 ;;
 ;; TODO: should extract baseline-skip from each argument somehow..
 ;; 

-(define-markup-command (column layout props args) (markup-list?)
+(define-builtin-markup-command (column layout props args) (markup-list?)

   "Stack the markups in @var{args} vertically.  The property
 @code{baseline-skip} determines the space between each markup in @var{args}."
 
   (let*
   "Stack the markups in @var{args} vertically.  The property
 @code{baseline-skip} determines the space between each markup in @var{args}."
 
   (let*

-      ((arg-stencils (map (lambda (m) (interpret-markup layout props m)) args))
+      ((arg-stencils (interpret-markup-list layout props args))

        (skip (chain-assoc-get 'baseline-skip props)))
 
     
        (skip (chain-assoc-get 'baseline-skip props)))
 
     


@@ -573,7 +629,7 @@ line-width, where X is the number of staff spaces."
      (remove ly:stencil-empty? arg-stencils))))
 
 
      (remove ly:stencil-empty? arg-stencils))))
 
 

-(define-markup-command (dir-column layout props args) (markup-list?)
+(define-builtin-markup-command (dir-column layout props args) (markup-list?)

   "Make a column of args, going up or down, depending on the setting
 of the @code{#'direction} layout property."
   (let* ((dir (chain-assoc-get 'direction props)))
   "Make a column of args, going up or down, depending on the setting
 of the @code{#'direction} layout property."
   (let* ((dir (chain-assoc-get 'direction props)))


@@ -581,59 +637,58 @@ of the @code{#'direction} layout property."
      (if (number? dir) dir -1)
      0.0
      (chain-assoc-get 'baseline-skip props)
      (if (number? dir) dir -1)
      0.0
      (chain-assoc-get 'baseline-skip props)

-     (map (lambda (x) (interpret-markup layout props x)) args))))
+     (interpret-markup-list layout props args))))

 
 

-(define-markup-command (center-align layout props args) (markup-list?)
-  "Put @code{args} in a centered column. "
-  (let* ((mols (map (lambda (x) (interpret-markup layout props x)) args))
+(define-builtin-markup-command (center-align layout props args) (markup-list?)
+  "Put @code{args} in a centered column."
+  (let* ((mols (interpret-markup-list layout props args))

          (cmols (map (lambda (x) (ly:stencil-aligned-to x X CENTER)) mols)))
     
     (stack-lines -1 0.0 (chain-assoc-get 'baseline-skip props) cmols)))
 
          (cmols (map (lambda (x) (ly:stencil-aligned-to x X CENTER)) mols)))
     
     (stack-lines -1 0.0 (chain-assoc-get 'baseline-skip props) cmols)))
 

-(define-markup-command (vcenter layout props arg) (markup?)
-  "Align @code{arg} to its Y center. "
+(define-builtin-markup-command (vcenter layout props arg) (markup?)
+  "Align @code{arg} to its Y@tie{}center."

   (let* ((mol (interpret-markup layout props arg)))
     (ly:stencil-aligned-to mol Y CENTER)))
 
   (let* ((mol (interpret-markup layout props arg)))
     (ly:stencil-aligned-to mol Y CENTER)))
 

-(define-markup-command (hcenter layout props arg) (markup?)
-  "Align @code{arg} to its X center. "
+(define-builtin-markup-command (hcenter layout props arg) (markup?)
+  "Align @code{arg} to its X@tie{}center."

   (let* ((mol (interpret-markup layout props arg)))
     (ly:stencil-aligned-to mol X CENTER)))
 
   (let* ((mol (interpret-markup layout props arg)))
     (ly:stencil-aligned-to mol X CENTER)))
 

-(define-markup-command (right-align layout props arg) (markup?)
-  "Align @var{arg} on its right edge. "
+(define-builtin-markup-command (right-align layout props arg) (markup?)
+  "Align @var{arg} on its right edge."

   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m X RIGHT)))
 
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m X RIGHT)))
 

-(define-markup-command (left-align layout props arg) (markup?)
-  "Align @var{arg} on its left edge. "
+(define-builtin-markup-command (left-align layout props arg) (markup?)
+  "Align @var{arg} on its left edge."

   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m X LEFT)))
 
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m X LEFT)))
 

-(define-markup-command (general-align layout props axis dir arg)  (integer? number? markup?)
+(define-builtin-markup-command (general-align layout props axis dir arg)  (integer? number? markup?)

   "Align @var{arg} in @var{axis} direction to the @var{dir} side."
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m axis dir)))
 
   "Align @var{arg} in @var{axis} direction to the @var{dir} side."
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m axis dir)))
 

-(define-markup-command (halign layout props dir arg) (number? markup?)
-  "Set horizontal alignment. If @var{dir} is @code{-1}, then it is
-left-aligned, while @code{+1} is right. Values in between interpolate
+(define-builtin-markup-command (halign layout props dir arg) (number? markup?)
+  "Set horizontal alignment.  If @var{dir} is @code{-1}, then it is
+left-aligned, while @code{+1} is right.  Values inbetween interpolate

 alignment accordingly."
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m X dir)))
 
 
 
 alignment accordingly."
   (let* ((m (interpret-markup layout props arg)))
     (ly:stencil-aligned-to m X dir)))
 
 
 

-(define-markup-command (with-dimensions layout props x y arg) (number-pair? number-pair? markup?)
-  "Set the dimensions of @var{arg} to @var{x} and @var{y}."
+(define-builtin-markup-command (with-dimensions layout props x y arg) (number-pair? number-pair? markup?)
+  "Set the dimensions of @var{arg} to @var{x} and@tie{}@var{y}."

   
   (let* ((m (interpret-markup layout props arg)))
     (ly:make-stencil (ly:stencil-expr m) x y)))
 
 
   
   (let* ((m (interpret-markup layout props arg)))
     (ly:make-stencil (ly:stencil-expr m) x y)))
 
 

-(define-markup-command (pad-around layout props amount arg) (number? markup?)
-
-  "Add padding @var{amount} all around @var{arg}. "
+(define-builtin-markup-command (pad-around layout props amount arg) (number? markup?)
+  "Add padding @var{amount} all around @var{arg}."

   
   (let*
       ((m (interpret-markup layout props arg))
   
   (let*
       ((m (interpret-markup layout props arg))


@@ -647,9 +702,8 @@ alignment accordingly."
    ))
 
 
    ))
 
 

-(define-markup-command (pad-x layout props amount arg) (number? markup?)
-
-  "Add padding @var{amount} around @var{arg} in the X-direction. "
+(define-builtin-markup-command (pad-x layout props amount arg) (number? markup?)
+  "Add padding @var{amount} around @var{arg} in the X@tie{}direction."

   (let*
       ((m (interpret-markup layout props arg))
        (x (ly:stencil-extent m X))
   (let*
       ((m (interpret-markup layout props arg))
        (x (ly:stencil-extent m X))


@@ -662,18 +716,16 @@ alignment accordingly."
    ))
 
 
    ))
 
 

-(define-markup-command (put-adjacent layout props arg1 axis dir arg2) (markup? integer? ly:dir?  markup?)
-
-  "Put @var{arg2} next to @var{arg1}, without moving @var{arg1}.  "
-  
+(define-builtin-markup-command (put-adjacent layout props arg1 axis dir arg2) (markup? integer? ly:dir?  markup?)
+  "Put @var{arg2} next to @var{arg1}, without moving @var{arg1}."

   (let* ((m1 (interpret-markup layout props arg1))
         (m2 (interpret-markup layout props arg2)))
 
   (let* ((m1 (interpret-markup layout props arg1))
         (m2 (interpret-markup layout props arg2)))
 

-    (ly:stencil-combine-at-edge m1 axis dir m2 0.0 0.0)
+    (ly:stencil-combine-at-edge m1 axis dir m2 0.0)

   ))
 
   ))
 

-(define-markup-command (transparent layout props arg) (markup?)
-  "Make the argument transparent"
+(define-builtin-markup-command (transparent layout props arg) (markup?)
+  "Make the argument transparent."

   (let*
       ((m (interpret-markup layout props arg))
        (x (ly:stencil-extent m X))
   (let*
       ((m (interpret-markup layout props arg))
        (x (ly:stencil-extent m X))


@@ -685,9 +737,9 @@ alignment accordingly."
                     x y)))
 
 
                     x y)))
 
 

-(define-markup-command (pad-to-box layout props x-ext y-ext arg)
+(define-builtin-markup-command (pad-to-box layout props x-ext y-ext arg)

   (number-pair? number-pair? markup?)
   (number-pair? number-pair? markup?)

-  "Make @var{arg} take at least @var{x-ext}, @var{y-ext} space"
+  "Make @var{arg} take at least @var{x-ext}, @var{y-ext} space."

 
   (let*
       ((m (interpret-markup layout props arg))
 
   (let*
       ((m (interpret-markup layout props arg))


@@ -699,7 +751,7 @@ alignment accordingly."
                     (interval-union y-ext y))))
 
 
                     (interval-union y-ext y))))
 
 

-(define-markup-command (hcenter-in layout props length arg)
+(define-builtin-markup-command (hcenter-in layout props length arg)

   (number? markup?)
   "Center @var{arg} horizontally within a box of extending
 @var{length}/2 to the left and right."
   (number? markup?)
   "Center @var{arg} horizontally within a box of extending
 @var{length}/2 to the left and right."


@@ -715,19 +767,19 @@ alignment accordingly."
 ;; property
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; property
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(define-markup-command (fromproperty layout props symbol) (symbol?)
+(define-builtin-markup-command (fromproperty layout props symbol) (symbol?)

   "Read the @var{symbol} from property settings, and produce a stencil
   "Read the @var{symbol} from property settings, and produce a stencil

-  from the markup contained within. If @var{symbol} is not defined, it
-  returns an empty markup"
+from the markup contained within.  If @var{symbol} is not defined, it
+returns an empty markup."

   (let* ((m (chain-assoc-get symbol props)))
     (if (markup? m)
        (interpret-markup layout props m)
        (ly:make-stencil '()  '(1 . -1) '(1 . -1)))))
 
 
   (let* ((m (chain-assoc-get symbol props)))
     (if (markup? m)
        (interpret-markup layout props m)
        (ly:make-stencil '()  '(1 . -1) '(1 . -1)))))
 
 

-(define-markup-command (on-the-fly layout props procedure arg) (symbol? markup?)
-  "Apply the @var{procedure} markup command to
-@var{arg}. @var{procedure} should take a single argument."
+(define-builtin-markup-command (on-the-fly layout props procedure arg) (symbol? markup?)
+  "Apply the @var{procedure} markup command to @var{arg}.
+@var{procedure} should take a single argument."

   (let* ((anonymous-with-signature (lambda (layout props arg) (procedure layout props arg))))
     (set-object-property! anonymous-with-signature
                          'markup-signature
   (let* ((anonymous-with-signature (lambda (layout props arg) (procedure layout props arg))))
     (set-object-property! anonymous-with-signature
                          'markup-signature


@@ -736,24 +788,22 @@ alignment accordingly."
 
 
 
 
 
 

-(define-markup-command (override layout props new-prop arg) (pair? markup?)
+(define-builtin-markup-command (override layout props new-prop arg) (pair? markup?)

   "Add the first argument in to the property list.  Properties may be
 any sort of property supported by @internalsref{font-interface} and
 @internalsref{text-interface}, for example
 
   "Add the first argument in to the property list.  Properties may be
 any sort of property supported by @internalsref{font-interface} and
 @internalsref{text-interface}, for example
 

-@verbatim
+@example

 \\override #'(font-family . married) \"bla\"
 \\override #'(font-family . married) \"bla\"

-@end verbatim
-
-"
+@end example"

   (interpret-markup layout (cons (list new-prop) props) arg))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; files
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
   (interpret-markup layout (cons (list new-prop) props) arg))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; files
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(define-markup-command (verbatim-file layout props name) (string?)
-  "Read the contents of a file, and include verbatimly"
+(define-builtin-markup-command (verbatim-file layout props name) (string?)
+  "Read the contents of a file, and include it verbatim."

 
   (interpret-markup
    layout props
 
   (interpret-markup
    layout props


@@ -772,27 +822,27 @@ any sort of property supported by @internalsref{font-interface} and
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 

-(define-markup-command (bigger layout props arg) (markup?)
-  "Increase the font size relative to current setting"
+(define-builtin-markup-command (bigger layout props arg) (markup?)
+  "Increase the font size relative to current setting."

   (interpret-markup layout props
    `(,fontsize-markup 1 ,arg)))
 
   (interpret-markup layout props
    `(,fontsize-markup 1 ,arg)))
 

-(define-markup-command (smaller layout props arg) (markup?)
-  "Decrease the font size relative to current setting"
+(define-builtin-markup-command (smaller layout props arg) (markup?)
+  "Decrease the font size relative to current setting."

   (interpret-markup layout props
    `(,fontsize-markup -1 ,arg)))
 
   (interpret-markup layout props
    `(,fontsize-markup -1 ,arg)))
 

-(define-markup-command larger (markup?) bigger-markup)
+(define-builtin-markup-command larger (markup?) bigger-markup)

 
 

-(define-markup-command (finger layout props arg) (markup?)
+(define-builtin-markup-command (finger layout props arg) (markup?)

   "Set the argument as small numbers."
   (interpret-markup layout
                     (cons '((font-size . -5) (font-encoding . fetaNumber)) props)
                     arg))
 
 
   "Set the argument as small numbers."
   (interpret-markup layout
                     (cons '((font-size . -5) (font-encoding . fetaNumber)) props)
                     arg))
 
 

-(define-markup-command (fontsize layout props increment arg) (number? markup?)
-  "Add @var{increment} to the font-size. Adjust baseline skip accordingly."
+(define-builtin-markup-command (fontsize layout props increment arg) (number? markup?)
+  "Add @var{increment} to the font-size.  Adjust baseline skip accordingly."

 
   (let* ((fs (chain-assoc-get 'font-size props 0))
         (bs (chain-assoc-get 'baseline-skip props 2)) 
 
   (let* ((fs (chain-assoc-get 'font-size props 0))
         (bs (chain-assoc-get 'baseline-skip props 2)) 


@@ -801,77 +851,74 @@ any sort of property supported by @internalsref{font-interface} and
                   (cons 'font-size (+ fs increment )))))
 
     (interpret-markup layout (cons entries props) arg)))
                   (cons 'font-size (+ fs increment )))))
 
     (interpret-markup layout (cons entries props) arg)))

-  

 
 

+(define-builtin-markup-command (magnify layout props sz arg) (number? markup?)
+  "Set the font magnification for its argument.  In the following
+example, the middle@tie{}A is 10% larger:

 
 

-;; FIXME -> should convert to font-size.
-(define-markup-command (magnify layout props sz arg) (number? markup?)
-  "Set the font magnification for the its argument. In the following
-example, the middle A will be 10% larger:

 @example
 A \\magnify #1.1 @{ A @} A
 @end example
 
 @example
 A \\magnify #1.1 @{ A @} A
 @end example
 

-Note: magnification only works if a font-name is explicitly selected.
+Note: Magnification only works if a font name is explicitly selected.

 Use @code{\\fontsize} otherwise."
   (interpret-markup
    layout 
 Use @code{\\fontsize} otherwise."
   (interpret-markup
    layout 

-   (prepend-alist-chain 'font-magnification sz props)
+   (prepend-alist-chain 'font-size (magnification->font-size sz) props)

    arg))
 
    arg))
 

-(define-markup-command (bold layout props arg) (markup?)
-  "Switch to bold font-series"
+(define-builtin-markup-command (bold layout props arg) (markup?)
+  "Switch to bold font-series."

   (interpret-markup layout (prepend-alist-chain 'font-series 'bold props) arg))
 
   (interpret-markup layout (prepend-alist-chain 'font-series 'bold props) arg))
 

-(define-markup-command (sans layout props arg) (markup?)
-  "Switch to the sans serif family"
+(define-builtin-markup-command (sans layout props arg) (markup?)
+  "Switch to the sans serif family."

   (interpret-markup layout (prepend-alist-chain 'font-family 'sans props) arg))
 
   (interpret-markup layout (prepend-alist-chain 'font-family 'sans props) arg))
 

-(define-markup-command (number layout props arg) (markup?)
+(define-builtin-markup-command (number layout props arg) (markup?)

   "Set font family to @code{number}, which yields the font used for
 time signatures and fingerings.  This font only contains numbers and
   "Set font family to @code{number}, which yields the font used for
 time signatures and fingerings.  This font only contains numbers and

-some punctuation. It doesn't have any letters.  "
+some punctuation.  It doesn't have any letters."

   (interpret-markup layout (prepend-alist-chain 'font-encoding 'fetaNumber props) arg))
 
   (interpret-markup layout (prepend-alist-chain 'font-encoding 'fetaNumber props) arg))
 

-(define-markup-command (roman layout props arg) (markup?)
+(define-builtin-markup-command (roman layout props arg) (markup?)

   "Set font family to @code{roman}."
   (interpret-markup layout (prepend-alist-chain 'font-family 'roman props) arg))
 
   "Set font family to @code{roman}."
   (interpret-markup layout (prepend-alist-chain 'font-family 'roman props) arg))
 

-(define-markup-command (huge layout props arg) (markup?)
+(define-builtin-markup-command (huge layout props arg) (markup?)

   "Set font size to +2."
   (interpret-markup layout (prepend-alist-chain 'font-size 2 props) arg))
 
   "Set font size to +2."
   (interpret-markup layout (prepend-alist-chain 'font-size 2 props) arg))
 

-(define-markup-command (large layout props arg) (markup?)
+(define-builtin-markup-command (large layout props arg) (markup?)

   "Set font size to +1."
   (interpret-markup layout (prepend-alist-chain 'font-size 1 props) arg))
 
   "Set font size to +1."
   (interpret-markup layout (prepend-alist-chain 'font-size 1 props) arg))
 

-(define-markup-command (normalsize layout props arg) (markup?)
+(define-builtin-markup-command (normalsize layout props arg) (markup?)

   "Set font size to default."
   (interpret-markup layout (prepend-alist-chain 'font-size 0 props) arg))
 
   "Set font size to default."
   (interpret-markup layout (prepend-alist-chain 'font-size 0 props) arg))
 

-(define-markup-command (small layout props arg) (markup?)
+(define-builtin-markup-command (small layout props arg) (markup?)

   "Set font size to -1."
   (interpret-markup layout (prepend-alist-chain 'font-size -1 props) arg))
 
   "Set font size to -1."
   (interpret-markup layout (prepend-alist-chain 'font-size -1 props) arg))
 

-(define-markup-command (tiny layout props arg) (markup?)
+(define-builtin-markup-command (tiny layout props arg) (markup?)

   "Set font size to -2."
   (interpret-markup layout (prepend-alist-chain 'font-size -2 props) arg))
 
   "Set font size to -2."
   (interpret-markup layout (prepend-alist-chain 'font-size -2 props) arg))
 

-(define-markup-command (teeny layout props arg) (markup?)
+(define-builtin-markup-command (teeny layout props arg) (markup?)

   "Set font size to -3."
   (interpret-markup layout (prepend-alist-chain 'font-size -3 props) arg))
 
   "Set font size to -3."
   (interpret-markup layout (prepend-alist-chain 'font-size -3 props) arg))
 

-(define-markup-command (caps layout props arg) (markup?)
+(define-builtin-markup-command (fontCaps layout props arg) (markup?)

   "Set @code{font-shape} to @code{caps}."
   (interpret-markup layout (prepend-alist-chain 'font-shape 'caps props) arg))
 
 ;; Poor man's caps
   "Set @code{font-shape} to @code{caps}."
   (interpret-markup layout (prepend-alist-chain 'font-shape 'caps props) arg))
 
 ;; Poor man's caps

-(define-markup-command (smallCaps layout props text) (markup?)
+(define-builtin-markup-command (smallCaps layout props text) (markup?)

   "Turn @code{text}, which should be a string, to small caps.
 @example
 \\markup \\smallCaps \"Text between double quotes\"
   "Turn @code{text}, which should be a string, to small caps.
 @example
 \\markup \\smallCaps \"Text between double quotes\"

-@end example
-"
+@end example"

   (define (make-small-caps-markup chars)
     (cond ((null? chars)
           (markup))
   (define (make-small-caps-markup chars)
     (cond ((null? chars)
           (markup))


@@ -931,15 +978,19 @@ some punctuation. It doesn't have any letters.  "
                                                 #f
                                                 #f)))
 
                                                 #f
                                                 #f)))
 

-(define-markup-command (dynamic layout props arg) (markup?)
+(define-builtin-markup-command (caps layout props arg) (markup?)
+  "Emit @var{arg} as small caps."
+  (interpret-markup layout props (make-smallCaps-markup arg)))
+
+(define-builtin-markup-command (dynamic layout props arg) (markup?)

   "Use the dynamic font.  This font only contains @b{s}, @b{f}, @b{m},
   "Use the dynamic font.  This font only contains @b{s}, @b{f}, @b{m},

-@b{z}, @b{p}, and @b{r}.  When producing phrases, like ``pi@`{u} @b{f}'', the
-normal words (like ``pi@`{u}'') should be done in a different font.  The
-recommend font for this is bold and italic"
+@b{z}, @b{p}, and @b{r}.  When producing phrases, like
+@q{pi@`{u}@tie{}@b{f}}, the normal words (like @q{pi@`{u}}) should be
+done in a different font.  The recommended font for this is bold and italic."

   (interpret-markup
    layout (prepend-alist-chain 'font-encoding 'fetaDynamic props) arg))
 
   (interpret-markup
    layout (prepend-alist-chain 'font-encoding 'fetaDynamic props) arg))
 

-(define-markup-command (text layout props arg) (markup?)
+(define-builtin-markup-command (text layout props arg) (markup?)

   "Use a text font instead of music symbol or music alphabet font."  
 
   ;; ugh - latin1
   "Use a text font instead of music symbol or music alphabet font."  
 
   ;; ugh - latin1


@@ -947,27 +998,28 @@ recommend font for this is bold and italic"
                    arg))
 
 
                    arg))
 
 

-(define-markup-command (italic layout props arg) (markup?)
-  "Use italic @code{font-shape} for @var{arg}. "
+(define-builtin-markup-command (italic layout props arg) (markup?)
+  "Use italic @code{font-shape} for @var{arg}."

   (interpret-markup layout (prepend-alist-chain 'font-shape 'italic props) arg))
 
   (interpret-markup layout (prepend-alist-chain 'font-shape 'italic props) arg))
 

-(define-markup-command (typewriter layout props arg) (markup?)
+(define-builtin-markup-command (typewriter layout props arg) (markup?)

   "Use @code{font-family} typewriter for @var{arg}."
   (interpret-markup
    layout (prepend-alist-chain 'font-family 'typewriter props) arg))
 
   "Use @code{font-family} typewriter for @var{arg}."
   (interpret-markup
    layout (prepend-alist-chain 'font-family 'typewriter props) arg))
 

-(define-markup-command (upright layout props arg) (markup?)
+(define-builtin-markup-command (upright layout props arg) (markup?)

   "Set font shape to @code{upright}.  This is the opposite of @code{italic}."
   (interpret-markup
    layout (prepend-alist-chain 'font-shape 'upright props) arg))
 
   "Set font shape to @code{upright}.  This is the opposite of @code{italic}."
   (interpret-markup
    layout (prepend-alist-chain 'font-shape 'upright props) arg))
 

-(define-markup-command (medium layout props arg) (markup?)
-  "Switch to medium font-series (in contrast to bold)."
+(define-builtin-markup-command (medium layout props arg) (markup?)
+  "Switch to medium font series (in contrast to bold)."

   (interpret-markup layout (prepend-alist-chain 'font-series 'medium props)
                    arg))
 
   (interpret-markup layout (prepend-alist-chain 'font-series 'medium props)
                    arg))
 

-(define-markup-command (normal-text layout props arg) (markup?)
-  "Set all font related properties (except the size) to get the default normal text font, no matter what font was used earlier."
+(define-builtin-markup-command (normal-text layout props arg) (markup?)
+  "Set all font related properties (except the size) to get the default
+normal text font, no matter what font was used earlier."

   ;; ugh - latin1
   (interpret-markup layout
                     (cons '((font-family . roman) (font-shape . upright)
   ;; ugh - latin1
   (interpret-markup layout
                     (cons '((font-family . roman) (font-shape . upright)


@@ -979,45 +1031,46 @@ recommend font for this is bold and italic"
 ;; symbols.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; symbols.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(define-markup-command (doublesharp layout props) ()
+(define-builtin-markup-command (doublesharp layout props) ()

   "Draw a double sharp symbol."
 
   "Draw a double sharp symbol."
 

-  (interpret-markup layout props (markup #:musicglyph "accidentals.4")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get 1 standard-alteration-glyph-name-alist ""))))

 
 

-(define-markup-command (sesquisharp layout props) ()
+(define-builtin-markup-command (sesquisharp layout props) ()

   "Draw a 3/2 sharp symbol."
   "Draw a 3/2 sharp symbol."

-  (interpret-markup layout props (markup #:musicglyph "accidentals.3")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get 3/4 standard-alteration-glyph-name-alist ""))))
+                                        

 
 

-(define-markup-command (sharp layout props) ()
+(define-builtin-markup-command (sharp layout props) ()

   "Draw a sharp symbol."
   "Draw a sharp symbol."

-  (interpret-markup layout props (markup #:musicglyph "accidentals.2")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get 1/2 standard-alteration-glyph-name-alist ""))))

 
 

-(define-markup-command (semisharp layout props) ()
+(define-builtin-markup-command (semisharp layout props) ()

   "Draw a semi sharp symbol."
   "Draw a semi sharp symbol."

-  (interpret-markup layout props (markup #:musicglyph "accidentals.1")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get 1/4 standard-alteration-glyph-name-alist ""))))

 
 

-(define-markup-command (natural layout props) ()
+(define-builtin-markup-command (natural layout props) ()

   "Draw a natural symbol."
   "Draw a natural symbol."

-  (interpret-markup layout props (markup #:musicglyph "accidentals.0")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get 0 standard-alteration-glyph-name-alist ""))))

 
 

-(define-markup-command (semiflat layout props) ()
+(define-builtin-markup-command (semiflat layout props) ()

   "Draw a semiflat."
   "Draw a semiflat."

-  (interpret-markup layout props (markup #:musicglyph "accidentals.M1")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get -1/4 standard-alteration-glyph-name-alist ""))))

 
 

-(define-markup-command (flat layout props) ()
+(define-builtin-markup-command (flat layout props) ()

   "Draw a flat symbol."
   "Draw a flat symbol."

-  (interpret-markup layout props (markup #:musicglyph "accidentals.M2")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get -1/2 standard-alteration-glyph-name-alist ""))))

 
 

-(define-markup-command (sesquiflat layout props) ()
+(define-builtin-markup-command (sesquiflat layout props) ()

   "Draw a 3/2 flat symbol."
   "Draw a 3/2 flat symbol."

-  (interpret-markup layout props (markup #:musicglyph "accidentals.M3")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get -3/4 standard-alteration-glyph-name-alist ""))))

 
 

-(define-markup-command (doubleflat layout props) ()
+(define-builtin-markup-command (doubleflat layout props) ()

   "Draw a double flat symbol."
   "Draw a double flat symbol."

-  (interpret-markup layout props (markup #:musicglyph "accidentals.M4")))
+  (interpret-markup layout props (markup #:musicglyph (assoc-get -1 standard-alteration-glyph-name-alist ""))))

 
 

-(define-markup-command (with-color layout props color arg) (color? markup?)
-  "Draw @var{arg} in color specified by @var{color}"
+(define-builtin-markup-command (with-color layout props color arg) (color? markup?)
+  "Draw @var{arg} in color specified by @var{color}."

 
   (let* ((stil (interpret-markup layout props arg)))
 
 
   (let* ((stil (interpret-markup layout props arg)))
 


@@ -1031,9 +1084,10 @@ recommend font for this is bold and italic"
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 

-(define-markup-command (arrow-head layout props axis direction filled)
+(define-builtin-markup-command (arrow-head layout props axis direction filled)

   (integer? ly:dir? boolean?)
   (integer? ly:dir? boolean?)

-  "produce an arrow head in specified direction and axis. Use the filled head if @var{filled} is  specified."
+  "Produce an arrow head in specified direction and axis.
+Use the filled head if @var{filled} is specified."

   (let*
       ((name (format "arrowheads.~a.~a~a"
                     (if filled
   (let*
       ((name (format "arrowheads.~a.~a~a"
                     (if filled


@@ -1046,25 +1100,26 @@ recommend font for this is bold and italic"
                                     props))
      name)))
 
                                     props))
      name)))
 

-(define-markup-command (musicglyph layout props glyph-name) (string?)
-  "This is converted to a musical symbol, e.g. @code{\\musicglyph
-#\"accidentals.0\"} will select the natural sign from the music font.
-See @usermanref{The Feta font} for  a complete listing of the possible glyphs."
+(define-builtin-markup-command (musicglyph layout props glyph-name) (string?)
+  "@var{glyph0name} is converted to a musical symbol; for example,
+@code{\\musicglyph #\"accidentals.natural\"} selects the natural sign from
+the music font.  See @usermanref{The Feta font} for a complete listing of
+the possible glyphs."

   (ly:font-get-glyph
    (ly:paper-get-font layout (cons '((font-encoding . fetaMusic))
                                   props))
    glyph-name))
 
   (ly:font-get-glyph
    (ly:paper-get-font layout (cons '((font-encoding . fetaMusic))
                                   props))
    glyph-name))
 

-(define-markup-command (lookup layout props glyph-name) (string?)
+(define-builtin-markup-command (lookup layout props glyph-name) (string?)

   "Lookup a glyph by name."
   (ly:font-get-glyph (ly:paper-get-font layout props)
                     glyph-name))
 
   "Lookup a glyph by name."
   (ly:font-get-glyph (ly:paper-get-font layout props)
                     glyph-name))
 

-(define-markup-command (char layout props num) (integer?)
-  "Produce a single character, e.g. @code{\\char #65} produces the 
-letter 'A'."
-  (ly:get-glyph (ly:paper-get-font layout props) num))
+(define-builtin-markup-command (char layout props num) (integer?)
+  "Produce a single character.  For example, @code{\\char #65} produces the 
+letter @q{A}."

 
 

+  (ly:text-interface::interpret-markup layout props (ly:wide-char->utf-8 num)))

 
 (define number->mark-letter-vector (make-vector 25 #\A))
 
 
 (define number->mark-letter-vector (make-vector 25 #\A))
 


@@ -1088,23 +1143,23 @@ letter 'A'."
                       (number->markletter-string vec (remainder n lst)))
        (make-string 1 (vector-ref vec n)))))
 
                       (number->markletter-string vec (remainder n lst)))
        (make-string 1 (vector-ref vec n)))))
 

-(define-markup-command (markletter layout props num) (integer?)
-  "Make a markup letter for @var{num}.  The letters start with A to Z
- (skipping I), and continues with double letters."
+(define-builtin-markup-command (markletter layout props num) (integer?)
+  "Make a markup letter for @var{num}.  The letters start with A to@tie{}Z
+(skipping letter@tie{}I), and continue with double letters."

   (ly:text-interface::interpret-markup layout props
     (number->markletter-string number->mark-letter-vector num)))
 
   (ly:text-interface::interpret-markup layout props
     (number->markletter-string number->mark-letter-vector num)))
 

-(define-markup-command (markalphabet layout props num) (integer?)
-   "Make a markup letter for @var{num}.  The letters start with A to Z
- and continues with double letters."
+(define-builtin-markup-command (markalphabet layout props num) (integer?)
+   "Make a markup letter for @var{num}.  The letters start with A to@tie{}Z
+and continue with double letters."

    (ly:text-interface::interpret-markup layout props
      (number->markletter-string number->mark-alphabet-vector num)))
 
 
 
    (ly:text-interface::interpret-markup layout props
      (number->markletter-string number->mark-alphabet-vector num)))
 
 
 

-(define-markup-command (slashed-digit layout props num) (integer?)
-  "A feta number, with slash. This is for use in the context of
-figured bass notation"
+(define-builtin-markup-command (slashed-digit layout props num) (integer?)
+  "A feta number, with slash.  This is for use in the context of
+figured bass notation."

   (let*
       ((mag (magstep (chain-assoc-get 'font-size props 0)))
        (thickness
   (let*
       ((mag (magstep (chain-assoc-get 'font-size props 0)))
        (thickness


@@ -1117,30 +1172,42 @@ figured bass notation"
        (num-x (interval-widen (ly:stencil-extent number-stencil X)
                              (* mag 0.2)))
        (num-y (ly:stencil-extent number-stencil Y))
        (num-x (interval-widen (ly:stencil-extent number-stencil X)
                              (* mag 0.2)))
        (num-y (ly:stencil-extent number-stencil Y))

-       (slash-stencil 
-       (ly:make-stencil
-        `(draw-line
-          ,thickness
-          ,(car num-x) ,(- (interval-center num-y) dy)
-          ,(cdr num-x) ,(+ (interval-center num-y) dy))
-        num-x num-y
-        )))
-
-    (ly:stencil-add number-stencil
-                   (cond
-                    ((= num 5) (ly:stencil-translate slash-stencil
-                                                     ;;(cons (* mag -0.05) (* mag 0.42))
-                                                     (cons (* mag -0.00) (* mag -0.07))
-
-                                                     ))
-                    ((= num 7) (ly:stencil-translate slash-stencil
-                                                     ;;(cons (* mag -0.05) (* mag 0.42))
-                                                     (cons (* mag -0.00) (* mag -0.15))
-
-                                                     ))
-                    
-                    (else slash-stencil)))
-    ))
+       (is-sane (and (interval-sane? num-x) (interval-sane? num-y)))
+       
+       (slash-stencil
+       (if is-sane
+           (ly:make-stencil
+            `(draw-line
+              ,thickness
+              ,(car num-x) ,(- (interval-center num-y) dy)
+              ,(cdr num-x) ,(+ (interval-center num-y) dy))
+            num-x num-y)
+           #f)))
+
+    (set! slash-stencil
+         (cond
+          ((not (ly:stencil? slash-stencil)) #f)
+          ((= num 5) (ly:stencil-translate slash-stencil
+                                           ;;(cons (* mag -0.05) (* mag 0.42))
+                                           (cons (* mag -0.00) (* mag -0.07))
+
+                                           ))
+          ((= num 7) (ly:stencil-translate slash-stencil
+                                           ;;(cons (* mag -0.05) (* mag 0.42))
+                                           (cons (* mag -0.00) (* mag -0.15))
+
+                                           ))
+          
+          (else slash-stencil)))
+
+    (if slash-stencil
+       (set! number-stencil
+             (ly:stencil-add number-stencil slash-stencil))
+       
+       (ly:warning "invalid number for slashed digit ~a" num))
+
+
+    number-stencil))

 \f
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; the note command.
 \f
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; the note command.


@@ -1149,9 +1216,10 @@ figured bass notation"
 
 ;; TODO: better syntax.
 
 
 ;; TODO: better syntax.
 

-(define-markup-command (note-by-number layout props log dot-count dir) (number? number? number?)
+(define-builtin-markup-command (note-by-number layout props log dot-count dir) (number? number? number?)

   "Construct a note symbol, with stem.  By using fractional values for
 @var{dir}, you can obtain longer or shorter stems."
   "Construct a note symbol, with stem.  By using fractional values for
 @var{dir}, you can obtain longer or shorter stems."

+

   (define (get-glyph-name-candidates dir log style)
     (map (lambda (dir-name)
      (format "noteheads.~a~a~a" dir-name (min log 2)
   (define (get-glyph-name-candidates dir log style)
     (map (lambda (dir-name)
      (format "noteheads.~a~a~a" dir-name (min log 2)


@@ -1173,22 +1241,22 @@ figured bass notation"
         (size-factor (magstep (chain-assoc-get 'font-size props 0)))
         (style (chain-assoc-get 'style props '()))
          (stem-length (*  size-factor (max 3 (- log 1))))
         (size-factor (magstep (chain-assoc-get 'font-size props 0)))
         (style (chain-assoc-get 'style props '()))
          (stem-length (*  size-factor (max 3 (- log 1))))

-         (head-glyph-name (get-glyph-name font (get-glyph-name-candidates dir log style)))
+         (head-glyph-name (get-glyph-name font (get-glyph-name-candidates (sign dir) log style)))

          (head-glyph (ly:font-get-glyph font head-glyph-name))
         (attach-indices (ly:note-head::stem-attachment font head-glyph-name))
          (stem-thickness (* size-factor 0.13))
          (stemy (* dir stem-length))
          (attach-off (cons (interval-index
                            (ly:stencil-extent head-glyph X)
          (head-glyph (ly:font-get-glyph font head-glyph-name))
         (attach-indices (ly:note-head::stem-attachment font head-glyph-name))
          (stem-thickness (* size-factor 0.13))
          (stemy (* dir stem-length))
          (attach-off (cons (interval-index
                            (ly:stencil-extent head-glyph X)

-                           (* dir (car attach-indices)))
-                          (* dir       ; fixme, this is inconsistent between X & Y.
+                           (* (sign dir) (car attach-indices)))
+                          (* (sign dir)        ; fixme, this is inconsistent between X & Y.

                              (interval-index
                               (ly:stencil-extent head-glyph Y)
                               (cdr attach-indices)))))
          (stem-glyph (and (> log 0)
                          (ly:round-filled-box
                           (ordered-cons (car attach-off)
                              (interval-index
                               (ly:stencil-extent head-glyph Y)
                               (cdr attach-indices)))))
          (stem-glyph (and (> log 0)
                          (ly:round-filled-box
                           (ordered-cons (car attach-off)

-                                        (+ (car attach-off)  (* (- dir) stem-thickness)))
+                                        (+ (car attach-off)  (* (- (sign dir)) stem-thickness)))

                           (cons (min stemy (cdr attach-off))
                                 (max stemy (cdr attach-off)))
                           (/ stem-thickness 3))))
                           (cons (min stemy (cdr attach-off))
                                 (max stemy (cdr attach-off)))
                           (/ stem-thickness 3))))


@@ -1199,8 +1267,8 @@ figured bass notation"
                     (apply ly:stencil-add
                            (map (lambda (x)
                                   (ly:stencil-translate-axis
                     (apply ly:stencil-add
                            (map (lambda (x)
                                   (ly:stencil-translate-axis

-                                   dot  (* (+ 1 (* 2 x)) dotwid) X))
-                                (iota dot-count 1)))))
+                                   dot (* 2 x dotwid) X))
+                                (iota dot-count)))))

          (flaggl (and (> log 2)
                       (ly:stencil-translate
                        (ly:font-get-glyph font
          (flaggl (and (> log 2)
                       (ly:stencil-translate
                        (ly:font-get-glyph font


@@ -1208,6 +1276,9 @@ figured bass notation"
                                                         (if (> dir 0) "u" "d")
                                                         (number->string log)))
                        (cons (+ (car attach-off) (/ stem-thickness 2)) stemy)))))
                                                         (if (> dir 0) "u" "d")
                                                         (number->string log)))
                        (cons (+ (car attach-off) (/ stem-thickness 2)) stemy)))))

+
+    (if (and dots flaggl (> dir 0))
+       (set! dots (ly:stencil-translate-axis dots 0.35 X)))

     (if flaggl
         (set! stem-glyph (ly:stencil-add flaggl stem-glyph)))
     (if (ly:stencil? stem-glyph)
     (if flaggl
         (set! stem-glyph (ly:stencil-add flaggl stem-glyph)))
     (if (ly:stencil? stem-glyph)


@@ -1218,12 +1289,7 @@ figured bass notation"
               (ly:stencil-add
                (ly:stencil-translate-axis
                dots
               (ly:stencil-add
                (ly:stencil-translate-axis
                dots

-               (+ (if (and (> dir 0) (> log 2))
-                      (* 1.5 dotwid)
-                      0)
-                  ;; huh ? why not necessary?
-                  ;;(cdr (ly:stencil-extent head-glyph X))
-                  dotwid)
+               (+ (cdr (ly:stencil-extent head-glyph X)) dotwid)

                X)
                stem-glyph)))
     stem-glyph))
                X)
                stem-glyph)))
     stem-glyph))


@@ -1245,9 +1311,9 @@ figured bass notation"
                 (if dots (string-length dots) 0)))
         (ly:error (_ "not a valid duration string: ~a") duration-string))))
 
                 (if dots (string-length dots) 0)))
         (ly:error (_ "not a valid duration string: ~a") duration-string))))
 

-(define-markup-command (note layout props duration dir) (string? number?)
+(define-builtin-markup-command (note layout props duration dir) (string? number?)

   "This produces a note with a stem pointing in @var{dir} direction, with
   "This produces a note with a stem pointing in @var{dir} direction, with

-the @var{duration} for the note head type and augmentation dots. For
+the @var{duration} for the note head type and augmentation dots.  For

 example, @code{\\note #\"4.\" #-0.75} creates a dotted quarter note, with
 a shortened down stem."
   (let ((parsed (parse-simple-duration duration)))
 example, @code{\\note #\"4.\" #-0.75} creates a dotted quarter note, with
 a shortened down stem."
   (let ((parsed (parse-simple-duration duration)))


@@ -1258,18 +1324,16 @@ a shortened down stem."
 ;; translating.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; translating.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(define-markup-command (lower layout props amount arg) (number? markup?)
-  "
-Lower @var{arg}, by the distance @var{amount}.
-A negative @var{amount} indicates raising, see also @code{\\raise}.
-"
+(define-builtin-markup-command (lower layout props amount arg) (number? markup?)
+  "Lower @var{arg} by the distance @var{amount}.
+A negative @var{amount} indicates raising; see also @code{\\raise}."

   (ly:stencil-translate-axis (interpret-markup layout props arg)
                             (- amount) Y))
 
 
   (ly:stencil-translate-axis (interpret-markup layout props arg)
                             (- amount) Y))
 
 

-(define-markup-command (translate-scaled layout props offset arg) (number-pair? markup?)
-  "Translate @var{arg} by @var{offset}, scaling the offset by the @code{font-size}."
-
+(define-builtin-markup-command (translate-scaled layout props offset arg) (number-pair? markup?)
+  "Translate @var{arg} by @var{offset}, scaling the offset by the
+@code{font-size}."

   (let*
       ((factor (magstep (chain-assoc-get 'font-size props 0)))
        (scaled (cons (* factor (car offset))
   (let*
       ((factor (magstep (chain-assoc-get 'font-size props 0)))
        (scaled (cons (* factor (car offset))


@@ -1278,13 +1342,12 @@ A negative @var{amount} indicates raising, see also @code{\\raise}.
   (ly:stencil-translate (interpret-markup layout props arg)
                        scaled)))
 
   (ly:stencil-translate (interpret-markup layout props arg)
                        scaled)))
 

-(define-markup-command (raise layout props amount arg) (number? markup?)
-  "
-Raise @var{arg}, by the distance @var{amount}.
+(define-builtin-markup-command (raise layout props amount arg) (number? markup?)
+  "Raise @var{arg} by the distance @var{amount}.

 A negative @var{amount} indicates lowering, see also @code{\\lower}.
 @c
 @lilypond[verbatim,fragment,relative=1]
 A negative @var{amount} indicates lowering, see also @code{\\lower}.
 @c
 @lilypond[verbatim,fragment,relative=1]

- c1^\\markup { C \\small \\raise #1.0 \\bold { \"9/7+\" }}
+c1^\\markup { C \\small \\raise #1.0 \\bold { \"9/7+\" } }

 @end lilypond
 The argument to @code{\\raise} is the vertical displacement amount,
 measured in (global) staff spaces.  @code{\\raise} and @code{\\super}
 @end lilypond
 The argument to @code{\\raise} is the vertical displacement amount,
 measured in (global) staff spaces.  @code{\\raise} and @code{\\super}


@@ -1293,40 +1356,41 @@ raise objects in relation to their surrounding markups.
 If the text object itself is positioned above or below the staff, then
 @code{\\raise} cannot be used to move it, since the mechanism that
 positions it next to the staff cancels any shift made with
 If the text object itself is positioned above or below the staff, then
 @code{\\raise} cannot be used to move it, since the mechanism that
 positions it next to the staff cancels any shift made with

-@code{\\raise}. For vertical positioning, use the @code{padding}
-and/or @code{extra-offset} properties. "
+@code{\\raise}.  For vertical positioning, use the @code{padding}
+and/or @code{extra-offset} properties."

   (ly:stencil-translate-axis (interpret-markup layout props arg) amount Y))
 
   (ly:stencil-translate-axis (interpret-markup layout props arg) amount Y))
 

-(define-markup-command (fraction layout props arg1 arg2) (markup? markup?)
+(define-builtin-markup-command (fraction layout props arg1 arg2) (markup? markup?)

   "Make a fraction of two markups."
   (let* ((m1 (interpret-markup layout props arg1))
   "Make a fraction of two markups."
   (let* ((m1 (interpret-markup layout props arg1))

-         (m2 (interpret-markup layout props arg2)))
+         (m2 (interpret-markup layout props arg2))
+         (factor (magstep (chain-assoc-get 'font-size props 0)))
+         (boxdimen (cons (* factor -0.05) (* factor 0.05)))
+         (padding (* factor 0.2))
+         (baseline (* factor 0.6))
+         (offset (* factor 0.75)))

     (set! m1 (ly:stencil-aligned-to m1 X CENTER))
     (set! m2 (ly:stencil-aligned-to m2 X CENTER))
     (let* ((x1 (ly:stencil-extent m1 X))
            (x2 (ly:stencil-extent m2 X))
     (set! m1 (ly:stencil-aligned-to m1 X CENTER))
     (set! m2 (ly:stencil-aligned-to m2 X CENTER))
     (let* ((x1 (ly:stencil-extent m1 X))
            (x2 (ly:stencil-extent m2 X))

-           (line (ly:round-filled-box (interval-union x1 x2) '(-0.05 . 0.05) 0.0))
+           (line (ly:round-filled-box (interval-union x1 x2) boxdimen 0.0))

            ;; should stack mols separately, to maintain LINE on baseline
            ;; should stack mols separately, to maintain LINE on baseline

-           (stack (stack-lines -1 0.2 0.6 (list m1 line m2))))
+           (stack (stack-lines DOWN padding baseline (list m1 line m2))))

       (set! stack
            (ly:stencil-aligned-to stack Y CENTER))
       (set! stack
            (ly:stencil-aligned-to stack X LEFT))
       ;; should have EX dimension
       ;; empirical anyway
       (set! stack
            (ly:stencil-aligned-to stack Y CENTER))
       (set! stack
            (ly:stencil-aligned-to stack X LEFT))
       ;; should have EX dimension
       ;; empirical anyway

-      (ly:stencil-translate-axis stack 0.75 Y))))
-
-
+      (ly:stencil-translate-axis stack offset Y))))

 
 

-
-
-(define-markup-command (normal-size-super layout props arg) (markup?)
+(define-builtin-markup-command (normal-size-super layout props arg) (markup?)

   "Set @var{arg} in superscript with a normal font size."
   (ly:stencil-translate-axis
    (interpret-markup layout props arg)
    (* 0.5 (chain-assoc-get 'baseline-skip props)) Y))
 
   "Set @var{arg} in superscript with a normal font size."
   (ly:stencil-translate-axis
    (interpret-markup layout props arg)
    (* 0.5 (chain-assoc-get 'baseline-skip props)) Y))
 

-(define-markup-command (super layout props arg) (markup?)
+(define-builtin-markup-command (super layout props arg) (markup?)

   "
 @cindex raising text
 @cindex lowering text
   "
 @cindex raising text
 @cindex lowering text


@@ -1335,15 +1399,12 @@ and/or @code{extra-offset} properties. "
 
 @cindex @code{\\super}
 
 
 @cindex @code{\\super}
 

-

 Raising and lowering texts can be done with @code{\\super} and
 @code{\\sub}:
 Raising and lowering texts can be done with @code{\\super} and
 @code{\\sub}:

-
+@c

 @lilypond[verbatim,fragment,relative=1]
 @lilypond[verbatim,fragment,relative=1]

- c1^\\markup { E \"=\" mc \\super \"2\" }
-@end lilypond
-
-"
+c1^\\markup { E \"=\" \\concat { \"mc\" \\super \"2\" } }
+@end lilypond"

   (ly:stencil-translate-axis
    (interpret-markup
     layout
   (ly:stencil-translate-axis
    (interpret-markup
     layout


@@ -1352,21 +1413,21 @@ Raising and lowering texts can be done with @code{\\super} and
    (* 0.5 (chain-assoc-get 'baseline-skip props))
    Y))
 
    (* 0.5 (chain-assoc-get 'baseline-skip props))
    Y))
 

-(define-markup-command (translate layout props offset arg) (number-pair? markup?)
-  "This translates an object. Its first argument is a cons of numbers
+(define-builtin-markup-command (translate layout props offset arg) (number-pair? markup?)
+  "This translates an object.  Its first argument is a cons of numbers.
+

 @example
 A \\translate #(cons 2 -3) @{ B C @} D
 @end example
 @example
 A \\translate #(cons 2 -3) @{ B C @} D
 @end example

-This moves `B C' 2 spaces to the right, and 3 down, relative to its
-surroundings. This command cannot be used to move isolated scripts
-vertically, for the same reason that @code{\\raise} cannot be used for
-that.

 
 

-"
+This moves @q{B C} 2@tie{}spaces to the right, and 3 down, relative to its
+surroundings.  This command cannot be used to move isolated scripts
+vertically, for the same reason that @code{\\raise} cannot be used for
+that."

   (ly:stencil-translate (interpret-markup  layout props arg)
                        offset))
 
   (ly:stencil-translate (interpret-markup  layout props arg)
                        offset))
 

-(define-markup-command (sub layout props arg) (markup?)
+(define-builtin-markup-command (sub layout props arg) (markup?)

   "Set @var{arg} in subscript."
   (ly:stencil-translate-axis
    (interpret-markup
   "Set @var{arg} in subscript."
   (ly:stencil-translate-axis
    (interpret-markup


@@ -1376,7 +1437,7 @@ that.
    (* -0.5 (chain-assoc-get 'baseline-skip props))
    Y))
 
    (* -0.5 (chain-assoc-get 'baseline-skip props))
    Y))
 

-(define-markup-command (normal-size-sub layout props arg) (markup?)
+(define-builtin-markup-command (normal-size-sub layout props arg) (markup?)

   "Set @var{arg} in subscript, in a normal font size."
   (ly:stencil-translate-axis
    (interpret-markup layout props arg)
   "Set @var{arg} in subscript, in a normal font size."
   (ly:stencil-translate-axis
    (interpret-markup layout props arg)


@@ -1387,94 +1448,80 @@ that.
 ;; brackets.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; brackets.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(define-markup-command (hbracket layout props arg) (markup?)
+(define-builtin-markup-command (hbracket layout props arg) (markup?)

   "Draw horizontal brackets around @var{arg}."  
   (let ((th 0.1) ;; todo: take from GROB.
         (m (interpret-markup layout props arg)))
     (bracketify-stencil m X th (* 2.5 th) th)))
 
   "Draw horizontal brackets around @var{arg}."  
   (let ((th 0.1) ;; todo: take from GROB.
         (m (interpret-markup layout props arg)))
     (bracketify-stencil m X th (* 2.5 th) th)))
 

-(define-markup-command (bracket layout props arg) (markup?)
+(define-builtin-markup-command (bracket layout props arg) (markup?)

   "Draw vertical brackets around @var{arg}."  
   (let ((th 0.1) ;; todo: take from GROB.
         (m (interpret-markup layout props arg)))
     (bracketify-stencil m Y th (* 2.5 th) th)))
   "Draw vertical brackets around @var{arg}."  
   (let ((th 0.1) ;; todo: take from GROB.
         (m (interpret-markup layout props arg)))
     (bracketify-stencil m Y th (* 2.5 th) th)))

+\f
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Delayed markup evaluation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 
 

-(define-markup-command (bracketed-y-column layout props indices args)
-  (list? markup-list?)
-  "Make a column of the markups in @var{args}, putting brackets around
-the elements marked in @var{indices}, which is a list of numbers.
-
-"
-;;
-;; DROPME? This command is a relic from the old figured bass implementation.
-;;
-  
-  (define (sublist lst start stop)
-    (take (drop lst start) (- (1+ stop) start)))
-
-  (define (stencil-list-extent ss axis)
-    (cons
-     (apply min (map (lambda (x) (car (ly:stencil-extent x axis))) ss))
-     (apply max (map (lambda (x) (cdr (ly:stencil-extent x axis))) ss))))
-  
+(define-builtin-markup-command (page-ref layout props label gauge default)
+  (symbol? markup? markup?)
+  "Reference to a page number. @var{label} is the label set on the referenced
+page (using the @code{\\label} command), @var{gauge} a markup used to estimate
+the maximum width of the page number, and @var{default} the value to display
+when @var{label} is not found."
+  (let* ((gauge-stencil (interpret-markup layout props gauge))
+        (x-ext (ly:stencil-extent gauge-stencil X))
+        (y-ext (ly:stencil-extent gauge-stencil Y)))
+    (ly:make-stencil
+     `(delay-stencil-evaluation
+       ,(delay (ly:stencil-expr
+               (let* ((table (ly:output-def-lookup layout 'label-page-table))
+                      (label-page (and (list? table) (assoc label table)))
+                      (page-number (and label-page (cdr label-page)))
+                      (page-markup (if page-number (format "~a" page-number) default))
+                      (page-stencil (interpret-markup layout props page-markup))
+                      (gap (- (interval-length x-ext)
+                              (interval-length (ly:stencil-extent page-stencil X)))))
+                 (interpret-markup layout props
+                                   (markup #:concat (#:hspace gap page-markup)))))))
+     x-ext
+     y-ext)))

 
 

-  (define (stack-stencils-vertically stencils bskip last-stencil)
-    (cond
-     ((null? stencils) '())
-     ((not (ly:stencil? last-stencil))
-      (cons (car stencils)
-           (stack-stencils-vertically (cdr stencils) bskip (car stencils))))
-     (else
-      (let* ((orig (car stencils))
-            (dir (chain-assoc-get 'direction  props DOWN))
-            (new (ly:stencil-moved-to-edge last-stencil Y dir
-                                           orig
-                                           0.1 bskip)))
-
-       (cons new (stack-stencils-vertically (cdr stencils) bskip new))))))
-
-  (define (make-brackets stencils indices acc)
-    (if (and stencils
-            (pair? indices)
-            (pair? (cdr indices)))
-       (let* ((encl (sublist stencils (car indices) (cadr indices)))
-              (x-ext (stencil-list-extent encl X))
-              (y-ext (stencil-list-extent encl Y))
-              (thick 0.10)
-              (pad 0.35)
-              (protusion (* 2.5 thick))
-              (lb
-               (ly:stencil-translate-axis 
-                (ly:bracket Y y-ext thick protusion)
-                (- (car x-ext) pad) X))
-              (rb (ly:stencil-translate-axis
-                   (ly:bracket Y y-ext thick (- protusion))
-                   (+ (cdr x-ext) pad) X)))
-
-         (make-brackets
-          stencils (cddr indices)
-          (append
-           (list lb rb)
-           acc)))
-       acc))
-
-  (let* ((stencils
-         (map (lambda (x)
-                (interpret-markup
-                 layout
-                 props
-                 x)) args))
-        (leading
-         (chain-assoc-get 'baseline-skip props))
-        (stacked (stack-stencils-vertically
-                  (remove ly:stencil-empty? stencils) 1.25 #f))
-        (brackets (make-brackets stacked indices '())))
-
-    (apply ly:stencil-add
-          (append stacked brackets))))

 \f
 \f

-

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

-;; size indications arrow
+;; Markup list commands

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

+(define (space-lines baseline-skip lines)
+  (map (lambda (line)
+        (stack-lines DOWN 0.0 (/ baseline-skip 2.0)
+                     (list (ly:make-stencil "" (cons 0 0) (cons 0 0))
+                           line
+                           (ly:make-stencil "" (cons 0 0) (cons 0 0)))))
+       lines))
+
+(define-builtin-markup-list-command (justified-lines layout props args) (markup-list?)
+  "Like @code{\\justify}, but return a list of lines instead of a single markup.
+Use @code{\\override #'(line-width . @var{X})} to set the line width;
+@var{X}@tie{}is the number of staff spaces."
+  (space-lines (chain-assoc-get 'baseline-skip props)
+              (wordwrap-markups layout props args #t)))
+
+(define-builtin-markup-list-command (wordwrap-lines layout props args) (markup-list?)
+  "Like @code{\\wordwrap}, but return a list of lines instead of a single markup.
+Use @code{\\override #'(line-width . @var{X})} to set the line width,
+where @var{X} is the number of staff spaces."
+  (space-lines (chain-assoc-get 'baseline-skip props)
+              (wordwrap-markups layout props args #f)))
+
+(define-builtin-markup-list-command (column-lines layout props args) (markup-list?)
+  "Like @code{\\column}, but return a list of lines instead of a single markup.
+@code{baseline-skip} determines the space between each markup in @var{args}."
+  (space-lines (chain-assoc-get 'baseline-skip props)
+              (interpret-markup-list layout props args)))
+
+(define-builtin-markup-list-command (override-lines layout props new-prop args)
+  (pair? markup-list?)
+  "Like @code{\\override}, for markup lists."
+  (interpret-markup-list layout (cons (list new-prop) props) args))