Gitarrensaiten: Buchstaben statt Zahlen möglich?

Begonnen von soloquintett, Mittwoch, 8. Juni 2022, 22:48

« vorheriges - nächstes »

soloquintett

Hi,

Ich habe das Gitarrenspielen mit Buchstaben in Kreisen als Saitenbezeichnungen gelernt. Nun unterrichte ich schon lange selbst und bringe dies auch meinen Schülern so bei. Gibt es eine Möglichkeit dies umzusetzen?

Beispiel:

\relative g' {
 \time 4/4
 g\3 g8 g g4
 g8 g g g
 g g g2
  }

Ich würde gern folgendes schreiben:
\relative g' {
 \time 4/4
 g\"G" g8 g g4
 g8 g g g
 g g g2
  }

Vielen Dank!

Hilflos-im-Code

Zitat von: soloquintett am Mittwoch,  8. Juni 2022, 22:48Ich habe das Gitarrenspielen mit Buchstaben in Kreisen als Saitenbezeichnungen gelernt. Nun unterrichte ich schon lange selbst und bringe dies auch meinen Schülern so bei. Gibt es eine Möglichkeit dies umzusetzen?
Wenn Du unterrichtest, solltest Du Dich fragen, ob deine Vorgehensweise dem Standard entspricht. Du bereitest deine Schüler*Innen auf gebräuchliche Noten vor.

Bei solchen angenommenen Vereinfachungen stellt sich auch die Frage, wenn es später kein großes Problem ist, sich an den Standard umzugewöhnen, warum ist es jetzt ein großes Problem, damit zu arbeiten?

Die mir bekannten Kinderschulen erachten es grundsätzlich nicht als nötig, solche Informationen an die Noten zu schreiben. Warum Du?

soloquintett

Ich finde nicht, dass einen Unterschied macht, ob man mit Zahlen oder Nummern anfängt.
Entscheidend ist für mich, dass man möglichst sofort anfangen kann zu spielen.
Das lernen des Notensystems kommt in meinem Unterricht viel später dran.
Für letzteres ist es meiner Meinung nach aber leichter, wenn man die Saiten von Beginn an mit den Tonnamen bezeichnet hat. So erklärt sich leichter, warum im zweiten Bund auf der G-Saite das a gespielt wird.

Anders gefragt, wo liegt der Vorteil von Zahlen, außer dass es "Standard" ist?

Ich möchte nicht respektlos erscheinen. Ich bin wirklich für jeden Beitrag dankbar, aber ich wollte jetzt nicht meinen über viele Jahre erarbeiteten pädagogischen Ansatz diskutieren, sondern nur wissen, ob ich mit lilypond irgendwie Buchstaben in Kreisen als Saitenbezeichnungen setzen kann. :)


soloquintett

#3
Ich habe einen Weg gefunden:
https://lilypond.org/doc/v2.22/Documentation/snippets/fretted-strings
das unterste Beispiel Erlaubt auch Buchstaben!

stringNumberSpanner =
  #(define-music-function (StringNumber) (string?)
    #{
      \override TextSpanner.style = #'solid
      \override TextSpanner.font-size = #-5
      \override TextSpanner.bound-details.left.stencil-align-dir-y = #CENTER
      \override TextSpanner.bound-details.left.text =
        \markup { \circle \number $StringNumber }
    #})


\relative c {
  \clef "treble_8"
  \stringNumberSpanner "G"
  \textSpannerDown
  a8\startTextSpan
  b c d e f\stopTextSpan
  \stringNumberSpanner "4"
  g\startTextSpan a
  bes4 a g2\stopTextSpan
}

Vielen Dank dennoch!

Hilflos-im-Code

Zitat von: soloquintett am Donnerstag,  9. Juni 2022, 08:39Anders gefragt, wo liegt der Vorteil von Zahlen, außer dass es "Standard" ist?
Ich rechne

Erleichterung_Schüler/(Umlernaufwand_Schüler + Arbeisaufwand_Lehrer)
Ergibt die Bilanz aus meiner Erfahrung ein verdutztes "Häh?", dann frage ich nach.


harm6

Zahlen als Saitenbezeichnung ist sicherlich standard. Es gibt aber auch Gegenbeispiele:




