RE: nom des variables utilisant des chiffres ?

[daniel.bernair]

Merci Valentin pour votre réponse. Je vais examiner ces nouvelles fonctions et 
essayer de corriger ma partition proprement. 
Pour ces fonctions n'y connaissant rien en Scheme je n'y comprends rien. Donc 
je dois étudier Scheme. J'ai déjà commencé plusieurs fois mais j'ai dû 
abandonner pour plus urgent et ce n'est pas évident à comprendre même pour un 
ancien IBMer.
Bien amicalement,
Daniel Bernair       

-----Message d'origine-----
De : lilypond-user-fr <lilypond-user-fr-bounces+daniel.bernair=address@hidden> 
De la part de Valentin Villenave
Envoyé : lundi 11 novembre 2019 10:49
À : address@hidden
Cc : address@hidden
Objet : Re: nom des variables utilisant des chiffres ?

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.



This email has been scanned by BullGuard antivirus protection.
For more info visit www.bullguard.com