;;;; This file is part of LilyPond, the GNU music typesetter.
;;;;
-;;;; (c) 1998--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
+;;;; (c) 1998--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
;;;; Jan Nieuwenhuizen <janneke@gnu.org>
;;;;
;;;; LilyPond is free software: you can redistribute it and/or modify
;; metronome marks
(define-public (format-metronome-markup event context)
- (let ((hide-note (ly:context-property context 'tempoHideNote #f))
- (text (ly:event-property event 'text))
- (dur (ly:event-property event 'tempo-unit))
- (count (ly:event-property event 'metronome-count)))
-
- (metronome-markup text dur count hide-note)))
-
-(define-public (metronome-markup text dur count hide-note)
- (let* ((note-mark (if (and (not hide-note) (ly:duration? dur))
- (make-smaller-markup
- (make-note-by-number-markup (ly:duration-log dur)
- (ly:duration-dot-count dur)
- 1))
- #f))
+ (let ((hide-note (ly:context-property context 'tempoHideNote #f))
+ (text (ly:event-property event 'text))
+ (dur (ly:event-property event 'tempo-unit))
+ (count (ly:event-property event 'metronome-count)))
+ (metronome-markup text dur count hide-note)))
+(export format-metronome-markup)
+
+(define (metronome-markup text dur count hide-note)
+ (let* ((note-mark
+ (if (and (not hide-note) (ly:duration? dur))
+ (make-smaller-markup
+ (make-note-by-number-markup
+ (ly:duration-log dur)
+ (ly:duration-dot-count dur)
+ UP))
+ #f))
(count-markup (cond ((number? count)
(if (> count 0)
- (make-simple-markup (number->string count))
+ (make-simple-markup
+ (number->string count))
#f))
((pair? count)
(make-concat-markup
(list
- (make-simple-markup (number->string (car count)))
+ (make-simple-markup
+ (number->string (car count)))
(make-simple-markup " ")
(make-simple-markup "–")
(make-simple-markup " ")
- (make-simple-markup (number->string (cdr count))))))
+ (make-simple-markup
+ (number->string (cdr count))))))
(else #f)))
(note-markup (if (and (not hide-note) count-markup)
(make-concat-markup
;; Create the dot-placement list for the grob
(set! (ly:grob-property grob 'dot-placement-list) placement-list)))
-(define-public
- (determine-frets context notes specified-info . rest)
+(define*-public
+ ((determine-frets #:optional (support-non-integer-fret? #f))
+ context notes specified-info . rest)
"Determine string numbers and frets for playing @var{notes}
as a chord, given specified information @var{specified-info}.
@var{specified-info} is a list with two list elements,
is not @code {#f}. If @var{rest} is present, it contains the
@code{FretBoard} grob, and a fretboard will be
created. Otherwise, a list of @code{(string fret finger)} lists will
-be returned."
+be returned.
+If the optional @var{support-non-integer-fret?} is set @code{#t}, micro-tones
+are supported for TabStaff, but not not for FretBoards."
;; helper functions
if no fingering is present."
(let* ((articulations (ly:event-property ev 'articulations))
(finger-found #f))
- (map (lambda (art)
- (let* ((num (ly:event-property art 'digit)))
-
- (if (and (ly:in-event-class? art 'fingering-event)
- (number? num)
- (> num 0))
- (set! finger-found num))))
- articulations)
+ (for-each (lambda (art)
+ (let* ((num (ly:event-property art 'digit)))
+
+ (if (and (ly:in-event-class? art 'fingering-event)
+ (number? num)
+ (> num 0))
+ (set! finger-found num))))
+ articulations)
finger-found))
(define (delete-free-string string)
(and (or (and (not restrain-open-strings)
(zero? fret))
(>= fret minimum-fret))
- (integer? fret)
+ (if (and support-non-integer-fret? (null? rest))
+ (integer? (truncate fret))
+ (integer? fret))
(close-enough fret))))
(define (open-string string pitch)
(if (< this-fret 0)
(ly:warning (_ "Negative fret for pitch ~a on string ~a")
(car pitch-entry) string)
- (if (not (integer? this-fret))
+ (if (and (not (integer? this-fret)) (not support-non-integer-fret?))
(ly:warning (_ "Missing fret for pitch ~a on string ~a")
(car pitch-entry) string)))
(delete-free-string string)
(define-public (fret-letter-tablature-format
context string-number fret-number)
(let ((labels (ly:context-property context 'fretLabels)))
- (make-vcenter-markup
+ (make-translate-scaled-markup '(0 . -0.5)
(cond
((= 0 (length labels))
(string (integer->char (+ fret-number (char->integer #\a)))))
;; Display the fret number as a number
(define-public (fret-number-tablature-format
context string-number fret-number)
- (make-vcenter-markup
- (format #f "~a" fret-number)))
+ (if (integer? fret-number)
+ (make-vcenter-markup
+ (format #f "~a" fret-number))
+ ;; for non-integer fret-number print p.e. "2½"
+ (let* ((whole-part (truncate fret-number))
+ (remaining (- fret-number whole-part))
+ (fret
+ (if (and (zero? whole-part) (not (zero? remaining)))
+ ""
+ (format #f "~a" whole-part)))
+ (frac
+ (if (zero? remaining)
+ ""
+ (format #f "~a" remaining))))
+ (make-concat-markup
+ (list (make-vcenter-markup fret)
+ (make-vcenter-markup
+ ;; the value `-2.5' is my choice
+ (make-fontsize-markup -2.5 frac)))))))
;; The 5-string banjo has got an extra string, the fifth (duh), which
;; starts at the fifth fret on the neck. Frets on the fifth string
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; bar numbers
-(define-public ((every-nth-bar-number-visible n) barnum mp)
+(define ((every-nth-bar-number-visible n) barnum mp)
(= 0 (modulo barnum n)))
+(export every-nth-bar-number-visible)
-(define-public ((modulo-bar-number-visible n m) barnum mp)
+(define ((modulo-bar-number-visible n m) barnum mp)
(and (> barnum 1) (= m (modulo barnum n))))
+(export modulo-bar-number-visible)
-(define-public ((set-bar-number-visibility n) tr)
+(define ((set-bar-number-visibility n) tr)
(let ((bn (ly:context-property tr 'currentBarNumber)))
(ly:context-set-property! tr 'barNumberVisibility
(modulo-bar-number-visible n (modulo bn n)))))
+(export set-bar-number-visibility)
(define-public (first-bar-number-invisible barnum mp)
(> barnum 1))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; percent repeat counters
-(define-public ((every-nth-repeat-count-visible n) count context)
+(define ((every-nth-repeat-count-visible n) count context)
(= 0 (modulo count n)))
+(export every-nth-repeat-count-visible)
(define-public (all-repeat-counts-visible count context) #t)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; make-engraver helper macro
-
-(defmacro-public make-engraver forms
- "Helper macro for creating Scheme engravers.
-
-The usual form for an engraver is an association list (or alist)
-mapping symbols to either anonymous functions or to another such
-alist.
-
-@code{make-engraver} accepts forms where the first element is either
-an argument list starting with the respective symbol, followed by the
-function body (comparable to the way @code{define} is used for
-defining functions), or a single symbol followed by subordinate forms
-in the same manner. You can also just make an alist pair
-literally (the @samp{car} is quoted automatically) as long as the
-unevaluated @samp{cdr} is not a pair. This is useful if you already
-have defined your engraver functions separately.
-
-Symbols mapping to a function would be @code{initialize},
-@code{start-translation-timestep}, @code{process-music},
-@code{process-acknowledged}, @code{stop-translation-timestep}, and
-@code{finalize}. Symbols mapping to another alist specified in the
-same manner are @code{listeners} with the subordinate symbols being
-event classes, and @code{acknowledgers} and @code{end-acknowledgers}
-with the subordinate symbols being interfaces."
- (let loop ((forms forms))
- (if (cheap-list? forms)
- `(list
- ,@(map (lambda (form)
- (if (pair? (car form))
- `(cons ',(caar form) (lambda ,(cdar form) ,@(cdr form)))
- `(cons ',(car form) ,(loop (cdr form)))))
- forms))
- forms)))