Akkordnamen unterstreichen (gelöst)

[Manuela]

Arnold möge mir verzeihen 

Ich arbeite an einer Notation für Akkordeonbass und habe Workarounds gefunden, um Bezeichnungen für Akkorde mit Kleinbuchstaben und für die Bassnoten mit Großbuchstaben zu schreiben.

Für die Terzbässe brauche ich die Akkordnamen unterstrichen, auch dafür habe ich einen Workaround gefunden. Der Nachteil bei meiner Lösung ist, dass die Unterstriche nicht an die Schriftart und Namensbreite angepasst wird. Gibt es irgendeine Möglichkeit, z.B. \underline anzuwenden?

Hier mein Workaround:

Code: [Auswählen]

\version "2.19.52"
\language "deutsch"

chExceptionMusic = {
  <c es g b d'>1-\markup { \super \fontsize #1 "m" }
  <c>1-\markup { \null \hspace #-1.6 \fontsize #2 "_" }
  <c d>1-\markup { \null \hspace #-3.5 \fontsize #1.2 "__" }
}

chExceptions = #( append
                  ( sequential-music-to-chord-exceptions chExceptionMusic #t)
                  ignatzekExceptions)

chordnotes = \chordmode {
  \set chordNameLowercaseMinor = ##t
  \set chordNameExceptions = #chExceptions
  c < c > < cis dis > c:m c:m9 c:m7 c:dim
}

\new ChordNames \chordnotes

[fugenkomponist]

Du müßtest vermutlich chordRootNamer ersetzen. Hier eine angepaßte Version des defaults note-name->markup. Dafür mußte ich drei Hilfsfunktionen kopieren, die sind genau so im LilyPond-Code zu finden, ich komm bloß als Nutzer anscheinend nicht dran, weil sie per define statt define-public definiert sind (ich nehm zumindest an, daß das der Grund ist). Deshalb sieht das jetzt nach viel Text aus, ist aber eigentlich nur eine winzige Änderung

Code: [Auswählen]

\version "2.19.53"
\language "deutsch"

% copied from scm/chord-name.scm
#(define (conditional-string-downcase str condition)
   (if condition
       (string-downcase str)
       str))

% copied from scm/chord-generic-names.scm
#(define (conditional-kern-before markup bool amount)
   "Add AMOUNT of space before MARKUP if BOOL is true."
   (if bool
       (make-line-markup
        (list (make-hspace-markup amount)
          markup))
       markup))

% copied from scm/chord-name.scm
#(define (accidental->markup alteration)
   "Return accidental markup for ALTERATION."
   (if (= alteration 0)
       (make-line-markup (list empty-markup))
       (conditional-kern-before
        (alteration->text-accidental-markup alteration)
        (= alteration FLAT) 0.094725)))

% copied from scm/chord-name.scm, renamed, added make-underline-markup
#(define (note-name->underlined-markup pitch lowercase?)
   "Return pitch markup for @var{pitch}."
   (make-underline-markup
    (make-line-markup
     (list
      (make-simple-markup
       (conditional-string-downcase
        (vector-ref #("C" "D" "E" "F" "G" "A" "B") (ly:pitch-notename pitch))
        lowercase?))
      (accidental->markup (ly:pitch-alteration pitch))))))

\chords {
  c fis g:7
  \set ChordNames.chordRootNamer = #note-name->underlined-markup
  c fis g:7
}


[Manuela]

Danke, das sieht echt super aus!

Die Lösung kann sogar mehr, unterstrichene Dominantseptakkorde werden in der Akkordeonnotation nicht gebraucht 

Wenn man dann noch folgendes einbaut:

Code: [Auswählen]

counterbass= \once \set ChordNames.chordRootNamer = #note-name->underlined-markup

\chords {
  c fis g:7
  \counterbass g
  c fis g:7
}
dann kann man einzelne Chordnamen unterstreichen.

[Manuela]

So, ich dachte, ich schaffe es alleine, die Funktion so umzustricken, dass statt C# beispielsweise Cis erscheint.
Und scheitere 

Ich habe verschiedene Varianten probiert

Code: [Auswählen]

