[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: select a note in a chord

From: Valentin Villenave
Subject: Re: select a note in a chord
Date: Mon, 28 Jan 2019 20:11:17 +0000

On 1/28/19, Davide Bonetti <address@hidden> wrote:
> It reminds me something that happens when a variable in lilypond is
> called with $ instead of # , but in scheme I don't see this difference.
> Could it be something like that?

Nope, it turned out to be a lot more idiotic: I was modifying the
'octavation property of some notes… then not taking that into account
when sorting the pitches. (And, as David noted, I was displacing the
pitches onto the notes without moving any articulations they might
have attached.)

Here’s the new updated function, now it sort of works!

#(define-public (move-chord-note n direction)
   (_i "Transpose a note (numbered as @var{n}) by one octave in
   (lambda (music)
     (let* ((elts (ly:music-property music 'elements))
            (l (length elts))
            ;; if direction is up, count from the bottom note upward,
            ;; if direction is down, count from the top note downward.
            (count-from (cond ((= direction UP) (- n 1))
                          ((= direction DOWN) (- l n))))
            ;; Notes may not have been entered from bottom to top;
            ;; extract the pitches and their possible octavation.
            (pitches (map
                      (lambda (x)
                        (let ((oct (ly:music-property x 'octavation))
                              (p (ly:music-property x 'pitch)))
                          (if (null? oct) p
                              (ly:pitch-transpose p
                                (ly:make-pitch oct 0 0)))))
                       (lambda (y)
                         (music-is-of-type? y 'note-event))
       (if (and (music-is-of-type? music 'event-chord)
                (not (zero? n)) (>= l n))
            ;; Sort the actual notes, depending on their pitch.
            (set! elts
                  (sort elts
                    (lambda (a b)
                       (ly:music-property a 'pitch)
                       (ly:music-property b 'pitch)))))
            ;; then transpose the note up or
            ;; down, depending on direction.
            (let* ((note (list-ref elts count-from))
                   (oct (ly:music-property note 'octavation)))
              (list-set! elts count-from
                (ly:music-transpose note
                    ((= direction UP) +1)
                    ((= direction DOWN) -1))
              (ly:music-set-property! note 'octavation
                (+ (cond
                    ((= direction UP) 1)
                    ((= direction DOWN) -1))
                  (if (null? oct) 0 oct))))


reply via email to

[Prev in Thread] Current Thread [Next in Thread]