Akkordsymbole mit LilyJAZZ erzeigen

[Carlo]

Hallo,

ich versuche ein Notenblatt mit LilyJAZZ zu erstellen, ganz analog dem beigefügten Beispiel von „All Of Me“, habe aber seltsamerweise nur einen Teilerfolg, den ich mir nicht erklären kann (durchaus auch mangels Erfahrung mit LilyJAZZ...).

Der Reihe nach:
- auf meinem Linux Mint - Mate System (18.3) benutze ich Frescobaldi (2.18.1) und LilyPond 2.20.0. Die  LilyPond 2.20.0-Version habe ich extra installiert in der Version von git hub und liegt im User-Verzeichnis (ich weiß nicht, ob das eine Rolle spielt) unter /home/MEINUSERNAME/lilypond.
- Unter /home/MEINUSERNAME /lilypond/usr/share/lilypond/current/fonts habe ich jeweils unter otf bzw. svg die entsprechenden lilyjazz*.otf bzw. lilyjazz*.svg und lilyjazz*.woff aus dem lilyjazz-master-Paket reinkopiert.
- Im Frescobaldi habe ich dann noch den Pfad zu den 3 Stylesheets (jazzchords.ily, jazzextras.ily, lillyjazz.ily) eingetragen, bei mir /home/MEINUSERNAME /lilypond/lilyjazz-master/stylesheet.

Zum Problem:
- dem lilyjazz-Paket liegt eine sehr schöne Beispiel-Datei von „All Of Me“ bei (.ly und .pdf).
Unten meine stark vereinfachte Version.
- Das PDF, das ich erhalte nach Kompilieren, enthält die Notenschlüssel, Taktangabe, Noten und Wiederholungszeichen in schönem Jazz-Stil, nicht aber die Akkordsymbole und auch nicht den Liedtext (der ist mir weniger wichtig).
- Das Lily-Pond-Protokoll zeigt keine Fehlermeldungen, d.h. ich habe wohl nichts „kaputt gemacht“, aber irgendwas fehlt wohl  -nur was?

Hat jemand eine Idee?
Vielen Dank!
Carlo

Hier noch die vereinfachte .ly-Datei:
\version "2.20.0"
#(set-global-staff-size 18)
\include "jazzchords.ily"
\include "lilyjazz.ily"
\include "jazzextras.ily"

\paper {
  #(set-paper-size "letter")
%  paper-height = 11\in
%  paper-width = 8.5\in
  indent = 0\mm
  between-system-space = 2.5\cm
  between-system-padding = #0
  %%set to ##t if your score is less than one page:
  ragged-last-bottom = ##f
  ragged-bottom = ##f
  markup-system-spacing = #'((basic-distance . 23)
                             (minimum-distance .
                             (padding . 1))
}


theNotes = \relative c' {
  \set Staff.midiInstrument = "flute"
  \key c \major
  \showStartRepeatBar \bar "[|:"
     c'4 g8 e ~ e2
          \bar ":|]"
     }


theChords = \chordmode {
      c1:maj
 
}

theWords = \lyricmode {
  All of me

}

\score {
  <<
    \new ChordNames \theChords
    \new Voice = soloist \theNotes
    \new Lyrics \lyricsto soloist \theWords
  >>
  \layout {
  }
  }

[Manuela]