#(define ((chord-name->german-markup-text-alteration B-instead-of-Bb) pitch lowercase?)

   (define (pitch-alteration-semitones pitch)
     (inexact->exact (round (* (ly:pitch-alteration pitch) 2))))

   (define (conditional-string-downcase str condition)
     (if condition
         (string-downcase str)
         str))

   (let* ((name (ly:pitch-notename pitch))
          (alt-semitones  (pitch-alteration-semitones pitch))
          (n-a (if (member (cons name alt-semitones) `((6 . -1) (6 . -1)))
                   (cons 7 (+ (if B-instead-of-Bb 1 1) alt-semitones))
                   (cons name alt-semitones))))
     (make-line-markup
      (list
       (make-simple-markup
        (conditional-string-downcase
         (vector-ref #("C" "D" "E" "F" "G" "A" "H" "B") (car n-a))
         lowercase?))
       (let ((alteration (/ (cdr n-a) 2)))
         (cond
          ((and (equal? lowercase? #f) (= alteration FLAT) (= (car n-a) 7)) (make-simple-markup ""))
          ((and (= alteration FLAT) (or (= (car n-a) 5) (= (car n-a) 2) )) (make-simple-markup "s"))
          ((= alteration FLAT) (make-simple-markup "es"))
          ((and (= alteration DOUBLE-FLAT) (or (= (car n-a) 5)(= (car n-a) 2) )) (make-simple-markup "ses"))
          ((= alteration DOUBLE-FLAT) (make-simple-markup "eses"))
          ((= alteration SHARP) (make-simple-markup "is"))
          ((= alteration DOUBLE-SHARP) (make-simple-markup "isis"))
          (else empty-markup)))))))
in die Funktion einzubauen, zB.

Code: [Auswählen]

#(define (note-name->underlined-markup pitch lowercase?)
   "Return pitch markup for @var{pitch}."
   (make-underline-markup
    (make-line-markup
     (list
      (make-simple-markup
       ((chord-name->german-markup-text-alteration #f) pitch lowercase?))))))
was nur Fehlermeldungen ergibt.
Wahrscheinlich nur eine Kleinigkeit, aber meine (zugegebenermaßen nicht so tollen) Scheme-Kenntnisse rosten so schnell ein, wenn ich sie eine Weile nicht brauche, es ist erschreckend.

[xr]

Hallo,

da ich mich ja gerade selbst durch die Syntax von Scheme kämpfe und versuche, Lilys Grob-Hierarchie zu verstehen, hätte ich mir deinen Code zumindest gern mal angeschaut.
Kannst du mal ein vollständiges Codebeispiel geben, das ich nicht erst aus den anderen Beispielen zusammenstückeln muss?

Grüße,
Xaver

[Manuela]

Ok, hier ein vollständiges Beispiel

Code: [Auswählen]

\version "2.19.52"

\language "deutsch"

% copied from scm/chord-name.scm
#(define (conditional-string-downcase str condition)
   (if condition
       (string-downcase str)
       str))

% copied from scm/chord-generic-names.scm
#(define (conditional-kern-before markup bool amount)
   "Add AMOUNT of space before MARKUP if BOOL is true."
   (if bool
       (make-line-markup
        (list (make-hspace-markup amount)
          markup))
       markup))

% copied from scm/chord-name.scm
#(define (accidental->markup alteration)
   "Return accidental markup for ALTERATION."
   (if (= alteration 0)
       (make-line-markup (list empty-markup))
       (conditional-kern-before
        (alteration->text-accidental-markup alteration)
        (= alteration FLAT) 0.094725)))

% copied from scm/chord-name.scm, renamed, added make-underline-markup
#(define (note-name->underlined-markup pitch lowercase?)
   "Return pitch markup for @var{pitch}."
   (make-underline-markup
    (make-line-markup
     (list
      (make-simple-markup
       (conditional-string-downcase
        (vector-ref #("C" "D" "E" "F" "G" "A" "B") (ly:pitch-notename pitch))
        lowercase?))
      (accidental->markup (ly:pitch-alteration pitch))))))

#(define ((chord-name->german-markup-text-alteration B-instead-of-Bb) pitch lowercase?)
   (define (pitch-alteration-semitones pitch)
     (inexact->exact (round (* (ly:pitch-alteration pitch) 2))))
   (define (conditional-string-downcase str condition)
     (if condition
         (string-downcase str)
         str))
   (let* ((name (ly:pitch-notename pitch))
          (alt-semitones  (pitch-alteration-semitones pitch))
          (n-a (if (member (cons name alt-semitones) `((6 . -1) (6 . -1)))
                   (cons 7 (+ (if B-instead-of-Bb 1 1) alt-semitones))
                   (cons name alt-semitones))))
     (make-line-markup
      (list
       (make-simple-markup
        (conditional-string-downcase
         (vector-ref #("C" "D" "E" "F" "G" "A" "H" "B") (car n-a))
         lowercase?))
       (let ((alteration (/ (cdr n-a) 2)))
         (cond
          ((and (equal? lowercase? #f) (= alteration FLAT) (= (car n-a) 7)) (make-simple-markup ""))
          ((and (= alteration FLAT) (or (= (car n-a) 5) (= (car n-a) 2) )) (make-simple-markup "s"))
          ((= alteration FLAT) (make-simple-markup "es"))
          ((and (= alteration DOUBLE-FLAT) (or (= (car n-a) 5)(= (car n-a) 2) )) (make-simple-markup "ses"))
          ((= alteration DOUBLE-FLAT) (make-simple-markup "eses"))
          ((= alteration SHARP) (make-simple-markup "is"))
          ((= alteration DOUBLE-SHARP) (make-simple-markup "isis"))
          (else empty-markup)))))))

counterbass= \once \set ChordNames.chordRootNamer = #note-name->underlined-markup
#(define germanChords (chord-name->german-markup-text-alteration #t))

\chords {
  c fis g:7
  \set ChordNames.chordRootNamer = #note-name->underlined-markup
  c fis g:7
  \unset ChordNames.chordRootNamer
  cis
  \counterbass es:7
  des:9
  es
}


[xr]

Wenn ich das richtig verstehe, soll #(define ((chord-name->german-markup-text-alteration B-instead-of-Bb) pitch lowercase?) die Vorzeichen in ausgeschriebene deutsche Bezeichnungen umwandeln? Also F# -> Fis.
Bei mir wird die Methode aber gar nicht aufgerufen.

[Manuela]

Wenn ich das richtig verstehe, soll #(define ((chord-name->german-markup-text-alteration B-instead-of-Bb) pitch lowercase?) die Vorzeichen in ausgeschriebene deutsche Bezeichnungen umwandeln? Also F# -> Fis.

Ja, das ist die Funktion dafür.

Bei mir wird die Methode aber gar nicht aufgerufen.

Genau, ich habe sie deswegen eingefügt, damit der passende Code gleich zur Verfügung steht und nicht erst mühsam gesucht werden muss.

Die beiden Aufrufe

Code: [Auswählen]

#note-name->underlined-markup
und

Code: [Auswählen]

chord-name->german-markup-text-alteration
sollten zu einem Aufruf zusammengesetzt werden, der beides macht: unterstreichen und deutsche Akkordnamen verwenden.

[xr]

Ich habe die Funktion note-name->underlined-markup so erweitert, dass die Namen direkt ins markup geschrieben werden.
Die Inline Funktion handle-sharp-flat könnte man natürlich auch auslagern.

Code: [Auswählen]

#(define (note-name->underlined-markup pitch lowercase?)
   "Return pitch markup for @var{pitch}."

   (define handle-sharp-flat (lambda (m)
       
       (let* (
            (n (ly:pitch-alteration pitch))
            (name (vector-ref #("C" "D" "E" "F" "G" "A" "B") (ly:pitch-notename pitch)))
            (isEorA  (not(equal? (member name '( "E" "A" )) #f)))
            )

            (cond
                (isEorA
                    (cond
                        ((= n 0)
                            "")
                        ((= n 1/2)
                            "is")
                        ((= n 1)
                            "isis")
                        ((= n -1/2)
                            "s")
                        ((= n -1)
                            "ses")))
                (else
                    (cond
                        ((= n 0)
                            "")
                        ((= n 1/2)
                            "is")
                        ((= n 1)
                            "isis")
                        ((= n -1/2)
                            "es")
                        ((= n -1)
                            "eses")))
            )
       ))
   )
   
   (let* (
        (new-markup
            (make-underline-markup
                (make-line-markup
                    (list
                        (make-simple-markup
                        (conditional-string-downcase
                        (vector-ref #("C" "D" "E" "F" "G" "A" "B") (ly:pitch-notename pitch))
                        lowercase?)
                        )
                        (make-simple-markup (handle-sharp-flat  pitch ))
                    )
                )
       
            )
        ))
       new-markup
   )
)

Mein Auseinanderreißen der Klammern entspricht zwar nicht der Schemekonvention, aber bei hintereinander klebenden Klammern suche ich mir bei Fehlern immer einen Wolf.

Gruß,
Xaver

EDIT: Ach ja, das "H" müsste man natürlich auch noch abfragen

[harm6]

Hallo,

mir ist im ganzen Thread nicht richtig klar geworden was eigentlich unterstrichen werden soll und wie es nachher aussehen soll.

Insoweit im Anhang ein png (erstellt mit markup-commands)

Wie sollen moll-Akkorde gedruckt werden? Klein oder mit einem Zeichen für moll ("m" oder "-" oder ...)?
Zusätzliche Bässe groß oder klein?
Wie weit soll das Unterstreichen ausgedehnt werden?

Gruß,
  Harm

[Manuela]

Hallo Harm,

es geht nur die Terzbassnoten bei Akkordeonbässen. Diese bestehen bloß aus Großbuchstaben für die Töne, es sind eigentlich überhaupt keine Akkorde, sondern nur Töne, also C, Cis, Des, ... Um sie von den normalen Baßtönen (die sich in der 2. Knopfreihe befinden) zu unterscheiden, werden sie unterstrichen.

Ideal wäre zusätzlich, wenn ich bei einem Akkord die Note nach dem Schrägstrich auch unterstreichen könnte, z.B. C7/E

[Manuela]

Xaver, danke für deine Unterstützung. Ich habe es jetzt mit deiner Hilfe geschafft 

Hier der Code (als Ergänzung zum bereits geposteten):

Code: [Auswählen]

#(define (note-name->german-underlined-markup pitch lowercase?)
   (make-underline-markup
    (make-line-markup
     (list
      ((chord-name->german-markup-text-alteration #t) pitch lowercase?)))))

germancounterbass= \once \set ChordNames.chordRootNamer = #note-name->german-underlined-markup
counterbass= \once \set ChordNames.chordRootNamer = #note-name->underlined-markup

\new ChordNames \chordmode { a \germancounterbass cis \counterbass des }
Und unterstrichene Akkordnamen nach dem Schrägstrich gehen auch

Code: [Auswählen]

germanNoteNamer= \once \set ChordNames.chordNoteNamer = #note-name->german-underlined-markup