\language "deutsch"

\include "default_style.ily"
\include "default_songinfo_style.ily"
\include "footer_with_songinfo.ily"

\include #(if (defined? 'customStyleOverridesFile) customStyleOverridesFile "../void.ily")

#(set-default-paper-size songFormatAndSize)
#(set-global-staff-size globalSize)

\paper {
  property-defaults.fonts.serif = \songChordFont
  property-defaults.fonts.sans = \songLyricFont
  %annotate-spacing = ##t
  % spacing stuff
  two-sided = ##t
  inner-margin = 1.5\cm
  outer-margin = \songMargin
  binding-offset = 0\cm
  top-margin = \songMargin
  bottom-margin = \songMargin
  system-system-spacing = #'((basic-distance . 10) (padding . 1.5))
  markup-system-spacing = #'((basic-distance . 1))
  score-markup-spacing = #'((padding . 2))
  top-markup-spacing = #'((basic-distance . 0) (minimum-distance . 0) (padding . 0))
  refMarkupFormatter = #(lambda (layout props stanzanumbers)
    (interpret-markup layout props
    (if (null? stanzanumbers)
        refString
        (ly:format refStringWithNumbers (string-join (map (lambda (stanzanumber) (ly:format "~a" stanzanumber)) stanzanumbers) ", ")))))
  bridgeMarkupFormatter = #(lambda (layout props stanzanumbers)
    (interpret-markup layout props
    (if (null? stanzanumbers)
        bridgeString
        (ly:format bridgeStringWithNumbers (string-join (map (lambda (stanzanumber) (ly:format "~a" stanzanumber)) stanzanumbers) ", ")))))
}

generalLayout = \layout {
  indent = #0
  \context {
    \Lyrics
    \override LyricText.font-size = #lyricSize
    \override StanzaNumber.font-size = #lyricSize
    \override StanzaNumber.font-family = #'sans
    \override LyricText.font-family = #'sans
    \override LyricExtender.minimum-length = 0
  }
  \context {
    \Staff
    \accidentalStyle modern-voice-cautionary
    \consists \Better_Merge_rests_engraver
  }
  \context {
    \Score
    \remove "Bar_number_engraver"
    \remove "Metronome_mark_engraver"
    \RemoveEmptyStaves
    \override VerticalAxisGroup.remove-first = ##t
    \numericTimeSignature
    rehearsalMarkFormatter = #format-mark-box-alphabet
    \overrideTimeSignatureSettings
      4/4               % timeSignatureFraction
      1/4               % baseMomentFraction
      #'(1 1 1 1)       % beatStructure
      #'()		% beamExceptions
    \overrideTimeSignatureSettings
      3/4               % timeSignatureFraction
      1/4               % baseMomentFraction
      #'(1 1 1 1)       % beatStructure
      #'()		% beamExceptions
  }
  \context {
    \Voice
    % ich will lines breaken wie ich will!
    \remove "Forbid_line_break_engraver"
    \override NoteHead.layer = 2
    \override Rest.layer = 2
    \override Dots.layer = 2
    \override Stem.layer = 2
    \override Flag.layer = 2
    \override Beam.layer = 2
    \override Slur.layer = 2
    \override Tie.layer = 2
    \override Accidental.layer = 2
  }
}

