Re: nom des variables utilisant des chiffres ?

[Valentin Villenave]

On 11/11/19, address@hidden <address@hidden> wrote:
> Voici l'ensemble de mes fichiers d'encodage. C'est loin d'être terminé. Le
> fichier maître est La-Fiancée-vendue_orch.ly

Bonjour,
bravo pour ce travail de copiste ; juste quelques commentaires mineurs :

- attention juste au début (mesure 6), vous avez un _sf auquel il
manque une barre oblique (_\sf).

- dans certaines fonctions vous utilisez encore l’ancienne syntaxe
#(define-music-function (parser location blablabla
alors qu’aujourd’hui on n’a plus besoin de "parser location" :
#(define-music-function (blablablabla

Ce qui suit peut intéresser toute la liste :

- je remarque que vous utilisez presque systématiquement la syntaxe
_\nuance au lieu de mettre \nuance toute seule ; non seulement cela
vous permettrait d’économiser un caractère mais cela offre aussi plus
de souplesse (par défaut toutes les nuances se placeront en-dessous
donc ça ne changera rien, mais cela vous permettra de changer tous les
placements de nuances en une seule fois avec \dynamicUp et
\dynamicDown).

- de surcroît, si vous avez besoin d’utiliser mes commandes de
nettoyage automatique des nuances, elles reposent précisément sur
cette astuce : les nuances indiquées tout simplement sont enlevées,
mais celles qui incluent une direction explicite (donc un signe _ ou
^) sont conservées ! Pas étonnant que ça ne marche pas dans votre
code, du coup…

- je remarque que vous avez défini beaucoup de nuances supplémentaires
en tant que markups. Si vous voulez pouvoir les utiliser directement
sans avoir besoin du caractère "_", il suffit d’ajouter celui ci dans
la définition :

fsF = _\markup \dynamic fsf

ce qui permet ensuite de faire

{ c' d' e'2\fsF }

… cependant, ce n’est pas idéal car ce ne seront toujours pas de
vraies nuances (et du coup elles seront ignorées par \enleverNuances
etc.). En fait, il y a une autre solution encore meilleure : utiliser
de _vraies_ nuances (dont on trafique le contenu), plutôt qu’un
markup. Voici le code que j’utilise pour cela :


%%%%%%%%%%%%%%

#(define-public (char-punctuation? ch)
   (char-set-contains? char-set:punctuation ch))

#(define-public char-set:dynamics
   (char-set #\f #\m #\p #\r #\s #\z))

#(define-markup-command
  (dynamic-string layout props str) (string?)
  (let ((composite-chars (char-set-union
                          char-set:dynamics
                          char-set:whitespace
                          char-set:punctuation))
        (split (lambda (s) (string-index s #\sp )))
        (str-list '())
        (dyn-markup (lambda (s)
                       (make-dynamic-markup s)))
        (text-markup (lambda (s)
                        (make-normal-text-markup
                         (make-italic-markup s)))))
    (do ((current-str (string-append str " ")))
      ((not (split current-str)))
      (begin
       (set! str-list
             (append str-list
               (list
                (string-take current-str
                  (split current-str)))))
       (set! current-str
             (string-drop current-str
               (+ (split current-str) 1)))))
    (interpret-markup layout props
      (make-line-markup
       (map (lambda (word)
              (if (string-every composite-chars word)
                  (if (string-every char-set:dynamics word)
                      (dyn-markup word)
                      (let ((word-lst (string->list word)))
                        (make-concat-markup
                         (map
                          (lambda (ch)
                            (let ((print-ch (string ch)))
                              (if (char-punctuation? ch)
                                  (text-markup print-ch)
                                  (dyn-markup print-ch))))
                          word-lst))))
                  (text-markup word)))
         str-list)))))

nuance =
#(define-event-function (arg) (markup?)
   (let ((d (make-music 'AbsoluteDynamicEvent)))
     (ly:music-set-property! d 'text
       (cond
        ((string? arg)
         (if (string-every char-set:dynamics arg)
             arg
             (markup #:dynamic-string arg)))
        (else arg)))
     d))

%% Quelques exemples :

{ b1\nuance pp }
{ b1\nuance "pp sub." }
{ b1\nuance "più pp (ma non troppo)" }

%% On peut même y mettre des markups (mais
%% cela reste de vraies nuances) :
{ b1\nuance \markup { \hspace #-3 \normal-text \italic più pp} }

%% Ou même dans une variable :
moltoF = \nuance "molto f"
{b1\moltoF }


%%%%%%%%%%%%%%

Donc si j’étais vous (faites une sauvagarde au préalable) :
- je remplacerais tous les _\quelquechose par \quelquechose
- je redéfinierais les nuances faites-maison en tant que vraies
nuances, pas que markups.

Bon courage !

V.