line-thickness))
+(define (grob::objects-from-interface grob iface)
+ "For grob @var{grob} return the name and contents of all properties
+ within interface @var{iface} having type @code{ly:grob?} or
+ @code{ly:grob-array?}."
+ (let* ((iface-entry (hashq-ref (ly:all-grob-interfaces) iface))
+ (props (if iface-entry (last iface-entry) '()))
+ (pointer-props
+ (filter
+ (lambda (prop)
+ (let ((type (object-property prop 'backend-type?)))
+ (or (eq? type ly:grob?)
+ (eq? type ly:grob-array?))))
+ props)))
+ (if (null? pointer-props)
+ '()
+ (list iface
+ (map
+ (lambda (prop) (list prop (ly:grob-object grob prop)))
+ pointer-props)))))
+
+(define-public (grob::all-objects grob)
+ "Return a list of the names and contents of all properties having type
+ @code{ly:grob?} or @code{ly:grob-array?} for all interfaces supported by
+ grob @var{grob}."
+ (let loop ((ifaces (ly:grob-interfaces grob)) (result '()))
+ (if (null? ifaces)
+ (cons grob (list result))
+ (let ((entry (grob::objects-from-interface grob (car ifaces))))
+ (if (pair? entry)
+ (loop (cdr ifaces) (append result (list entry)))
+ (loop (cdr ifaces) result))))))
+
+(use-modules (ice-9 pretty-print))
+(define-public (grob::display-objects grob)
+ "Display all objects stored in properties of grob @var{grob}."
+ (pretty-print (grob::all-objects grob))
+ (newline))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; beam slope
(set! rp (ly:make-stencil (ly:stencil-expr rp)
rp-x-extent
(ly:stencil-extent rp Y)))
- (list (stencil-whiteout lp)
- (stencil-whiteout rp))))
+ (list (stencil-whiteout-box lp)
+ (stencil-whiteout-box rp))))
+
+(define-public (parentheses-item::y-extent grob) (ly:grob::stencil-height grob))
(define (parenthesize-elements grob . rest)
(let* ((refp (if (null? rest)
grob
(car rest)))
- (elts (ly:grob-object grob 'elements))
- (x-ext (ly:relative-group-extent elts refp X))
+ (elts (ly:grob-array->list (ly:grob-object grob 'elements)))
+ (get-friends
+ (lambda (g)
+ (let ((syms (ly:grob-property g 'parenthesis-friends '()))
+ (get-friend (lambda (s)
+ (let ((f (ly:grob-object g s)))
+ (cond
+ ((ly:grob? f) (list f))
+ ((ly:grob-array? f) (ly:grob-array->list f))
+ (else '()))))))
+ (apply append (map get-friend syms)))))
+ (friends (apply append elts (map get-friends elts)))
+ (x-ext (ly:relative-group-extent friends refp X))
(stencils (ly:grob-property grob 'stencils))
(lp (car stencils))
(rp (cadr stencils))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
-(define-public (chain-grob-member-functions grob value . funcs)
- (for-each
- (lambda (func)
- (set! value (func grob value)))
- funcs)
-
- value)
-
+(define-public (grob::compose-function func data)
+ "This creates a callback entity to be stored in a grob property,
+based on the grob property data @var{data} (which can be plain data, a
+callback itself, or an unpure-pure-container).
+
+Function or unpure-pure-container @var{func} accepts a grob and a
+value and returns another value. Depending on the type of @var{data},
+@var{func} is used for building a grob callback or an
+unpure-pure-container."
+ (if (or (ly:unpure-pure-container? func)
+ (ly:unpure-pure-container? data))
+ (ly:make-unpure-pure-container
+ (lambda (grob) (ly:unpure-call func grob (ly:unpure-call data grob)))
+ (lambda (grob start end)
+ (ly:pure-call func grob start end
+ (ly:pure-call data grob start end))))
+ (lambda (grob) (ly:unpure-call func grob (ly:unpure-call data grob)))))
+
+(define*-public (grob::offset-function func data
+ #:optional (plus +))
+ "This creates a callback entity to be stored in a grob property,
+based on the grob property data @var{data} (which can be plain data, a
+callback itself, or an unpure-pure-container).
+
+Function @var{func} accepts a grob and returns a value that is added
+to the value resulting from @var{data}. Optional argument @var{plus}
+defaults to @code{+} but may be changed to allow for using a different
+underlying accumulation.
+
+If @var{data} is @code{#f} or @code{'()}, it is not included in the sum."
+ (cond ((or (not data) (null? data))
+ func)
+ ((or (ly:unpure-pure-container? func)
+ (ly:unpure-pure-container? data))
+ (ly:make-unpure-pure-container
+ (lambda rest
+ (plus (apply ly:unpure-call func rest)
+ (apply ly:unpure-call data rest)))
+ (lambda rest
+ (plus (apply ly:pure-call func rest)
+ (apply ly:pure-call data rest)))))
+ ((or (procedure? func)
+ (procedure? data))
+ (lambda rest
+ (plus (apply ly:unpure-call func rest)
+ (apply ly:unpure-call data rest))))
+ (else (plus func data))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; falls/doits
(let* ((shift-when-alone (ly:grob-property grob 'toward-stem-shift 0.0))
(shift-in-column (ly:grob-property grob 'toward-stem-shift-in-column))
(script-column (ly:grob-object grob 'script-column))
- (shift (if (and (ly:grob? script-column) (number? shift-in-column))
- shift-in-column shift-when-alone))
+ (shift
+ (if (and (ly:grob? script-column)
+ (number? shift-in-column)
+ ;; ScriptColumn can contain grobs other than Script.
+ ;; These should not result in a shift.
+ (any (lambda (s)
+ (and (not (eq? s grob))
+ (grob::has-interface s 'script-interface)
+ (not (grob::has-interface s
+ 'accidental-suggestion-interface))))
+ (ly:grob-array->list
+ (ly:grob-object script-column 'scripts))))
+ shift-in-column shift-when-alone))
(note-head-location
(ly:self-alignment-interface::aligned-on-x-parent grob))
(note-head-grob (ly:grob-parent grob X))
projects / lilypond.git / blobdiff