Harry Lime Thema (Klavier)

Zur Navigation springen Zur Suche springen

Lilypond Score

sop = \relative c'' {
  \numericTimeSignature
  \key c \major
  \tupletSpan 4
  \voiceOne
  \repeat unfold 2 { \tuplet 3/2 { g4 gis8 a4 gis8 } a4. gis8 a1 }
  g8 gis a ais h4. ais8
  h ais h ais h2
  a4. gis8 a4. gis8 a1
  \repeat unfold 2 { g8 gis a4 ~ a8 gis a gis a1 }
  g8 gis a ais h4. ais8 h ais h2 e4
  \oneVoice
  < c g e >4 g,8 a ~ a h c4
  e8 a4 as8 g2
  \voiceOne
  g8 gis a4 ~ a8 gis a gis
  \oneVoice
  < a e c >2 < c e g a >-^
  \voiceOne
  g8 gis a4 ~ a8 gis a gis
  \oneVoice
  < a f h, >2 < h d f a >-^
  \voiceOne
  g8 gis a4 ~ a8 gis a gis
  \oneVoice
  < h f h,>2 < h f' g h>-^
  \voiceOne
  a4. gis8 a4. gis8 a gis a gis a2
  a4. gis8 a4. gis8 a gis a2 e4
  g4 fis f e
  \oneVoice
  < d a f >2 ~ q4 a'4
  \voiceOne
  g8 gis a4 ~ a8 gis a ais
  \oneVoice
  < h f h, >2 < f h e >2
  < c' e, >4 g8 g ~ g fis g a
  g2 < g d' f g >-^
}

"fh1" = \relative c' {
  < f h, >4 q q q
}

"fh2" = \relative c' {
  < f h, >4 q2 q4
}

fh = { $fh1 $fh2 }

"ce1" = \relative c' {
  < c e >4 q q q
}

"ce2" = \relative c' {
  < c e >4 q2 q4
}

ce = { $ce1 $ce2 }

alt = \relative c' {
  \voiceTwo
  \ce
  \fh $fh1 $fh1
  $ce $ce2 $ce2
  $fh2 $fh2 $fh1
  < f h, >4 q2 < f h >4
  s1 s
  \repeat unfold 2 {
    < c e >4 q r q
    s1
  }
  < f h, >4 q r q s1
  $ce1 $ce1
  \repeat unfold 4 { r4 < cis a > }
  < d a >2. < cis g >4 s1
}

cg = \relative c {
  c4 g' g, c
}

dg = \relative c {
  d4 g g, g'
}

bas = \relative c {
  \clef bass
  \numericTimeSignature
  \repeat unfold 2 \cg
  \repeat unfold 4 \dg
  \repeat unfold 4 \cg
  \repeat unfold 4 \dg
  c4 g8 a ~ a h c4
  e8 a4 as8 g4 g,
  \cg \cg
  \repeat unfold 4 \dg
  \cg \cg
  \repeat unfold 2 { a g' e, g' }
  < d d, >2. a4
  d8 a4 f8 d4 r
  g d' d, d'
  g, d' g g,
  < c g' > g'8 g ~ g fis g a
  g2 < h d, g, >
}

OAkk = \chordmode {
  c1 c g:7 q
  q q c c
  g:7 q q q
  c s
  c s
  c c2 c:6
  \repeat unfold 2 { g1:7 q2 g:9 }
  c1 c
  a:7 q
  d4:sus4 d d:m a:7 d1:m
  g:7 q2 < g h d' e'' >
  c1 c2 g:7
}

Struktur = {
  \override Score.SpacingSpanner.base-shortest-duration = #(ly:make-moment 1/16)
  \time 4/4
  \override Score.MetronomeMark.self-alignment-X = #1
  \tempo 4=90
  \mark "Moderately"
  s1 * 16
  \bar "||"
  s1 * 16
  \bar "|."
}

\paper {
  #(include-special-characters)
  top-margin = 20\mm
  ragged-right = ##f
  ragged-last = ##f
  ragged-bottom = ##f
  ragged-last-bottom = ##f
  bottom-margin = 20\mm
  indent = 0\mm
  line-width = 160\mm
  print-all-headers = ##f
  #(include-special-characters)
  print-first-page-number = ##t
  first-page-number = #1
  oddFooterMarkup = ##f
  evenFooterMarkup = ##f
  oddHeaderMarkup = #oddFooterMarkup
  evenHeaderMarkup = #evenFooterMarkup
  markup-system-spacing.padding = #2
  score-markup-spacing.padding = #0
  annotate-spacing = ##f
}

kopf=\header {
  title = "Harry-Lime Thema"
  composer = "M: Anton Karas"
}

\bookpart {
  \kopf
  \score {
    \new PianoStaff
    <<
      \new ChordNames \OAkk
      \new Staff=melodie
      <<
        \new Voice="chor" $sop
        \new Voice $alt
        \new NullVoice \Struktur
      >>
      \new Staff \bas

    >>
  }
}

#(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
  }
}