Bitte Code in Code-Tags einschließen (der Button mit dem #-Zeichen drauf), da kann man ihn besser zum Testen rauskopieren

Ich kann jetzt nur eine Ferndiagnose stellen, weil ich kein Lilypond hier habe. Ich denke, du musst dem System auch noch mitteilen, dass es die Fontnamen verwenden soll, etwa in der der Art

Code: [Auswählen]

\layout {
  \context {
    \ChordNames
    \override ChordName.font-name = #"LilyJAZZ Text"
  }
}
Handbuch: 3.3.1 Was sind Kontexte?
Internals: 2.1 Contexts

[Carlo]

Vielen Dank, Manuela,

habe den Code in \layout {} ausprobiert, hilft aber leider nicht. Ich habe auch nochmal in Frescobaldi die verfügbaren Fonts ausgeben lassen, da sind (neben vielen anderen) die LilyJazz-Fonts jedenfalls dabei, woraus ich schließe, das die Fonts nicht falsch "installiert" sind:
family LilyJAZZ-Brace
 LilyJAZZ\-Brace:style=Brace
family LilyJAZZ-11
 LilyJAZZ\-11:style=11
family LilyJAZZ-13
 LilyJAZZ\-13:style=13
family LilyJAZZ-14
 LilyJAZZ\-14:style=14
family LilyJAZZ-16
 LilyJAZZ\-16:style=16
family LilyJAZZ-18
 LilyJAZZ\-18:style=18
family LilyJAZZ-20
 LilyJAZZ\-20:style=20
family LilyJAZZ-23
 LilyJAZZ\-23:style=23
family LilyJAZZ-26
 LilyJAZZ\-26:style=26
...
Font dir: /home/MEINUSERNAME/.fonts


Trotzdem erscheinen Akkordsymbole und Text im Standardfont (in welchem eigentlich? Kann ich das irgendwo sehen?)

Hier nochmal mein aktuelles .ly-Beispiel und die Ausgabe als pdf-Anhang.

Viele Grüße,
Carlo

Code: [Auswählen]

\version "2.20.0"
\include "jazzchords.ily"
\include "lilyjazz.ily"
\include "jazzextras.ily"

\paper {
}

theNotes = \relative c' {
  \key c \major
  \showStartRepeatBar \bar "[|:"
     c'4 g8 e ~ e2
          \bar ":|]"
     }

theChords = \chordmode {
      c1:7
}

theWords = \lyricmode {
  All of me

}

\score {
  <<
    \new ChordNames \theChords
    \new Voice = soloist \theNotes
    \new Lyrics \lyricsto soloist \theWords
  >>
 \layout {  %% These lines in \layout {} were added based on recommendation of the lilypond forum, but don't seem to help
  \context {
   \ChordNames
    chordRootNamer = #JazzChordNames % update the chord names
    chordNameExceptions = #JazzChords % update the chord exceptions
    \override ChordName.font-name = #"LilyJAZZ Text"
  }
}
  }


[Manuela]

Bei mir kompiliert dein Code nicht (irgendwas fehlt),
so kompiliert er:

Code: [Auswählen]

\version "2.20.0"
\language "deutsch"

%\include "jazzchords.ily"
\include "lilyjazz.ily"
%\include "jazzextras.ily"

theNotes = \relative c' {
  \key c \major
  c'4 g8 e ~ e2
}

theChords = \chordmode {
  c1:7
}

theWords = \lyricmode {
  All of me

}

\score {
  <<
    \new ChordNames \theChords
    \new Voice = soloist \theNotes
    \new Lyrics \lyricsto soloist \theWords
  >>
  \layout {
    %% These lines in \layout {} were added based on recommendation of the lilypond forum, but don't seem to help
    \context {
      \ChordNames
      %       chordRootNamer = #JazzChordNames % update the chord names
      %       chordNameExceptions = #JazzChords % update the chord exceptions
      \override ChordName.font-name = #"LilyJAZZ Text"
    }
    \context {
      \Lyrics
      \override LyricText.font-name = #"LilyJAZZ Text"
    }
  }
}
die Ausgabe füge ich als Bild an.  Es schaut alles gut aus, sowohl Chordnames als auch Liedtext im gewünschten Font.

[Carlo]

Vielen Dank,
aber mein Lilypond weigert sich immer noch, egal ob mit Frescobaldi oder auf der Konsole.
Es liegt aber wohl nicht daran, dass er die Fonts per se nicht findet, denn mein Lilypond benutzt eindeutig den Emmentaler-20 Font, der in dem gleichen Verzeichnis liegt, wo ich die LilyJazz-Fonts (.otf) abgelegt habe. (habe das System gechallenged und die Fonts systematisch "weggenommen").