`stringNumberSpanner' ist jetzt aber eigentlich keine Saitenangabe, sondern ein umfunktionierter TextSpanner. Es sollte aber machbar sein Buchstaben direkt auszugeben indem man die stencil-procedure für die StringNumber modifiziert.
Möglicherweise komme ich am Wochenende dazu genauer nachzuforschen...

Gruß,
  Harm

harm6

\version "2.22.1"

#(use-modules
  ((ice-9 format) #:select ((format . ice9-format))))
 
%% NB `guitar-tuning' is already taken !!
guitarTuning =
  #'((1 . "E")
     (2 . "B")
     (3 . "G")
     (4 . "D")
     (5 . "A")
     (6 . "E"))
     
#(set! string-number::calc-text
  (lambda (grob)
    (let ((event (event-cause grob)))
      (or (ly:event-property event 'text #f)
          (let ((strg-nr (ly:event-property event 'string-number)))
           (number-format
            (ly:grob-property grob 'number-type)
            strg-nr
            (ice9-format #f "~a" (assoc-get strg-nr guitarTuning))))))))
           
\layout {
  \context {
    \Voice
    \override StringNumber.text = #string-number::calc-text
    %% If 'number-type is 'custom use font "Arial" or the like
    \override StringNumber.before-line-breaking =
      #(lambda (grob)
        (if (eq? (ly:grob-property grob 'number-type) 'custom)
            (ly:grob-set-property! grob 'font-name "Arial")))
  }
}
           
mus = {
  e'4\1 b\2 g\3 d\4 a,\5 e,\6
}

letterStringNumbers  = \override StringNumber.number-type = #'custom


{
  \clef "G_8"
  \time 6/4
  \mus
  \letterStringNumbers
  \mus
  \romanStringNumbers
  \mus
  %% back to default
  \arabicStringNumbers
  \mus
}

Natürlich gibt es jetzt zwei E-Saiten. Du kannst das natürlich noch anpassen.

Gruß,
  Harm

soloquintett

Wunderbar!
Ich habe nicht die Illusion das ganze Beispiel verstehen zu können (bin noch weit am Anfang) - Könnten Sie dennoch grob erklären, wie sich das aufbaut?

Ich habe oben nicht erwähnt, dass die Linien unter den Noten auch ein von mir oft benutztes Mittel sind, um die Noten für Schüler schneller spielbar zu machen.

Kann man diese auch noch mit Ihrer Methode kombinieren? Mich stört der aus meiner (naiven?) Sicht recht hohe Schreibaufwand, wenn ich viele Linien unter die Noten setzen will.

In folgendem Beispiel hält sich dies noch in Grenzen, da stets viele Noten auf einer Saite gespielt werden. Aber bei vielen Wechseln wäre es gut, wenn man es vereinfachen könnte a la:
a4\5\I\startSpan [...] d\4\M\stopSpan

Ohne jedes mal
\stringNumberSpanner "saite" angeben zu müssen.

Mein aktuelles Arbeitsbeispiel:
\version "2.22.2"

\language "deutsch"

stringNumberSpanner =
#(define-music-function (StringNumber) (string?)
  #{
  \override TextSpanner.style = #'solid
  \override TextSpanner.font-size = #-2
  \override TextSpanner.bound-details.left.stencil-align-dir-y = #CENTER
  \override TextSpanner.bound-details.left.stencil-offset = #'(0 . -0.5)
  \override TextSpanner.bound-details.left.text =
  \markup { \circle  $StringNumber }
  \override TextSpanner.direction = -1
  #})

P =
\rightHandFinger #1

I =
\rightHandFinger #2

M =
\rightHandFinger #3

A =
\rightHandFinger #4

\relative c {
  \clef "treble_8"
  \set strokeFingerOrientations = #'(up)

  \stringNumberSpanner "A"
  | a4\startTextSpan\I a8\M a\I a4\M a8\I a\M |
  | a\I a\M a\I a\M a2\stopTextSpan\I |

  \stringNumberSpanner "D"
  | d4\startTextSpan\M d8\I d\M d4\I d8\M d\I |
  | d\M d\I d\M d\I d2\stopTextSpan\M |

  \stringNumberSpanner "G"
  | g4\startTextSpan\I g8\M g\I g4\M g8\I g\M |
  | g\I g\M g\I g\M g2\stopTextSpan\I |

  \stringNumberSpanner "H"
  | h4\startTextSpan\M h8\I h\M h4\I h8\M h\I |
  | h\M h\I h\M h\I h2\stopTextSpan\M |

  \stringNumberSpanner "e"
  | e4\startTextSpan\I e8\M e\I e4\M e8\I e\M |
  | e\I e\M e\I e\M e2\stopTextSpan\I |
  \bar "|."
}

Vielen Dank für den bisherigen Aufwand!

harm6

ZitatIch habe nicht die Illusion das ganze Beispiel verstehen zu können (bin noch weit am Anfang) - Könnten Sie dennoch grob erklären, wie sich das aufbaut?
Da ich Deine (wir duzen uns hier) Vorkenntnisse nicht einschätzen kann, erkläre ich nur die Grundzüge.

Zunächst ist es sinnvoll sich den default zu vergegenwärtigen (siehe auch IR).

Das was für die StringNumber letztlich gedruckt wird ist das Ergebnis der 'stencil-procedure `print-circled-text-callback', definiert in scm/output-lib.scm als
(define-public (print-circled-text-callback grob)
  (grob-interpret-markup grob (make-circle-markup
                               (ly:grob-property grob 'text))))
De facto wird hier nur das Resultat des 'text-property eingekreist.

Der default für 'text ist `string-number::calc-text', auch definiert in scm/output-lib.scm als
(define-public (string-number::calc-text grob)
  (let ((event (event-cause grob)))
    (or (ly:event-property event 'text #f)
        (number-format
         (ly:grob-property grob 'number-type)
         (ly:event-property event 'string-number)))))
Diese procedure übernimmt eine mögliche user-Setzung für 'text (mittels \tweak oder \override) oder verwendet `number-format' zur Formatierung.

`number-format' ist definiert in scm/lily-library.scm als:
(define-public (number-format number-type num . custom-format)
  "Print @var{num} according to the requested @var{number-type}.
Choices include @code{arabic}, @code{custom}, @code{roman-ij-lower},
@code{roman-ij-upper}, @code{roman-lower} (the default), and
@code{roman-upper}.

For @code{custom}, @var{custom-format} must be present; it gets
applied to @var{num}."
  (case number-type
    ((roman-lower)
     (ice9-format #f "~(~@r~)" num))
    ((roman-upper)
     (ice9-format #f "~@r" num))
    ((arabic)
     (ice9-format #f "~d" num))
    ((custom)
     (ice9-format #f (car custom-format) num))
    ((roman-ij-lower)
     (let* ((text (ice9-format #f "~(~@r~)" num))
            (text (string-regexp-substitute "i$" "j" text))
            (text (string-regexp-substitute
                   "ij$" (ly:wide-char->utf-8 #x0133) text))) ; ij ligature
       text))
    ((roman-ij-upper)
     (let* ((text (ice9-format #f "~@r" num))
            (text (string-regexp-substitute "I$" "J" text))
            (text (string-regexp-substitute
                   "IJ$" (ly:wide-char->utf-8 #x0132) text))) ; IJ ligature
       text))
    (else (ice9-format #f "~(~@r~)" num))))
Ohne in details einsteigen zu müssen sollte man erkennen können, daß hier je nach `number-type' unterschiedlich formatiert wird.
Möglich sind 'roman-lower, 'roman-upper, 'arabic, 'custom und noch andere. Bis auf 'custom geben alle arabisch oder römische Zahlen/Ziffern aus. Laut doc-string braucht es für die 'custom-Setzung zusätzlich eine 'custom-format-Setzung.

Mein Coding basiert auf dem Grundsatz den input, z.B.
{
  e'4\1 b\2 g\3 d\4 a,\5 e,\6
}
unangetastet zu lassen und nur die Formatierung der StringNumber zu ändern.
Zu diesem Zweck habe ich `string-number::calc-text' um eine Formatierungsoption erweitert, falls 'custom als 'number-type gesetzt ist. Diese Formatierungsoption holt sich den aktuell benötigten Text aus der alist `guitarTuning' und benötigt `ice9-format' (nicht standard, deshalb das (use-modules ...).
Ansonsten hat mir die Schriftart nicht gefallen, deshalb der override für 'before-line-breaking, der nur für 'custom zum tragen kommt.
Die stencil-procedure ist unangetastet, da wir nach wie vor einkreisen wollen.
Das wars eigentlich.

Falls Dir jedoch egal ist, daß der input anders wird könntest Du auch folgendes machen:
\version "2.23.9"

"e'" = \tweak font-name "Arial" \tweak text "e'" \1
"b" = \tweak font-name "Arial" \tweak text "b" \2
"g" = \tweak font-name "Arial" \tweak text "g" \3
"d" = \tweak font-name "Arial" \tweak text "d" \4
"A" = \tweak font-name "Arial" \tweak text "A" \5
"E" = \tweak font-name "Arial" \tweak text "E" \6

{
  \clef "G_8"
  e'\"e'" b\"b" g\"g" d\"d" a,\"A" e,\"E"
}
Hat zumindest den Charme leichter verständlich zu sein.

Gruß,
  Harm

harm6

ZitatKann man diese auch noch mit Ihrer Methode kombinieren? Mich stört der aus meiner (naiven?) Sicht recht hohe Schreibaufwand, wenn ich viele Linien unter die Noten setzen will.
Wie ich schon sagte ist `stringNumberSpanner' ein modifizierter TextSpanner, als solcher nicht direkt mit der eigentlichen StringNumber kombinierbar. Indirekt mag es gehen, wird aber mit Sicherheit zu einem ausgedehnten scheme-coding führen und ich fürchte das Ergebnis wird trotzdem armselig bleiben. Bitte habe Verständnis, daß ich das gar nicht erst versuche...

Darüberhinaus gibt es das generelle Problem, daß nur ein TextSpanner per Voice akzeptiert wird. Ich erwarte, daß Du bald auf diese Limitierung stoßen wirst...

Nichtsdestotrotz kann man folgendes machen:
\version "2.22.2"

\language "deutsch"

stringNumberSpanner =
#(define-music-function (StringNumber) (string?)
  #{
  \override TextSpanner.style = #'solid
  \override TextSpanner.font-size = #-2
  \override TextSpanner.bound-details.left.stencil-align-dir-y = #CENTER
  \override TextSpanner.bound-details.left.stencil-offset = #'(0 . -0.5)
  \override TextSpanner.bound-details.left.text =
  \markup { \circle  $StringNumber }
  \override TextSpanner.direction = -1
  #})

P = \rightHandFinger #1
I = \rightHandFinger #2
M = \rightHandFinger #3
A = \rightHandFinger #4


Esp = \single \stringNumberSpanner "E" \startTextSpan
Asp = \single \stringNumberSpanner "A" \startTextSpan
dsp = \single \stringNumberSpanner "d" \startTextSpan
gsp = \single \stringNumberSpanner "g" \startTextSpan
bsp = \single \stringNumberSpanner "b" \startTextSpan
esp = \single \stringNumberSpanner "e" \startTextSpan

\relative c {
  \clef "treble_8"
  \set strokeFingerOrientations = #'(up)

  | a4\Asp\I a8\M a\I a4\M a8\I a\M |
  | a\I a\M a\I a\M a2\stopTextSpan\I |

  | d4\dsp\M d8\I d\M d4\I d8\M d\I |
  | d\M d\I d\M d\I d2\stopTextSpan\M |

  | g4\gsp\I g8\M g\I g4\M g8\I g\M |
  | g\I g\M g\I g\M g2\stopTextSpan\I |

  | h4\bsp\M h8\I h\M h4\I h8\M h\I |
  | h\M h\I h\M h\I h2\stopTextSpan\M |

  | e4\esp\I e8\M e\I e4\M e8\I e\M |
  | e\I e\M e\I e\M e2\stopTextSpan\I |
  \bar "|."
}

Gruß,
  Harm

P.S. Dein exzessiver Gebrauch von BarCheck, i.e. "|", ist befremdlich, das Ding hat ja eine Funktion und ist kein optisches Hilfsmittel für die Ubersichtlichkeit Deines ly-files (habs aber nicht verändert)

soloquintett

Das war sehr Hilfreich! Danke!
Ich freue mich darauf tiefer in die Materie einzusteigen. Dieser Überblick hilft dabei ungemein.

ZitatDarüberhinaus gibt es das generelle Problem, daß nur ein TextSpanner per Voice akzeptiert wird. Ich erwarte, daß Du bald auf diese Limitierung stoßen wirst...
An die bin ich bereits gestoßen. Ich fand allerdings einen alten Beitrag aus diesem Forum, in dem eine Möglichkeit aufgezeigt wird mehrere zu benutzen. Natürlich ist es recht aufwendig. Ich kann den link gerade nicht finden.. Es folgt das Beispiel, welches ich im Archiv fand.

%% Example for creating multiple custom text spanners
%% Based on:
% http://lilypond.org/doc/v2.18/input/regression/collated-files.html
% look for:
% 'scheme-text-spanner.ly'

\version "2.19.52"

#(define (add-grob-definition grob-name grob-entry)
   (let* ((meta-entry   (assoc-get 'meta grob-entry))
          (class        (assoc-get 'class meta-entry))
          (ifaces-entry (assoc-get 'interfaces meta-entry)))
     (set-object-property! grob-name 'translation-type? ly:grob-properties?)
     (set-object-property! grob-name 'is-grob? #t)
     (set! ifaces-entry (append (case class
                                  ((Item) '(item-interface))
                                  ((Spanner) '(spanner-interface))
                                  ((Paper_column) '((item-interface
                                                     paper-column-interface)))
                                  ((System) '((system-interface
                                               spanner-interface)))
                                  (else '(unknown-interface)))
                                ifaces-entry))
     (set! ifaces-entry (uniq-list (sort ifaces-entry symbol<?)))
     (set! ifaces-entry (cons 'grob-interface ifaces-entry))
     (set! meta-entry (assoc-set! meta-entry 'name grob-name))
     (set! meta-entry (assoc-set! meta-entry 'interfaces
                                  ifaces-entry))
     (set! grob-entry (assoc-set! grob-entry 'meta meta-entry))
     (set! all-grob-descriptions
           (cons (cons grob-name grob-entry)
                 all-grob-descriptions))))
                 
#(define (add-bound-item spanner item)
   (if (null? (ly:spanner-bound spanner LEFT))
       (ly:spanner-set-bound! spanner LEFT item)
       (ly:spanner-set-bound! spanner RIGHT item)))

#(define (axis-offset-symbol axis)
   (if (eqv? axis X) 'X-offset 'Y-offset))

#(define (set-axis! grob axis)
  (if (not (number? (ly:grob-property grob 'side-axis)))
      (begin
        (set! (ly:grob-property grob 'side-axis) axis)
        (ly:grob-chain-callback
         grob
         (if (eqv? axis X)
             ly:side-position-interface::x-aligned-side
             side-position-interface::y-aligned-side)
         (axis-offset-symbol axis)))))
   
#(define (scheme-event-spanner-types-proc class-lst type-lst)
  (map
    (lambda (x y)
      (cons
        x
        (list
          '(description
            .
            "Used to signal where scheme text spanner brackets start and stop.")
           (cons 'types
                 (list 'post-event
                       y
                       'span-event
                       'event)))))
    class-lst
    type-lst))
   
#(define scheme-event-spanner-type
  (lambda (x)
    (set-object-property! (car x)
                          'music-description
                          (cdr (assq 'description (cdr x))))
    (let ((lst (cdr x)))
      (set! lst (assoc-set! lst 'name (car x)))
      (set! lst (assq-remove! lst 'description))
      (hashq-set! music-name-to-property-table (car x) lst)
      (cons (car x) lst))))
   
#(define spanner-props
  `(
    (bound-details . ((left . ((Y . 0)
                               (padding . 0.25)
                               (attach-dir . ,LEFT)
                               ))
                      (left-broken . ((end-on-note . #t)))
                      (right . ((Y . 0)
                                (padding . 0.25)
                                ))
                      ))
    (dash-fraction . 0.2)
    (dash-period . 3.0)
    (direction . ,UP)
    (font-shape . italic)
    (left-bound-info . ,ly:line-spanner::calc-left-bound-info)
    (outside-staff-priority . 350)
    (right-bound-info . ,ly:line-spanner::calc-right-bound-info)
    (staff-padding . 0.8)
    (stencil . ,ly:line-spanner::print)
    (style . dashed-line)
 
    (meta . ((class . Spanner)
             (interfaces . (font-interface
                            line-interface
                            line-spanner-interface
                            outside-staff-interface
                            side-position-interface))))))

#(define define-engraver
  (lambda (engr-name g-name event-types)
    (module-define! (current-module) engr-name
      (lambda (context)
        (let ((span '())
              (finished '())
              (event-start '())
              (event-stop '()))
          `((listeners
              (,event-types
                .
                ,(lambda (engraver event)
                  (if (= START (ly:event-property event 'span-direction))
                      (set! event-start event)
                      (set! event-stop event)))))
            (acknowledgers
              (note-column-interface
              .
              ,(lambda (engraver grob source-engraver)
                (if (ly:spanner? span)
                    (begin
                      (ly:pointer-group-interface::add-grob
                        span 'note-columns grob)
                      (add-bound-item span grob)))
                (if (ly:spanner? finished)
                    (begin
                      (ly:pointer-group-interface::add-grob
                        finished 'note-columns grob)
                      (add-bound-item finished grob))))))
            (process-music
              .
              ,(lambda (trans)
                 (if (ly:stream-event? event-stop)
                     (if (null? span)
                         (ly:warning "You're trying to end a scheme text spanner
but you haven't started one.")
                         (begin
                           (set! finished span)
                           (ly:engraver-announce-end-grob
                             trans finished event-start)
                           (set! span '())
                           (set! event-stop '()))))
                 (if (ly:stream-event? event-start)
                     (begin
                       (set! span
                             (ly:engraver-make-grob trans g-name event-start))
                       (set-axis! span Y)
                       (set! event-start '())))))
            (stop-translation-timestep
              .
              ,(lambda (trans)
                 (if (and (ly:spanner? span)
                          (null? (ly:spanner-bound span LEFT)))
                     (ly:spanner-set-bound! span LEFT
                       (ly:context-property context 'currentMusicalColumn)))
                 (if (ly:spanner? finished)
                     (begin
                       (if (null? (ly:spanner-bound finished RIGHT))
                           (ly:spanner-set-bound! finished RIGHT
                             (ly:context-property
                               context
                               'currentMusicalColumn)))
                       (set! finished '())
                       (set! event-start '())
                       (set! event-stop '())))))
            (finalize
              .
              ,(lambda (trans)
                 (if (ly:spanner? finished)
                     (begin
                       (if (null? (ly:spanner-bound finished RIGHT))
                           (ly:spanner-set-bound! finished RIGHT
                             (ly:context-property
                               context
                               'currentMusicalColumn)))
                       (set! finished '())))
                 (if (ly:spanner? span)
                     (begin
                       (ly:warning
                         "I think there's a dangling scheme text spanner :-)")
                       (ly:grob-suicide! span)
               (set! span '())))))))))))

createSpannersAndEngravers =
#(define-void-function (name-list)(list?)
 (let* ((naming-lst
          (map
            (lambda (name)
              (list
                (string->symbol (format #f "~aTextSpanEvent" name))
                (ly:camel-case->lisp-identifier
                  (string->symbol (format #f "~aTextSpanEvent" name)))
                (string->symbol (format #f "~aTextSpanner" name))
                (string->symbol (format #f "~aTextSpannerEngraver" name))
                (string->symbol (string-downcase (format #f "~a-start" name)))
                (string->symbol (string-downcase (format #f "~a-stop" name)))))
            name-list))
        (new-scheme-event-spanner-types
           (scheme-event-spanner-types-proc
             (map car naming-lst)
             (map second naming-lst)))
        (scheme-event-spanner-types
          (map
            scheme-event-spanner-type
            new-scheme-event-spanner-types)))

    (set! music-descriptions
          (append scheme-event-spanner-types music-descriptions))
   
    (set! music-descriptions
          (sort music-descriptions alist<?))

    (for-each
      (lambda (evt
               text-span-event-name
               g-name
               engr-name
               cmd-start
               cmd-stop)
        (define-event-class text-span-event-name 'span-event)
        (add-grob-definition g-name spanner-props)
        (define-engraver engr-name g-name text-span-event-name)
        (module-define! (current-module) cmd-start
          (make-span-event evt START))
        (module-define! (current-module) cmd-stop
          (make-span-event evt STOP)))
      (map car naming-lst)
      (map second naming-lst)
      (map third naming-lst)
      (map fourth naming-lst)
      (map fifth naming-lst)
      (map sixth naming-lst))

    (newline)
    (pretty-print
      (cons
        "The following events (class and type), grobs, engravers and
start/stop-commands are created"
        naming-lst))))
     
%%%%%%%%%%%%%%%%%%%%%%%
%% Example
%%%%%%%%%%%%%%%%%%%%%%%
%{
       
%% rename path to your file, which holds the engraver code
% \include "multiple-spanner-grobs-engravers.ly"

\createSpannersAndEngravers  #'(Hallo Welt A)

\layout {
  \context {
    \Global
    \grobdescriptions #all-grob-descriptions
  }
  \context {
    \Voice
    \consists \HalloTextSpannerEngraver
    \consists \WeltTextSpannerEngraver
    \consists \ATextSpannerEngraver
  }
}

\relative {
  \override HalloTextSpanner.to-barline = ##f
 
  \override HalloTextSpanner.bound-details.left.text = #"hall"
  \override HalloTextSpanner.bound-details.right.text = #"lo"
  \override WeltTextSpanner.bound-details.left.text = #"we"
  \override WeltTextSpanner.bound-details.right.text = #"lt"
  \override ATextSpanner.bound-details.left.text = #"A"
  \override ATextSpanner.bound-details.right.text = #"A"
 
  a4 b\hallo-start c\welt-start d
  a4 b c d
  a4 \a-start b c\hallo-stop d \welt-stop \break
 
  a4\hallo-start \welt-start b d \a-stop c
  a4 b\hallo-stop c d  \welt-stop
  a1

}
%}


Ich stelle mir für die Zukunft vor, eine (vermutlich umfangreiche) externe custom.ly anzulegen, in der ich u.a. eigene Spanner für jede Saite anlege und deine Lösung anwende um einzelne Saiten zu beschriften.

Schließlich binde ich dann in jedes meiner Stücke diese custom.ly ein und habe Zugriff auf alle meine besonderen Modifikationen. Ist das eine "good practice"?

ZitatDein exzessiver Gebrauch von BarCheck, i.e. "|", ist befremdlich, das Ding hat ja eine Funktion und ist kein optisches Hilfsmittel für die Ubersichtlichkeit Deines ly-files
Darüber dachte ich bereits nach. Ich weiß noch nicht, wie ich die Noten optisch formatieren soll um Übersichtlichkeit zu schaffen und dachte in der Tat die Funktion von BarChecks sei die Übersichtlichkeit zu verbessern. Danke für den Hinweis, ich werde mir mehr Beispiele anschaun müssen, um eine schöne Formatierung zu lernen.

harm6

ZitatIch kann den link gerade nicht finden.
Sollte https://archiv.lilypondforum.de/index.php/topic,2503.msg14199.html#msg14199
sein.

Noch besser und weniger invasiv ist https://lilypondforum.de/index.php/topic,675.msg3847.html#msg3847, der Code ist von David Nalesnik, ich hatte nur ein update gemacht.

ZitatIch stelle mir für die Zukunft vor, eine (vermutlich umfangreiche) externe custom.ly anzulegen, in der ich u.a. eigene Spanner für jede Saite anlege und deine Lösung anwende um einzelne Saiten zu beschriften.

Schließlich binde ich dann in jedes meiner Stücke diese custom.ly ein und habe Zugriff auf alle meine besonderen Modifikationen. Ist das eine "good practice"?

Kann man so machen, vorausgesetzt Du baust keine einander widersprechenden Befehle oder "cyclic dependencies" ein.
Es wird natürlich dann problematisch wenn Du etwas anderes als in custom.ly vordefiniert haben willst.
Deshalb binde ich solche include-files (Plural!) immer nur für das jeweilige Projekt ein.

Gruß,
  Harm

trulli

@ Malte
Kannst du bitte diesen Thread in die Gitarrenecke verschieben?

LG trulli

Hilflos-im-Code

Zitat von: harm6 am Freitag, 10. Juni 2022, 10:43Zahlen als Saitenbezeichnung ist sicherlich standard. Es gibt aber auch Gegenbeispiele:

Ja, die sind mir dann auch eingefallen.