;;;; This file is part of LilyPond, the GNU music typesetter.
;;;;
-;;;; Copyright (C) 1998--2010 Jan Nieuwenhuizen <janneke@gnu.org>
+;;;; Copyright (C) 1998--2012 Jan Nieuwenhuizen <janneke@gnu.org>
;;;; Han-Wen Nienhuys <hanwen@xs4all.nl>
;;;;
;;;; LilyPond is free software: you can redistribute it and/or modify
(define-public (grob::is-live? grob)
(pair? (ly:grob-basic-properties grob)))
-(define-public (make-stencil-boxer thickness padding callback)
+(define-public (grob::x-parent-width grob)
+ (ly:grob-property (ly:grob-parent grob X) 'X-extent))
+(define-public (make-stencil-boxer thickness padding callback)
"Return function that adds a box around the grob passed as argument."
(lambda (grob)
(box-stencil (callback grob) thickness padding)))
(define-public (make-stencil-circler thickness padding callback)
"Return function that adds a circle around the grob passed as argument."
-
- (lambda (grob) (circle-stencil (callback grob) thickness padding)))
+ (lambda (grob)
+ (circle-stencil (callback grob) thickness padding)))
(define-public (print-circled-text-callback grob)
(grob-interpret-markup grob (make-circle-markup
(ly:text-interface::interpret-markup layout props text)))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; beam slope
+
+;; calculates each slope of a broken beam individually
+(define-public (beam::place-broken-parts-individually grob)
+ (ly:beam::quanting grob '(+inf.0 . -inf.0) #f))
+
+;; calculates the slope of a beam as a single unit,
+;; even if it is broken. this assures that the beam
+;; will pick up where it left off after a line break
+(define-public (beam::align-with-broken-parts grob)
+ (ly:beam::quanting grob '(+inf.0 . -inf.0) #t))
+
+;; uses the broken beam style from edition peters combines the
+;; values of place-broken-parts-individually and align-with-broken-parts above,
+;; favoring place-broken-parts-individually when the beam naturally has a steeper
+;; incline and align-with-broken-parts when the beam is flat
+(define-public (beam::slope-like-broken-parts grob)
+ (define (slope y x)
+ (/ (- (cdr y) (car y)) (- (cdr x) (car x))))
+ (let* ((quant1 (ly:beam::quanting grob '(+inf.0 . -inf.0) #t))
+ (original (ly:grob-original grob))
+ (siblings (if (ly:grob? original)
+ (ly:spanner-broken-into original)
+ '())))
+ (if (null? siblings)
+ quant1
+ (let* ((quant2 (ly:beam::quanting grob '(+inf.0 . -inf.0) #f))
+ (x-span (ly:grob-property grob 'X-positions))
+ (slope1 (slope quant1 x-span))
+ (slope2 (slope quant2 x-span))
+ (quant2 (if (not (= (sign slope1) (sign slope2)))
+ '(0 . 0)
+ quant2))
+ (factor (/ (atan (abs slope1)) PI-OVER-TWO))
+ (base (cons-map
+ (lambda (x)
+ (+ (* (x quant1) (- 1 factor))
+ (* (x quant2) factor)))
+ (cons car cdr))))
+ (ly:beam::quanting grob base #f)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; cross-staff stuff
+
+(define-public (script-or-side-position-cross-staff g)
+ (or
+ (ly:script-interface::calc-cross-staff g)
+ (ly:side-position-interface::calc-cross-staff g)))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; note heads
(ly:duration-log
(ly:event-property (event-cause grob) 'duration)))
+(define-public (stem::length grob)
+ (let* ((ss (ly:staff-symbol-staff-space grob))
+ (beg (ly:grob-property grob 'stem-begin-position))
+ (beam (ly:grob-object grob 'beam)))
+ (if (null? beam)
+ (abs (- (ly:stem::calc-stem-end-position grob) beg))
+ (begin
+ (ly:programming-error
+ "stem::length called but will not be used for beamed stem.")
+ 0.0))))
+
+(define-public (stem::pure-length grob beg end)
+ (let* ((ss (ly:staff-symbol-staff-space grob))
+ (beg (ly:grob-pure-property grob 'stem-begin-position 0 1000)))
+ (abs (- (ly:stem::pure-calc-stem-end-position grob 0 2147483646) beg))))
+
+(define (stem-stub::do-calculations grob)
+ (and (ly:grob-property (ly:grob-parent grob X) 'cross-staff)
+ (not (ly:grob-property (ly:grob-parent grob X) 'transparent))))
+
+(define-public (stem-stub::pure-height grob beg end)
+ (if (stem-stub::do-calculations grob)
+ '(0 . 0)
+ '(+inf.0 . -inf.0)))
+
+(define-public (stem-stub::width grob)
+ (if (stem-stub::do-calculations grob)
+ (grob::x-parent-width grob)
+ '(+inf.0 . -inf.0)))
+
+(define-public (stem-stub::extra-spacing-height grob)
+ (if (stem-stub::do-calculations grob)
+ (let* ((dad (ly:grob-parent grob X))
+ (refp (ly:grob-common-refpoint grob dad Y))
+ (stem_ph (ly:grob-pure-height dad refp 0 1000000))
+ (my_ph (ly:grob-pure-height grob refp 0 1000000))
+ ;; only account for distance if stem is on different staff than stub
+ (dist (if (grob::has-interface refp 'hara-kiri-group-spanner-interface)
+ 0
+ (- (car my_ph) (car stem_ph)))))
+ (if (interval-empty? (interval-intersection stem_ph my_ph)) #f (coord-translate stem_ph dist)))
+ #f))
+
+;; FIXME: NEED TO FIND A BETTER WAY TO HANDLE KIEVAN NOTATION
(define-public (note-head::calc-duration-log grob)
- (min 2
- (ly:duration-log
- (ly:event-property (event-cause grob) 'duration))))
+ (let ((style (ly:grob-property grob 'style)))
+ (if (and (symbol? style) (string-match "kievan*" (symbol->string style)))
+ (min 3
+ (ly:duration-log
+ (ly:event-property (event-cause grob) 'duration)))
+ (min 2
+ (ly:duration-log
+ (ly:event-property (event-cause grob) 'duration))))))
(define-public (dots::calc-dot-count grob)
(ly:duration-dot-count
(if (< log 0)
(string-append (number->string log) "mensural")
(string-append (number->string log) (symbol->string style))))
+ ((blackpetrucci)
+ (if (< log 0)
+ (string-append (number->string log) "blackmensural")
+ (string-append (number->string log) (symbol->string style))))
+ ((semipetrucci)
+ (if (< log 0)
+ (string-append (number->string log) "semimensural")
+ (string-append (number->string log) "petrucci")))
((neomensural)
(string-append (number->string log) (symbol->string style)))
+ ((kievan)
+ (string-append (number->string log) "kievan"))
(else
(if (string-match "vaticana*|hufnagel*|medicaea*" (symbol->string style))
(symbol->string style)
(symbol->string style))))))
(define-public (note-head::calc-glyph-name grob)
- (let ((style (ly:grob-property grob 'style))
- (log (min 2 (ly:grob-property grob 'duration-log))))
-
+ (let* ((style (ly:grob-property grob 'style))
+ (log (if (string-match "kievan*" (symbol->string style))
+ (min 3 (ly:grob-property grob 'duration-log))
+ (min 2 (ly:grob-property grob 'duration-log)))))
(select-head-glyph style log)))
(define-public (note-head::brew-ez-stencil grob)
letter)))
radius X)))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; clipping
+
+(define-public (make-rhythmic-location bar-num num den)
+ (cons
+ bar-num (ly:make-moment num den)))
+
+(define-public (rhythmic-location? a)
+ (and (pair? a)
+ (integer? (car a))
+ (ly:moment? (cdr a))))
+
+(define-public (make-graceless-rhythmic-location loc)
+ (make-rhythmic-location
+ (car loc)
+ (ly:moment-main-numerator (rhythmic-location-measure-position loc))
+ (ly:moment-main-denominator (rhythmic-location-measure-position loc))))
+
+(define-public rhythmic-location-measure-position cdr)
+(define-public rhythmic-location-bar-number car)
+
+(define-public (rhythmic-location<? a b)
+ (cond
+ ((< (car a) (car b)) #t)
+ ((> (car a) (car b)) #f)
+ (else
+ (ly:moment<? (cdr a) (cdr b)))))
+
+(define-public (rhythmic-location<=? a b)
+ (not (rhythmic-location<? b a)))
+(define-public (rhythmic-location>=? a b)
+ (rhythmic-location<? a b))
+(define-public (rhythmic-location>? a b)
+ (rhythmic-location<? b a))
+
+(define-public (rhythmic-location=? a b)
+ (and (rhythmic-location<=? a b)
+ (rhythmic-location<=? b a)))
+
+(define-public (rhythmic-location->file-string a)
+ (ly:format "~a.~a.~a"
+ (car a)
+ (ly:moment-main-numerator (cdr a))
+ (ly:moment-main-denominator (cdr a))))
+
+(define-public (rhythmic-location->string a)
+ (ly:format "bar ~a ~a"
+ (car a)
+ (ly:moment->string (cdr a))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; break visibility
(define-public center-visible #(#f #t #f))
(define-public end-of-line-visible #(#t #f #f))
(define-public all-invisible #(#f #f #f))
+(define-public (inherit-x-parent-visibility grob)
+ (let ((parent (ly:grob-parent grob X)))
+ (ly:grob-property parent 'break-visibility all-invisible)))
+(define-public (inherit-y-parent-visibility grob)
+ (let ((parent (ly:grob-parent grob X)))
+ (ly:grob-property parent 'break-visibility)))
+
(define-public spanbar-begin-of-line-invisible #(#t #f #f))
("S|:" . ("S" . "|:"))
(".S|:" . ("|" . "S|:"))
(":|S|:" . (":|" . "S|:"))
- (":|S.|:" . (":|S" . "|:"))))
+ (":|S.|:" . (":|S" . "|:"))
+
+ ;; ancient bar lines
+ ("kievan" . ("kievan" . ""))))
(define-public (bar-line::calc-glyph-name grob)
(let* ((glyph (ly:grob-property grob 'glyph))
(equal? (ly:item-break-dir g) RIGHT))
(ly:grob-translate-axis! g 3.5 X)))
+(define-public (pure-from-neighbor-interface::extra-spacing-height-at-beginning-of-line grob)
+ (if (= 1 (ly:item-break-dir grob))
+ (pure-from-neighbor-interface::extra-spacing-height grob)
+ (cons -0.1 0.1)))
+
+(define-public (pure-from-neighbor-interface::extra-spacing-height grob)
+ (let* ((height (ly:grob-pure-height grob grob 0 10000000))
+ (from-neighbors (interval-union
+ height
+ (ly:axis-group-interface::pure-height
+ grob
+ 0
+ 10000000))))
+ (coord-operation - from-neighbors height)))
+
+(define-public (pure-from-neighbor-interface::account-for-span-bar grob)
+ (let* ((esh (pure-from-neighbor-interface::extra-spacing-height grob))
+ (hsb (ly:grob-property grob 'has-span-bar))
+ (ii (interval-intersection esh (cons -1.01 1.01))))
+ (if (pair? hsb)
+ (cons (car (if (and (car hsb)
+ (ly:grob-property grob 'allow-span-bar))
+ esh ii))
+ (cdr (if (cdr hsb) esh ii)))
+ ii)))
+
+(define-public (pure-from-neighbor-interface::extra-spacing-height-including-staff grob)
+ (let ((esh (pure-from-neighbor-interface::extra-spacing-height grob))
+ (to-staff (coord-operation -
+ (interval-widen
+ '(0 . 0)
+ (ly:staff-symbol-staff-radius grob))
+ (ly:grob::stencil-height grob))))
+ (interval-union esh to-staff)))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Tuplets
+(define-public (tuplet-number::calc-direction grob)
+ (ly:tuplet-bracket::calc-direction (ly:grob-object grob 'bracket)))
+
(define-public (tuplet-number::calc-denominator-text grob)
(number->string (ly:event-property (event-cause grob) 'denominator)))
(define-public (tuplet-number::calc-fraction-text grob)
(let ((ev (event-cause grob)))
- (format "~a:~a"
+ (format #f "~a:~a"
(ly:event-property ev 'denominator)
(ly:event-property ev 'numerator))))
(den (if denominator denominator (ly:event-property ev 'denominator)))
(num (if numerator numerator (ly:event-property ev 'numerator))))
- (format "~a:~a" den num)))
+ (format #f "~a:~a" den num)))
;; Print a tuplet fraction with note durations appended to the numerator and the
;; denominator
(num (if numerator numerator (ly:event-property ev 'numerator))))
(make-concat-markup (list
- (make-simple-markup (format "~a" den))
+ (make-simple-markup (format #f "~a" den))
(markup #:fontsize -5 #:note denominatornote UP)
(make-simple-markup " : ")
- (make-simple-markup (format "~a" num))
+ (make-simple-markup (format #f "~a" num))
(markup #:fontsize -5 #:note numeratornote UP)))))
(+ c0 p))))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; annotations
+
+(define-public (numbered-footnotes int)
+ (markup #:tiny (number->string (+ 1 int))))
+
+(define-public (symbol-footnotes int)
+ (define (helper symbols out idx n)
+ (if (< n 1)
+ out
+ (helper symbols
+ (string-append out (list-ref symbols idx))
+ idx
+ (- n 1))))
+ (markup #:tiny (helper '("*" "†" "‡" "§" "¶")
+ ""
+ (remainder int 5)
+ (+ 1 (quotient int 5)))))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; accidentals
(0 . "accidentals.vaticana0")
(1/2 . "accidentals.mensural1")))
+(define-public alteration-kievan-glyph-name-alist
+ '((-1/2 . "accidentals.kievanM1")
+ (1/2 . "accidentals.kievan1")))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; * Pitch Trill Heads
(ly:stencil-translate-axis rp (+ (cdr x-ext) padding) X))))
-(define (parentheses-item::print me)
+(define-public (parentheses-item::print me)
(let* ((elts (ly:grob-object me 'elements))
(y-ref (ly:grob-common-refpoint-of-array me elts Y))
(x-ref (ly:grob-common-refpoint-of-array me elts X))
(let* ((event (event-cause grob))
(digit (ly:event-property event 'digit)))
- (if (> digit 5)
- (ly:input-message (ly:event-property event 'origin)
- "Warning: Fingering notation for finger number ~a"
- digit))
-
(number->string digit 10)))
(define-public (string-number::calc-text grob)
;; dynamics
(define-public (hairpin::calc-grow-direction grob)
- (if (eq? (ly:event-property (event-cause grob) 'class) 'decrescendo-event)
+ (if (ly:in-event-class? (event-cause grob) 'decrescendo-event)
START
STOP))
(define-public (system-start-text::calc-y-offset grob)
(define (live-elements-list me)
- (let* ((elements (ly:grob-object me 'elements))
- (elts-length (ly:grob-array-length elements))
- (live-elements '()))
-
- (let get-live ((len elts-length))
- (if (> len 0)
- (let ((elt (ly:grob-array-ref elements (1- len))))
+ (let ((elements (ly:grob-object me 'elements)))
- (if (grob::is-live? elt)
- (set! live-elements (cons elt live-elements)))
- (get-live (1- len)))))
- live-elements))
+ (filter! grob::is-live?
+ (ly:grob-array->list elements))))
(let* ((left-bound (ly:spanner-bound grob LEFT))
(live-elts (live-elements-list grob))
(begin
(ly:grob-suicide! grob)
(list)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; laissez-vibrer tie
+;;
+;; needed so we can make laissez-vibrer a pure print
+;;
+(define-public (laissez-vibrer::print grob)
+ (ly:tie::print grob))
+