Add dodecaphonic-first accidental style

scm/music-functions.scm

 ;;;; This file is part of LilyPond, the GNU music typesetter.
 ;;;;
 ;;;; Copyright (C) 1998--2014 Jan Nieuwenhuizen <janneke@gnu.org>
 ;;;;                 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.
 ;;;;
@@ skipping 1401 matching lines @@
                   alteration-def)))
     (and (symbol? def) def)))
 
 (define (extract-alteration alteration-def)
   (cond ((number? alteration-def)
          alteration-def)
         ((pair? alteration-def)
          (car alteration-def))
         (else 0)))
 
-(define (check-pitch-against-signature context pitch barnum laziness octaveness)
+(define (check-pitch-against-signature context pitch barnum laziness octaveness all-naturals)
   "Checks the need for an accidental and a @q{restore} accidental against
 @code{localKeySignature}.  The @var{laziness} is the number of measures
 for which reminder accidentals are used (i.e., if @var{laziness} is zero,
 only cancel accidentals in the same measure; if @var{laziness} is three,
 we cancel accidentals up to three measures after they first appear.
 @var{octaveness} is either @code{'same-octave} or @code{'any-octave} and
-specifies whether accidentals should be canceled in different octaves."
+specifies whether accidentals should be canceled in different octaves.
+If @var{all-naturals} is ##t, notes that do not occur in @code{keySignature}
+also get an accidental."
   (let* ((ignore-octave (cond ((equal? octaveness 'any-octave) #t)
                               ((equal? octaveness 'same-octave) #f)
                               (else
                                (ly:warning (_ "Unknown octaveness type: ~S ") octaveness)
                                (ly:warning (_ "Defaulting to 'any-octave."))
                                #t)))
          (key-sig (ly:context-property context 'keySignature))
          (local-key-sig (ly:context-property context 'localKeySignature))
          (notename (ly:pitch-notename pitch))
          (octave (ly:pitch-octave pitch))
@@ skipping 37 matching lines @@
      ;; not recent enough, extract from key signature/local key signature
      (from-key-sig
       (set! previous-alteration from-key-sig)))
 
     (if (accidental-invalid? previous-alteration)
         (set! need-accidental #t)
 
         (let* ((prev-alt (extract-alteration previous-alteration))
                (this-alt (ly:pitch-alteration pitch)))
 
-          (if (not (= this-alt prev-alt))
+          (if (or (and all-naturals (eq? #f previous-alteration)) (not (= this-alt prev-alt)))
               (begin
                 (set! need-accidental #t)
                 (if (and (not (= this-alt 0))
                          (and (< (abs this-alt) (abs prev-alt))
                               (> (* prev-alt this-alt) 0)))
                     (set! need-restore #t))))))
 
     (cons need-restore need-accidental)))
 
 (define-public ((make-accidental-rule octaveness laziness) context pitch barnum measurepos)
   "Create an accidental rule that makes its decision based on the octave of
 the note and a laziness value.
 
 @var{octaveness} is either @code{'same-octave} or @code{'any-octave} and
 defines whether the rule should respond to accidental changes in other
 octaves than the current.  @code{'same-octave} is the normal way to typeset
 accidentals -- an accidental is made if the alteration is different from the
 last active pitch in the same octave.  @code{'any-octave} looks at the last
 active pitch in any octave.
 
 @var{laziness} states over how many bars an accidental should be remembered.
 @code{0}@tie{}is the default -- accidental lasts over 0@tie{}bar lines, that
 is, to the end of current measure.  A positive integer means that the
 accidental lasts over that many bar lines.  @w{@code{-1}} is `forget
 immediately', that is, only look at key signature.  @code{#t} is `forever'."
 
-  (check-pitch-against-signature context pitch barnum laziness octaveness))
+  (check-pitch-against-signature context pitch barnum laziness octaveness #f))
+
+(define-public ((make-accidental-dodecaphonic-rule octaveness laziness) context pitch barnum measurepos)
+  "Variation on function make-accidental-rule that creates an dodecaphonic
+accidental rule."
+
+  (check-pitch-against-signature context pitch barnum laziness octaveness #t))
 
 (define (key-entry-notename entry)
   "Return the pitch of an @var{entry} in @code{localKeySignature}.
 The @samp{car} of the entry is either of the form @code{notename} or
 of the form @code{(octave . notename)}.  The latter form is used for special
 key signatures or to indicate an explicit accidental.
 
 The @samp{cdr} of the entry is either a rational @code{alter} indicating
 a key signature alteration, or of the form
 @code{(alter . (barnum . measurepos))} indicating an alteration caused by
@@ skipping 192 matching lines @@
                                   '()
                                   context))
      ;; As in dodecaphonic style with the exception that immediately
      ;; repeated notes (in the same voice) don't get an accidental
      ((equal? style 'dodecaphonic-no-repeat)
       (set-accidentals-properties #f
                                   `(Staff ,(make-accidental-rule 'same-octave 0)
                                           ,dodecaphonic-no-repeat-rule)
                                           '()
                                           context))
+     ;; Variety of the dodecaphonic style. Each note gets an accidental,
+     ;; except notes that were already handled in the same measure.
+     ((equal? style 'dodecaphonic-first)
+      (set-accidentals-properties #f
+                                  `(Staff ,(make-accidental-dodecaphonic-rule 'same-octave 0))
+                                  '()
+                                  context))
+
      ;; Multivoice accidentals to be read both by musicians playing one voice
      ;; and musicians playing all voices.
      ;; Accidentals are typeset for each voice, but they ARE canceled across voices.
      ((equal? style 'modern-voice)
       (set-accidentals-properties  #f
                                    `(Voice ,(make-accidental-rule 'same-octave 0)
                                            ,(make-accidental-rule 'any-octave 0)
                                            ,(make-accidental-rule 'same-octave 1)
                                            Staff ,(make-accidental-rule 'same-octave 0)
                                            ,(make-accidental-rule 'any-octave 0)
@@ skipping 617 matching lines @@
 
                 (if (>= total-found 2)
                     (helper siblings offsets)
                     (offset-multiple-types vals (car offsets)))))
 
               (begin
                 (ly:warning "the property '~a of ~a cannot be offset" property grob)
                 vals))))
     ; return the closure named `self'
     self)