#(define (customized-layout base-layout)
   (let
     ((custom-size (ly:output-def-lookup base-layout 'size #f)))
     (if custom-size (layout-set-staff-size custom-size))))

% Scores in Markups (z.B. inline-score) kopieren ihr \layout schon beim Parsen,
% also bevor customized-layout greift. Deshalb nachträglich anpassen.
#(define (customize-embedded-score-layouts! obj)
   (cond
     ((ly:score? obj)
      (for-each
        (lambda (def)
          (let ((custom-size (ly:output-def-lookup def 'size #f))
                (scope (ly:output-def-scope def)))
            (if custom-size
              (layout-set-absolute-staff-size-in-module scope (* custom-size (eval 'pt scope))))))
        (ly:score-output-defs obj)))
     ((pair? obj)
      (customize-embedded-score-layouts! (car obj))
      (customize-embedded-score-layouts! (cdr obj)))))

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%% kleine Helferlein:

textp = \lyricmode { \markup { \raise #1 \musicglyph #"rests.3" } }

% zweite Stimme alles grau
secondVoiceStyle = {
  \override NoteHead.color = #grey
  \override Rest.color = #grey
  \override Dots.color = #grey
  \override Stem.color = #grey
  \override Flag.color = #grey
  \override Beam.color = #grey
  \override Slur.color = #grey
  \override Tie.color = #grey
  \override Accidental.color = #grey
  \override NoteHead.layer = 1
  \override Rest.layer = 1
  \override Dots.layer = 1
  \override Stem.layer = 1
  \override Flag.layer = 1
  \override Beam.layer = 1
  \override Slur.layer = 1
  \override Tie.layer = 1
  \override Accidental.layer = 1
}

firstVoiceStyle = {
  \override NoteHead.color = #black
  \override Rest.color = #black
  \override Dots.color = #black
  \override Stem.color = #black
  \override Flag.color = #black
  \override Beam.color = #black
  \override Slur.color = #black
  \override Tie.color = #black
  \override Accidental.color = #black
}

% Deprecated: einzelne Noten innerhalb von \secondVoiceStyle mit schwarzem statt grauem Kopf
schwarzkopf =
  #(define-music-function (parser location noten) (ly:music?)
    (begin (ly:warning "\\schwarzkopf brauchts nicht mehr, das kann ersatzlos weg!") noten))

romanStanza =
  #(define-music-function (parser location) ()
  #{ \override StanzaNumber.style = #'roman #})

#(define (number-or-number-list? x) (or (number? x) (number-list? x)))

% "1,4" -> (1 4); Einträge, die keine Zahl sind, bleiben Strings ("1b,2b" -> ("1b" "2b"))
#(define (stanza-numbers-from-string str)
  (map (lambda (s) (or (string->number s) s))
       (remove string-null? (map string-trim-both (string-split str #\,)))))

% Kein number? hier, sonst kann der Parser 1,4 nicht mehr als Liste lesen
#(define (stanza-numbers? x) (or (number-list? x) (string? x)))

override-stanza =
#(define-music-function (stanzanumbers) (number-or-number-list?)
#{
  \once \override StanzaNumber.details.custom-stanzanumber-override = #(if (number? stanzanumbers) (list stanzanumbers) stanzanumbers)
#}
)

#(define (romanize-stanza-numbers numbers style)
  (if (eq? style 'roman)
      (map (lambda (n) (if (number? n) (format #f "~@r" n) n)) numbers)
      numbers))

#(define (format-stanza-numbers numbers style)
  (string-join
    (map (lambda (n) (format #f stanzaFormat n)) (romanize-stanza-numbers numbers style))
    ", "))

% Strophennummer, die erst beim Setzen aus den Eigenschaften des StanzaNumber-Grobs gebaut wird
% (details.custom-stanza-type, details.custom-stanza-numbers, style, details.custom-inline-text).
% So können \fstanza, \ref, \bridge und \repStartWithTag im selben Zeitschritt kombiniert werden.
#(define-markup-command (formatted-stanza layout props) ()
  #:properties ((details '()) (style #f))
  (let* ((realstanza (ly:assoc-get 'custom-realstanza details #f))
         (type (ly:assoc-get 'custom-stanza-type details 'verse))
         (numbers (ly:assoc-get 'custom-stanzanumber-override details
                    (ly:assoc-get 'custom-stanza-numbers details '())))
         (inline-text (ly:assoc-get 'custom-inline-text details #f))
         (inline-direction (ly:assoc-get 'custom-inline-direction details CENTER))
         (rep-start (and inline-text (eqv? inline-direction LEFT)))
         (roman-numbers (romanize-stanza-numbers numbers style))
         (stanza-stencil
           (and realstanza
             (case type
               ((ref) ((ly:output-def-lookup layout 'refMarkupFormatter) layout props roman-numbers))
               ((bridge) ((ly:output-def-lookup layout 'bridgeMarkupFormatter) layout props roman-numbers))
               (else (interpret-markup layout props (format-stanza-numbers numbers style))))))
         (padded-stanza-stencil
           (and stanza-stencil
             (interpret-markup layout props (make-pad-left-markup 1 (make-stencil-markup stanza-stencil))))))
    (if rep-start
      (interpret-markup layout props
        (make-concat-markup
          (append
            (if padded-stanza-stencil (list (make-stencil-markup padded-stanza-stencil) (make-hspace-markup 1)) '())
            (list (make-override-markup '(font-series . normal) inline-text)))))
      (or padded-stanza-stencil empty-stencil))))

#(define (formatted-stanza-music type stanzanumbers)
#{
  \once \override StanzaNumber.details.custom-realstanza = ##t % set this to signal that there is a real stanza and no repeat signs
  \once \override StanzaNumber.details.custom-stanza-type = #type
  \once \override StanzaNumber.details.custom-stanza-numbers = #stanzanumbers
  \stanza \markup \formatted-stanza
#})

% \fstanza 1      -> "1."
% \fstanza 1,4    -> "1., 4." (nur im Notenmodus, z.B. \chordverse { \fstanza 1,4 } ...)
% \fstanza "1,4"  -> "1., 4." (auch im \lyricmode, dort versteht LilyPond 1,4 nicht als Liste)
fstanza =
#(define-music-function (stanzanumbers) (stanza-numbers?)
  (formatted-stanza-music 'verse
    (if (string? stanzanumbers) (stanza-numbers-from-string stanzanumbers) stanzanumbers)))

ref =
#(define-music-function (stanzanumbers lyrics) ((number-list? (list)) ly:music?)
#{ \lyricmode {
    #(formatted-stanza-music 'ref stanzanumbers)
    #lyrics
  }
#}
)

bridge =
#(define-music-function (stanzanumbers lyrics) ((number-list? (list)) ly:music?)
#{ \lyricmode {
    #(formatted-stanza-music 'bridge stanzanumbers)
    #lyrics
  }
#}
)

% prints a repStart Sign as stanza if the tag 'repeats is kept.
% if there is a stanza set by \fstanza in the same moment, \formatted-stanza prints both.
% Sets custom-inline-text for ChordPro export so it can collect the repeat sign separately
repStartWithTag =
#(define-music-function () ()
#{ \lyricmode {
  \tag #'repeats {
    \once \override StanzaNumber.details.custom-inline-text = \repStart
    \once \override StanzaNumber.details.custom-inline-direction = #LEFT
    \stanza \markup \formatted-stanza
  }
} #})

repStopWithTag = \lyricmode {
  \tag #'repeats {
    \once \override StanzaNumber.details.custom-inline-text = \repStop
    \once \override StanzaNumber.details.custom-inline-direction = #RIGHT
    \once \override StanzaNumber.font-series = #'normal
    \once \override StanzaNumber.direction = 1
    \stanza \markup { \pad-x-right #1 \repStop }
  }
}

rightHyphen = \lyricmode {
  \once \override StanzaNumber.font-series = #'normal
  \once \override StanzaNumber.direction = 1
  \stanza "-"
}

leftHyphen = \lyricmode {
  \once \override StanzaNumber.font-series = #'normal
  \stanza "-"
}

multiVerseSkips =
#(define-music-function (parser location skips) (number?)
  #{ \tag #'multiVerse { \repeat unfold #skips { \skip4 } } #})

alt =
#(define-music-function (parser location a b) (ly:music? ly:music?)
  #{ \tag #'firstVerse { #a } \tag #'multiVerse { #b } #})

updown =
#(define-music-function (parser location word) (string?)
(let ((first-char (string-take word 1))
      (rest (substring word 1 (string-length word))))
#{
  \lyricmode {
    \markup {
      \tag #'up #(string-append (string-capitalize first-char) rest)
      \tag #'down #(string-append (string-downcase first-char) rest)
    }
  }
#}))

dottedExtender = {
  \override LyricExtender.style = #'dotted-line
  \override LyricExtender.thickness = 2
  \override LyricExtender.Y-offset = 0.1
  \override LyricExtender.stencil =
    #(lambda (grob)
      (let* ((stil (ly:lyric-extender::print grob))
             (nostil (null? stil))
             (x-ext (if nostil 0 (ly:stencil-extent stil X))))
         (if nostil
           stil
           (make-connected-line
             (list
               (cons (car x-ext) 0)
               (cons (cdr x-ext) 0))
             grob))))
}

melisOff = \set ignoreMelismata = ##t
melisOn = \unset ignoreMelismata

cue =
#(define-music-function (zahlen) (number-list?)
  #{
      \tag #'cues {
        \tweak self-alignment-X #LEFT
        \mark
          #(make-on-the-fly-markup
            (lambda (layout props m) (interpret-markup layout (prepend-alist-chain 'cues zahlen props) (ly:output-def-lookup layout 'cueMarkup)))
            (make-null-markup))
      }
  #})

#(define-markup-command (ruf-style layout props text) (string?)
   (interpret-markup layout props
                     (markup #:italic (string-append "(" text ")"))))
rufWithMarkup =
#(define-music-function (text) (markup?)
   #{
     \lyricmode {
       \once \override StanzaNumber.font-series = #'normal
       \once \override StanzaNumber.direction = 1
       \stanza #text
     }
   #})
ruf =
#(define-music-function (text) (string?)
   (rufWithMarkup (make-ruf-style-markup text)))

underlineOn =
#(define-music-function () ()
   #{
     \override LyricText.stencil =
     #(lambda (grob)
        (grob-interpret-markup grob (make-underline-markup (ly:grob-property grob 'text))))
   #})

underlineOff =
#(define-music-function () ()
   #{
     \revert LyricText.stencil
   #})