Moments musicaux 3

Zur Navigation springen Zur Suche springen

Notensatz nach Henle

RH= \relative c' {
  \key as \major
  \tempo "Allegro moderato"
  R2
  R2
  \repeat volta 2 {
    \grace { b'16 } as8-. as16 ( b ) as8-. g-.
    \appoggiatura { as16 b } <as c>4->
    \appoggiatura { as16 b }  <as c>4->
    \grace b16 as8-. as16 ( b ) as8-. <g c>-.
    \grace c16 <as f'>4-> \grace c16 <as f'>4->
    \voiceOne
    \grace ges'16  f8 f16 ( ges! f8 ) f
    f8 ( b16 )
    \oneVoice
    r16 <as,! f'>4
    <as c>16 ( <g b> <f as> <g b> )
    \voiceOne
    c16 (des) c (e)
    \oneVoice
    <as, c f>4 <as c f>4
  }
  \repeat volta 2 {
    c-> c->
    c16 des es des des8. c16
    \grace c16 b8 b c16 ( b as b ) b4 ( c )
    \grace es16 <c as'>4-> \grace es8 <c as'>4->
    <es g>16 <des f> <c e> <des f> <des f>4
    \voiceOne
    f16 (es! <des es>4) <des es>8
    \oneVoice
    <as c es>4 <as c es>4
  }
  \repeat volta 2 {
    <g b c e>-> <g b c e>->
    \voiceOne
    \grace f'16 as8 as16 g f8 es16 des
    <g, b c>4-> <g b c e>->
    \grace f'16 as8 as16 g f8 es!16 des
    \oneVoice
    <as c>4 <ges c>
    \voiceOne
    c16 des es des <f, des'>8 <es c'>16 ( <des b'> )
    <c as'>8 <c as'> <c as'>16 ( <des b'> <es c'> <des b'> )
    <c as'>4 <c as'>
  }
  \oneVoice \pageBreak
  \once \stemUp
  \grace b'16 as8 as16 ( b ) as8-. g-.
  \set tieWaitForNote = ##t
  \appoggiatura { as16 b }
  <as c>4 \appoggiatura { as16 b }
  <as c>4
  \grace b16 as8 as16 ( b ) as8-. <g c>-.
  \grace c8 <as f'>4->
  \grace c8 <as f'>4->
  \voiceOne
  \grace ges'16 f8 f16 ( ges f8 ) f
  f8 ( b16 )
  r16 f4
  <as, c>16 ( <g b> <f as> <g b> )
  \voiceOne
  c16 (des) c (e)
  \oneVoice
  <as, c f>4 <as c f>4
  \voiceOne
  \grace as'16 g8 g16( as g8 ) g ( b!8 ) as4 ( g16 f )
  \grace des16 c8
  c16 ( des c8 e )
  \oneVoice
  <as, c f>4 <as c f>4
  \voiceOne
  \grace as'16 g8 g16 ( as g8 ) g ( b!8 ) as4 ( g16 f )
  \grace d16 c8
  c16 ( d c8 d )
  \grace d16 c8 c16 ( d c8 d )
  \grace d16 c8 c16 ( d c8 e )
  \oneVoice
  <a, f'>4 <a f'>
  \voiceOne
  \grace d16 c8 c16 ( d c8 a )
  <e b'>4 <e b'>
  \voiceOne
  \grace c'16 b8 b16 ( c b8 e, )
  \oneVoice
  <a, f'>4 <a f'>
  \voiceOne
  \grace d'16 c8 c16 ( d c8 a )
  <e b'>4 <e b'>
  \grace c'16 b8 b16 ( c b8 e, )
  \oneVoice
  <a, f'>4 <a f'> <a f'> <a f'> <a f'>2\fermata \bar "|."
}

alt = \relative c'' {
  s2 * 6 \voiceTwo
  as8  as a a
  b8. s16 s4
  s4 as8 < b g >
  s2 * 7
  < d g, >8 g,16( as b8 as16 g
  \once \hideNotes as4)
  s4 s2
  < as c >8 q4.
  s2
  q8 q4.
  s2 f4 s
  s2 * 6
  as8 as a a
  b8. s16 as!4
  s4 as8 < b g >
  s2
  e8 e4 e8
  f4. r8
  as,8 as4 < c b g >8
  s2
  e8 e4 e8
  f4. r8
  a,8 a4 b8
  a8 a4 b8
  a8 a4 b8 s2
  a8 a4 f8 s2
  e8 e4 b8 s2
  a'8 a4 es!8 s2
  e8 e4 b8
}