Ich glaube, mein Problem hat irgendwie mit dem Aufruf des entsprechenden Fonts zu tun, der nicht richtig funktioniert bzw. umgesetzt wird, also mit:

Code: [Auswählen]

\override ChordName.font-name = #"LilyJazz Text"

Wenn ich ein wenig rumspiele:

Code: [Auswählen]


 \layout {
    \context {
      \ChordNames
      \override ChordName.font-name = #"lilyjazz-26"
    }
}
kommt mal was anderes raus, aber nicht unbedingt was vernünftiges (s. Bild)

Bin gerade etwas ratlos...

[Manuela]

Hast du schon mal probiert, den Font Cache zu leeren? Das war zwar ein Windows-Problem, aber weiß, vielleicht hilft es bei dir auch.

Vll. findest du in diesem Thread ja was nützliches: Lilypond braucht plötzlich ewig zum Kompilieren

Ansonsten fällt mir leider nichts mehr ein, was dir helfen könnte.

[harm6]

Hallo Carlo,

ich habe zu wenig harte Informationen, um sinnvoll helfen zu können.

(1)

Die  LilyPond 2.20.0-Version habe ich extra installiert in der Version von git hub

Demnach scheinst Du LilyPond selbst zu kompilieren, aber was für eine "Version von git hub"?
Gib bitte mal den link.
Die offizielle Version ist auf Savannah gehostet und mittels
git clone git://git.sv.gnu.org/lilypond.git
beschaffbar, siehe CG

Auf der anderen Seite legt der Pfad
/home/MEINUSERNAME /lilypond/usr/share/lilypond/current/fonts
nahe, das Du eine Version mittels precompiled Installer verwendest.

Hier siehst Du mich verwirrt ..

(2)
Poste bitte den output von
~$ ls /home/MEINUSERNAME/lilypond/usr/share/lilypond/current/fonts/otf/
MEINUSERNAME ist natürlich anzupassen(*)

Bei mir sehe ich dann folgendes:

C059-BdIta.otf
C059-Bold.otf
C059-Italic.otf
C059-Roman.otf
emmentaler-11.otf
emmentaler-13.otf
emmentaler-14.otf
emmentaler-16.otf
emmentaler-18.otf
emmentaler-20.otf
emmentaler-23.otf
emmentaler-26.otf
emmentaler-brace.otf
lilyjazz-11.otf
lilyjazz-13.otf
lilyjazz-14.otf
lilyjazz-16.otf
lilyjazz-18.otf
lilyjazz-20.otf
lilyjazz-23.otf
lilyjazz-26.otf
lilyjazz-brace.otf
lilyjazz-chord.otf
lilyjazz-text.otf
NimbusMonoPS-BoldItalic.otf
NimbusMonoPS-Bold.otf
NimbusMonoPS-Italic.otf
NimbusMonoPS-Regular.otf
NimbusSans-BoldItalic.otf
NimbusSans-Bold.otf
NimbusSans-Italic.otf
NimbusSans-Regular.otf
texgyrecursor-bolditalic.otf
texgyrecursor-bold.otf
texgyrecursor-italic.otf
texgyrecursor-regular.otf
texgyreheros-bolditalic.otf
texgyreheros-bold.otf
texgyreheros-italic.otf
texgyreheros-regular.otf
texgyreschola-bolditalic.otf
texgyreschola-bold.otf
texgyreschola-italic.otf
texgyreschola-regular.otf

Die rot markierten Einträge habe ich dort rein kopiert. Sie kommen aus dem repository zu dem ich unter (3) verlinkt habe.

(3) Was meinst du mit

dem lilyjazz-master-Paket

?

Das sagt mit nichts. Woher hast Du es?
Ich habe extra für diesen thread
https://github.com/OpenLilyPondFonts/lilyjazz
verwendet.

(4)
Ich habe mal ein Beispiel mit Testcode erstellt. (**)
Die Pfade zu den includes müssen natürlich angepasst werden.
Funktioniert nicht mit
\language "deutsch"
!

Code: [Auswählen]

\version "2.20.0"

#(define pretty-print pretty-print)

