From: hanwen Date: Sun, 25 Jan 2004 14:34:36 +0000 (+0000) Subject: * scm/define-grobs.scm (all-grob-descriptions): remove X-Git-Tag: release/2.1.15~12 X-Git-Url: https://git.donarmstrong.com/lilypond.git?a=commitdiff_plain;h=3ae6872d0d0816f5dc535c6b8fb11adfbc49abb2;p=lilypond.git * scm/define-grobs.scm (all-grob-descriptions): remove enclose-bounds in OttavaBracket and PianoPedalBracket * scm/new-markup.scm (def-markup-command) new macro, which takes care of defining the COMMAND-markup and make-COMMAND-markup procedures, setting markup-signature and keyword-signature object properties, and pushing the markup command in markup-function-list. * scm/new-markup.scm:Little scheme style clean-up: there should be no parenthese alone on a line; LET* should not be used where LET is enough. (Nicolas Sceaux) --- diff --git a/ChangeLog b/ChangeLog index ba397ec07a..78647286fd 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,21 @@ +2004-01-25 Han-Wen Nienhuys + + * scm/define-grobs.scm (all-grob-descriptions): remove + enclose-bounds in OttavaBracket and PianoPedalBracket + + * scm/new-markup.scm (def-markup-command) new macro, which takes + care of defining the COMMAND-markup and make-COMMAND-markup + procedures, setting markup-signature and keyword-signature object + properties, and pushing the markup command in + markup-function-list. + + All markup commands are defined thanks to it. Users may also use + it to define their own markup commands. (Nicolas Sceaux) + + * scm/new-markup.scm:Little scheme style clean-up: there should be + no parenthese alone on a line; LET* should not be used where LET + is enough. (Nicolas Sceaux) + 2004-01-25 Jan Nieuwenhuizen * scripts/filter-lilypond-book.py: Add script. @@ -8,6 +26,9 @@ 2004-01-24 Han-Wen Nienhuys + * Documentation/user/refman.itely (Fingering instructions): add + single note chords. + * lily/multi-measure-rest-engraver.cc: use a single MultiMeasureEvent for mm rests. This prevents problems with the new part combiner. diff --git a/Documentation/user/refman.itely b/Documentation/user/refman.itely index 88eeef73cf..66eef429e6 100644 --- a/Documentation/user/refman.itely +++ b/Documentation/user/refman.itely @@ -2153,6 +2153,9 @@ to note heads: \property Voice.fingeringOrientations = #'(up right down) 4 @end lilypond + +By using single note chords, fingering instructions can be put close +to note heads in monophonic music. @seealso diff --git a/input/mutopia/F.Schubert/morgenlied.ly b/input/mutopia/F.Schubert/morgenlied.ly index 450b515b09..0a246875e6 100644 --- a/input/mutopia/F.Schubert/morgenlied.ly +++ b/input/mutopia/F.Schubert/morgenlied.ly @@ -32,7 +32,7 @@ manuscriptBreak = { \break } \paper { - #(set-global-staff-size(* 6.0 1 )) + #(paper-set-staff-size (* 5.8 mm)) linewidth = #(* mm 160) indent = 8\mm interscoreline = 2.\mm diff --git a/input/regression/markup-user.ly b/input/regression/markup-user.ly new file mode 100644 index 0000000000..d1563e6d8f --- /dev/null +++ b/input/regression/markup-user.ly @@ -0,0 +1,22 @@ + +\header { + + texidoc = "Users may define their own markup commands using the + @code{def-markup-command} scheme macro." + + + } + +\version "2.1.14" % to be updated + +#(def-markup-command (upcase paper props str) (string?) + "Upcase the string characters. Syntax: \\upcase #\"string\"" + (interpret-markup paper props (make-simple-markup (string-upcase str)))) + +\score { + \notes { + c''-\markup \upcase #"hello world" + % produces a "HELLO WORLD" markup + } + \paper { raggedright = ##t } +} diff --git a/scm/define-grobs.scm b/scm/define-grobs.scm index 8e04506c20..f2f3487513 100644 --- a/scm/define-grobs.scm +++ b/scm/define-grobs.scm @@ -723,7 +723,6 @@ (font-family . roman) (style . line) (if-text-padding . 1.0) - (enclose-bounds . -1.0) (direction . -1) (bracket-flare . (0.5 . 0.5)) (edge-height . (1.0 . 1.0)) @@ -1083,7 +1082,6 @@ (shorten-pair . (0.0 . -0.6)) (staff-padding . 1.0) (padding . 0.5) - (enclose-bounds . 1) (minimum-length . 1.0) (dash-fraction . 0.3) (edge-height . (0 . 1.2)) diff --git a/scm/music-functions.scm b/scm/music-functions.scm index ce99ba7585..d0ca581467 100644 --- a/scm/music-functions.scm +++ b/scm/music-functions.scm @@ -975,7 +975,7 @@ Rest can contain a list of beat groupings ((> (length notes2) 1) (put 'apart)) (else (if - (and (= (length pitches1) (length pitches2)) + (and (= (length pitches1) 1) (= (length pitches2) 1) (< chord-threshold (ly:pitch-steps (ly:pitch-diff (car pitches1) (car pitches2))))) (put 'apart) @@ -1000,6 +1000,9 @@ Rest can contain a list of beat groupings (analyse-time-step (1+ i1) (1+ i2) (1+ ri) new-active1 new-active2)) ))))) +;; + + (analyse-time-step 0 0 0 '() '()) ; (display result) diff --git a/scm/new-markup.scm b/scm/new-markup.scm index 87432cf354..06356aa985 100644 --- a/scm/new-markup.scm +++ b/scm/new-markup.scm @@ -14,251 +14,471 @@ The function should return a molecule (i.e. a formatted, ready to print object). +To add a function, use the def-markup-command utility. -To add a function, + (def-markup-command (mycommand paper prop arg1 ...) (arg1-type? ...) + \"my command usage and description\" + ...function body...) -1. It should be named COMMAND-markup +The command is now available in markup mode, e.g. -2. It should have an object property set that describes it's -signature. This is to allow the parser to figure out how many -arguments to expect: - (set-object-property! COMMAND-markup scm0-markup1) + \\markup { .... \\MYCOMMAND #1 argument ... } -(insert in the list below). +" ; " -3. The command is now available in markup mode, e.g. +;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; markup definer utilities +;;; `def-markup-command' can be used both for built-in markup +;;; definitions and user defined markups. +(defmacro-public def-markup-command (command-and-args signature . body) + "Define a COMMAND-markup function after command-and-args and body, +register COMMAND-markup and its signature, +add COMMAND-markup to markup-function-list, +sets COMMAND-markup markup-signature and markup-keyword object properties, +define a make-COMMAND-markup function. +Syntax: + (def-markup-command (COMMAND paper props arg1 arg2 ...) (arg1-type? arg2-type? ...) + \"documentation string\" + ...command body...) + or: + (def-markup-command COMMAND (arg1-type? arg2-type? ...) + function) +" + (let* ((command (if (pair? command-and-args) (car command-and-args) command-and-args)) + (args (if (pair? command-and-args) (cdr command-and-args) '())) + (command-name (string->symbol (string-append (symbol->string command) "-markup"))) + (make-markup-name (string->symbol (string-append "make-" (symbol->string command-name))))) + `(begin + (define-public ,(if (pair? args) + (cons command-name args) + command-name) + ,@body) + (set! (markup-command-signature ,command-name) (list ,@signature)) + (if (not (member ,command-name markup-function-list)) + (set! markup-function-list (cons ,command-name markup-function-list))) + (define-public (,make-markup-name . args) + (let ((sig (list ,@signature))) + (make-markup ,command-name ,(symbol->string make-markup-name) sig args)))))) + +(define-public (make-markup markup-function make-name signature args) + " Construct a markup object from MARKUP-FUNCTION and ARGS. Typecheck +against SIGNATURE, reporting MAKE-NAME as the user-invoked function. +" + (let* ((arglen (length args)) + (siglen (length signature)) + (error-msg (if (and (> siglen 0) (> arglen 0)) + (markup-argument-list-error signature args 1) + #f))) + (if (or (not (= arglen siglen)) (< siglen 0) (< arglen 0)) + (scm-error 'markup-format make-name + "Expect ~A arguments for ~A. Found ~A: ~S" + (list siglen make-name arglen args) + #f)) + (if error-msg + (scm-error 'markup-format make-name + "Invalid argument in position ~A\nExpect: ~A\nFound: ~S." + error-msg #f) + (cons markup-function args)))) + +;;;;;;;;;;;;;;; +;;; Utilities for storing and accessing markup commands signature +;;; and keyword. +;;; Examples: +;;; +;;; (set! (markup-command-signature raise-markup) (list number? markup?)) +;;; ==> ((# #) . scheme0-markup1) +;;; +;;; (markup-command-signature raise-markup) +;;; ==> (# #) +;;; +;;; (markup-command-keyword raise-markup) ==> "scheme0-markup1" +;;; + +(define markup-command-signatures (make-hash-table 50)) + +(define (markup-command-signature-ref markup-command) + "Return markup-command's signature, e.g. (number? markup?). +markup-command may be a procedure." + (let ((sig-key (hashq-ref markup-command-signatures + markup-command))) + (if sig-key (car sig-key) #f))) + +(define-public (markup-command-keyword markup-command) + "Return markup-command's keyword, e.g. \"scheme0markup1\". +markup-command may be a procedure." + (let ((sig-key (hashq-ref markup-command-signatures + markup-command))) + (if sig-key (cdr sig-key) #f))) + +(define (markup-command-signatureset! markup-command signature) + "Set markup-command's signature. markup-command must be a named procedure. +Also set markup-signature and markup-keyword object properties." + (hashq-set! markup-command-signatures + markup-command + (cons signature (markup-signature-to-keyword signature))) + ;; these object properties are still in use somewhere + (set-object-property! markup-command 'markup-signature signature) + (set-object-property! markup-command 'markup-keyword (markup-signature-to-keyword signature))) + +(define-public markup-command-signature + (make-procedure-with-setter markup-command-signature-ref markup-command-signatureset!)) - \\markup { .... \\COMMAND #1 argument ... } +(define (markup-symbol-to-proc markup-sym) + "Return the markup command procedure which name is `markup-sym', if any." + (hash-fold (lambda (key val prev) + (or prev + (if (eqv? (procedure-name key) markup-sym) key #f))) + #f + markup-command-signatures)) +(define-public markup-function-list '()) -BUGS: +(define-public (markup-signature-to-keyword sig) + " (A B C) -> a0-b1-c2 " + (if (null? sig) + 'empty + (string->symbol (string-join (map + (let* ((count 0)) + (lambda (func) + (set! count (+ count 1)) + (string-append + ;; for reasons I don't get, + ;; (case func ((markup?) .. ) + ;; doesn't work. + (cond + ((eq? func markup?) "markup") + ((eq? func markup-list?) "markup-list") + (else "scheme")) + (number->string (- count 1))))) + sig) + "-")))) -At present, markup functions must be defined in this -file. Implementing user-access for markup functions is an excercise -for the reader. +(define-public (lookup-markup-command code) + (let ((proc (markup-symbol-to-proc (string->symbol (string-append code "-markup"))))) + (and proc (cons proc (markup-command-keyword proc))))) +;;;;;;;;;;;;;;;;;;;;;; +;;; markup type predicates - +(define (markup-function? x) + (not (not (markup-command-signature x)))) -" ; " +(define (markup-list? arg) + (define (markup-list-inner? l) + (or (null? l) + (and (markup? (car l)) (markup-list-inner? (cdr l))))) + (and (list? arg) (markup-list-inner? arg))) +(define (markup-argument-list? signature arguments) + "Typecheck argument list." + (if (and (pair? signature) (pair? arguments)) + (and ((car signature) (car arguments)) + (markup-argument-list? (cdr signature) (cdr arguments))) + (and (null? signature) (null? arguments)))) -;;;;;;;;;;;;;;;;; + +(define (markup-argument-list-error signature arguments number) + "return (ARG-NR TYPE-EXPECTED ARG-FOUND) if an error is detected, or +#f is no error found. +" + (if (and (pair? signature) (pair? arguments)) + (if (not ((car signature) (car arguments))) + (list number (type-name (car signature)) (car arguments)) + (markup-argument-list-error (cdr signature) (cdr arguments) (+ 1 number))) + #f)) + +;; +;; full recursive typecheck. +;; +(define (markup-typecheck? arg) + (or (string? arg) + (and (pair? arg) + (markup-function? (car arg)) + (markup-argument-list? (markup-command-signature (car arg)) + (cdr arg))))) + +;; +;; typecheck, and throw an error when something amiss. +;; +(define (markup-thrower-typecheck arg) + (cond ((string? arg) #t) + ((not (pair? arg)) + (throw 'markup-format "Not a pair" arg)) + ((not (markup-function? (car arg))) + (throw 'markup-format "Not a markup function " (car arg))) + ((not (markup-argument-list? (markup-command-signature (car arg)) + (cdr arg))) + (throw 'markup-format "Arguments failed typecheck for " arg))) + #t) + +;; +;; good enough if you only use make-XXX-markup functions. +;; +(define (cheap-markup? x) + (or (string? x) + (and (pair? x) + (markup-function? (car x))))) + +;; +;; replace by markup-thrower-typecheck for more detailed diagnostics. +;; +(define-public markup? cheap-markup?) + +;; utility + +(define (markup-join markups sep) + "Return line-markup of MARKUPS, joining them with markup SEP" + (if (pair? markups) + (make-line-markup (list-insert-separator markups sep)) + empty-markup)) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; markup commands ;; TODO: ;; each markup function should have a doc string with ;; syntax, description and example. ;; -(define-public (simple-markup paper props . rest) +(define-public brew-new-markup-molecule Text_item::brew_molecule) + +(define-public interpret-markup Text_item::interpret_markup) + +(def-markup-command (simple paper props str) (string?) "A simple text-string; @code{\\markup @{ foo @}} is equivalent with @code{\\markup @{ \\simple #\"foo\" @}}. " - - (Text_item::interpret_markup paper props (car rest))) + (interpret-markup paper props str)) + +(define-public empty-markup (make-simple-markup "")) (define-public (stack-molecule-line space molecules) (if (pair? molecules) (if (pair? (cdr molecules)) - (let* ( - (tail (stack-molecule-line space (cdr molecules))) - (head (car molecules)) - (xoff (+ space (cdr (ly:molecule-get-extent head X)))) - ) - - (ly:molecule-add - head - (ly:molecule-translate-axis tail xoff X)) - ) - (car molecules)) - '()) - ) - -(define-public (line-markup paper props . rest) + (let* ((tail (stack-molecule-line space (cdr molecules))) + (head (car molecules)) + (xoff (+ space (cdr (ly:molecule-get-extent head X))))) + (ly:molecule-add head + (ly:molecule-translate-axis tail xoff X))) + (car molecules)) + '())) + +(def-markup-command (line paper props markps) (markup-list?) "A horizontal line of markups. Syntax: \\line << MARKUPS >> " - (stack-molecule-line (cdr (chain-assoc 'word-space props)) - (map (lambda (x) (interpret-markup paper props x)) (car rest))) - ) - + (map (lambda (m) (interpret-markup paper props m)) markps))) -(define-public (combine-markup paper props . rest) +(def-markup-command (combine paper props m1 m2) (markup? markup?) "Overstrike two markups." (ly:molecule-add - (interpret-markup paper props (car rest)) - (interpret-markup paper props (cadr rest)))) - -(define (font-markup qualifier value) - (lambda (paper props . rest) - (interpret-markup paper (cons (cons `(,qualifier . ,value) (car props)) (cdr props)) (car rest)) - - )) + (interpret-markup paper props m1) + (interpret-markup paper props m2))) +(def-markup-command (finger paper props arg) (markup?) + (interpret-markup paper + (cons '((font-size . -4) (font-family . number)) props) + arg)) (define-public (set-property-markup qualifier) - (lambda (paper props . rest ) + (lambda (paper props qualifier-val markp) (interpret-markup paper - (cons (cons `(,qualifier . ,(car rest)) - (car props)) (cdr props)) - (cadr rest)) - )) + (cons (cons `(,qualifier . ,qualifier-val) (car props)) (cdr props)) + markp))) -(define-public (finger-markup paper props . rest) - (interpret-markup paper - (cons (list '(font-size . -4) - '(font-family . number)) - props) - (car rest))) +(def-markup-command fontsize (number? markup?) + (set-property-markup 'font-size)) -(define-public fontsize-markup (set-property-markup 'font-size)) -(define-public magnify-markup (set-property-markup 'font-magnification)) +(def-markup-command magnify (number? markup?) + (set-property-markup 'font-magnification)) -(define-public bold-markup +(define (font-markup qualifier value) + (lambda (paper props markp) + (interpret-markup paper + (cons (cons `(,qualifier . ,value) (car props)) (cdr props)) + markp))) + +(def-markup-command bold (markup?) (font-markup 'font-series 'bold)) -(define-public sans-markup + +(def-markup-command sans (markup?) (font-markup 'font-family 'sans)) -(define-public number-markup + +(def-markup-command number (markup?) (font-markup 'font-family 'number)) -(define-public roman-markup - (font-markup 'font-family 'roman)) +(def-markup-command roman (markup?) + (font-markup 'font-family 'roman)) -(define-public huge-markup +(def-markup-command huge (markup?) (font-markup 'font-size 2)) -(define-public large-markup + +(def-markup-command large (markup?) (font-markup 'font-size 1)) -(define-public normalsize-markup + +(def-markup-command normalsize (markup?) (font-markup 'font-size 0)) -(define-public small-markup + +(def-markup-command small (markup?) (font-markup 'font-size -1)) -(define-public tiny-markup + +(def-markup-command tiny (markup?) (font-markup 'font-size -2)) -(define-public teeny-markup + +(def-markup-command teeny (markup?) (font-markup 'font-size -3)) -(define-public dynamic-markup + +(def-markup-command dynamic (markup?) (font-markup 'font-family 'dynamic)) -(define-public italic-markup + +(def-markup-command italic (markup?) (font-markup 'font-shape 'italic)) -(define-public typewriter-markup - (font-markup 'font-family 'typewriter)) +(def-markup-command typewriter (markup?) + (font-markup 'font-family 'typewriter)) -;; TODO: baseline-skip should come from the font. -(define-public (column-markup paper props . rest) +(def-markup-command (column paper props mrkups) (markup-list?) (stack-lines -1 0.0 (cdr (chain-assoc 'baseline-skip props)) - (map (lambda (x) (interpret-markup paper props x)) (car rest))) - ) + (map (lambda (m) (interpret-markup paper props m)) mrkups))) -(define-public (dir-column-markup paper props . rest) +(def-markup-command (dir-column paper props mrkups) (markup-list?) "Make a column of args, going up or down, depending on the setting of the #'direction layout property." - - (let* - ( - (dir (cdr (chain-assoc 'direction props))) - ) + (let* ((dir (cdr (chain-assoc 'direction props)))) (stack-lines (if (number? dir) dir -1) - 0.0 (cdr (chain-assoc 'baseline-skip props)) - (map (lambda (x) (interpret-markup paper props x)) (car rest))) - )) + 0.0 + (cdr (chain-assoc 'baseline-skip props)) + (map (lambda (x) (interpret-markup paper props x)) mrkups)))) -(define-public (center-markup paper props . rest) - (let* - ( - (mols (map (lambda (x) (interpret-markup paper props x)) (car rest))) - (cmols (map (lambda (x) (ly:molecule-align-to! x X CENTER)) mols)) - ) - - (stack-lines - -1 0.0 (cdr (chain-assoc 'baseline-skip props)) - mols) - )) +(def-markup-command (center paper props mrkups) (markup-list?) + (let* ((mols (map (lambda (x) (interpret-markup paper props x)) mrkups)) + (cmols (map (lambda (x) (ly:molecule-align-to! x X CENTER)) mols))) + (stack-lines -1 0.0 (cdr (chain-assoc 'baseline-skip props)) mols))) -(define-public (right-align-markup paper props . rest) - (let* ((m (interpret-markup paper props (car rest)))) +(def-markup-command (right-align paper props mrkup) (markup?) + (let* ((m (interpret-markup paper props mrkup))) (ly:molecule-align-to! m X RIGHT) m)) -(define-public (left-align-markup paper props . rest) - (let* ((m (interpret-markup paper props (car rest)))) + +(def-markup-command (left-align paper props mrkup) (markup?) + (let* ((m (interpret-markup paper props mrkup))) (ly:molecule-align-to! m X LEFT) m)) -(define-public (halign-markup paper props . rest) + +(def-markup-command (halign paper props dir mrkup) (number? markup?) "Set horizontal alignment. Syntax: halign A MARKUP. A=-1 is LEFT, A=1 is right, values in between vary alignment accordingly." - (let* ((m (interpret-markup paper props (cadr rest)))) - (ly:molecule-align-to! m X (car rest)) + (let* ((m (interpret-markup paper props mrkup))) + (ly:molecule-align-to! m X dir) m)) - - -(define-public (musicglyph-markup paper props . rest) +(def-markup-command (musicglyph paper props glyph-name) (string?) (ly:find-glyph-by-name (ly:paper-get-font paper (cons '((font-name . ()) - (font-shape . *) - (font-series . *) - (font-family . music)) props)) - (car rest))) + (font-shape . *) + (font-series . *) + (font-family . music)) + props)) + glyph-name)) -(define-public (lookup-markup paper props . rest) +(def-markup-command (lookup paper props glyph-name) (string?) "Lookup a glyph by name." - (ly:find-glyph-by-name - (ly:paper-get-font paper props) - (car rest)) - ) + (ly:find-glyph-by-name (ly:paper-get-font paper props) + glyph-name)) -(define-public (char-markup paper props . rest) +(def-markup-command (char paper props num) (integer?) "Syntax: \\char NUMBER. " - (ly:get-glyph (ly:paper-get-font paper props) (car rest)) - ) + (ly:get-glyph (ly:paper-get-font paper props) num)) -(define-public (raise-markup paper props . rest) +(def-markup-command (raise paper props amount mrkup) (number? markup?) "Syntax: \\raise AMOUNT MARKUP. " - (ly:molecule-translate-axis (interpret-markup - paper - props - (cadr rest)) - (car rest) Y)) + (ly:molecule-translate-axis (interpret-markup paper props mrkup) + amount Y)) -(define-public (fraction-markup paper props . rest) +(def-markup-command (fraction paper props mrkup1 mrkup2) (markup? markup?) "Make a fraction of two markups. Syntax: \\fraction MARKUP1 MARKUP2." - - (let* - ((m1 (interpret-markup paper props (car rest))) - (m2 (interpret-markup paper props (cadr rest)))) - + (let* ((m1 (interpret-markup paper props mrkup1)) + (m2 (interpret-markup paper props mrkup2))) (ly:molecule-align-to! m1 X CENTER) - (ly:molecule-align-to! m2 X CENTER) - - (let* - ((x1 (ly:molecule-get-extent m1 X)) - (x2 (ly:molecule-get-extent m2 X)) - (line (ly:round-filled-box (interval-union x1 x2) '(-0.05 . 0.05) 0.0)) - - ;; should stack mols separately, to maintain LINE on baseline - (stack (stack-lines -1 0.2 0.6 (list m1 line m2)))) - + (ly:molecule-align-to! m2 X CENTER) + (let* ((x1 (ly:molecule-get-extent m1 X)) + (x2 (ly:molecule-get-extent m2 X)) + (line (ly:round-filled-box (interval-union x1 x2) '(-0.05 . 0.05) 0.0)) + ;; should stack mols separately, to maintain LINE on baseline + (stack (stack-lines -1 0.2 0.6 (list m1 line m2)))) (ly:molecule-align-to! stack Y CENTER) (ly:molecule-align-to! stack X LEFT) ;; should have EX dimension ;; empirical anyway - (ly:molecule-translate-axis stack 0.75 Y) - ))) + (ly:molecule-translate-axis stack 0.75 Y)))) ;; TODO: better syntax. - -(use-modules (ice-9 optargs) - (ice-9 regex)) +(def-markup-command (note-by-number paper props log dot-count dir) (number? number? number?) + "Syntax: \\note-by-number #LOG #DOTS #DIR. By using fractional values +for DIR, you can obtain longer or shorter stems." + (let* ((font (ly:paper-get-font paper (cons '((font-family . music)) props))) + (stemlen (max 3 (- log 1))) + (headgl (ly:find-glyph-by-name + font + (string-append "noteheads-" (number->string (min log 2))))) + (stemth 0.13) + (stemy (* dir stemlen)) + (attachx (if (> dir 0) + (- (cdr (ly:molecule-get-extent headgl X)) stemth) + 0)) + (attachy (* dir 0.28)) + (stemgl (and (> log 0) + (ly:round-filled-box + (cons attachx (+ attachx stemth)) + (cons (min stemy attachy) + (max stemy attachy)) + (/ stemth 3)))) + (dot (ly:find-glyph-by-name font "dots-dot")) + (dotwid (interval-length (ly:molecule-get-extent dot X))) + (dots (and (> dot-count 0) + (apply ly:molecule-add + (map (lambda (x) + (ly:molecule-translate-axis + dot (* (+ 1 (* 2 x)) dotwid) X) ) + (iota dot-count 1))))) + (flaggl (and (> log 2) + (ly:molecule-translate + (ly:find-glyph-by-name font + (string-append "flags-" + (if (> dir 0) "u" "d") + (number->string log))) + (cons (+ attachx (/ stemth 2)) stemy))))) + (if flaggl + (set! stemgl (ly:molecule-add flaggl stemgl))) + (if (ly:molecule? stemgl) + (set! stemgl (ly:molecule-add stemgl headgl)) + (set! stemgl headgl)) + (if (ly:molecule? dots) + (set! stemgl + (ly:molecule-add + (ly:molecule-translate-axis dots + (+ (if (and (> dir 0) (> log 2)) + (* 1.5 dotwid) + 0) + ;; huh ? why not necessary? + ;;(cdr (ly:molecule-get-extent headgl X)) + dotwid) + X) + stemgl))) + stemgl)) + +(use-modules (ice-9 regex)) (define-public log2 (let ((divisor (log 2))) @@ -277,240 +497,121 @@ Syntax: \\fraction MARKUP1 MARKUP2." (if dots (string-length dots) 0))) (error "This is not a valid duration string:" duration-string)))) - -(define-public (note-markup paper props . rest) +(def-markup-command (note paper props duration-string dir) (string? number?) "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 example, @code{\note #\"4.\" #-0.75} creates a dotted quarter note, with a shortened down stem." + (let ((parsed (parse-simple-duration duration-string))) + (note-by-number-markup paper props (car parsed) (cadr parsed) dir))) - (let* - ((parsed (parse-simple-duration (car rest))) - (dir (cadr rest))) - (note-by-number-markup paper props (car parsed) (cadr parsed) dir) - )) - -(define-public (note-by-number-markup paper props . rest ) - "Syntax: \\note #LOG #DOTS #DIR. By using fractional values -for DIR, you can obtain longer or shorter stems." - - (let* - ( - (log (car rest)) - (dot-count (cadr rest)) - (dir (caddr rest)) - (font (ly:paper-get-font paper (cons '((font-family . music)) props))) - (stemlen (max 3 (- log 1))) - (headgl - (ly:find-glyph-by-name font (string-append "noteheads-" (number->string (min log 2))))) - - (stemth 0.13) - (stemy (* dir stemlen)) - (attachx (if (> dir 0) (- (cdr (ly:molecule-get-extent headgl X)) stemth) - 0)) - (attachy (* dir 0.28)) - (stemgl (if (> log 0) - (ly:round-filled-box - (cons attachx (+ attachx stemth)) - (cons (min stemy attachy) - (max stemy attachy)) - (/ stemth 3) - ) #f)) - (dot (ly:find-glyph-by-name font "dots-dot")) - (dotwid (interval-length (ly:molecule-get-extent dot X))) - (dots (if (> dot-count 0) - (apply ly:molecule-add - (map (lambda (x) - (ly:molecule-translate-axis - dot (* (+ 1 (* 2 x)) dotwid) X) ) - (iota dot-count 1))) - #f)) - - (flaggl (if (> log 2) - (ly:molecule-translate - (ly:find-glyph-by-name - font - (string-append "flags-" - (if (> dir 0) "u" "d") - (number->string log) - )) - (cons (+ attachx (/ stemth 2)) stemy)) - - #f))) - - (if flaggl - (set! stemgl (ly:molecule-add flaggl stemgl))) - - (if (ly:molecule? stemgl) - (set! stemgl (ly:molecule-add stemgl headgl)) - (set! stemgl headgl) - ) - - (if (ly:molecule? dots) - (set! stemgl - (ly:molecule-add - (ly:molecule-translate-axis - dots - (+ - (if (and (> dir 0) (> log 2)) - (* 1.5 dotwid) 0) - ;; huh ? why not necessary? - ;(cdr (ly:molecule-get-extent headgl X)) - dotwid - ) - X) - stemgl - ) - )) - - stemgl - )) - -(define-public (normal-size-super-markup paper props . rest) +(def-markup-command (normal-size-super paper props mrkup) (markup?) (ly:molecule-translate-axis (interpret-markup - paper - props (car rest)) - (* 0.5 (cdr (chain-assoc 'baseline-skip props))) - Y) - ) + paper + props mrkup) + (* 0.5 (cdr (chain-assoc 'baseline-skip props))) + Y)) -(define-public (super-markup paper props . rest) +(def-markup-command (super paper props mrkup) (markup?) "Syntax: \\super MARKUP. " - (ly:molecule-translate-axis (interpret-markup - paper - (cons `((font-size . - ,(- (chain-assoc-get 'font-size props 0) 3))) props) (car rest)) - (* 0.5 (cdr (chain-assoc 'baseline-skip props))) - Y) - ) - -(define-public (translate-markup paper props . rest) - "Syntax: \\translate OFFSET MARKUP. " - (ly:molecule-translate (interpret-markup paper props (cadr rest)) - (car rest)) + (ly:molecule-translate-axis + (interpret-markup + paper + (cons `((font-size . ,(- (chain-assoc-get 'font-size props 0) 3))) props) + mrkup) + (* 0.5 (cdr (chain-assoc 'baseline-skip props))) + Y)) - ) +(def-markup-command (translate paper props offset mrkup) (number-pair? markup?) + "Syntax: \\translate OFFSET MARKUP. " + (ly:molecule-translate (interpret-markup paper props mrkup) + offset)) -(define-public (sub-markup paper props . rest) +(def-markup-command (sub paper props mrkup) (markup?) "Syntax: \\sub MARKUP." (ly:molecule-translate-axis (interpret-markup paper - (cons `((font-size . - ,(- (chain-assoc-get 'font-size props 0) 3))) props) - (car rest)) + (cons `((font-size . ,(- (chain-assoc-get 'font-size props 0) 3))) props) + mrkup) (* -0.5 (cdr (chain-assoc 'baseline-skip props))) - Y) ) + Y)) -(define-public (normal-size-sub-markup paper props . rest) +(def-markup-command (normal-size-sub paper props mrkup) (markup?) (ly:molecule-translate-axis - (interpret-markup - paper - props (car rest)) + (interpret-markup paper props mrkup) (* -0.5 (cdr (chain-assoc 'baseline-skip props))) - Y) ) + Y)) -(define-public (hbracket-markup paper props . rest) +(def-markup-command (hbracket paper props mrkup) (markup?) "Horizontal brackets around its single argument. Syntax \\hbracket MARKUP." - - (let* - ((th 0.1) ;; todo: take from GROB. - (m (interpret-markup paper props (car rest))) ) + (let ((th 0.1) ;; todo: take from GROB. + (m (interpret-markup paper props mrkup))) + (bracketify-molecule m X th (* 2.5 th) th))) - (bracketify-molecule m X th (* 2.5 th) th) -)) - -(define-public (bracket-markup paper props . rest) +(def-markup-command (bracket paper props mrkup) (markup?) "Vertical brackets around its single argument. Syntax \\bracket MARKUP." - (let* - ((th 0.1) ;; todo: take from GROB. - (m (interpret-markup paper props (car rest))) ) - - (bracketify-molecule m Y th (* 2.5 th) th) -)) + (let ((th 0.1) ;; todo: take from GROB. + (m (interpret-markup paper props mrkup))) + (bracketify-molecule m Y th (* 2.5 th) th))) ;; todo: fix negative space -(define (hspace-markup paper props . rest) +(def-markup-command (hspace paper props amount) (number?) "Syntax: \\hspace NUMBER." - (let* - ((amount (car rest))) - (if (> amount 0) - (ly:make-molecule "" (cons 0 amount) '(-1 . 1) ) - (ly:make-molecule "" (cons amount amount) '(-1 . 1))) - )) - -(define-public (override-markup paper props . rest) + (if (> amount 0) + (ly:make-molecule "" (cons 0 amount) '(-1 . 1) ) + (ly:make-molecule "" (cons amount amount) '(-1 . 1)))) +(def-markup-command (override paper props new-prop mrkup) (pair? markup?) "Add the first argument in to the property list. Properties may be any sort of property supported by @ref{font-interface} and @ref{text-interface}, for example \\override #'(font-family . married) \"bla\" - " - - (interpret-markup paper (cons (list (car rest)) props) - (cadr rest))) + (interpret-markup paper (cons (list new-prop) props) mrkup)) -(define-public (smaller-markup paper props . rest) +(def-markup-command (smaller paper props mrkup) (markup?) "Syntax: \\smaller MARKUP" - (let* - ((fs (chain-assoc-get 'font-size props 0)) - (entry (cons 'font-size (- fs 1))) - ) - (interpret-markup - paper (cons (list entry) props) - (car rest)) - )) + (let* ((fs (chain-assoc-get 'font-size props 0)) + (entry (cons 'font-size (- fs 1)))) + (interpret-markup paper (cons (list entry) props) mrkup))) -(define-public (bigger-markup paper props . rest) +(def-markup-command (bigger paper props mrkup) (markup?) "Syntax: \\bigger MARKUP" - (let* - ((fs (chain-assoc-get 'font-size props 0)) - (entry (cons 'font-size (+ fs 1))) - ) - (interpret-markup - paper (cons (list entry) props) - (car rest)) - )) + (let* ((fs (chain-assoc-get 'font-size props 0)) + (entry (cons 'font-size (+ fs 1)))) + (interpret-markup paper (cons (list entry) props) mrkup))) -(define-public larger-markup bigger-markup) +(def-markup-command larger (markup?) + bigger-markup) - -(define-public (box-markup paper props . rest) +(def-markup-command (box paper props mrkup) (markup?) "Syntax: \\box MARKUP" - (let* - ((th 0.1) - (pad 0.2) - (m (interpret-markup paper props (car rest))) - ) - (box-molecule m th pad) - )) + (let ((th 0.1) + (pad 0.2) + (m (interpret-markup paper props mrkup))) + (box-molecule m th pad))) - -(define-public (strut-markup paper props . rest) +(def-markup-command (strut paper props) () "Syntax: \\strut A box of the same height as the space. " - - (let* - ((m (Text_item::interpret_markup paper props " "))) - + (let ((m (Text_item::interpret_markup paper props " "))) (ly:molecule-set-extent! m X '(1000 . -1000)) m)) - (define number->mark-letter-vector (make-vector 25 #\A)) (do ((i 0 (1+ i)) - (j 0 (1+ j)) ) + (j 0 (1+ j))) ((>= i 26)) (if (= i (- (char->integer #\I) (char->integer #\A))) (set! i (1+ i))) (vector-set! number->mark-letter-vector j - (integer->char (+ i (char->integer #\A)))) ) + (integer->char (+ i (char->integer #\A))))) (define (number->markletter-string n) "Double letters for big marks." @@ -519,340 +620,27 @@ any sort of property supported by @ref{font-interface} and (if (>= n l) (string-append (number->markletter-string (1- (quotient n l))) - (number->markletter-string (remainder n l))) + (number->markletter-string (remainder n l))) (make-string 1 (vector-ref number->mark-letter-vector n))))) -(define-public (markletter-markup paper props . rest) +(def-markup-command (markletter paper props num) (number?) "Markup letters: skip I and do double letters for big marks. Syntax: \\markletter #25" - - (Text_item::interpret_markup paper props - (number->markletter-string (car rest)) - )) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -(define (markup-signature-to-keyword sig) - " (A B C) -> a0-b1-c2 " - (if (equal? sig '()) - 'empty - (let* ((count 0)) - (string->symbol (string-join - - (map - (lambda (func) - (set! count (+ count 1)) - (string-append - - ;; for reasons I don't get, - ;; (case func ((markup?) .. ) - ;; doesn't work. - (cond - ((eq? func markup?) "markup") - ((eq? func markup-list?) "markup-list") - (else "scheme") - ) - (number->string (- count 1)) - )) - - sig) - "-")) - - ))) - -(define (markup-function? x) - (object-property x 'markup-signature) ) - -(define (markup-list? arg) - (define (markup-list-inner? l) - (if (null? l) - #t - (and (markup? (car l)) (markup-list-inner? (cdr l))) ) ) - (and (list? arg) (markup-list-inner? arg))) - -(define (markup-argument-list? signature arguments) - "Typecheck argument list." - (if (and (pair? signature) (pair? arguments)) - (and ((car signature) (car arguments)) - (markup-argument-list? (cdr signature) (cdr arguments))) - (and (null? signature) (null? arguments))) - ) - - -(define (markup-argument-list-error signature arguments number) - "return (ARG-NR TYPE-EXPECTED ARG-FOUND) if an error is detected, or -#f is no error found. -" - (if (and (pair? signature) (pair? arguments)) - (if (not ((car signature) (car arguments))) - (list number (type-name (car signature)) (car arguments)) - (markup-argument-list-error (cdr signature) (cdr arguments) (+ 1 number))) - #f - )) - -;; -;; full recursive typecheck. -;; -(define (markup-typecheck? arg) - (or (string? arg) - (and (pair? arg) - (markup-function? (car arg)) - (markup-argument-list? - (object-property (car arg) 'markup-signature) - (cdr arg)) - )) -) - -;; -;; typecheck, and throw an error when something amiss. -;; -(define (markup-thrower-typecheck arg) - (cond - ((string? arg) #t) - ((not (pair? arg)) - (throw 'markup-format "Not a pair" arg) - ) - ((not (markup-function? (car arg))) - (throw 'markup-format "Not a markup function " (car arg))) - - - ((not (markup-argument-list? - (object-property (car arg) 'markup-signature) - (cdr arg))) - (throw 'markup-format "Arguments failed typecheck for " arg))) - #t - ) - -;; -;; good enough if you only use make-XXX-markup functions. -;; -(define (cheap-markup? x) - (or (string? x) - (and (pair? x) - (markup-function? (car x)))) -) - -;; -;; replace by markup-thrower-typecheck for more detailed diagnostics. -;; -(define markup? cheap-markup?) - -(define markup-functions-and-signatures - (list - - ;; abs size - (cons teeny-markup (list markup?)) - (cons tiny-markup (list markup?)) - (cons small-markup (list markup?)) - (cons dynamic-markup (list markup?)) - (cons large-markup (list markup?)) - (cons normalsize-markup (list markup?)) - - (cons huge-markup (list markup?)) - - ;; size - (cons smaller-markup (list markup?)) - (cons bigger-markup (list markup?)) - (cons larger-markup (list markup?)) -; (cons char-number-markup (list string?)) - - ;; - (cons sub-markup (list markup?)) - (cons normal-size-sub-markup (list markup?)) - - (cons super-markup (list markup?)) - (cons normal-size-super-markup (list markup?)) - - (cons finger-markup (list markup?)) - (cons bold-markup (list markup?)) - (cons italic-markup (list markup?)) - (cons typewriter-markup (list markup?)) - (cons roman-markup (list markup?)) - (cons number-markup (list markup?)) - (cons hbracket-markup (list markup?)) - (cons bracket-markup (list markup?)) - (cons note-markup (list string? number?)) - (cons note-by-number-markup (list number? number? number?)) - (cons fraction-markup (list markup? markup?)) - (cons markletter-markup (list number?)) - (cons column-markup (list markup-list?)) - (cons dir-column-markup (list markup-list?)) - (cons center-markup (list markup-list?)) - (cons line-markup (list markup-list?)) - - (cons right-align-markup (list markup?)) - (cons left-align-markup (list markup?)) - (cons halign-markup (list number? markup?)) - - (cons combine-markup (list markup? markup?)) - (cons simple-markup (list string?)) - (cons musicglyph-markup (list string?)) - (cons translate-markup (list number-pair? markup?)) - (cons override-markup (list pair? markup?)) - (cons char-markup (list integer?)) - (cons lookup-markup (list string?)) - - (cons hspace-markup (list number?)) - - (cons raise-markup (list number? markup?)) - (cons magnify-markup (list number? markup?)) - (cons fontsize-markup (list number? markup?)) - - (cons box-markup (list markup?)) - (cons strut-markup '()) - )) - - -(define markup-module (current-module)) - -(map (lambda (x) - (set-object-property! (car x) 'markup-signature (cdr x)) - (set-object-property! (car x) 'markup-keyword (markup-signature-to-keyword (cdr x))) - ) - markup-functions-and-signatures) - -(define-public markup-function-list (map car markup-functions-and-signatures)) - - -;; construct a -;; -;; make-FOO-markup function that typechecks its arguments. -;; -;; TODO: should construct a message says -;; Invalid argument 4 : expecting a BLADIBLA, found: (list-ref 4 args) -;; -;; right now, you get the entire argument list. - - -(define (make-markup-maker entry) - (let* - ((foo-markup (car entry)) - (signature (cons 'list (cdr entry))) - (name (symbol->string (procedure-name foo-markup))) - (make-name (string-append "make-" name)) - ) - - `(define (,(string->symbol make-name) . args) - (let* - ( - (arglen (length args)) - (siglen (length ,signature)) - (error-msg - (if (and (> 0 siglen) (> 0 arglen)) - (markup-argument-list-error ,signature args 1))) - - ) - - (if (or (not (= arglen siglen)) (< siglen 0) (< 0 arglen)) - (scm-error 'markup-format ,make-name "Expect ~A arguments for ~A. Found ~A: ~S" - (list (length ,signature) - ,make-name - (length args) - args) #f)) - (if error-msg - (scm-error 'markup-format ,make-name "Invalid argument in position ~A\n Expect: ~A\nFound: ~S." error-msg #f) - - (cons ,foo-markup args) - ))) - ) -) - - - -(define (make-markup markup-function make-name signature args) - - " Construct a markup object from MARKUP-FUNCTION and ARGS. Typecheck -against SIGNATURE, reporting MAKE-NAME as the user-invoked function. -" - - (let* - ((arglen (length args)) - (siglen (length signature)) - (error-msg - (if (and (> siglen 0) (> arglen 0)) - (markup-argument-list-error signature args 1) - #f))) - - - (if (or (not (= arglen siglen)) (< siglen 0) (< arglen 0)) - (scm-error 'markup-format make-name "Expect ~A arguments for ~A. Found ~A: ~S" - (list siglen - make-name - arglen - args) #f)) - - (if error-msg - (scm-error 'markup-format make-name "Invalid argument in position ~A\nExpect: ~A\nFound: ~S." error-msg #f) - - (cons markup-function args) - ))) - -(define (make-markup-maker entry) - (let* ( - (name (symbol->string (procedure-name (car entry)))) - (make-name (string-append "make-" name)) - (signature (object-property (car entry) 'markup-signature)) - ) - - `(define-public (,(string->symbol make-name) . args) - (make-markup ,(car entry) ,make-name ,(cons 'list signature) args) - )) - ) - -(eval - (cons 'begin (map make-markup-maker markup-functions-and-signatures)) - markup-module - ) - -;; -;; TODO: add module argument so user-defined markups can also be -;; processed. -;; -(define-public (lookup-markup-command code) - (let* - ((sym (string->symbol (string-append code "-markup"))) - (var (module-local-variable markup-module sym)) - ) - (if (eq? var #f) - #f - (cons (variable-ref var) (object-property (variable-ref var) 'markup-keyword)) - ) - )) - - -(define-public brew-new-markup-molecule Text_item::brew_molecule) - -(define-public empty-markup (make-simple-markup "")) - -(define-public interpret-markup Text_item::interpret_markup) - - -;;;;;;;;;;;;;;;; -;; utility - -(define (markup-join markups sep) - "Return line-markup of MARKUPS, joining them with markup SEP" - (if (pair? markups) - (make-line-markup (list-insert-separator markups sep)) - empty-markup)) - + (Text_item::interpret_markup paper props (number->markletter-string num))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (if #f - (define (typecheck-with-error x) - (catch - 'markup-format - (lambda () (markup? x)) - (lambda (key message arg) - (display "\nERROR: markup format error: \n") - (display message) - (newline) - (write arg (current-output-port)) - ) - ))) + (define (typecheck-with-error x) + (catch + 'markup-format + (lambda () (markup? x)) + (lambda (key message arg) + (display "\nERROR: markup format error: \n") + (display message) + (newline) + (write arg (current-output-port)))))) ;; test make-foo-markup functions (if #f @@ -863,31 +651,22 @@ against SIGNATURE, reporting MAKE-NAME as the user-invoked function. (make-line-markup (make-simple-markup "FOO")) (make-line-markup (make-simple-markup "FOO") (make-simple-markup "foo")) - (make-raise-markup "foo" (make-simple-markup "foo")) - ) - ) - + (make-raise-markup "foo" (make-simple-markup "foo")))) ;; ;; test typecheckers. Not wholly useful, because errors are detected ;; in other places than they're made. ;; (if #f - (begin - - ;; To get error messages, see above to install the alternate - ;; typecheck routine for markup?. - - - - (display (typecheck-with-error `(,simple-markup "foobar"))) - (display (typecheck-with-error `(,simple-markup "foobar"))) - (display (typecheck-with-error `(,simple-markup 1))) - (display - (typecheck-with-error `(,line-markup ((,simple-markup "foobar")) - (,simple-markup 1)))) - (display - (typecheck-with-error `(,line-markup (,simple-markup "foobar") - (,simple-markup "bla")))) - - )) + (begin + ;; To get error messages, see above to install the alternate + ;; typecheck routine for markup?. + (display (typecheck-with-error `(,simple-markup "foobar"))) + (display (typecheck-with-error `(,simple-markup "foobar"))) + (display (typecheck-with-error `(,simple-markup 1))) + (display + (typecheck-with-error `(,line-markup ((,simple-markup "foobar")) + (,simple-markup 1)))) + (display + (typecheck-with-error `(,line-markup (,simple-markup "foobar") + (,simple-markup "bla"))))))