LH = \relative c {
  \clef bass
  \key as \major
  f8  <c' f> f, q
  f q f q
  f q f <c' e>
  f, <c' f> f, q
  f q f <c' e>
  f, <c' f> f, q
  des <des' f> c, <c' es f>
  b, <b' des f> f <c' f>
  c, <c' f> c, <c' e>
  f, <c' f> f, <c' f>
  \clef treble
  as <c es as> as q
  as <b es g> as q
  as <des es g> as q
  as <c es as> as q
  as <c es as> as q
  \clef bass
  des, <des' f> des, q
  es <b' des es> es, q
  as <c es> as q
  \clef bass
  c, <c' e> c, q
  c <c' f> c, q
  c <c' e> c, q
  c <c' f> f, q
  as, <as' c> a, <ges' c>
  b, <f' b> des, <des' f> es, <es' as> es, <es' g>
  as, <es' as> as, q
  f'8 <c' f> f, <c' e>
  f, <
  c' f> f, q
  f q f <c' e>
  f, <c' f> f, q
  des <des' f> c, <c' es f>
  b, <b' des f> f <as c f> c, <c' f> c, <c' e>
  f, <c' f> f, q
  b, <b' des> b, q
  h <h' d> h, q
  c <c' f> c, <c' e> f, <c' f> f, q
  b, <b' des> b, <b' des>
  h, <h' d> h, q
  \repeat unfold 2 { c <c' f> c, <c' e> }
  c, <c' f> c, <c' g'>
  f,, <c' f> f, q
  f q f q
  f <c' g'> f, q
  f <c' g'> f, q
  f <c' f> f, q
  f <c' f> f, <c' fis>
  f, <c' g'> f, <c' g'>
  f, q f <des' g>
  f, <c' f> f, q
  f q f q
  <f c' f>2\fermata
}

Struktur =
{
  \time 2/4
  \override Score.NonMusicalPaperColumn.page-break-permission = ##f
  \override Score.SpacingSpanner.common-shortest-duration = #(ly:make-moment 1/8)
  s2 * 26
  \newSpacingSection
  \override Score.SpacingSpanner.common-shortest-duration = #(ly:make-moment 1/14)
}