#(define (lists-map function ls)
  "Apply @var{function} to @var{ls} and all of it sublists.
First it recurses over the children, then the function is applied to
@var{ls}."
    (if (list? ls)
        (set! ls (map (lambda (y) (lists-map function y)) ls))
        ls)
    (function ls))
   
#(define print-grob-font-name
  (lambda (grob)
    (pretty-print
     (let ((output '()))
      (lists-map
        (lambda (entry)
          (cond ((and (list? entry)
                      (eq? 'named-glyph (car entry))
                      (ly:font-metric? (cadr entry)))
                  (set! output
                        (cons
                          (cons (grob::name grob)
                                (ly:font-name (cadr entry))
                                )
                          output)))
                ((and (list? entry)
                      (eq? 'glyph-string (car entry))
                      (ly:font-metric? (cadr entry)))
                  (set! output
                        (cons
                          (cons (grob::name grob)
                                (caddr entry)
                                )
                          output)))
                (else entry) ))
        (ly:stencil-expr (ly:grob-property grob 'stencil)))
        (reverse output)))))

\layout {
  \override ChordName.after-line-breaking = #print-grob-font-name   
  \override NoteHead.after-line-breaking = #print-grob-font-name   
  \override Flag.after-line-breaking = #print-grob-font-name
  \override Rest.after-line-breaking = #print-grob-font-name
  \override Accidental.after-line-breaking = #print-grob-font-name
  \override TextScript.after-line-breaking = #print-grob-font-name
  \override MultiMeasureRest.after-line-breaking = #print-grob-font-name
  \override Staff.Clef.after-line-breaking = #print-grob-font-name
  \override Staff.TimeSignature.after-line-breaking = #print-grob-font-name
  \override Staff.KeySignature.after-line-breaking = #print-grob-font-name
  \override Score.MetronomeMark.after-line-breaking = #print-grob-font-name
 
}
\version "2.20.0"

\include "../../../lilyjazz/stylesheet/jazzchords.ily"
\include "../../../lilyjazz/stylesheet/lilyjazz.ily"
\include "../../../lilyjazz/stylesheet/jazzextras.ily"

\header { title = "EXAMPLE" }

theNotes = \relative c' {
  \key c \major
  \tempo "Example" 4 = 120
  c'4 g8 e ~ e!2_"end"
}

theChords = \chordmode { c1:7 }

theWords = \lyricmode { All of me }

\score {
  \transpose c a
  <<
    \new ChordNames \theChords
    \new Voice = soloist \theNotes
    \new Lyrics \lyricsto soloist \theWords
  >>
  \layout {
    \context {
      \ChordNames
        chordRootNamer = #JazzChordNames % update the chord names
        chordNameExceptions = #JazzChords % update the chord exceptions
    }
  }
}

Im Terminal erscheint bei mir:

((ChordName . "lilyjazz-chord")
 (ChordName . "lilyjazz-chord"))
((NoteHead . "LilyJAZZ-20"))
((Clef . "LilyJAZZ-20"))
((KeySignature . "LilyJAZZ-20")
 (KeySignature . "LilyJAZZ-20")
 (KeySignature . "LilyJAZZ-20"))
((TimeSignature . "LilyJAZZ-20"))
((MetronomeMark . "lilyjazz-text")
 (MetronomeMark . "lilyjazz-text")
 (MetronomeMark . "LilyJAZZ-18")
 (MetronomeMark . "lilyjazz-text"))
((NoteHead . "LilyJAZZ-20"))
((NoteHead . "LilyJAZZ-20"))
((NoteHead . "LilyJAZZ-20"))
((TextScript . "lilyjazz-text"))
((Accidental . "LilyJAZZ-20"))
((Accidental . "LilyJAZZ-20"))

Wenn ich die drei include-files, sowie chordRootNamer und chordNameExceptions auskommentiere, dann erhalte ich:

((ChordName . "TeXGyreHeros-Regular")
 (ChordName . "TeXGyreHeros-Regular"))
((NoteHead . "Emmentaler-20"))
((Clef . "Emmentaler-20"))
((KeySignature . "Emmentaler-20")
 (KeySignature . "Emmentaler-20")
 (KeySignature . "Emmentaler-20"))
((TimeSignature . "Emmentaler-20"))
((MetronomeMark . "TeXGyreSchola-Bold")
 (MetronomeMark . "TeXGyreSchola-Regular")
 (MetronomeMark . "Emmentaler-18")
 (MetronomeMark . "TeXGyreSchola-Regular"))
((NoteHead . "Emmentaler-20"))
((NoteHead . "Emmentaler-20"))
((NoteHead . "Emmentaler-20"))
((TextScript . "TeXGyreSchola-Regular"))
((Accidental . "Emmentaler-20"))
((Accidental . "Emmentaler-20"))

Alles wie erwrtet.

Was bekommst Du?

Bild im Anhang (um die Kollision mit der MetronomeMark hab ich mich nicht gekümmert...)

Gruß,
  Harm

P.S.
Bitte click "Keine Smileys benutzen" unter "Erweiterte Optionen..." an, falls so ein Unsinn wie

  markup-system-spacing = #'((basic-distance . 23)
                             (minimum-distance .
                             (padding . 1))
zu sehen ist.

(*) Ich schreib sehr ausführlich. Auch wenn ich davon ausgehe, daß Du manche Erklärung wirklich nicht brauchst. Aber es lesen ja auch nicht so erfahrene User mit. Mir zumindest hat eine solche Ausführlichkeit als Anfänger sehr geholfen.
(**) print-grob-font-name funktioniert bei vielen, aber nicht allen grobs. Ich habs nur soweit entwickelt, daß es für die jetzigen Fälle funktioniert

EDIT vergessenen Anhang hinzugefügt

[Carlo]

Hallo harm6,

Vielen Dank für Deine Mühe!

Hier die Punkte:
zu (1): nein, ich habe lilypond nicht selbst kompiliert. Ich muss mich korrigieren: lilypond 2.20.0 habe ich von https://lilypond.org/unix.de.html heruntergeladen und das .sh-Skript laufen lassen auf meinem Linux-System.
Von https://github.com/OpenLilyPondFonts/lilyjazz stammt das LilyJazz-Paket (sorry for confusion). Wenn man das herunterlädt (lilyjazz-master.zip) und entpackt, erhält man automatisch einen Ordner namens "lilyjazz-master", wo dann die Fonts und Stylesheets etc in entsprechenden Unterordnern zu finden sind. Ich habe den Namen dieses Ordners "lilyjazz-master" einfach so gelassen, soweit zur Frage (3). Die *.otf-Fontfiles aus  .../lilyjazz-master/otf hatte ich in die entspr. Ordner meiner lilypond 2.20.0-Installation reinkopiert (was nicht alle nötigen *.otf erfasste- dazu gleich mehr unter (2)).

zu (2):
~$ ls /home/MEINUSERNAME/lilypond/usr/share/lilypond/current/fonts/otf/ liefert bei mir:

C059-BdIta.otf
C059-Bold.otf
C059-Italic.otf
C059-Roman.otf
emmentaler-11.otf
emmentaler-13.otf
emmentaler-14.otf
emmentaler-16.otf
emmentaler-18.otf
emmentaler-20.otf
emmentaler-23.otf
emmentaler-26.otf
emmentaler-brace.otf
lilyjazz-11.otf
lilyjazz-13.otf
lilyjazz-14.otf
lilyjazz-16.otf
lilyjazz-18.otf
lilyjazz-20.otf
lilyjazz-23.otf
lilyjazz-26.otf
lilyjazz-brace.otf
NimbusMonoPS-BoldItalic.otf
NimbusMonoPS-Bold.otf
NimbusMonoPS-Italic.otf
NimbusMonoPS-Regular.otf
NimbusSans-BoldItalic.otf
NimbusSans-Bold.otf
NimbusSans-Italic.otf
NimbusSans-Regular.otf
texgyrecursor-bolditalic.otf
texgyrecursor-bold.otf
texgyrecursor-italic.otf
texgyrecursor-regular.otf
texgyreheros-bolditalic.otf
texgyreheros-bold.otf
texgyreheros-italic.otf
texgyreheros-regular.otf
texgyreschola-bolditalic.otf
texgyreschola-bold.otf
texgyreschola-italic.otf
texgyreschola-regular.otf

BINGO: lilyjazz-chord.otf und lilyjazz-text.otf haben bei mir gefehlt. Die liegen unglücklicherweise in einem gesonderten Verzeichnis im lilyjazz-master-Ordner (s.o.), nämlich unter .../lilyjazz-master/supplementary-files/lilyjazz-text bzw. .../lilyjazz-master/supplementary-files/lilyjazz-chord, und nicht unter .../lilyjazz-master/otf, wie die anderen.

OK - Fehler erkannt, habe die beiden .otf jetzt zu den anderen .otf kopiert und: es funktioniert!!

Ich werde das mal an den LilyJazz-Programmierer Abraham Lee schicken, das steht nämlich nicht so klar in der Anleitung zu LilyJazz https://github.com/OpenLilyPondFonts/lilyjazz/blob/master/LilyPond-Fonts-Installation-And-Usage.txt#L1. Vielleicht habe nur ich es nicht gerafft, dass man erst noch eine Suchfunktion über den Download-Ordner schicken muss um wirklich nach allen *.otf zu suchen, weil die nicht alle schön zusammen sortiert sind, aber evtl. hilft es auch anderen unbedarften Usern.

zu (4):

da ich den Fehler gefunden habe, erspare ich mir erstmal die Outputs zu Deinem Testfile; aber könntest Du vielleicht noch kurz erklären, was dieser Code eigentlich macht?

Tausend Dank jedenfalls schonmal!

Viele Grüße,
Carlo [in memoriam: Carlo Bohländer]

[harm6]

zu (4):

da ich den Fehler gefunden habe, erspare ich mir erstmal die Outputs zu Deinem Testfile; aber könntest Du vielleicht noch kurz erklären, was dieser Code eigentlich macht?

Es geht darum auszulesen welche Schriftarten tatsächlich genommen werden. Und zwar auch die defaults, nicht nur die, die man selber ausdrücklich angegeben hat.

Um einen solchen Testcode zu entwickeln gehe ich immer schrittweise vor (dagestellt am Beispiel der MetronomeMark)

(1)
Basis ist etwas wie:

Code: [Auswählen]

printGrob = #(lambda (grob) (pretty-print grob))

{
  \override Score.MetronomeMark.after-line-breaking = \printGrob
  \tempo 4 = 120
  b1
}

Das after-line-breaking ist prädestiniert dazu auf eine procedure gesetzt zu werden. Hier auf printGrob. Welche einfach das grob anzeigt.
-->
#<Grob MetronomeMark >

Alle weiteren codings weiter unten.

(2) Dann laß ich mir den stencil anzeigen: after-line-breaking wird auf printStencil gesetzt.
-->
#<Stencil>

(3) Dann schau ich mir die "Bauanleitung" des stencils an: after-line-breaking wird auf printStencilExpression gesetzt.
-->

(combine-stencil
  (translate-stencil
    (0.0 . 0.488764434793895)
    (combine-stencil
      (round-filled-box
        -1.04485121604389
        1.16066804940214
        -0.159793833831026
        2.67269615442102
        0.0386056111194147)
      (named-glyph
        #<Font_metric ("emmentaler-18" . 0.568990432408091)>
        "noteheads.s2")))
  (translate-stencil
    (1.16066804940214 . 0.0)
    (translate-stencil
      (0.0 . 0.0)
      (glyph-string
        #<Font_metric (#f . 1.0)>
        "TeXGyreSchola-Regular"
        3.865234375
        #f
        '((0.614579527559055 (0.0 . 0.0) 0.0 0.0 "space")
          (1.33158897637795
           (0.239003149606299 . 0.853582677165354)
           0.0
           0.0
           "equal")
          (0.614579527559055 (0.0 . 0.0) 0.0 0.0 "space")
          (1.22915905511811
           (0.0 . 1.53644881889764)
           0.0
           0.0
           "one")
          (1.22915905511811
           (0.0 . 1.53644881889764)
           0.0
           0.0
           "two")
          (1.22915905511811
           (-0.0341433070866142 . 1.53644881889764)
           0.0
           0.0
           "zero"))))))

Eigentlich kann man hier schon alles sehen, es ist aber sehr verwirrend und unübersichtlich.

(4) Ich reduziere das Ganze, indem ich nur den Namen des grobs und die Schriftarten ausgeben lasse, alles andere weglasse: after-line-breaking wird auf printStencilExpressionFonts gesetzt.
Zu diesem Zweck muß rekursiv durch all die geschachtelten Listen gegangen werden (das macht 'lists-map') und je nach Situation (das macht die Fallunterscheidung via 'cond') die Schriftart gefunden oder ausgewählt werden.
Die Schriftarten werden gesammelt und mit dem Namen des grobs ausgegeben.
-->
(MetronomeMark
  "Emmentaler-18"
  "TeXGyreSchola-Regular")


Das Coding ist ein bißchen anders als zuletzt, aber folgt demselben Prinzip.

Code: [Auswählen]

printStencil = #(lambda (grob) (pretty-print (ly:grob-property grob 'stencil)))

printStencilExpression =
#(lambda (grob)
  (let ((stil (ly:grob-property grob 'stencil)))
    (pretty-print (ly:stencil-expr stil))))
   
#(define (lists-map function ls)
  "Apply @var{function} to @var{ls} and all of it sublists.
First it recurses over the children, then the function is applied to
@var{ls}."
    (if (list? ls)
        (set! ls (map (lambda (y) (lists-map function y)) ls))
        ls)
    (function ls))

printStencilExpressionFonts = 
#(lambda (grob)
  (let* ((stil (ly:grob-property grob 'stencil))
         (stil-expr (ly:stencil-expr stil))
         (output '())
         ;; Finde font-names und speichere sie in "output"
         ;; Die Methode muß zwischen "named-glyph" und "glyph-string"
         ;; differenzieren, da LilyPond das intern anders umsetzt.
         (store-font-names
           (lambda (entry)
             (cond
                   ;; Wenn die stencil-expression irgendwo "named-glyph"
                   ;; beinhaltet, dann extrahiere die Schriftart via
                   ;; ly:font-name aus dem zweiten Eintrag der mit "named-glyph"
                   ;; anfangenden Liste.
                   ;; Erweitere output mit dem Ergebnis.
                   ((and (list? entry)
                         (eq? 'named-glyph (car entry))
                         (ly:font-metric? (cadr entry)))
                     (set! output
                           (cons (ly:font-name (cadr entry)) output)))
                   ((and (list? entry)
                   ;; Wenn die stencil-expression irgendwo "glyph-string"
                   ;; beinhaltet, dann extrahiere die Schriftart indem das
                   ;; dritte Element, der mit "glyph-string" anfangenden Liste
                   ;; ausgewählt wird, ly:font-name würde hier #f zurückgeben.
                   ;; Erweitere output mit dem Ergebnis.
                         (eq? 'glyph-string (car entry))
                         (ly:font-metric? (cadr entry)))
                     (set! output
                           (cons (caddr entry) output)))
                   ;; Ansonsten mache nichts weiter.
                   (else entry)))))
        (lists-map store-font-names stil-expr)

       
       
    (pretty-print (cons (grob::name grob) (reverse output)))))
   
{
  \override Score.MetronomeMark.after-line-breaking = \printStencil
  %\override Score.MetronomeMark.after-line-breaking = \printStencilExpression
  %\override Score.MetronomeMark.after-line-breaking = \printStencilExpressionFonts
 
  \tempo 4 = 120
  b1
}


habe die beiden .otf jetzt zu den anderen .otf kopiert und: es funktioniert!!

Sehr schön


Gruß,
  Harm