;;;; This file is part of LilyPond, the GNU music typesetter.
;;;;
-;;;; Copyright (C) 1998--2014 Jan Nieuwenhuizen <janneke@gnu.org>
+;;;; Copyright (C) 1998--2015 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 (grob::name grob)
+ "Return the name of the grob @var{grob} as a symbol."
+ (assq-ref (ly:grob-property grob 'meta) 'name))
+
+(define-public (grob::rhythmic-location grob)
+ "Return a pair consisting of the measure number and moment within
+ the measure of grob @var{grob}."
+ (let* (; all grobs support either spanner- or item-interface
+ (item (if (grob::has-interface grob 'spanner-interface)
+ (ly:spanner-bound grob LEFT)
+ grob))
+ (col (ly:item-get-column item)))
+ (if (ly:grob? col)
+ (ly:grob-property col 'rhythmic-location)
+ '())))
+
+(define-public (grob::when grob)
+ "Return the global timestep (a moment) of grob @var{grob}."
+ (let* (; all grobs support either spanner- or item-interface
+ (item (if (grob::has-interface grob 'spanner-interface)
+ (ly:spanner-bound grob LEFT)
+ grob))
+ (col (ly:item-get-column item)))
+ (if (ly:grob? col)
+ (ly:grob-property col 'when)
+ '())))
+
(define-public (make-stencil-boxer thickness padding callback)
"Return function that adds a box around the grob passed as argument."
(lambda (grob)
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
(define-public (script-interface::calc-x-offset grob)
(ly:grob-property grob 'positioning-done)
- (let* ((shift (ly:grob-property grob 'toward-stem-shift 0.0))
+ (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)
+ ;; 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))
(stem-grob (ly:grob-object note-head-grob 'stem)))
(+ note-head-location
- ;; If the property 'toward-stem-shift is defined and the script
- ;; has the same direction as the stem, move the script accordingly.
- ;; Since scripts can also be over skips, we need to check whether
- ;; the grob has a stem at all.
+ ;; If the script has the same direction as the stem, move the script
+ ;; in accordance with the value of 'shift'. Since scripts can also be
+ ;; over skips, we need to check whether the grob has a stem at all.
(if (ly:grob? stem-grob)
(let ((dir1 (ly:grob-property grob 'direction))
(dir2 (ly:grob-property stem-grob 'direction)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; measure counter
-(define (measure-counter-stencil grob)
+(define-public (measure-counter-stencil grob)
"Print a number for a measure count. The number is centered using
the extents of @code{BreakAlignment} grobs associated with the left and
right bounds of a @code{MeasureCounter} spanner. Broken measures are
projects / lilypond.git / blobdiff