myTitel = "Moments Musicaux №3"
mycomp=\markup \line { #schubert "♫" \hspace #-1 "♫" \hspace #-1 "♫"  \hspace #-1 "♪" }

Dyn= {
  s2\p
  s2 * 17 s2\f
  s2 s s
  s4\p s\< s8\> s8\! s4
  s2 s
  s\pp s2 s s
  \override Hairpin.to-barline = ##f
  s4 s8 s\< s8.\! s16 s4
  s2 s
  \override Hairpin.to-barline = ##t
  s8 s4.\< s8\> s8\! s4
  s2 s
  s\ppp\< s4\> s\!
  s8 s4\dynamictext "dimin." s8
  s2 s s
  s\dynamictext "dimin."
}

\bookpart {
  \paper {
    top-margin = 20\mm
    ragged-bottom = ##f
    ragged-last-bottom = ##f
    bottom-margin = 20\mm
    line-width = 170\mm
    annotate-spacing = ##f
    markup-system-spacing.padding = #4
    system-system-spacing.padding = #0
  }

  \score
  {
    \header {
      title = \myTitel
      subsubtitle = ##f
      poet = ##f
      composer = #schubert
      opus = "Op.94, №3 D780"
      typesetter ="lilypond.miraheze.org"
    }
    \new PianoStaff="leadsheet"
    <<
      \new Staff="Discant"
      <<
        \new Voice \RH
        \new Voice \alt
      >>
      \new Dynamics \Dyn
      \new Staff="Bass"
      <<
        \new Voice \LH
        \context Voice {
         % \repeat unfold 212 s8-.
        }
        \new NullVoice \Struktur
      >>
    >>
  }
}

#(set-global-staff-size 22)
#(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)))))))

#(define germanChords (chord-name->german-markup-text-alteration #t))

make-midi-list =
#(define-void-function (name score tempolist)
   ((string? #f) ly:score? list?)
   (for-each
    (lambda (tempo)
      (ly:book-process
       (apply
        ly:make-book
        $defaultpaper
        $defaultheader
        (list score))
       $defaultpaper
       #{
         \midi {
           \tempo 4 = $tempo
         }
       #}
       (format #f "~a_~a"
         (or name "midi")
         tempo)))
    tempolist))

editorsColor = #grey
ed =
#(define-music-function (grob col mus)
   (symbol-list-or-symbol? (color? editorsColor) ly:music?)
   ;; for abbreviations, we need a symbol instead of a one-element list
   (let ((grob (if (= 1 (length grob)) (car grob) grob)))
     (case
      grob
      ;; define abbreviations
      ;; which call the function recursively with a value
      ;; leading into the (else) clause
      ;; (or to _another_ abbreviation)
      ;; be careful to avoid infinite recursion :-)
      ;; – abbreviation names must not be actual grob names
      ;; (at least if they’re used in the corresponding
      ;; clause) or recursion will be infinite also
      ;; It is recommended to use singular forms only
      ;; for abbreviations.
      ((Caut) #{ \ed Staff.AccidentalCautionary #})
      ((LedgerLine) #{ % barline is workaround to issue 3949
        \stopStaff
        \ed Staff.LedgerLineSpanner {
          \startStaff
          $mus
          \stopStaff
        }
        \startStaff #})
      ((Mmr) #{ \ed MultiMeasureRest $mus #})
      ((Note) #{ \ed Staff.Accidental
                 \ed Beam
                 \ed Dots
                 \ed Flag
                 \ed LedgerLine
                 \ed NoteHead
                 \ed Rest
                 \ed Stem $mus #})
      ((Pitch) #{ \ed NoteHead $mus #})
      ((Suggest) #{ \ed Staff.AccidentalSuggestion #})
      ((StemWithFlag) #{ \ed Stem \ed Flag $mus #})
      ((Tuplet) #{ \ed TupletNumber \ed TupletBracket $mus #})
      ;; ‘normal’ case
      (else
       #{
         \override $grob . color = #col
         $mus
         \revert $grob . color
       #}))))

#(define new-stil
   (lambda (grob)
     (let* ((sz (ly:grob-property grob 'font-size 0.0))
            (mult (magstep sz))
            (dir (ly:grob-property grob 'direction))
            (thick 0.15)
            (radius 0.7)
            (scaled-radius (* mult radius))
            (ps-command-string
             (format #f
               "
             0 ~a translate
             ~a setlinewidth
             ~a 0 moveto
             0 0 ~a 180 0 ~a
             stroke
             "
               ;mult
               (* thick dir)
               thick
               (- scaled-radius)
               scaled-radius
               (if (negative? dir) "arcn" "arc"))))

       (ly:make-stencil
        (list 'embedded-ps
          (format #f
            "
              gsave currentpoint translate
              ~a
              grestore
              "
            ps-command-string))
        (cons (- scaled-radius) scaled-radius)
        (cons
         (if (negative? dir) 0 (- scaled-radius))
         (if (negative? dir) scaled-radius 0))))))

soft =
-\tweak stencil #new-stil \fermata

#(define-markup-command (text-fromproperty layout props text-1 symbol text-2)
   (markup? symbol? markup?)
   #:category other
   (let ((m (chain-assoc-get symbol props)))
     (if (markup? m)
         ;; prevent infinite loops by clearing the interpreted property:
         (interpret-markup
          layout
          (cons (list (cons symbol `(,property-recursive-markup ,symbol))) props)
          (make-concat-markup (list text-1 m text-2)))
         empty-stencil)))



klavier =
%% simple orgelsatz nur SATBs
#(define-music-function (sop alt ten bas stru)
   (ly:music? ly:music? ly:music? ly:music? ly:music?)
   #{
     <<
       \new PianoStaff="leadsheet"
       <<
         \new Staff="Discant"
         <<
           \new Voice="Alt" { $sop }
           \new Voice { $alt }
         >>
         \new Staff="Bass"
         <<
           \new Voice { $ten }
           \new Voice { $bas }
           \new NullVoice $stru
         >>
       >>
     >>
   #}
   )

mynote =
#(define-music-function (m)
   (ly:duration?)
   #{
     \override Score.RehearsalMark.break-align-symbols = #'(time-signature)
     \once \override Score.RehearsalMark.self-alignment-X = #-1
     \mark \markup \fontsize #-3.5 \note { $m } #UP
   #}
   )


oob = { \once \override Score.BarNumber.stencil = ##f \bar "" }
bnf = \once \override Score.BarNumber.stencil = ##f
#(use-modules (ice-9 regex))

dynamictext =
#(define-event-function (text) (markup?)
   (if (string? text)
       (let* ((underscores-replaced
               (string-map
                (lambda (x) (if (eq? x #\_) #\space x))
                text))
              (split-text (string-split underscores-replaced #\space))
              (formatted (map
                          (lambda (word)
                            (if (string-match "^[mrzfps]*$" word)
                                (markup #:dynamic word)
                                (markup #:normal-text #:italic word)))
                          split-text)))
         #{
           #(make-dynamic-script (make-line-markup formatted))
         #})
       ;; user provided a full-blown markup, so we don't mess with it:
       #{
         #(make-dynamic-script (markup #:normal-text text))
       #}))

startMyGrace = {
  \temporary \override Slur.minimum-length = #0.1
  \startSlashedGraceMusic
  <>-#(make-music 'LaissezVibrerEvent)
  \revert Slur.minimum-length
}

myAcc =
#(def-grace-function startMyGrace stopSlashedGraceMusic)

dropLyrics =
#(define-scheme-function (amount) (number?)
   #{
     \override LyricText.extra-offset = #`(0 . ,amount)
     \override LyricHyphen.extra-offset = #`(0 . ,amount)
     \override LyricExtender.extra-offset = #`(0 . ,amount)
     \override StanzaNumber.extra-offset = #`(0 . ,amount)
   #}
   )

raiseLyrics = {
  \revert LyricText.extra-offset
  \revert LyricHyphen.extra-offset
  \revert LyricExtender.extra-offset
  \revert StanzaNumber.extra-offset
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% Liedverse Formatierung
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

#(define-markup-list-command (paragraph layout props args) (markup-list?)
   #:properties ((x-shift 2))
   (interpret-markup-list layout props
     (make-justified-lines-markup-list (cons (make-hspace-markup x-shift) args))))

#(define (numbering-start lst strt)
   "Returns a list of custom formated markups for numbers, relying on the length
of @var{lst}, starting with number 2"
   (if (eq? strt 0)
       (map
        (lambda (i)
          #{ \markup \concat \paragraph { " " } #})
        (iota (length lst)))
       (map
        (lambda (i)
          #{ \markup \concat \paragraph { \bold #(format #f "~2d. " i) } #})
        (iota (length lst) strt 1))))

#(define (equal-sized-splited-list lst n rl)
   "Split @var{lst} in equal sized parts of length @var{n}.
If @var{lst} is finally not empty add the remaining rest."
   (cond ((null? lst) (reverse rl))
     ((< (length lst) n) (reverse (cons lst rl)))
     (else
      (equal-sized-splited-list (drop lst n) n (cons (take lst n) rl)))))

columns-markup-list =
#(define-scheme-function (lines-per-verse ls)(index? markup-list?)
   "Returns a markup-list.  Each markup is done from a subset of @var{ls} under
control of @var{lines-per-verse}.  The markups are custom-formated using
@code{\\column-lines}, @code{\\column} and a hard-coded @code{baseline-skip} of
value 3"
   (let ((splitted-ls (equal-sized-splited-list ls lines-per-verse '())))
     (map
      (lambda (l)
        #{ \markup \override #'(baseline-skip . 3)
           %\override #`(font-name . ,myMin)
           \override \largerFont
           \column \column-lines $l #})
      splitted-ls) ))

formatAdditionalVerses =
#(define-scheme-function (center-overshoot number-start columns lst)
   ((boolean? #t) index? index? markup-list?)
   (let* ((numberings (numbering-start lst number-start))
          (new-list
           (map
            (lambda (x y)
              #{
                \markup
                \override #'(baseline-skip . 3)
                \line {
                  \paragraph {
                    \overlay {
                      \right-align \transparent "222"
                      \right-align \number $x
                    }
                  }
                  $y
                }
              #})
            numberings
            lst))
          (lst-lngth (length lst))
          (table-lst
           (if (and (odd? lst-lngth)
                    (= (remainder lst-lngth columns) 1)
                    center-overshoot)
               (drop-right new-list 1)
               new-list))
          (odd-tail
           (if (and (odd? lst-lngth)
                    (= (remainder lst-lngth columns) 1)
                    center-overshoot)
               (take-right new-list 1)
               #f))
          (columns-format-list (make-list columns LEFT))
          (args-list
           #{ \markuplist {
             \override #'(font-size . -1)
             \table #columns-format-list #table-lst
           } #})
          (args-list-rev
           (append
            args-list
            (if odd-tail
                #{
                  \markuplist \override #'(font-size . -1)
                  %% hier nix ändern, das sind die Nummerierungen!!
                  \column-lines { \fill-line { \line { #odd-tail } } }
                #}
                '()))))
     args-list-rev))

#(define-markup-list-command (paragraph layout props args) (markup-list?)
   #:properties ((x-shift 2))
   (interpret-markup-list layout props
     (make-justified-lines-markup-list (cons (make-hspace-markup x-shift) args))))

#(define (reorder-lists lists)
   ;; TODO better name and DOC
   "Example:
   (reorder-lists '((a) (b c) (d e f)))
   ->'(a b d "" c e "" "" f)"
   (let* ((max-length (apply max 0 (map length lists)))
          (equal-length-lists
           (map
            (lambda (l)
              (let ((length-diff (- max-length (length l))))
                (if (zero? length-diff)
                    l
                    (append l (make-list length-diff "")))))
            lists)))

     (define (new-lists lists rl)
       ;; TODO better name and DOC
       "Example
       (new-lists '((a b c) (d e f) (g h i)) '())
       ->
       '((a d g) (b e h) (c f i))"
       (if (every null? lists)
           (reverse rl)
           (new-lists
            (map cdr lists)
            (cons (map car lists) rl))))

     (apply append '() (new-lists equal-length-lists '()))))

#(define (numbering-start lst strt)
   "Returns a list of custom formated markups for numbers, relying on the length
of @var{lst}, starting with number 2"
   (if (eq? strt 0)
       (map
        (lambda (i)
          #{ \markup \concat \paragraph { " " } #})
        (iota (length lst)))
       (map
        (lambda (i)
          #{ \markup \concat \paragraph { \bold #(format #f "~2d. " i) } #})
        (iota (length lst) strt 1))))

formatTwoColumns =
#(define-scheme-function (trenner r-col r-start l-col l-start)
   ((string? " ") markup-list? index? markup-list? index?)
   #{
     \markuplist {
       %\override #`(font-name . ,myMin)
       %s\override \largerFont
       %\override #'(baseline-skip . 3)
       %\override #'(padding . 0)
       \table
       #'(1 -1 1 1 -1)
       #(reorder-lists
         (list
          ;; numbering is done for each list, because we can't warrant equal
          ;; length of each list
          (numbering-start r-col r-start)
          r-col
          (make-list (length r-col) trenner)
          (numbering-start l-col l-start)
          l-col))
     }
   #}
   )

%% LSR 233 https://lsr.di.unimi.it/LSR/Item?id=233
hairpinWithCenteredText =
#(define-music-function (parser location text) (markup?)
  #{
    \once \override Voice.Hairpin.after-line-breaking = 
      #(lambda (grob)
        (let* ((stencil (ly:hairpin::print grob))
               (par-y (ly:grob-parent grob Y))
               (dir (ly:grob-property par-y 'direction))
               (staff-line-thickness
                 (ly:output-def-lookup (ly:grob-layout grob) 'line-thickness))
               (new-stencil (ly:stencil-aligned-to
                 (ly:stencil-combine-at-edge
                   (ly:stencil-aligned-to stencil X CENTER)
                   Y dir
                   (ly:stencil-aligned-to
                     (grob-interpret-markup
                       grob
                       (make-fontsize-markup
                         (magnification->font-size
                           (+ (ly:staff-symbol-staff-space grob)
                              (/ staff-line-thickness 2)))
                           text)) X CENTER))
                 X LEFT))
               (staff-space (ly:output-def-lookup
                 (ly:grob-layout grob) 'staff-space))
               (par-x (ly:grob-parent grob X))
               (dyn-text (grob::has-interface par-x 'dynamic-text-interface))
               (dyn-text-stencil-x-length
                 (if dyn-text
                   (interval-length 
                     (ly:stencil-extent (ly:grob-property par-x 'stencil) X))
                   0))
               (x-shift 
                 (if dyn-text 
                   (- 
                     (+ staff-space dyn-text-stencil-x-length)
                     (* 0.5 staff-line-thickness)) 0)))
  
        (ly:grob-set-property! grob 'Y-offset 0)
        (ly:grob-set-property! grob 'stencil 
           (ly:stencil-translate-axis
            new-stencil
            x-shift X))))
  #})
\layout {
  \context {
    \Voice
    beamExceptions = #'()
    \override BreathingSign.text =
    \markup { \musicglyph "scripts.lvarcomma" }
    \override Stem.neutral-direction = #down
    \override Script.outside-staff-priority = #'()
    \override Script.padding = #1
    \override Tie.thickness = #1
    \override PhrasingSlur.thickness = #3
    \override Rest.voiced-position = #0
    \override MultiMeasureRest.expand-limit = #3
  }
  \context {
    \Voice
    \name FirstVoice
    \alias Voice
    \voiceOne
  }
  \context {
    \Voice
    \name SecondVoice
    \alias Voice
    \remove "Tuplet_engraver"
    \remove "Rest_engraver"
    \remove "Multi_measure_rest_engraver"
    %\override NoteHead.font-size = #smallerNoteHead
    \voiceTwo
  }
  \context {
    \Lyrics
    \override VerticalAxisGroup.staff-affinity = #CENTER
    \override LyricText.font-size = #-1.5
    \override StanzaNumber.font-size = #-1.5
  }
  \context {
    \Staff
    printPartCombineTexts = ##f
    beamExceptions = #'()
    \override BreathingSign.text =
    \markup { \musicglyph "scripts.lvarcomma" }
    \override InstrumentName.font-features = #'("smcp")
    \consists #Span_stem_engraver
    \accepts FirstVoice
    \accepts SecondVoice
  }
  \context {
    \Score
    \override VerticalAxisGroup.remove-first = ##t
    skipBars = ##f
    \override MetronomeMark.font-size = #1
    \override MetronomeMark.font-shape = #'caps
    \override BarLine.thick-thickness = 5
    \override Timing.beamExceptions = #'()
    \override BarNumber.color = #(rgb-color 0.7 0.7 0.7)
    \override BarNumber.layer = #-200
    \override BarNumber.padding = #0.4
    \override BarNumber.outside-staff-priority =#'()
    \override BarNumber.after-line-breaking = ##f
    \override BarNumber.font-size = #-1
    \override BarNumber.font-series = #'bold
    \override BarNumber.self-alignment-X = #0
    \override BarNumber.break-visibility = #end-of-line-invisible
    \override SystemStartBar.collapse-height = #4

  }
  \context {
    \ChordNames
    chordNameLowercaseMinor = ##f
    \remove Staff_performer
    chordRootNamer = #germanChords
    \override ChordName.font-name = #"Orator10 BT"
    chordNoteNamer = #(chord-name->german-markup #f)
    \override ChordName.X-offset =
    #ly:self-alignment-interface::aligned-on-x-parent
    \override ChordName.self-alignment-X = #CENTER
    \override ChordName.font-name = #"Arial Narrow"
    \override ChordName.layer = #2
    \override ChordName.font-size = #-0.5
    noChordSymbol = ##f
  }
  \context {
    \PianoStaff
    \override StaffGrouper.staffgroup-staff-spacing.basic-distance = #2
    \override StaffGrouper.staffgroup-staff-spacing.minimum-distance = #0
  }
  \context {
    \StaffGroup
    \override SystemStartBracket.collapse-height = #4
    \override SystemStartBracket.thickness = #.2
  }
}