-;;;; part-combiner.scm -- Part combining, staff changes.
+;;;; This file is part of LilyPond, the GNU music typesetter.
;;;;
-;;;; source file of the GNU LilyPond music typesetter
+;;;; Copyright (C) 2004--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
;;;;
-;;;; (c) 2004--2009 Han-Wen Nienhuys <hanwen@xs4all.nl>
+;;;; LilyPond is free software: you can redistribute it and/or modify
+;;;; it under the terms of the GNU General Public License as published by
+;;;; the Free Software Foundation, either version 3 of the License, or
+;;;; (at your option) any later version.
+;;;;
+;;;; LilyPond is distributed in the hope that it will be useful,
+;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;;;; GNU General Public License for more details.
+;;;;
+;;;; You should have received a copy of the GNU General Public License
+;;;; along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
;; todo: figure out how to make module,
;; without breaking nested ly scopes
(define-method (note-events (vs <Voice-state>))
(define (f? x)
- (equal? (ly:event-property x 'class) 'note-event))
+ (ly:in-event-class? x 'note-event))
(filter f? (events vs)))
(define-method (previous-voice-state (vs <Voice-state>))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-class <Split-state> ()
+ ;; The automatically determined split configuration
(configuration #:init-value '() #:accessor configuration)
+ ;; Allow overriding split configuration, takes precedence over configuration
+ (forced-configuration #:init-value #f #:accessor forced-configuration)
(when-moment #:accessor when #:init-keyword #:when)
;; voice-states are states starting with the Split-state or later
;;
"Analyse EVS at INDEX, given state ACTIVE."
(define (analyse-tie-start active ev)
- (if (equal? (ly:event-property ev 'class) 'tie-event)
+ (if (ly:in-event-class? ev 'tie-event)
(acons 'tie (split-index (vector-ref voice-state-vec index))
active)
active))
(define (analyse-tie-end active ev)
- (if (equal? (ly:event-property ev 'class) 'note-event)
+ (if (ly:in-event-class? ev 'note-event)
(assoc-remove! active 'tie)
active))
(define (analyse-absdyn-end active ev)
- (if (or (equal? (ly:event-property ev 'class) 'absolute-dynamic-event)
- (and (equal? (ly:event-property ev 'class) 'crescendo-event)
+ (if (or (ly:in-event-class? ev 'absolute-dynamic-event)
+ (and (ly:in-event-class? ev 'span-dynamic-event)
(equal? STOP (ly:event-property ev 'span-direction))))
(assoc-remove! (assoc-remove! active 'cresc) 'decr)
active))
(define (active<? a b)
(cond ((symbol<? (car a) (car b)) #t)
- ((symbol<? (car b) (car b)) #f)
+ ((symbol<? (car b) (car a)) #f)
(else (< (cdr a) (cdr b)))))
(define (analyse-span-event active ev)
- (let* ((name (ly:event-property ev 'class))
+ (let* ((name (car (ly:event-property ev 'class)))
(key (cond ((equal? name 'slur-event) 'slur)
((equal? name 'phrasing-slur-event) 'tie)
((equal? name 'beam-event) 'beam)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define-public (recording-group-emulate music odef)
- "Interprets music according to odef, but stores all events in a chronological
-list, similar to the Recording_group_engraver in 2.8 and earlier"
+ "Interpret @var{music} according to @var{odef}, but store all events
+in a chronological list, similar to the @code{Recording_group_engraver} in
+LilyPond version 2.8 and earlier."
(let*
((context-list '())
(now-mom (ly:make-moment 0 0))
(ly:interpret-music-expression (make-non-relative-music music) global)
context-list))
-(define-public (make-part-combine-music parser music-list)
+(define-public (make-part-combine-music parser music-list direction)
(let* ((m (make-music 'PartCombineMusic))
(m1 (make-non-relative-music (context-spec-music (first music-list) 'Voice "one")))
(m2 (make-non-relative-music (context-spec-music (second music-list) 'Voice "two")))
(evs1 (recording-group-emulate m1 listener)))
(set! (ly:music-property m 'elements) (list m1 m2))
+ (set! (ly:music-property m 'direction) direction)
(set! (ly:music-property m 'split-list)
(if (and (assoc "one" evs1) (assoc "two" evs2))
(determine-split-list (reverse! (assoc-get "one" evs1) '())
m))
(define-public (determine-split-list evl1 evl2)
- "EVL1 and EVL2 should be ascending"
+ "@var{evl1} and @var{evl2} should be ascending."
(let* ((pc-debug #f)
(chord-threshold 8)
(voice-state-vec1 (make-voice-states evl1))
(voice-state-vec2 (make-voice-states evl2))
(result (make-split-state voice-state-vec1 voice-state-vec2)))
+ ;; Go through all moments recursively and check if the events of that
+ ;; moment contain a part-combine-force-event override. If so, store its
+ ;; value in the forced-configuration field, which will override. The
+ ;; previous configuration is used to determine non-terminated settings.
+ (define (analyse-forced-combine result-idx prev-res)
+
+ (define (get-forced-event x)
+ (if (ly:in-event-class? x 'part-combine-force-event)
+ (cons (ly:event-property x 'forced-type) (ly:event-property x 'once))
+ #f))
+ (define (part-combine-events vs)
+ (if (not vs)
+ '()
+ (filter-map get-forced-event (events vs))))
+ ;; end part-combine-events
+
+ ;; forced-result: Take the previous config and analyse whether
+ ;; any change happened.... Return new once and permanent config
+ (define (forced-result evt state)
+ ;; sanity check, evt should always be (new-state . once)
+ (if (not (and (pair? evt) (pair? state)))
+ state
+ (if (cdr evt)
+ ;; Once-event, leave permanent state unchanged
+ (cons (car evt) (cdr state))
+ ;; permanent change, leave once state unchanged
+ (cons (car state) (car evt)))))
+ ;; end forced-combine-result
+
+ ;; body of analyse-forced-combine:
+ (if (< result-idx (vector-length result))
+ (let* ((now-state (vector-ref result result-idx)) ; current result
+ ;; Extract all part-combine force events
+ (ev1 (part-combine-events (car (voice-states now-state))))
+ (ev2 (part-combine-events (cdr (voice-states now-state))))
+ (evts (append ev1 ev2))
+ ;; result is (once-state permament-state):
+ (state (fold forced-result (cons 'automatic prev-res) evts))
+ ;; Now let once override permanent changes:
+ (force-state (if (equal? (car state) 'automatic)
+ (cdr state)
+ (car state))))
+ (set! (forced-configuration (vector-ref result result-idx))
+ force-state)
+ ;; For the next moment, ignore the once override (car stat)
+ ;; and pass on the permanent override, stored as (cdr state)
+ (analyse-forced-combine (1+ result-idx) (cdr state)))))
+ ;; end analyse-forced-combine
+
+
(define (analyse-time-step result-idx)
(define (put x . index)
"Put the result to X, starting from INDEX backwards.
(previous-voice-state vs)))
(define (try-solo type start-idx current-idx)
- "Find a maximum stretch that can be marked as solo. Only set
+ "Find a maximum stretch that can be marked as solo. Only set
the mark when there are no spanners active.
return next idx to analyse.
start-idx))
(define (analyse-moment result-idx)
- "Analyse 'apart starting at RESULT-IDX. Return next index. "
+ "Analyse 'apart starting at RESULT-IDX. Return next index."
(let* ((now-state (vector-ref result result-idx))
(vs1 (current-voice-state now-state 1))
(vs2 (current-voice-state now-state 2))
(display "***\n")
(display result)
(display "***\n")))
+
+ ;; Extract all forced combine strategies, i.e. events inserted by
+ ;; \partcombine(Apart|Automatic|SoloI|SoloII|Chords)[Once]
+ ;; They will in the end override the automaically determined ones.
+ ;; Initial state for both voices is no override
+ (analyse-forced-combine 0 #f)
+ ;; Now go through all time steps in a loop and find a combination strategy
+ ;; based only on the events of that one moment (i.e. neglecting longer
+ ;; periods of solo/apart, etc.)
(analyse-time-step 0)
;; (display result)
+ ;; Check for unisono or unisilence moments
(analyse-a2 0)
;;(display result)
(analyse-solo12 0)
;; (display result)
(set! result (map
- (lambda (x) (cons (when x) (configuration x)))
+ ;; forced-configuration overrides, if it is set
+ (lambda (x) (cons (when x) (or (forced-configuration x) (configuration x))))
(vector->list result)))
(if #f ;; pc-debug
(display result))
(define-public (add-quotable parser name mus)
(let* ((tab (eval 'musicQuotes (current-module)))
- (context-list (recording-group-emulate (context-spec-music mus 'Voice)
- (ly:parser-lookup parser 'partCombineListener))))
- (if (pair? context-list)
- (hash-set! tab name
- ;; cdr : skip name string
- (list->vector (reverse! (cdar context-list)
- '()))))))
+ (voicename (get-next-unique-voice-name))
+ ;; recording-group-emulate returns an assoc list (reversed!), so
+ ;; hand it a proper unique context name and extract that key:
+ (ctx-spec (context-spec-music mus 'Voice voicename))
+ (listener (ly:parser-lookup parser 'partCombineListener))
+ (context-list (reverse (recording-group-emulate ctx-spec listener)))
+ (raw-voice (assoc voicename context-list))
+ (quote-contents (if (pair? raw-voice) (cdr raw-voice) '())))
+
+ ;; If the context-specced quoted music does not contain anything, try to
+ ;; use the first child, i.e. the next in context-list after voicename
+ ;; That's the case e.g. for \addQuote "x" \relative c \new Voice {...}
+ (if (null? quote-contents)
+ (let find-non-empty ((current-tail (member raw-voice context-list)))
+ ;; if voice has contents, use them, otherwise check next ctx
+ (cond ((null? current-tail) #f)
+ ((and (pair? (car current-tail))
+ (pair? (cdar current-tail)))
+ (set! quote-contents (cdar current-tail)))
+ (else (find-non-empty (cdr current-tail))))))
+
+ (if (not (null? quote-contents))
+ (hash-set! tab name (list->vector (reverse! quote-contents '())))
+ (ly:music-warning mus (ly:format (_ "quoted music `~a' is empty") name)))))
projects / lilypond.git / blobdiff