-;;;; define-markup-commands.scm -- markup commands
+;;;; This file is part of LilyPond, the GNU music typesetter.
;;;;
-;;;; source file of the GNU LilyPond music typesetter
-;;;;
-;;;; (c) 2000--2009 Han-Wen Nienhuys <hanwen@xs4all.nl>
+;;;; Copyright (C) 2000--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
;;;; Jan Nieuwenhuizen <janneke@gnu.org>
-
-
-;;; markup commands
-;;; * each markup function should have a doc string with
-;; syntax, description and example.
+;;;;
+;;;; LilyPond is free software: you can redistribute it and/or modify
+;;;; it under the terms of the GNU General Public License as published by
+;;;; the Free Software Foundation, either version 3 of the License, or
+;;;; (at your option) any later version.
+;;;;
+;;;; LilyPond is distributed in the hope that it will be useful,
+;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;;;; GNU General Public License for more details.
+;;;;
+;;;; You should have received a copy of the GNU General Public License
+;;;; along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
+
+;;;
+;;; Markup commands and markup-list commands definitions.
+;;;
+;;; Markup commands which are part of LilyPond, are defined
+;;; in the (lily) module, which is the current module in this file,
+;;; using the `define-markup-command' macro.
+;;;
+;;; Usage:
+;;;
+;;; (define-markup-command (command-name layout props args...)
+;;; args-signature
+;;; [ #:category category ]
+;;; [ #:properties property-bindings ]
+;;; documentation-string
+;;; ..body..)
+;;;
+;;; with:
+;;; command-name
+;;; the name of the markup command
+;;;
+;;; layout and props
+;;; arguments that are automatically passed to the command when it
+;;; is interpreted.
+;;; `layout' is an output def, which properties can be accessed
+;;; using `ly:output-def-lookup'.
+;;; `props' is a list of property settings which can be accessed
+;;; using `chain-assoc-get' (more on that below)
+;;;
+;;; args...
+;;; the command arguments.
+;;; There is no limitation on the order of command arguments.
+;;; However, markup functions taking a markup as their last
+;;; argument are somewhat special as you can apply them to a
+;;; markup list, and the result is a markup list where the
+;;; markup function (with the specified leading arguments) has
+;;; been applied to every element of the original markup list.
+;;;
+;;; Since replicating the leading arguments for applying a
+;;; markup function to a markup list is cheap mostly for
+;;; Scheme arguments, you avoid performance pitfalls by just
+;;; using Scheme arguments for the leading arguments of markup
+;;; functions that take a markup as their last argument.
+;;;
+;;; args-signature
+;;; the arguments signature, i.e. a list of type predicates which
+;;; are used to type check the arguments, and also to define the general
+;;; argument types (markup, markup-list, scheme) that the command is
+;;; expecting.
+;;; For instance, if a command expects a number, then a markup, the
+;;; signature would be: (number? markup?)
+;;;
+;;; category
+;;; for documentation purpose, builtin markup commands are grouped by
+;;; category. This can be any symbol. When documentation is generated,
+;;; the symbol is converted to a capitalized string, where hyphens are
+;;; replaced by spaces.
+;;;
+;;; property-bindings
+;;; this is used both for documentation generation, and to ease
+;;; programming the command itself. It is list of
+;;; (property-name default-value)
+;;; or (property-name)
+;;; elements. Each property is looked-up in the `props' argument, and
+;;; the symbol naming the property is bound to its value.
+;;; When the property is not found in `props', then the symbol is bound
+;;; to the given default value. When no default value is given, #f is
+;;; used instead.
+;;; Thus, using the following property bindings:
+;;; ((thickness 0.1)
+;;; (font-size 0))
+;;; is equivalent to writing:
+;;; (let ((thickness (chain-assoc-get 'thickness props 0.1))
+;;; (font-size (chain-assoc-get 'font-size props 0)))
+;;; ..body..)
+;;; When a command `B' internally calls an other command `A', it may
+;;; desirable to see in `B' documentation all the properties and
+;;; default values used by `A'. In that case, add `A-markup' to the
+;;; property-bindings of B. (This is used when generating
+;;; documentation, but won't create bindings.)
+;;;
+;;; documentation-string
+;;; the command documentation string (used to generate manuals)
+;;;
+;;; body
+;;; the command body. The function is supposed to return a stencil.
+;;;
+;;; Each markup command definition shall have a documentation string
+;;; with description, syntax and example.
(use-modules (ice-9 regex))
;; geometric shapes
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (draw-line layout props dest)
+(define-markup-command (draw-line layout props dest)
(number-pair?)
- graphic
- ((thickness 1))
+ #:category graphic
+ #:properties ((thickness 1))
"
@cindex drawing lines within text
(y (cdr dest)))
(make-line-stencil th 0 0 x y)))
-(define-builtin-markup-command (draw-circle layout props radius thickness filled)
- (number? number? boolean?)
- graphic
+(define-markup-command (draw-hline layout props)
()
+ #:category graphic
+ #:properties ((draw-line-markup)
+ (line-width)
+ (span-factor 1))
+ "
+@cindex drawing a line across a page
+
+Draws a line across a page, where the property @code{span-factor}
+controls what fraction of the page is taken up.
+@lilypond[verbatim,quote]
+\\markup {
+ \\column {
+ \\draw-hline
+ \\override #'(span-factor . 1/3)
+ \\draw-hline
+ }
+}
+@end lilypond"
+ (interpret-markup layout
+ props
+ (markup #:draw-line (cons (* line-width
+ span-factor)
+ 0))))
+
+(define-markup-command (draw-circle layout props radius thickness filled)
+ (number? number? boolean?)
+ #:category graphic
"
@cindex drawing circles within text
@end lilypond"
(make-circle-stencil radius thickness filled))
-(define-builtin-markup-command (triangle layout props filled)
+(define-markup-command (triangle layout props filled)
(boolean?)
- graphic
- ((thickness 0.1)
- (font-size 0)
- (baseline-skip 2))
+ #:category graphic
+ #:properties ((thickness 0.1)
+ (font-size 0)
+ (baseline-skip 2))
"
@cindex drawing triangles within text
(cons 0 ex)
(cons 0 (* .86 ex)))))
-(define-builtin-markup-command (circle layout props arg)
+(define-markup-command (circle layout props arg)
(markup?)
- graphic
- ((thickness 1)
- (font-size 0)
- (circle-padding 0.2))
+ #:category graphic
+ #:properties ((thickness 1)
+ (font-size 0)
+ (circle-padding 0.2))
"
@cindex circling text
(m (interpret-markup layout props arg)))
(circle-stencil m th pad)))
-(define-builtin-markup-command (with-url layout props url arg)
+(define-markup-command (with-url layout props url arg)
(string? markup?)
- graphic
- ()
+ #:category graphic
"
@cindex inserting URL links into text
(ly:stencil-add (ly:make-stencil url-expr xextent yextent) stil)))
-(define-builtin-markup-command (beam layout props width slope thickness)
+(define-markup-command (page-link layout props page-number arg)
+ (number? markup?)
+ #:category other
+ "
+@cindex referencing page numbers in text
+
+Add a link to the page @var{page-number} around @var{arg}. This only works in
+the PDF backend.
+
+@lilypond[verbatim,quote]
+\\markup {
+ \\page-link #2 { \\italic { This links to page 2... } }
+}
+@end lilypond"
+ (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))
+ (link-expr (list 'page-link page-number `(quote ,xextent) `(quote ,yextent))))
+
+ (ly:stencil-add (ly:make-stencil link-expr xextent yextent) stil)))
+
+(define-markup-command (with-link layout props label arg)
+ (symbol? markup?)
+ #:category other
+ "
+@cindex referencing page labels in text
+
+Add a link to the page holding label @var{label} around @var{arg}. This
+only works in the PDF backend.
+
+@lilypond[verbatim,quote]
+\\markup {
+ \\with-link #\"label\" { \\italic { This links to the page containing the label... } }
+}
+@end lilypond"
+ (let* ((arg-stencil (interpret-markup layout props arg))
+ (x-ext (ly:stencil-extent arg-stencil X))
+ (y-ext (ly:stencil-extent arg-stencil Y)))
+ (ly:make-stencil
+ `(delay-stencil-evaluation
+ ,(delay (ly:stencil-expr
+ (let* ((table (ly:output-def-lookup layout 'label-page-table))
+ (page-number (if (list? table)
+ (assoc-get label table)
+ #f))
+ (link-expr (list 'page-link page-number
+ `(quote ,x-ext) `(quote ,y-ext))))
+ (ly:stencil-add (ly:make-stencil link-expr x-ext y-ext)
+arg-stencil)))))
+ x-ext
+ y-ext)))
+
+
+(define-markup-command (beam layout props width slope thickness)
(number? number? number?)
- graphic
- ()
+ #:category graphic
"
@cindex drawing beams within text
(half (/ thickness 2)))
(ly:make-stencil
- `(polygon ',(list
+ `(polygon ',(list
0 (/ thickness -2)
width (+ (* width slope) (/ thickness -2))
width (+ (* width slope) (/ thickness 2))
(cons (+ (- half) (car yext))
(+ half (cdr yext))))))
-(define-builtin-markup-command (underline layout props arg)
+(define-markup-command (underline layout props arg)
(markup?)
- font
- ((thickness 1))
+ #:category font
+ #:properties ((thickness 1) (offset 2))
"
@cindex underlining text
Underline @var{arg}. Looks at @code{thickness} to determine line
-thickness and y-offset.
+thickness, and @code{offset} to determine line y-offset.
@lilypond[verbatim,quote]
-\\markup {
- default
- \\hspace #2
- \\override #'(thickness . 2)
- \\underline {
- underline
- }
+\\markup \\fill-line {
+ \\underline \"underlined\"
+ \\override #'(offset . 5)
+ \\override #'(thickness . 1)
+ \\underline \"underlined\"
+ \\override #'(offset . 1)
+ \\override #'(thickness . 5)
+ \\underline \"underlined\"
}
@end lilypond"
- (let* ((thick (* (ly:output-def-lookup layout 'line-thickness)
- thickness))
+ (let* ((thick (ly:output-def-lookup layout 'line-thickness))
+ (underline-thick (* thickness thick))
(markup (interpret-markup layout props arg))
(x1 (car (ly:stencil-extent markup X)))
(x2 (cdr (ly:stencil-extent markup X)))
- (y (* thick -2))
- (line (make-line-stencil thick x1 y x2 y)))
+ (y (* thick (- offset)))
+ (line (make-line-stencil underline-thick x1 y x2 y)))
(ly:stencil-add markup line)))
-(define-builtin-markup-command (box layout props arg)
+(define-markup-command (box layout props arg)
(markup?)
- font
- ((thickness 1)
- (font-size 0)
- (box-padding 0.2))
+ #:category font
+ #:properties ((thickness 1)
+ (font-size 0)
+ (box-padding 0.2))
"
@cindex enclosing text within a box
(m (interpret-markup layout props arg)))
(box-stencil m th pad)))
-(define-builtin-markup-command (filled-box layout props xext yext blot)
+(define-markup-command (filled-box layout props xext yext blot)
(number-pair? number-pair? number?)
- graphic
- ()
+ #:category graphic
"
@cindex drawing solid boxes within text
@cindex drawing boxes with rounded corners
(ly:round-filled-box
xext yext blot))
-(define-builtin-markup-command (rounded-box layout props arg)
+(define-markup-command (rounded-box layout props arg)
(markup?)
- graphic
- ((thickness 1)
- (corner-radius 1)
- (font-size 0)
- (box-padding 0.5))
+ #:category graphic
+ #:properties ((thickness 1)
+ (corner-radius 1)
+ (font-size 0)
+ (box-padding 0.5))
"@cindex enclosing text in a box with rounded corners
@cindex drawing boxes with rounded corners around text
Draw a box with rounded corners around @var{arg}. Looks at @code{thickness},
}
}
c,8. c16 c4 r
-@end lilypond"
+@end lilypond"
(let ((th (* (ly:output-def-lookup layout 'line-thickness)
thickness))
(pad (* (magstep font-size) box-padding))
(ly:stencil-add (rounded-box-stencil m th pad corner-radius)
m)))
-(define-builtin-markup-command (rotate layout props ang arg)
+(define-markup-command (rotate layout props ang arg)
(number? markup?)
- align
- ()
+ #:category align
"
@cindex rotating text
(let* ((stil (interpret-markup layout props arg)))
(ly:stencil-rotate stil ang 0 0)))
-(define-builtin-markup-command (whiteout layout props arg)
+(define-markup-command (whiteout layout props arg)
(markup?)
- other
- ()
+ #:category other
"
@cindex adding a white background to text
@end lilypond"
(stencil-whiteout (interpret-markup layout props arg)))
-(define-builtin-markup-command (pad-markup layout props amount arg)
+(define-markup-command (pad-markup layout props amount arg)
(number? markup?)
- align
- ()
+ #:category align
"
@cindex padding text
@cindex putting space around text
;; space
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (strut layout props)
- ()
- other
+(define-markup-command (strut layout props)
()
+ #:category other
"
@cindex creating vertical spaces in text
)))
;; todo: fix negative space
-(define-builtin-markup-command (hspace layout props amount)
+(define-markup-command (hspace layout props amount)
(number?)
- align
- ()
+ #:category align
+ #:properties ((word-space))
"
@cindex creating horizontal spaces in text
three
}
@end lilypond"
- (if (> amount 0)
- (ly:make-stencil "" (cons 0 amount) '(-1 . 1))
- (ly:make-stencil "" (cons amount amount) '(-1 . 1))))
+ (let ((corrected-space (- amount word-space)))
+ (if (> corrected-space 0)
+ (ly:make-stencil "" (cons 0 corrected-space) '(0 . 0))
+ (ly:make-stencil "" (cons corrected-space corrected-space) '(0 . 0)))))
+
+;; todo: fix negative space
+(define-markup-command (vspace layout props amount)
+ (number?)
+ #:category align
+ "
+@cindex creating vertical spaces in text
+
+Create an invisible object taking up vertical space
+of @var{amount} multiplied by 3.
+
+@lilypond[verbatim,quote]
+\\markup {
+ \\center-column {
+ one
+ \\vspace #2
+ two
+ \\vspace #5
+ three
+ }
+}
+@end lilypond"
+ (let ((amount (* amount 3.0)))
+ (if (> amount 0)
+ (ly:make-stencil "" (cons 0 0) (cons 0 amount))
+ (ly:make-stencil "" (cons 0 0) (cons amount amount)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; importing graphics.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (stencil layout props stil)
+(define-markup-command (stencil layout props stil)
(ly:stencil?)
- other
- ()
+ #:category other
"
@cindex importing stencils into text
"Extract the bbox from STRING, or return #f if not present."
(let*
((match (regexp-exec bbox-regexp string)))
-
+
(if match
(map (lambda (x)
(string->number (match:substring match x)))
(cdr (iota 5)))
-
+
#f)))
-(define-builtin-markup-command (epsfile layout props axis size file-name)
+(define-markup-command (epsfile layout props axis size file-name)
(number? number? string?)
- graphic
- ()
+ #:category graphic
"
@cindex inlining an Encapsulated PostScript image
(eps-file->stencil axis size file-name)
))
-(define-builtin-markup-command (postscript layout props str)
+(define-markup-command (postscript layout props str)
(string?)
- graphic
- ()
+ #:category graphic
"
@cindex inserting PostScript directly into text
This inserts @var{str} directly into the output as a PostScript
command string.
@lilypond[verbatim,quote]
-eyeglassesps = #\"
+ringsps = #\"
0.15 setlinewidth
- -0.9 0 translate
- 1.1 1.1 scale
- 1.2 0.7 moveto
- 0.7 0.7 0.5 0 361 arc
- stroke
- 2.20 0.70 0.50 0 361 arc
- stroke
- 1.45 0.85 0.30 0 180 arc
+ 0.9 0.6 moveto
+ 0.4 0.6 0.5 0 361 arc
stroke
- 0.20 0.70 moveto
- 0.80 2.00 lineto
- 0.92 2.26 1.30 2.40 1.15 1.70 curveto
+ 1.0 0.6 0.5 0 361 arc
stroke
- 2.70 0.70 moveto
- 3.30 2.00 lineto
- 3.42 2.26 3.80 2.40 3.65 1.70 curveto
- stroke\"
+ \"
-eyeglasses = \\markup {
- \\with-dimensions #'(0 . 4.4) #'(0 . 2.5)
- \\postscript #eyeglassesps
+rings = \\markup {
+ \\with-dimensions #'(-0.2 . 1.6) #'(0 . 1.2)
+ \\postscript #ringsps
}
\\relative c'' {
- c2^\\eyeglasses
- a2_\\eyeglasses
+ c2^\\rings
+ a2_\\rings
}
@end lilypond"
;; FIXME
str))
'(0 . 0) '(0 . 0)))
-(define-builtin-markup-command (score layout props score)
+(define-markup-command (path layout props thickness commands) (number? list?)
+ #:category graphic
+ #:properties ((line-cap-style 'round)
+ (line-join-style 'round)
+ (filled #f))
+ "
+@cindex paths, drawing
+@cindex drawing paths
+Draws a path with line thickness @var{thickness} according to the
+directions given in @var{commands}. @var{commands} is a list of
+lists where the @code{car} of each sublist is a drawing command and
+the @code{cdr} comprises the associated arguments for each command.
+
+Line-cap styles and line-join styles may be customized by
+overriding the @code{line-cap-style} and @code{line-join-style}
+properties, respectively. Available line-cap styles are
+@code{'butt}, @code{'round}, and @code{'square}. Available
+line-join styles are @code{'miter}, @code{'round}, and
+@code{'bevel}.
+
+The property @code{filled} specifies whether or not the path is
+filled with color.
+
+There are seven commands available to use in the list
+@code{commands}: @code{moveto}, @code{rmoveto}, @code{lineto},
+@code{rlineto}, @code{curveto}, @code{rcurveto}, and
+@code{closepath}. Note that the commands that begin with @emph{r}
+are the relative variants of the other three commands.
+
+The commands @code{moveto}, @code{rmoveto}, @code{lineto}, and
+@code{rlineto} take 2 arguments; they are the X and Y coordinates
+for the destination point.
+
+The commands @code{curveto} and @code{rcurveto} create cubic
+Bézier curves, and take 6 arguments; the first two are the X and Y
+coordinates for the first control point, the second two are the X
+and Y coordinates for the second control point, and the last two
+are the X and Y coordinates for the destination point.
+
+The @code{closepath} command takes zero arguments and closes the
+current subpath in the active path.
+
+Note that a sequence of commands @emph{must} begin with a
+@code{moveto} or @code{rmoveto} to work with the SVG output.
+
+@lilypond[verbatim,quote]
+samplePath =
+ #'((moveto 0 0)
+ (lineto -1 1)
+ (lineto 1 1)
+ (lineto 1 -1)
+ (curveto -5 -5 -5 5 -1 0)
+ (closepath))
+
+\\markup {
+ \\path #0.25 #samplePath
+}
+@end lilypond"
+ (let* ((half-thickness (/ thickness 2))
+ (current-point '(0 . 0))
+ (set-point (lambda (lst) (set! current-point lst)))
+ (relative? (lambda (x)
+ (string-prefix? "r" (symbol->string (car x)))))
+ ;; For calculating extents, we want to modify the command
+ ;; list so that all coordinates are absolute.
+ (new-commands (map (lambda (x)
+ (cond
+ ;; for rmoveto, rlineto
+ ((and (relative? x) (eq? 3 (length x)))
+ (let ((cp (cons
+ (+ (car current-point)
+ (second x))
+ (+ (cdr current-point)
+ (third x)))))
+ (set-point cp)
+ (list (car cp)
+ (cdr cp))))
+ ;; for rcurveto
+ ((and (relative? x) (eq? 7 (length x)))
+ (let* ((old-cp current-point)
+ (cp (cons
+ (+ (car old-cp)
+ (sixth x))
+ (+ (cdr old-cp)
+ (seventh x)))))
+ (set-point cp)
+ (list (+ (car old-cp) (second x))
+ (+ (cdr old-cp) (third x))
+ (+ (car old-cp) (fourth x))
+ (+ (cdr old-cp) (fifth x))
+ (car cp)
+ (cdr cp))))
+ ;; for moveto, lineto
+ ((eq? 3 (length x))
+ (set-point (cons (second x)
+ (third x)))
+ (drop x 1))
+ ;; for curveto
+ ((eq? 7 (length x))
+ (set-point (cons (sixth x)
+ (seventh x)))
+ (drop x 1))
+ ;; keep closepath for filtering;
+ ;; see `without-closepath'.
+ (else x)))
+ commands))
+ ;; path-min-max does not accept 0-arg lists,
+ ;; and since closepath does not affect extents, filter
+ ;; out those commands here.
+ (without-closepath (filter (lambda (x)
+ (not (equal? 'closepath (car x))))
+ new-commands))
+ (extents (path-min-max
+ ;; set the origin to the first moveto
+ (list (list-ref (car without-closepath) 0)
+ (list-ref (car without-closepath) 1))
+ without-closepath))
+ (X-extent (cons (list-ref extents 0) (list-ref extents 1)))
+ (Y-extent (cons (list-ref extents 2) (list-ref extents 3)))
+ (command-list (fold-right append '() commands)))
+
+ ;; account for line thickness
+ (set! X-extent (interval-widen X-extent half-thickness))
+ (set! Y-extent (interval-widen Y-extent half-thickness))
+
+ (ly:make-stencil
+ `(path ,thickness `(,@',command-list)
+ ',line-cap-style ',line-join-style ,filled)
+ X-extent
+ Y-extent)))
+
+(define-markup-command (score layout props score)
(ly:score?)
- music
- ()
+ #:category music
+ #:properties ((baseline-skip))
"
@cindex inserting music into text
}
}
@end lilypond"
- (let* ((output (ly:score-embedded-format score layout)))
+ (let ((output (ly:score-embedded-format score layout)))
(if (ly:music-output? output)
- (paper-system-stencil
- (vector-ref (ly:paper-score-paper-systems output) 0))
+ (stack-stencils Y DOWN baseline-skip
+ (map paper-system-stencil
+ (vector->list
+ (ly:paper-score-paper-systems output))))
(begin
(ly:warning (_"no systems found in \\score markup, does it have a \\layout block?"))
empty-stencil))))
-(define-builtin-markup-command (null layout props)
- ()
- other
+(define-markup-command (null layout props)
()
+ #:category other
"
@cindex creating empty text objects
;; basic formatting.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (simple layout props str)
+(define-markup-command (simple layout props str)
(string?)
- font
- ()
+ #:category font
"
@cindex simple text strings
@end lilypond"
(interpret-markup layout props str))
-(define-builtin-markup-command (tied-lyric layout props str)
+(define-markup-command (tied-lyric layout props str)
(string?)
- music
- ()
+ #:category music
"
@cindex simple text strings with tie characters
(join-stencil (interpret-markup layout props tie-str))
)
- (interpret-markup layout
+ (interpret-markup layout
(prepend-alist-chain
'word-space
(/ (interval-length (ly:stencil-extent join-stencil X)) -3.5)
(make-simple-markup ""))
;; helper for justifying lines.
-(define (get-fill-space word-count line-width text-widths)
+(define (get-fill-space word-count line-width word-space text-widths)
"Calculate the necessary paddings between each two adjacent texts.
- The lengths of all texts are stored in @var{text-widths}.
- The normal formula for the padding between texts a and b is:
- padding = line-width/(word-count - 1) - (length(a) + length(b))/2
- The first and last padding have to be calculated specially using the
- whole length of the first or last text.
- Return a list of paddings."
+ The lengths of all texts are stored in @var{text-widths}.
+ The normal formula for the padding between texts a and b is:
+ padding = line-width/(word-count - 1) - (length(a) + length(b))/2
+ The first and last padding have to be calculated specially using the
+ whole length of the first or last text.
+ All paddings are checked to be at least word-space, to ensure that
+ no texts collide.
+ Return a list of paddings."
(cond
((null? text-widths) '())
-
+
;; special case first padding
((= (length text-widths) word-count)
- (cons
+ (cons
(- (- (/ line-width (1- word-count)) (car text-widths))
(/ (car (cdr text-widths)) 2))
- (get-fill-space word-count line-width (cdr text-widths))))
+ (get-fill-space word-count line-width word-space (cdr text-widths))))
;; special case last padding
((= (length text-widths) 2)
(list (- (/ line-width (1- word-count))
(+ (/ (car text-widths) 2) (car (cdr text-widths)))) 0))
(else
- (cons
- (- (/ line-width (1- word-count))
- (/ (+ (car text-widths) (car (cdr text-widths))) 2))
- (get-fill-space word-count line-width (cdr text-widths))))))
-
-(define-builtin-markup-command (fill-line layout props args)
+ (let ((default-padding
+ (- (/ line-width (1- word-count))
+ (/ (+ (car text-widths) (car (cdr text-widths))) 2))))
+ (cons
+ (if (> word-space default-padding)
+ word-space
+ default-padding)
+ (get-fill-space word-count line-width word-space (cdr text-widths)))))))
+
+(define-markup-command (fill-line layout props args)
(markup-list?)
- align
- ((text-direction RIGHT)
- (word-space 1)
- (line-width #f))
+ #:category align
+ #:properties ((text-direction RIGHT)
+ (word-space 0.6)
+ (line-width #f))
"Put @var{markups} in a horizontal line of width @var{line-width}.
The markups are spaced or flushed to fill the entire line.
If there are no arguments, return an empty stencil.
}
@end lilypond"
(let* ((orig-stencils (interpret-markup-list layout props args))
- (stencils
- (map (lambda (stc)
- (if (ly:stencil-empty? stc)
- point-stencil
- stc)) orig-stencils))
- (text-widths
- (map (lambda (stc)
- (if (ly:stencil-empty? stc)
- 0.0
- (interval-length (ly:stencil-extent stc X))))
- stencils))
- (text-width (apply + text-widths))
- (word-count (length stencils))
- (prop-line-width (chain-assoc-get 'line-width props #f))
- (line-width (or line-width (ly:output-def-lookup layout 'line-width)))
- (fill-space
- (cond
- ((= word-count 1)
- (list
- (/ (- line-width text-width) 2)
- (/ (- line-width text-width) 2)))
- ((= word-count 2)
- (list
- (- line-width text-width)))
- (else
- (get-fill-space word-count line-width text-widths))))
- (fill-space-normal
- (map (lambda (x)
- (if (< x word-space)
- word-space
- x))
- fill-space))
-
- (line-stencils (if (= word-count 1)
- (list
- point-stencil
- (car stencils)
- point-stencil)
- stencils)))
-
- (if (= text-direction LEFT)
- (set! line-stencils (reverse line-stencils)))
+ (stencils
+ (map (lambda (stc)
+ (if (ly:stencil-empty? stc)
+ point-stencil
+ stc)) orig-stencils))
+ (text-widths
+ (map (lambda (stc)
+ (if (ly:stencil-empty? stc)
+ 0.0
+ (interval-length (ly:stencil-extent stc X))))
+ stencils))
+ (text-width (apply + text-widths))
+ (word-count (length stencils))
+ (line-width (or line-width (ly:output-def-lookup layout 'line-width)))
+ (fill-space
+ (cond
+ ((= word-count 1)
+ (list
+ (/ (- line-width text-width) 2)
+ (/ (- line-width text-width) 2)))
+ ((= word-count 2)
+ (list
+ (- line-width text-width)))
+ (else
+ (get-fill-space word-count line-width word-space text-widths))))
+
+ (line-contents (if (= word-count 1)
+ (list
+ point-stencil
+ (car stencils)
+ point-stencil)
+ stencils)))
(if (null? (remove ly:stencil-empty? orig-stencils))
- empty-stencil
- (stack-stencils-padding-list X
- RIGHT fill-space-normal line-stencils))))
-
-(define-builtin-markup-command (line layout props args)
+ empty-stencil
+ (begin
+ (if (= text-direction LEFT)
+ (set! line-contents (reverse line-contents)))
+ (set! line-contents
+ (stack-stencils-padding-list
+ X RIGHT fill-space line-contents))
+ (if (> word-count 1)
+ ;; shift s.t. stencils align on the left edge, even if
+ ;; first stencil had negative X-extent (e.g. center-column)
+ ;; (if word-count = 1, X-extents are already normalized in
+ ;; the definition of line-contents)
+ (set! line-contents
+ (ly:stencil-translate-axis
+ line-contents
+ (- (car (ly:stencil-extent (car stencils) X)))
+ X)))
+ line-contents))))
+
+(define-markup-command (line layout props args)
(markup-list?)
- align
- ((word-space)
- (text-direction RIGHT))
+ #:category align
+ #:properties ((word-space)
+ (text-direction RIGHT))
"Put @var{args} in a horizontal line. The property @code{word-space}
determines the space between markups in @var{args}.
word-space
(remove ly:stencil-empty? stencils))))
-(define-builtin-markup-command (concat layout props args)
+(define-markup-command (concat layout props args)
(markup-list?)
- align
- ()
+ #:category align
"
@cindex concatenating text
@cindex ligatures in text
(define (wordwrap-stencils stencils
justify base-space line-width text-dir)
- "Perform simple wordwrap, return stencil of each line."
+ "Perform simple wordwrap, return stencil of each line."
(define space (if justify
;; justify only stretches lines.
(* 0.7 base-space)
line-stencils))))
(line-word-space (cond ((not justify) space)
;; don't stretch last line of paragraph.
- ;; hmmm . bug - will overstretch the last line in some case.
+ ;; hmmm . bug - will overstretch the last line in some case.
((null? (cdr line-break))
base-space)
((null? line-stencils) 0.0)
X)))
(reverse (cons line lines)))))))
-(define-builtin-markup-list-command (wordwrap-internal layout props justify args)
+(define-markup-list-command (wordwrap-internal layout props justify args)
(boolean? markup-list?)
- ((line-width #f)
- (word-space)
- (text-direction RIGHT))
+ #:properties ((line-width #f)
+ (word-space)
+ (text-direction RIGHT))
"Internal markup list command used to define @code{\\justify} and @code{\\wordwrap}."
(wordwrap-stencils (remove ly:stencil-empty?
(interpret-markup-list layout props args))
(ly:output-def-lookup layout 'line-width))
text-direction))
-(define-builtin-markup-command (justify layout props args)
+(define-markup-command (justify layout props args)
(markup-list?)
- align
- ((baseline-skip)
- wordwrap-internal-markup-list)
+ #:category align
+ #:properties ((baseline-skip)
+ wordwrap-internal-markup-list)
"
@cindex justifying text
(stack-lines DOWN 0.0 baseline-skip
(wordwrap-internal-markup-list layout props #t args)))
-(define-builtin-markup-command (wordwrap layout props args)
+(define-markup-command (wordwrap layout props args)
(markup-list?)
- align
- ((baseline-skip)
- wordwrap-internal-markup-list)
+ #:category align
+ #:properties ((baseline-skip)
+ wordwrap-internal-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 baseline-skip
(wordwrap-internal-markup-list layout props #f args)))
-(define-builtin-markup-list-command (wordwrap-string-internal layout props justify arg)
+(define-markup-list-command (wordwrap-string-internal layout props justify arg)
(boolean? string?)
- ((line-width)
- (word-space)
- (text-direction RIGHT))
+ #:properties ((line-width)
+ (word-space)
+ (text-direction RIGHT))
"Internal markup list command used to define @code{\\justify-string} and
@code{\\wordwrap-string}."
(let* ((para-strings (regexp-split
list-para-words)))
(apply append para-lines)))
-(define-builtin-markup-command (wordwrap-string layout props arg)
+(define-markup-command (wordwrap-string layout props arg)
(string?)
- align
- ((baseline-skip)
- wordwrap-string-internal-markup-list)
+ #:category align
+ #:properties ((baseline-skip)
+ wordwrap-string-internal-markup-list)
"Wordwrap a string. Paragraphs may be separated with double newlines.
-
+
@lilypond[verbatim,quote]
\\markup {
\\override #'(line-width . 40)
(stack-lines DOWN 0.0 baseline-skip
(wordwrap-string-internal-markup-list layout props #f arg)))
-(define-builtin-markup-command (justify-string layout props arg)
+(define-markup-command (justify-string layout props arg)
(string?)
- align
- ((baseline-skip)
- wordwrap-string-internal-markup-list)
+ #:category align
+ #:properties ((baseline-skip)
+ wordwrap-string-internal-markup-list)
"Justify a string. Paragraphs may be separated with double newlines
-
+
@lilypond[verbatim,quote]
\\markup {
\\override #'(line-width . 40)
(stack-lines DOWN 0.0 baseline-skip
(wordwrap-string-internal-markup-list layout props #t arg)))
-(define-builtin-markup-command (wordwrap-field layout props symbol)
+(define-markup-command (wordwrap-field layout props symbol)
(symbol?)
- align
- ()
+ #:category align
"Wordwrap the data which has been assigned to @var{symbol}.
-
+
@lilypond[verbatim,quote]
\\header {
title = \"My title\"
- description = \"Lorem ipsum dolor sit amet, consectetur adipisicing
+ myText = \"Lorem ipsum dolor sit amet, consectetur adipisicing
elit, sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco
laboris nisi ut aliquip ex ea commodo consequat.\"
\\column {
\\fill-line { \\fromproperty #'header:title }
\\null
- \\wordwrap-field #'header:descr
+ \\wordwrap-field #'header:myText
}
}
}
(wordwrap-string-markup layout props m)
empty-stencil)))
-(define-builtin-markup-command (justify-field layout props symbol)
+(define-markup-command (justify-field layout props symbol)
(symbol?)
- align
- ()
+ #:category align
"Justify the data which has been assigned to @var{symbol}.
-
+
@lilypond[verbatim,quote]
\\header {
title = \"My title\"
- description = \"Lorem ipsum dolor sit amet, consectetur adipisicing
+ myText = \"Lorem ipsum dolor sit amet, consectetur adipisicing
elit, sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco
laboris nisi ut aliquip ex ea commodo consequat.\"
\\column {
\\fill-line { \\fromproperty #'header:title }
\\null
- \\justify-field #'header:description
+ \\justify-field #'header:myText
}
}
}
(justify-string-markup layout props m)
empty-stencil)))
-(define-builtin-markup-command (combine layout props arg1 arg2)
+(define-markup-command (combine layout props arg1 arg2)
(markup? markup?)
- align
- ()
+ #:category align
"
@cindex merging text
;;
;; TODO: should extract baseline-skip from each argument somehow..
-;;
-(define-builtin-markup-command (column layout props args)
+;;
+(define-markup-command (column layout props args)
(markup-list?)
- align
- ((baseline-skip))
+ #:category align
+ #:properties ((baseline-skip))
"
@cindex stacking text in a column
(stack-lines -1 0.0 baseline-skip
(remove ly:stencil-empty? arg-stencils))))
-(define-builtin-markup-command (dir-column layout props args)
+(define-markup-command (dir-column layout props args)
(markup-list?)
- align
- ((direction)
- (baseline-skip))
+ #:category align
+ #:properties ((direction)
+ (baseline-skip))
"
@cindex changing direction of text columns
(define (general-column align-dir baseline mols)
"Stack @var{mols} vertically, aligned to @var{align-dir} horizontally."
-
+
(let* ((aligned-mols (map (lambda (x) (ly:stencil-aligned-to x X align-dir)) mols)))
(stack-lines -1 0.0 baseline aligned-mols)))
-(define-builtin-markup-command (center-column layout props args)
+(define-markup-command (center-column layout props args)
(markup-list?)
- align
- ((baseline-skip))
+ #:category align
+ #:properties ((baseline-skip))
"
@cindex centering a column of text
@end lilypond"
(general-column CENTER baseline-skip (interpret-markup-list layout props args)))
-(define-builtin-markup-command (left-column layout props args)
+(define-markup-command (left-column layout props args)
(markup-list?)
- align
- ((baseline-skip))
+ #:category align
+ #:properties ((baseline-skip))
"
-@cindex text columns, left-aligned
+@cindex text columns, left-aligned
Put @code{args} in a left-aligned column.
@end lilypond"
(general-column LEFT baseline-skip (interpret-markup-list layout props args)))
-(define-builtin-markup-command (right-column layout props args)
+(define-markup-command (right-column layout props args)
(markup-list?)
- align
- ((baseline-skip))
+ #:category align
+ #:properties ((baseline-skip))
"
@cindex text columns, right-aligned
@end lilypond"
(general-column RIGHT baseline-skip (interpret-markup-list layout props args)))
-(define-builtin-markup-command (vcenter layout props arg)
+(define-markup-command (vcenter layout props arg)
(markup?)
- align
- ()
+ #:category align
"
@cindex vertically centering text
(let* ((mol (interpret-markup layout props arg)))
(ly:stencil-aligned-to mol Y CENTER)))
-(define-builtin-markup-command (center-align layout props arg)
+(define-markup-command (center-align layout props arg)
(markup?)
- align
- ()
+ #:category align
"
@cindex horizontally centering text
(let* ((mol (interpret-markup layout props arg)))
(ly:stencil-aligned-to mol X CENTER)))
-(define-builtin-markup-command (right-align layout props arg)
+(define-markup-command (right-align layout props arg)
(markup?)
- align
- ()
+ #:category align
"
@cindex right aligning text
(let* ((m (interpret-markup layout props arg)))
(ly:stencil-aligned-to m X RIGHT)))
-(define-builtin-markup-command (left-align layout props arg)
+(define-markup-command (left-align layout props arg)
(markup?)
- align
- ()
+ #:category align
"
@cindex left aligning text
(let* ((m (interpret-markup layout props arg)))
(ly:stencil-aligned-to m X LEFT)))
-(define-builtin-markup-command (general-align layout props axis dir arg)
+(define-markup-command (general-align layout props axis dir arg)
(integer? number? markup?)
- align
- ()
+ #:category align
"
@cindex controlling general text alignment
(let* ((m (interpret-markup layout props arg)))
(ly:stencil-aligned-to m axis dir)))
-(define-builtin-markup-command (halign layout props dir arg)
+(define-markup-command (halign layout props dir arg)
(number? markup?)
- align
- ()
+ #:category align
"
@cindex setting horizontal text alignment
(let* ((m (interpret-markup layout props arg)))
(ly:stencil-aligned-to m X dir)))
-(define-builtin-markup-command (with-dimensions layout props x y arg)
+(define-markup-command (with-dimensions layout props x y arg)
(number-pair? number-pair? markup?)
- other
- ()
+ #:category other
"
@cindex setting extent of text objects
-Set the dimensions of @var{arg} to @var{x} and@tie{}@var{y}."
+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)))
-(define-builtin-markup-command (pad-around layout props amount arg)
+(define-markup-command (pad-around layout props amount arg)
(number? markup?)
- align
- ()
+ #:category align
"Add padding @var{amount} all around @var{arg}.
-
+
@lilypond[verbatim,quote]
\\markup {
\\box {
(interval-widen x amount)
(interval-widen y amount))))
-(define-builtin-markup-command (pad-x layout props amount arg)
+(define-markup-command (pad-x layout props amount arg)
(number? markup?)
- align
- ()
+ #:category align
"
@cindex padding text horizontally
(interval-widen x amount)
y)))
-(define-builtin-markup-command (put-adjacent layout props axis dir arg1 arg2)
+(define-markup-command (put-adjacent layout props axis dir arg1 arg2)
(integer? ly:dir? markup? markup?)
- align
- ()
+ #:category align
"Put @var{arg2} next to @var{arg1}, without moving @var{arg1}."
(let ((m1 (interpret-markup layout props arg1))
(m2 (interpret-markup layout props arg2)))
(ly:stencil-combine-at-edge m1 axis dir m2 0.0)))
-(define-builtin-markup-command (transparent layout props arg)
+(define-markup-command (transparent layout props arg)
(markup?)
- other
- ()
+ #:category other
"Make @var{arg} transparent.
-
+
@lilypond[verbatim,quote]
\\markup {
\\transparent {
(y (ly:stencil-extent m Y)))
(ly:make-stencil "" x y)))
-(define-builtin-markup-command (pad-to-box layout props x-ext y-ext arg)
+(define-markup-command (pad-to-box layout props x-ext y-ext arg)
(number-pair? number-pair? markup?)
- align
- ()
+ #:category align
"Make @var{arg} take at least @var{x-ext}, @var{y-ext} space.
@lilypond[verbatim,quote]
(interval-union x-ext x)
(interval-union y-ext y))))
-(define-builtin-markup-command (hcenter-in layout props length arg)
+(define-markup-command (hcenter-in layout props length arg)
(number? markup?)
- align
- ()
+ #:category align
"Center @var{arg} horizontally within a box of extending
@var{length}/2 to the left and right.
;; property
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (fromproperty layout props symbol)
+(define-markup-command (fromproperty layout props symbol)
(symbol?)
- other
- ()
+ #:category other
"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.
(interpret-markup layout props m)
empty-stencil)))
-(define-builtin-markup-command (on-the-fly layout props procedure arg)
+(define-markup-command (on-the-fly layout props procedure arg)
(symbol? markup?)
- other
- ()
+ #:category other
"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))))
(list markup?))
(interpret-markup layout props (list anonymous-with-signature arg))))
-(define-builtin-markup-command (override layout props new-prop arg)
+(define-markup-command (footnote layout props mkup note)
+ (markup? markup?)
+ #:category other
+ "Have footnote @var{note} act as an annotation to the markup @var{mkup}."
+ (ly:stencil-combine-at-edge
+ (interpret-markup layout props mkup)
+ X
+ RIGHT
+ (ly:make-stencil
+ `(footnote ,(interpret-markup layout props note))
+ '(0 . 0)
+ '(0 . 0))
+ 0.0))
+
+(define-markup-command (override layout props new-prop arg)
(pair? markup?)
- other
- ()
+ #:category other
"
@cindex overriding properties within text markup
;; files
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (verbatim-file layout props name)
+(define-markup-command (verbatim-file layout props name)
(string?)
- other
- ()
+ #:category other
"Read the contents of file @var{name}, and include it verbatim.
@lilypond[verbatim,quote]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (smaller layout props arg)
+(define-markup-command (smaller layout props arg)
(markup?)
- font
- ()
+ #:category font
"Decrease the font size relative to the current setting.
-
+
@lilypond[verbatim,quote]
\\markup {
\\fontsize #3.5 {
(interpret-markup layout props
`(,fontsize-markup -1 ,arg)))
-(define-builtin-markup-command (larger layout props arg)
+(define-markup-command (larger layout props arg)
(markup?)
- font
- ()
+ #:category font
"Increase the font size relative to the current setting.
@lilypond[verbatim,quote]
(interpret-markup layout props
`(,fontsize-markup 1 ,arg)))
-(define-builtin-markup-command (finger layout props arg)
+(define-markup-command (finger layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set @var{arg} as small numbers.
@lilypond[verbatim,quote]
}
@end lilypond"
(interpret-markup layout
- (cons '((font-size . -5) (font-encoding . fetaNumber)) props)
+ (cons '((font-size . -5) (font-encoding . fetaText)) props)
arg))
-(define-builtin-markup-command (abs-fontsize layout props size arg)
+(define-markup-command (abs-fontsize layout props size arg)
(number? markup?)
- font
- ()
+ #:category font
"Use @var{size} as the absolute font size to display @var{arg}.
Adjusts @code{baseline-skip} and @code{word-space} accordingly.
props)
arg)))
-(define-builtin-markup-command (fontsize layout props increment arg)
+(define-markup-command (fontsize layout props increment arg)
(number? markup?)
- font
- ((font-size 0)
- (word-space 1)
- (baseline-skip 2))
+ #:category font
+ #:properties ((font-size 0)
+ (word-space 1)
+ (baseline-skip 2))
"Add @var{increment} to the font-size. Adjusts @code{baseline-skip}
accordingly.
(cons 'font-size (+ font-size increment)))))
(interpret-markup layout (cons entries props) arg)))
-(define-builtin-markup-command (magnify layout props sz arg)
+(define-markup-command (magnify layout props sz arg)
(number? markup?)
- font
- ()
+ #:category font
"
@cindex magnifying text
}
@end lilypond"
(interpret-markup
- layout
+ layout
(prepend-alist-chain 'font-size (magnification->font-size sz) props)
arg))
-(define-builtin-markup-command (bold layout props arg)
+(define-markup-command (bold layout props arg)
(markup?)
- font
- ()
+ #:category font
"Switch to bold font-series.
-
+
@lilypond[verbatim,quote]
\\markup {
default
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-series 'bold props) arg))
-(define-builtin-markup-command (sans layout props arg)
+(define-markup-command (sans layout props arg)
(markup?)
- font
- ()
+ #:category font
"Switch to the sans serif font family.
-
+
@lilypond[verbatim,quote]
\\markup {
default
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-family 'sans props) arg))
-(define-builtin-markup-command (number layout props arg)
+(define-markup-command (number layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set font family to @code{number}, which yields the font used for
time signatures and fingerings. This font contains numbers and
some punctuation; it has no letters.
}
}
@end lilypond"
- (interpret-markup layout (prepend-alist-chain 'font-encoding 'fetaNumber props) arg))
+ (interpret-markup layout (prepend-alist-chain 'font-encoding 'fetaText props) arg))
-(define-builtin-markup-command (roman layout props arg)
+(define-markup-command (roman layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set font family to @code{roman}.
-
+
@lilypond[verbatim,quote]
\\markup {
\\sans \\bold {
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-family 'roman props) arg))
-(define-builtin-markup-command (huge layout props arg)
+(define-markup-command (huge layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set font size to +2.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-size 2 props) arg))
-(define-builtin-markup-command (large layout props arg)
+(define-markup-command (large layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set font size to +1.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-size 1 props) arg))
-(define-builtin-markup-command (normalsize layout props arg)
+(define-markup-command (normalsize layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set font size to default.
-
+
@lilypond[verbatim,quote]
\\markup {
\\teeny {
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-size 0 props) arg))
-(define-builtin-markup-command (small layout props arg)
+(define-markup-command (small layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set font size to -1.
-
+
@lilypond[verbatim,quote]
\\markup {
default
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-size -1 props) arg))
-(define-builtin-markup-command (tiny layout props arg)
+(define-markup-command (tiny layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set font size to -2.
-
+
@lilypond[verbatim,quote]
\\markup {
default
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-size -2 props) arg))
-(define-builtin-markup-command (teeny layout props arg)
+(define-markup-command (teeny layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set font size to -3.
-
+
@lilypond[verbatim,quote]
\\markup {
default
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-size -3 props) arg))
-(define-builtin-markup-command (fontCaps layout props arg)
+(define-markup-command (fontCaps layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set @code{font-shape} to @code{caps}
-
+
Note: @code{\\fontCaps} requires the installation and selection of
fonts which support the @code{caps} font shape."
(interpret-markup layout (prepend-alist-chain 'font-shape 'caps props) arg))
;; Poor man's caps
-(define-builtin-markup-command (smallCaps layout props arg)
+(define-markup-command (smallCaps layout props arg)
(markup?)
- font
- ()
+ #:category font
"Emit @var{arg} as small caps.
Note: @code{\\smallCaps} does not support accented characters.
(make-small-caps (string->list arg) (list) #f (list))
arg)))
-(define-builtin-markup-command (caps layout props arg)
+(define-markup-command (caps layout props arg)
(markup?)
- font
- ()
+ #:category font
"Copy of the @code{\\smallCaps} command.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (make-smallCaps-markup arg)))
-(define-builtin-markup-command (dynamic layout props arg)
+(define-markup-command (dynamic layout props arg)
(markup?)
- font
- ()
+ #:category font
"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
@q{pi@`{u}@tie{}@b{f}}, the normal words (like @q{pi@`{u}}) should be
}
@end lilypond"
(interpret-markup
- layout (prepend-alist-chain 'font-encoding 'fetaDynamic props) arg))
+ layout (prepend-alist-chain 'font-encoding 'fetaText props) arg))
-(define-builtin-markup-command (text layout props arg)
+(define-markup-command (text layout props arg)
(markup?)
- font
- ()
+ #:category font
"Use a text font instead of music symbol or music alphabet font.
-
+
@lilypond[verbatim,quote]
\\markup {
\\number {
(interpret-markup layout (prepend-alist-chain 'font-encoding 'latin1 props)
arg))
-(define-builtin-markup-command (italic layout props arg)
+(define-markup-command (italic layout props arg)
(markup?)
- font
- ()
+ #:category font
"Use italic @code{font-shape} for @var{arg}.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout (prepend-alist-chain 'font-shape 'italic props) arg))
-(define-builtin-markup-command (typewriter layout props arg)
+(define-markup-command (typewriter layout props arg)
(markup?)
- font
- ()
+ #:category font
"Use @code{font-family} typewriter for @var{arg}.
-
+
@lilypond[verbatim,quote]
\\markup {
default
(interpret-markup
layout (prepend-alist-chain 'font-family 'typewriter props) arg))
-(define-builtin-markup-command (upright layout props arg)
+(define-markup-command (upright layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set @code{font-shape} to @code{upright}. This is the opposite
of @code{italic}.
(interpret-markup
layout (prepend-alist-chain 'font-shape 'upright props) arg))
-(define-builtin-markup-command (medium layout props arg)
+(define-markup-command (medium layout props arg)
(markup?)
- font
- ()
+ #:category font
"Switch to medium font-series (in contrast to bold).
@lilypond[verbatim,quote]
(interpret-markup layout (prepend-alist-chain 'font-series 'medium props)
arg))
-(define-builtin-markup-command (normal-text layout props arg)
+(define-markup-command (normal-text layout props arg)
(markup?)
- font
- ()
+ #:category font
"Set all font related properties (except the size) to get the default
normal text font, no matter what font was used earlier.
;; symbols.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (doublesharp layout props)
- ()
- music
+(define-markup-command (musicglyph layout props glyph-name)
+ (string?)
+ #:category music
+ "@var{glyph-name} is converted to a musical symbol; for example,
+@code{\\musicglyph #\"accidentals.natural\"} selects the natural sign from
+the music font. See @ruser{The Feta font} for a complete listing of
+the possible glyphs.
+
+@lilypond[verbatim,quote]
+\\markup {
+ \\musicglyph #\"f\"
+ \\musicglyph #\"rests.2\"
+ \\musicglyph #\"clefs.G_change\"
+}
+@end lilypond"
+ (let* ((font (ly:paper-get-font layout
+ (cons '((font-encoding . fetaMusic)
+ (font-name . #f))
+
+ props)))
+ (glyph (ly:font-get-glyph font glyph-name)))
+ (if (null? (ly:stencil-expr glyph))
+ (ly:warning (_ "Cannot find glyph ~a") glyph-name))
+
+ glyph))
+
+(define-markup-command (doublesharp layout props)
()
+ #:category music
"Draw a double sharp symbol.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (markup #:musicglyph (assoc-get 1 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (sesquisharp layout props)
- ()
- music
+(define-markup-command (sesquisharp layout props)
()
+ #:category music
"Draw a 3/2 sharp symbol.
@lilypond[verbatim,quote]
\\sesquisharp
}
@end lilypond"
- (interpret-markup layout props (markup #:musicglyph (assoc-get 3/4 standard-alteration-glyph-name-alist ""))))
+ (interpret-markup layout props (markup #:musicglyph (assoc-get 3/4 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (sharp layout props)
- ()
- music
+(define-markup-command (sharp layout props)
()
+ #:category music
"Draw a sharp symbol.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (markup #:musicglyph (assoc-get 1/2 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (semisharp layout props)
- ()
- music
+(define-markup-command (semisharp layout props)
()
+ #:category music
"Draw a semisharp symbol.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (markup #:musicglyph (assoc-get 1/4 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (natural layout props)
- ()
- music
+(define-markup-command (natural layout props)
()
+ #:category music
"Draw a natural symbol.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (markup #:musicglyph (assoc-get 0 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (semiflat layout props)
- ()
- music
+(define-markup-command (semiflat layout props)
()
+ #:category music
"Draw a semiflat symbol.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (markup #:musicglyph (assoc-get -1/4 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (flat layout props)
- ()
- music
+(define-markup-command (flat layout props)
()
+ #:category music
"Draw a flat symbol.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (markup #:musicglyph (assoc-get -1/2 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (sesquiflat layout props)
- ()
- music
+(define-markup-command (sesquiflat layout props)
()
+ #:category music
"Draw a 3/2 flat symbol.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (markup #:musicglyph (assoc-get -3/4 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (doubleflat layout props)
- ()
- music
+(define-markup-command (doubleflat layout props)
()
+ #:category music
"Draw a double flat symbol.
@lilypond[verbatim,quote]
@end lilypond"
(interpret-markup layout props (markup #:musicglyph (assoc-get -1 standard-alteration-glyph-name-alist ""))))
-(define-builtin-markup-command (with-color layout props color arg)
+(define-markup-command (with-color layout props color arg)
(color? markup?)
- other
- ()
+ #:category other
"
@cindex coloring text
(ly:make-stencil (list 'color color (ly:stencil-expr stil))
(ly:stencil-extent stil X)
(ly:stencil-extent stil Y))))
-\f
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; glyphs
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (arrow-head layout props axis dir filled)
+(define-markup-command (arrow-head layout props axis dir filled)
(integer? ly:dir? boolean?)
- graphic
- ()
+ #:category graphic
"Produce an arrow head in specified direction and axis.
Use the filled head if @var{filled} is specified.
@lilypond[verbatim,quote]
props))
name)))
-(define-builtin-markup-command (musicglyph layout props glyph-name)
+(define-markup-command (lookup layout props glyph-name)
(string?)
- music
- ()
- "@var{glyph-name} is converted to a musical symbol; for example,
-@code{\\musicglyph #\"accidentals.natural\"} selects the natural sign from
-the music font. See @ruser{The Feta font} for a complete listing of
-the possible glyphs.
-
-@lilypond[verbatim,quote]
-\\markup {
- \\musicglyph #\"f\"
- \\musicglyph #\"rests.2\"
- \\musicglyph #\"clefs.G_change\"
-}
-@end lilypond"
- (let* ((font (ly:paper-get-font layout
- (cons '((font-encoding . fetaMusic)
- (font-name . #f))
-
- props)))
- (glyph (ly:font-get-glyph font glyph-name)))
- (if (null? (ly:stencil-expr glyph))
- (ly:warning (_ "Cannot find glyph ~a") glyph-name))
-
- glyph))
-
-
-(define-builtin-markup-command (lookup layout props glyph-name)
- (string?)
- other
- ()
+ #:category other
"Lookup a glyph by name.
-
+
@lilypond[verbatim,quote]
\\markup {
\\override #'(font-encoding . fetaBraces) {
(ly:font-get-glyph (ly:paper-get-font layout props)
glyph-name))
-(define-builtin-markup-command (char layout props num)
+(define-markup-command (char layout props num)
(integer?)
- other
- ()
+ #:category other
"Produce a single character. Characters encoded in hexadecimal
format require the prefix @code{#x}.
(define (number->markletter-string vec n)
"Double letters for big marks."
(let* ((lst (vector-length vec)))
-
+
(if (>= n lst)
(string-append (number->markletter-string vec (1- (quotient n lst)))
(number->markletter-string vec (remainder n lst)))
(make-string 1 (vector-ref vec n)))))
-(define-builtin-markup-command (markletter layout props num)
+(define-markup-command (markletter layout props num)
(integer?)
- other
- ()
+ #:category other
"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)))
-(define-builtin-markup-command (markalphabet layout props num)
+(define-markup-command (markalphabet layout props num)
(integer?)
- other
- ()
+ #:category other
"Make a markup letter for @var{num}. The letters start with A to@tie{}Z
and continue with double letters.
; backward slashes might use slope and point in the other direction!
(dy (* mag (if forward 0.4 -0.4)))
(number-stencil (interpret-markup layout
- (prepend-alist-chain 'font-encoding 'fetaNumber props)
+ (prepend-alist-chain 'font-encoding 'fetaText props)
(number->string num)))
(num-x (horizontal-slash-interval num forward (ly:stencil-extent number-stencil X) mag))
(center (interval-center (ly:stencil-extent number-stencil Y)))
(num-y (interval-widen (cons center center) (abs dy)))
(is-sane (and (interval-sane? num-x) (interval-sane? num-y)))
(slash-stencil (if is-sane
- (make-line-stencil thickness
+ (make-line-stencil thickness
(car num-x) (- (interval-center num-y) dy)
(cdr num-x) (+ (interval-center num-y) dy))
#f)))
number-stencil))
-(define-builtin-markup-command (slashed-digit layout props num)
+(define-markup-command (slashed-digit layout props num)
(integer?)
- other
- ((font-size 0)
- (thickness 1.6))
+ #:category other
+ #:properties ((font-size 0)
+ (thickness 1.6))
"
@cindex slashed digits
@end lilypond"
(slashed-digit-internal layout props num #t font-size thickness))
-(define-builtin-markup-command (backslashed-digit layout props num)
+(define-markup-command (backslashed-digit layout props num)
(integer?)
- other
- ((font-size 0)
- (thickness 1.6))
+ #:category other
+ #:properties ((font-size 0)
+ (thickness 1.6))
"
@cindex backslashed digits
@end lilypond"
(slashed-digit-internal layout props num #f font-size thickness))
+;; eyeglasses
+(define eyeglassespath
+ '((moveto 0.42 0.77)
+ (rcurveto 0 0.304 -0.246 0.55 -0.55 0.55)
+ (rcurveto -0.304 0 -0.55 -0.246 -0.55 -0.55)
+ (rcurveto 0 -0.304 0.246 -0.55 0.55 -0.55)
+ (rcurveto 0.304 0 0.55 0.246 0.55 0.55)
+ (closepath)
+ (moveto 2.07 0.77)
+ (rcurveto 0 0.304 -0.246 0.55 -0.55 0.55)
+ (rcurveto -0.304 0 -0.55 -0.246 -0.55 -0.55)
+ (rcurveto 0 -0.304 0.246 -0.55 0.55 -0.55)
+ (rcurveto 0.304 0 0.55 0.246 0.55 0.55)
+ (closepath)
+ (moveto 1.025 0.935)
+ (rcurveto 0 0.182 -0.148 0.33 -0.33 0.33)
+ (rcurveto -0.182 0 -0.33 -0.148 -0.33 -0.33)
+ (moveto -0.68 0.77)
+ (rlineto 0.66 1.43)
+ (rcurveto 0.132 0.286 0.55 0.44 0.385 -0.33)
+ (moveto 2.07 0.77)
+ (rlineto 0.66 1.43)
+ (rcurveto 0.132 0.286 0.55 0.44 0.385 -0.33)))
+
+(define-markup-command (eyeglasses layout props)
+ ()
+ #:category other
+ "Prints out eyeglasses, indicating strongly to look at the conductor.
+@lilypond[verbatim,quote]
+\\markup { \\eyeglasses }
+@end lilypond"
+ (interpret-markup layout props
+ (make-override-markup '(line-cap-style . butt)
+ (make-path-markup 0.15 eyeglassespath))))
+
+(define-markup-command (left-brace layout props size)
+ (number?)
+ #:category other
+ "
+A feta brace in point size @var{size}.
+
+@lilypond[verbatim,quote]
+\\markup {
+ \\left-brace #35
+ \\hspace #2
+ \\left-brace #45
+}
+@end lilypond"
+ (let* ((font (ly:paper-get-font layout
+ (cons '((font-encoding . fetaBraces)
+ (font-name . #f))
+ props)))
+ (glyph-count (1- (ly:otf-glyph-count font)))
+ (scale (ly:output-def-lookup layout 'output-scale))
+ (scaled-size (/ (ly:pt size) scale))
+ (glyph (lambda (n)
+ (ly:font-get-glyph font (string-append "brace"
+ (number->string n)))))
+ (get-y-from-brace (lambda (brace)
+ (interval-length
+ (ly:stencil-extent (glyph brace) Y))))
+ (find-brace (binary-search 0 glyph-count get-y-from-brace scaled-size))
+ (glyph-found (glyph find-brace)))
+
+ (if (or (null? (ly:stencil-expr glyph-found))
+ (< scaled-size (interval-length (ly:stencil-extent (glyph 0) Y)))
+ (> scaled-size (interval-length
+ (ly:stencil-extent (glyph glyph-count) Y))))
+ (begin
+ (ly:warning (_ "no brace found for point size ~S ") size)
+ (ly:warning (_ "defaulting to ~S pt")
+ (/ (* scale (interval-length
+ (ly:stencil-extent glyph-found Y)))
+ (ly:pt 1)))))
+ glyph-found))
+
+(define-markup-command (right-brace layout props size)
+ (number?)
+ #:category other
+ "
+A feta brace in point size @var{size}, rotated 180 degrees.
+
+@lilypond[verbatim,quote]
+\\markup {
+ \\right-brace #45
+ \\hspace #2
+ \\right-brace #35
+}
+@end lilypond"
+ (interpret-markup layout props (markup #:rotate 180 #:left-brace size)))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; the note command.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; TODO: better syntax.
-(define-builtin-markup-command (note-by-number layout props log dot-count dir)
+(define-markup-command (note-by-number layout props log dot-count dir)
(number? number? number?)
- music
- ((font-size 0)
- (style '()))
+ #:category music
+ #:properties ((font-size 0)
+ (style '()))
"
@cindex notes within text by log and dot-count
@end lilypond"
(define (get-glyph-name-candidates dir log style)
(map (lambda (dir-name)
- (format "noteheads.~a~a~a" dir-name (min log 2)
- (if (and (symbol? style)
- (not (equal? 'default style)))
- (symbol->string style)
- "")))
+ (format "noteheads.~a~a" dir-name
+ (if (and (symbol? style)
+ (not (equal? 'default style)))
+ (select-head-glyph style (min log 2))
+ (min log 2))))
(list (if (= dir UP) "u" "d")
"s")))
-
+
(define (get-glyph-name font cands)
(if (null? cands)
- ""
- (if (ly:stencil-empty? (ly:font-get-glyph font (car cands)))
- (get-glyph-name font (cdr cands))
- (car cands))))
-
- (let* ((font (ly:paper-get-font layout (cons '((font-encoding . fetaMusic)) props)))
+ ""
+ (if (ly:stencil-empty? (ly:font-get-glyph font (car cands)))
+ (get-glyph-name font (cdr cands))
+ (car cands))))
+
+ (let* ((font (ly:paper-get-font layout (cons '((font-encoding . fetaMusic))
+ props)))
(size-factor (magstep font-size))
- (stem-length (* size-factor (max 3 (- log 1))))
- (head-glyph-name (get-glyph-name font (get-glyph-name-candidates (sign dir) log style)))
+ (stem-length (* size-factor (max 3 (- log 1))))
+ (head-glyph-name
+ (let ((result (get-glyph-name font (get-glyph-name-candidates
+ (sign dir) log style))))
+ (if (string-null? result)
+ ;; If no glyph name can be found, select default heads. Though
+ ;; this usually means an unsupported style has been chosen, it
+ ;; also prevents unrelated 'style settings from other grobs
+ ;; (e.g., TextSpanner and TimeSignature) leaking into markup.
+ (get-glyph-name font (get-glyph-name-candidates
+ (sign dir) log 'default))
+ result)))
(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))
(attach-off (cons (interval-index
(ly:stencil-extent head-glyph X)
(* (sign dir) (car attach-indices)))
- (* (sign dir) ; fixme, this is inconsistent between X & Y.
+ (* (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)
- (+ (car attach-off) (* (- (sign dir)) stem-thickness)))
+ (+ (car attach-off)
+ (* (- (sign dir)) stem-thickness)))
(cons (min stemy (cdr attach-off))
(max stemy (cdr attach-off)))
(/ stem-thickness 3))))
-
+
(dot (ly:font-get-glyph font "dots.dot"))
(dotwid (interval-length (ly:stencil-extent dot X)))
(dots (and (> dot-count 0)
(string-append "flags."
(if (> dir 0) "u" "d")
(number->string log)))
- (cons (+ (car attach-off) (if (< dir 0) stem-thickness 0)) stemy)))))
-
- ; If there is a flag on an upstem and the stem is short, move the dots to avoid the flag.
- ; 16th notes get a special case because their flags hang lower than any other flags.
- (if (and dots (> dir 0) (> log 2) (or (< dir 1.15) (and (= log 4) (< dir 1.3))))
+ (cons (+ (car attach-off) (if (< dir 0)
+ stem-thickness 0))
+ stemy)))))
+
+ ;; If there is a flag on an upstem and the stem is short, move the dots
+ ;; to avoid the flag. 16th notes get a special case because their flags
+ ;; hang lower than any other flags.
+ (if (and dots (> dir 0) (> log 2)
+ (or (< dir 1.15) (and (= log 4) (< dir 1.3))))
(set! dots (ly:stencil-translate-axis dots 0.5 X)))
(if flaggl
(set! stem-glyph (ly:stencil-add flaggl stem-glyph)))
stem-glyph)))
stem-glyph))
-(define-public log2
+(define-public log2
(let ((divisor (log 2)))
(lambda (z) (inexact->exact (/ (log z) divisor)))))
(define (parse-simple-duration duration-string)
- "Parse the `duration-string', e.g. ''4..'' or ''breve.'', and return a (log dots) list."
- (let ((match (regexp-exec (make-regexp "(breve|longa|maxima|[0-9]+)(\\.*)") duration-string)))
+ "Parse the `duration-string', e.g. ''4..'' or ''breve.'',
+and return a (log dots) list."
+ (let ((match (regexp-exec (make-regexp "(breve|longa|maxima|[0-9]+)(\\.*)")
+ duration-string)))
(if (and match (string=? duration-string (match:substring match 0)))
- (let ((len (match:substring match 1))
+ (let ((len (match:substring match 1))
(dots (match:substring match 2)))
(list (cond ((string=? len "breve") -1)
((string=? len "longa") -2)
(if dots (string-length dots) 0)))
(ly:error (_ "not a valid duration string: ~a") duration-string))))
-(define-builtin-markup-command (note layout props duration dir)
+(define-markup-command (note layout props duration dir)
(string? number?)
- music
- (note-by-number-markup)
+ #:category music
+ #:properties (note-by-number-markup)
"
@cindex notes within text by string
;; translating.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (lower layout props amount arg)
+(define-markup-command (lower layout props amount arg)
(number? markup?)
- align
- ()
+ #:category align
"
@cindex lowering text
(ly:stencil-translate-axis (interpret-markup layout props arg)
(- amount) Y))
-(define-builtin-markup-command (translate-scaled layout props offset arg)
+(define-markup-command (translate-scaled layout props offset arg)
(number-pair? markup?)
- align
- ((font-size 0))
+ #:category align
+ #:properties ((font-size 0))
"
@cindex translating text
@cindex scaling text
(ly:stencil-translate (interpret-markup layout props arg)
scaled)))
-(define-builtin-markup-command (raise layout props amount arg)
+(define-markup-command (raise layout props amount arg)
(number? markup?)
- align
- ()
+ #:category align
"
@cindex raising text
-
+
Raise @var{arg} by the distance @var{amount}.
A negative @var{amount} indicates lowering, see also @code{\\lower}.
@end lilypond"
(ly:stencil-translate-axis (interpret-markup layout props arg) amount Y))
-(define-builtin-markup-command (fraction layout props arg1 arg2)
+(define-markup-command (fraction layout props arg1 arg2)
(markup? markup?)
- other
- ((font-size 0))
+ #:category other
+ #:properties ((font-size 0))
"
@cindex creating text fractions
;; empirical anyway
(ly:stencil-translate-axis stack offset Y))))
-(define-builtin-markup-command (normal-size-super layout props arg)
+(define-markup-command (normal-size-super layout props arg)
(markup?)
- font
- ((baseline-skip))
+ #:category font
+ #:properties ((baseline-skip))
"
@cindex setting superscript in standard font size
(interpret-markup layout props arg)
(* 0.5 baseline-skip) Y))
-(define-builtin-markup-command (super layout props arg)
+(define-markup-command (super layout props arg)
(markup?)
- font
- ((font-size 0)
- (baseline-skip))
- "
+ #:category font
+ #:properties ((font-size 0)
+ (baseline-skip))
+ "
@cindex superscript text
Set @var{arg} in superscript.
(* 0.5 baseline-skip)
Y))
-(define-builtin-markup-command (translate layout props offset arg)
+(define-markup-command (translate layout props offset arg)
(number-pair? markup?)
- align
- ()
+ #:category align
"
@cindex translating text
-
+
Translate @var{arg} relative to its surroundings. @var{offset}
is a pair of numbers representing the displacement in the X and Y axis.
(ly:stencil-translate (interpret-markup layout props arg)
offset))
-(define-builtin-markup-command (sub layout props arg)
+(define-markup-command (sub layout props arg)
(markup?)
- font
- ((font-size 0)
- (baseline-skip))
+ #:category font
+ #:properties ((font-size 0)
+ (baseline-skip))
"
@cindex subscript text
(* -0.5 baseline-skip)
Y))
-(define-builtin-markup-command (normal-size-sub layout props arg)
+(define-markup-command (normal-size-sub layout props arg)
(markup?)
- font
- ((baseline-skip))
+ #:category font
+ #:properties ((baseline-skip))
"
@cindex setting subscript in standard font size
(interpret-markup layout props arg)
(* -0.5 baseline-skip)
Y))
-\f
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; brackets.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (hbracket layout props arg)
+(define-markup-command (hbracket layout props arg)
(markup?)
- graphic
- ()
+ #:category graphic
"
@cindex placing horizontal brackets around text
-
+
Draw horizontal brackets around @var{arg}.
@lilypond[verbatim,quote]
(m (interpret-markup layout props arg)))
(bracketify-stencil m X th (* 2.5 th) th)))
-(define-builtin-markup-command (bracket layout props arg)
+(define-markup-command (bracket layout props arg)
(markup?)
- graphic
- ()
+ #:category graphic
"
@cindex placing vertical brackets around text
-
+
Draw vertical brackets around @var{arg}.
@lilypond[verbatim,quote]
(let ((th 0.1) ;; todo: take from GROB.
(m (interpret-markup layout props arg)))
(bracketify-stencil m Y th (* 2.5 th) th)))
+
+(define-markup-command (parenthesize layout props arg)
+ (markup?)
+ #:category graphic
+ #:properties ((angularity 0)
+ (padding)
+ (size 1)
+ (thickness 1)
+ (width 0.25))
+ "
+@cindex placing parentheses around text
+
+Draw parentheses around @var{arg}. This is useful for parenthesizing
+a column containing several lines of text.
+
+@lilypond[verbatim,quote]
+\\markup {
+ \\line {
+ \\parenthesize {
+ \\column {
+ foo
+ bar
+ }
+ }
+ \\override #'(angularity . 2) {
+ \\parenthesize {
+ \\column {
+ bah
+ baz
+ }
+ }
+ }
+ }
+}
+@end lilypond"
+ (let* ((markup (interpret-markup layout props arg))
+ (scaled-width (* size width))
+ (scaled-thickness
+ (* (chain-assoc-get 'line-thickness props 0.1)
+ thickness))
+ (half-thickness
+ (min (* size 0.5 scaled-thickness)
+ (* (/ 4 3.0) scaled-width)))
+ (padding (chain-assoc-get 'padding props half-thickness)))
+ (parenthesize-stencil
+ markup half-thickness scaled-width angularity padding)))
+
\f
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Delayed markup evaluation
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(define-builtin-markup-command (page-ref layout props label gauge default)
+(define-markup-command (page-ref layout props label gauge default)
(symbol? markup? markup?)
- other
- ()
+ #:category other
"
@cindex referencing page numbers in text
`(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-number (if (list? table)
+ (assoc-get label table)
+ #f))
(page-markup (if page-number (format "~a" page-number) default))
(page-stencil (interpret-markup layout props page-markup))
(gap (- (interval-length x-ext)
(markup #:concat (#:hspace gap page-markup)))))))
x-ext
y-ext)))
-\f
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; scaling
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define-markup-command (scale layout props factor-pair arg)
+ (number-pair? markup?)
+ #:category graphic
+ "
+@cindex scaling markup
+@cindex mirroring markup
+
+Scale @var{arg}. @var{factor-pair} is a pair of numbers
+representing the scaling-factor in the X and Y axes.
+Negative values may be used to produce mirror images.
+
+@lilypond[verbatim,quote]
+\\markup {
+ \\line {
+ \\scale #'(2 . 1)
+ stretched
+ \\scale #'(1 . -1)
+ mirrored
+ }
+}
+@end lilypond"
+ (let ((stil (interpret-markup layout props arg))
+ (sx (car factor-pair))
+ (sy (cdr factor-pair)))
+ (ly:stencil-scale stil sx sy)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Repeating
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define-markup-command (pattern layout props count axis space pattern)
+ (integer? integer? number? markup?)
+ #:category other
+ "
+Prints @var{count} times a @var{pattern} markup.
+Patterns are spaced apart by @var{space}.
+Patterns are distributed on @var{axis}.
+
+@lilypond[verbatim, quote]
+\\markup \\column {
+ \"Horizontally repeated :\"
+ \\pattern #7 #X #2 \\flat
+ \\null
+ \"Vertically repeated :\"
+ \\pattern #3 #Y #0.5 \\flat
+}
+@end lilypond"
+ (let ((pattern-width (interval-length
+ (ly:stencil-extent (interpret-markup layout props pattern) X)))
+ (new-props (prepend-alist-chain 'word-space 0 (prepend-alist-chain 'baseline-skip 0 props))))
+ (let loop ((i (1- count)) (patterns (markup)))
+ (if (zero? i)
+ (interpret-markup
+ layout
+ new-props
+ (if (= axis X)
+ (markup patterns pattern)
+ (markup #:column (patterns pattern))))
+ (loop (1- i)
+ (if (= axis X)
+ (markup patterns pattern #:hspace space)
+ (markup #:column (patterns pattern #:vspace space))))))))
+
+(define-markup-command (fill-with-pattern layout props space dir pattern left right)
+ (number? ly:dir? markup? markup? markup?)
+ #:category align
+ #:properties ((word-space)
+ (line-width))
+ "
+Put @var{left} and @var{right} in a horizontal line of width @code{line-width}
+with a line of markups @var{pattern} in between.
+Patterns are spaced apart by @var{space}.
+Patterns are aligned to the @var{dir} markup.
+
+@lilypond[verbatim, quote]
+\\markup \\column {
+ \"right-aligned :\"
+ \\fill-with-pattern #1 #RIGHT . first right
+ \\fill-with-pattern #1 #RIGHT . second right
+ \\null
+ \"center-aligned :\"
+ \\fill-with-pattern #1.5 #CENTER - left right
+ \\null
+ \"left-aligned :\"
+ \\override #'(line-width . 50) \\fill-with-pattern #2 #LEFT : left first
+ \\override #'(line-width . 50) \\fill-with-pattern #2 #LEFT : left second
+}
+@end lilypond"
+ (let* ((pattern-x-extent (ly:stencil-extent (interpret-markup layout props pattern) X))
+ (pattern-width (interval-length pattern-x-extent))
+ (left-width (interval-length (ly:stencil-extent (interpret-markup layout props left) X)))
+ (right-width (interval-length (ly:stencil-extent (interpret-markup layout props right) X)))
+ (middle-width (max 0 (- line-width (+ (+ left-width right-width) (* word-space 2)))))
+ (period (+ space pattern-width))
+ (count (truncate (/ (- middle-width pattern-width) period)))
+ (x-offset (+ (* (- (- middle-width (* count period)) pattern-width) (/ (1+ dir) 2)) (abs (car pattern-x-extent)))))
+ (interpret-markup layout props
+ (markup left
+ #:with-dimensions (cons 0 middle-width) '(0 . 0)
+ #:translate (cons x-offset 0)
+ #:pattern (1+ count) X space pattern
+ right))))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Markup list commands
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
dy-top)))))
(space-stil (cdr stils) (cons new-stil result))))))
-(define-builtin-markup-list-command (justified-lines layout props args)
+(define-markup-list-command (justified-lines layout props args)
(markup-list?)
- ((baseline-skip)
- wordwrap-internal-markup-list)
+ #:properties ((baseline-skip)
+ wordwrap-internal-markup-list)
"
@cindex justifying lines of text
(interpret-markup-list layout props
(make-wordwrap-internal-markup-list #t args))))
-(define-builtin-markup-list-command (wordwrap-lines layout props args)
+(define-markup-list-command (wordwrap-lines layout props args)
(markup-list?)
- ((baseline-skip)
- wordwrap-internal-markup-list)
+ #:properties ((baseline-skip)
+ wordwrap-internal-markup-list)
"Like @code{\\wordwrap}, but return a list of lines instead of a single markup.
Use @code{\\override-lines #'(line-width . @var{X})} to set the line width,
where @var{X} is the number of staff spaces."
(interpret-markup-list layout props
(make-wordwrap-internal-markup-list #f args))))
-(define-builtin-markup-list-command (column-lines layout props args)
+(define-markup-list-command (column-lines layout props args)
(markup-list?)
- ((baseline-skip))
+ #:properties ((baseline-skip))
"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)
+ (space-lines baseline-skip
(interpret-markup-list layout props args)))
-(define-builtin-markup-list-command (override-lines layout props new-prop args)
+(define-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))
projects / lilypond.git / blobdiff