just real persons for author toc

private_includes/base/all.ily

@@ -36,7 +36,6 @@
 \include "merge_rests_engraver_override.ily"
 \include "basic_format_and_style_settings.ily"
 \include "eps_file_from_song_dir.ily"
-\include "embedded_songs.ily"
 \include "title_with_category_images.ily"
 \include "chord_settings.ily"
 \include "chordpro.ily"
@@ -55,7 +54,6 @@ HEADER = {}
 MUSIC = {}
 TEXT = \markuplist {}
 TEXT_PAGES = #f
-EMBEDDED_SONGS = #'()
 
 verseChords = {}
 firstVoice = {}

private_includes/base/basic_format_and_style_settings.ily

@@ -57,8 +57,6 @@ generalLayout = \layout {
     \remove "Metronome_mark_engraver"
     \RemoveEmptyStaves
     \override VerticalAxisGroup.remove-first = ##t
-    \numericTimeSignature
-    rehearsalMarkFormatter = #format-mark-box-alphabet
     \overrideTimeSignatureSettings
       4/4               % timeSignatureFraction
       1/4               % baseMomentFraction
@@ -91,22 +89,6 @@ generalLayout = \layout {
      ((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:
 

private_includes/base/default_songinfo_style.ily

@@ -7,7 +7,6 @@
   poetAndComposerEqualPrefix = "Worte und Weise:"
   voicePrefix = "Stimme:"
   versePrefix = "Strophe:"
-  refPrefix = "Refrain:"
   translationAuthorPrefix = "Übersetzung:"
   translationPrefix = "Übersetzung:"
   pronunciationPrefix = "Aussprache:"
@@ -40,7 +39,6 @@
         (versePoetData '())
         (composerIds '())
         (verseComposerData '())
-        (refComposerIds '())
         (voiceComposerData '())
         (compositionIds '())
         (adaptionTextIds '())
@@ -50,7 +48,6 @@
         (year_text #f)
         (year_translation #f)
         (year_melody #f)
-        (year_melody_meloref #f)
         (year_composition #f)
         (year_adaption_text #f)
         (year_adaption_music #f)
@@ -63,14 +60,12 @@
         (adaptionTextPrefix "")
         (adaptionMusicPrefix "")
         (bridgePrefix "")
-        (interludePrefix "")
-        (refPrefix ""))
+        (interludePrefix ""))
       (if (and
             (equal? poetIds composerIds)
             (null? translatorIds)
             (null? versePoetData)
             (null? verseComposerData)
-            (null? refComposerIds)
             (null? voiceComposerData)
             (null? compositionIds)
             (null? adaptionTextIds)
@@ -109,7 +104,6 @@
                 (null? compositionIds)
                 (null? adaptionMusicIds)
                 (null? verseComposerData)
-                (null? refComposerIds)
                 (null? voiceComposerData)
                 (null? bridgeIds)
                 (null? interludeIds)) #f
@@ -122,10 +116,6 @@
                   year_melody
                 ) ", ")
                 (render-partial-contribution-group 'versePrefix verseComposerData)
-                (join-present (list
-                  (render-contribution-group refPrefix refComposerIds)
-                  year_melody_meloref
-                ) ", ")
                 (render-partial-contribution-group 'voicePrefix voiceComposerData)
                 (join-present (list
                   (render-contribution-group compositionPrefix compositionIds)

private_includes/base/embedded_songs.ily

@@ -1,157 +0,0 @@
-%% Mehrere Lieder in einer Liederdatei (z.B. zwei Lieder auf einer Seite)
-%%
-%% Das erste Lied ist das Hauptlied (HEADER), alle weiteren werden als
-%% eingebettete Lieder angemeldet. Eingebettete Lieder bekommen eigene
-%% Eintraege im Inhaltsverzeichnis, in den Kategorie-, Autoren- und
-%% Kapitelverzeichnissen, im PDF-Inhaltsverzeichnis, in der toc.csv und
-%% eine eigene Liednummer. Im Footer steht die Songinfo des letzten
-%% eingebetteten Lieds (abschaltbar mit footersong = ##f im HEADER bzw. mit
-%% footersong = \andereslied umstellbar), die Songinfo des Hauptlieds wird
-%% mit \songinfo-of selbst platziert.
-%%
-%% Beispiel:
-%%
-%%   \include "../../lilypond-song-includes/liedbausteine/lied_a.ly"
-%%   liedA = \captureSong
-%%   \include "../../lilypond-song-includes/liedbausteine/lied_b.ly"
-%%   liedB = \captureSong
-%%
-%%   TEXT = \markuplist {
-%%     \songinfo-of \liedA
-%%     \vspace #2
-%%     \embedded-song-title \liedB
-%%     \vspace #.5
-%%     \score { \songMusic \liedB \layout { \LAYOUT } }
-%%     \with-song \liedB {
-%%       \chordlyrics \secondVerse
-%%     }
-%%   }
-%%
-%%   \restoreSong \liedA
-%%   \embedSong \liedB
-%%   \include "public_includes/layout_bottom.ily"
-%%
-%% \captureSong sichert den Header (basicSongInfo) und die Variablen aus
-%% captured-song-variable-names, damit das naechste \include sie nicht
-%% ueberschreibt. Das Ergebnis ist ein normales Header-Modul, es kann also
-%% auch in \header { \liedA } verwendet werden.
-%%
-%% \restoreSong setzt basicSongInfo, HEADER und diese Variablen zurueck,
-%% TEXT aber nicht. TEXT also vor \restoreSong schreiben, solange darin noch
-%% Variablen des zuletzt eingebundenen Lieds (\secondVerse usw.) stehen.
-%%
-%% Ohne \with-song beziehen sich Strophen mit Akkorden auf das Hauptlied.
-%%
-%% Alle Verzeichniseintraege zeigen auf die erste Seite des Hauptlieds.
-
-#(define captured-song-variable-names '(MUSIC global firstVoice verseChords))
-
-#(define (song-variable song name)
-  (assq-ref (module-ref song 'captured-song-variables '()) name))
-
-#(define (extract-and-check-vars-from-module headermodule varlist)
-  (let* ((headervars (if (module? headermodule) (hash-map->list cons (struct-ref headermodule 0)) '()))
-         (extract-var-and-check (lambda (headervar)
-           (let* ((variableref (assoc-ref headervars headervar))
-                  (extracted (if variableref (variable-ref variableref) #f)))
-              (if (and extracted (not (and (string? extracted) (string-null? extracted)))) extracted #f)))))
-    (map (lambda (varsymbol)
-      (cons varsymbol (extract-var-and-check varsymbol))
-    ) varlist)))
-
-% Text des PDF-Lesezeichens eines Lieds, #f wenn es keins bekommt.
-% Gleiche Regel wie in build-full-title.
-#(define (song-pdf-bookmark-title headermodule)
-  (let* ((vars (extract-and-check-vars-from-module headermodule '(title starttext)))
-         (title (assq-ref vars 'title))
-         (starttext (assq-ref vars 'starttext))
-         (as-string (lambda (m) (if (markup? m) (markup->string m) ""))))
-    (cond ((and title starttext) (string-append (as-string starttext) " | " (as-string title)))
-          (title (as-string title))
-          (starttext (string-append (as-string starttext) " | "))
-          (else #f))))
-
-#(define (embedded-song-list songs)
-  (if (list? songs) (filter module? songs) '()))
-
-#(define (embedded-songs-of-header headermodule)
-  (if (module? headermodule)
-    (embedded-song-list (module-ref headermodule 'embeddedsongs '()))
-    '()))
-
-% Ersetzt alle header:*-Properties durch die Felder aus headermodule, damit
-% keine Felder des Hauptlieds in das andere Lied durchsickern.
-#(define (header-module->props headermodule props)
-  (let ((header-key? (lambda (entry)
-          (and (pair? entry) (symbol? (car entry))
-               (string-prefix? "header:" (symbol->string (car entry)))))))
-    (cons
-      (map (lambda (kv) (cons (symbol-append 'header: (car kv)) (cdr kv)))
-           (ly:module->alist headermodule))
-      (map (lambda (alist) (remove header-key? alist)) props))))
-
-captureSong =
-#(define-scheme-function () ()
-  (let ((song (make-module)))
-    (ly:module-copy song basicSongInfo)
-    (module-define! song 'captured-song-variables
-      (filter-map
-        (lambda (name)
-          (let ((value (ly:parser-lookup name)))
-            (and (not (null? value)) (cons name value))))
-        captured-song-variable-names))
-    song))
-
-% Stellt basicSongInfo, HEADER und die gesicherten Variablen eines Lieds
-% wieder her, als waere es das zuletzt eingebundene.
-restoreSong =
-#(define-void-function (song) (module?)
-  (for-each
-    (lambda (kv) (ly:parser-define! (car kv) (cdr kv)))
-    (module-ref song 'captured-song-variables '()))
-  (ly:parser-define! 'basicSongInfo song)
-  (ly:parser-define! 'HEADER #{ \bookpart { \header { $song } } #}))
-
-embedSong =
-#(define-void-function (song) (module?)
-  (set! EMBEDDED_SONGS (append EMBEDDED_SONGS (list song))))
-
-songMusic =
-#(define-music-function (song) (module?)
-  (let ((music (song-variable song 'MUSIC)))
-    (if (ly:music? music) music (make-music 'SequentialMusic))))
-
-% Strophen, \fromproperty #'header:... usw. beziehen sich innerhalb auf das
-% angegebene Lied. Die Transposition des Hauptlieds wird nicht uebernommen.
-#(define-markup-list-command (with-song layout props song args) (module? markup-list?)
-  (let* ((music-or-empty (lambda (name)
-           (let ((music (song-variable song name)))
-             (if (ly:music? music) music (make-music 'SequentialMusic)))))
-         (verseChords (music-or-empty 'verseChords))
-         (global (music-or-empty 'global))
-         (firstVoice (music-or-empty 'firstVoice)))
-    (interpret-markup-list layout
-      (prepend-alist-chain 'verse-chords #{ \chords { $verseChords } #}
-        (prepend-alist-chain 'verse-reference-voice #{ $global $firstVoice #}
-          (prepend-alist-chain 'transposition (cons #f #f)
-            (header-module->props song props))))
-      args)))
-
-#(define-markup-command (songinfo-of layout props song) (module?)
-  (interpret-markup layout (header-module->props song props)
-    (make-fractional-line-width-markup (make-songinfo-content-markup))))
-
-#(define-markup-command (embedded-song-title layout props song) (module?)
-  (interpret-markup layout (header-module->props song props)
-    (make-fill-line-markup (list (ly:output-def-lookup layout 'defaultTitleMarkup)))))
-
-% PDF-Lesezeichen der eingebetteten Lieder, wird von build-full-title direkt
-% nach dem Lesezeichen des Hauptlieds ausgegeben.
-#(define-markup-command (embedded-songs-to-pdf-toc layout props) ()
-  (apply ly:stencil-add
-    (cons empty-stencil
-      (filter-map
-        (lambda (song)
-          (let ((bookmark (song-pdf-bookmark-title song)))
-            (and bookmark (make-pdf-toc-stencil bookmark 0))))
-        (embedded-song-list (chain-assoc-get 'header:embeddedsongs props '()))))))

private_includes/base/eps_file_from_song_dir.ily

@@ -6,20 +6,10 @@
 #(define-markup-command (customEps layout props ysize filename)(number? string?)
    #:properties ((songfilename ""))
    (interpret-markup layout props
-     (let* ((defaulttitlemarkup (ly:output-def-lookup layout 'defaultTitleMarkup))
-            ;; Determine the song directory to resolve the EPS relative to.
-            ;; In TEXT the name arrives via the markup props (\setsongfilename),
-            ;; but inside MUSIC (e.g. \mark) the props do not carry it, so we
-            ;; fall back to the value stored in the score's \layout block.
-            (layout-songfilename (ly:output-def-lookup layout 'songfilename #f))
-            (songdir (cond ((not (string-null? songfilename)) songfilename)
-                           ((and (string? layout-songfilename)
-                                 (not (string-null? layout-songfilename)))
-                            layout-songfilename)
-                           (else #f)))
-            (filepath (if songdir
-                          (ly:format "~a/~a/~a" songPath songdir filename)
-                          filename)))
+     (let ((defaulttitlemarkup (ly:output-def-lookup layout 'defaultTitleMarkup))
+           (filepath (if (string-null? songfilename)
+                          filename
+                          (ly:format "~a/~a/~a" songPath songfilename filename))))
        (if (file-exists? filepath)
              (make-epsfile-markup Y ysize filepath)
              (if defaulttitlemarkup

private_includes/base/footer_with_songinfo.ily

@@ -33,8 +33,7 @@
 #(define (join-present items joiner)
   (string-join (filter (lambda (item) (and (string? item) (not (string-null? (string-trim-both item))))) items) joiner))
 
-% Songinfo aus den header:*-Properties, ohne Pruefung auf die letzte Seite.
-#(define-markup-command (songinfo-content layout props) ()
+#(define-markup-command (print-songinfo layout props) ()
   (define (songinfo-from songId key)
     (let ((song (if (defined? 'SONG_DATA) (assoc-ref SONG_DATA songId) #f)))
       (if song
@@ -102,7 +101,6 @@
         #:versePoetData (find-author-id-with-part-numbers 'verse authors)
         #:composerIds (find-author-ids-by 'melody authors)
         #:verseComposerData (find-author-id-with-part-numbers 'meloverse authors)
-        #:refComposerIds (find-author-ids-by 'meloref authors)
         #:voiceComposerData (find-author-id-with-part-numbers 'voice authors)
         #:compositionIds (find-author-ids-by 'composition authors)
         #:adaptionTextIds (find-author-ids-by 'adaption_text authors)
@@ -112,7 +110,6 @@
         #:year_text (chain-assoc-get 'header:year_text props #f)
         #:year_translation (chain-assoc-get 'header:year_translation props #f)
         #:year_melody (chain-assoc-get 'header:year_melody props #f)
-        #:year_melody_meloref (chain-assoc-get 'header:year_melody_meloref props #f)
         #:year_composition (chain-assoc-get 'header:year_composition props #f)
         #:year_adaption_text (chain-assoc-get 'header:year_adaption_text props #f)
         #:year_adaption_music (chain-assoc-get 'header:year_adaption_music props #f)
@@ -126,12 +123,13 @@
         #:adaptionMusicPrefix (ly:output-def-lookup layout 'adaptionMusicPrefix)
         #:bridgePrefix (ly:output-def-lookup layout 'bridgePrefix)
         #:interludePrefix (ly:output-def-lookup layout 'interludePrefix)
-        #:refPrefix (ly:output-def-lookup layout 'refPrefix))
+      )
       (list #f #f)
     )
   )
 
   (interpret-markup layout props
+    (if (chain-assoc-get 'page:is-bookpart-last-page props #f)
     (let* ((authors (chain-assoc-get 'header:authors props #f))
            (poet-and-composers (poet-and-composer-from-authors authors))
            (songId (chain-assoc-get 'header:songId props #f))
@@ -145,7 +143,7 @@
             (translation (chain-assoc-get 'header:translation props #f))
             (pronunciation (chain-assoc-get 'header:pronunciation props #f))
             (year_text (if (string? (car poet-and-composers)) #f (chain-assoc-get 'header:year_text props #f)))
-            (year_melody (if (string? (cadr poet-and-composers)) #f (chain-assoc-get 'header:year_melody props #f))))
+            (year_melody (if (string? (car poet-and-composers)) #f (chain-assoc-get 'header:year_melody props #f))))
             (markup
               #:override (cons 'songinfo:poet-maybe-with-composer
                 (if (and poet-maybe-with-composer (not (and (string? poet-maybe-with-composer) (string-null? poet-maybe-with-composer)))) poet-maybe-with-composer #f))
@@ -167,25 +165,10 @@
               #:fontsize songInfoFontSize
               #:sans
               (ly:output-def-lookup layout 'songinfoMarkup)
-            ))))
+            )))
+      (make-null-markup)))
 )
 
-% Songinfo im Footer, nur auf der letzten Seite des Bookparts. Gibt es
-% eingebettete Lieder (siehe embedded_songs.ily), steht hier die Songinfo des
-% letzten eingebetteten Lieds, ausser im Header ist footersong gesetzt
-% (##f = Hauptlied, oder ein mit \captureSong gesichertes Lied).
-#(define-markup-command (print-songinfo layout props) ()
-  (if (chain-assoc-get 'page:is-bookpart-last-page props #f)
-    (let* ((footersong (chain-assoc-get 'header:footersong props 'auto))
-           (embedded (embedded-song-list (chain-assoc-get 'header:embeddedsongs props '())))
-           (song (if (eq? footersong 'auto)
-                     (and (pair? embedded) (last embedded))
-                     footersong)))
-      (interpret-markup layout
-        (if (module? song) (header-module->props song props) props)
-        (make-songinfo-content-markup)))
-    (interpret-markup layout props (make-null-markup))))
-
 #(define-markup-command (print-pagenumber layout props)()
   (let ((label (chain-assoc-get 'header:myindexlabel props #f)))
    (interpret-markup layout props

private_includes/base/markup_tag_groups_hack.ily

@@ -9,8 +9,5 @@ tagGroup =
 
 #(define-markup-command (handle-tag-groups layout props recorded-groups m) (list? markup?)
    (resetTagGroups)
-   (for-each
-     (lambda (group)
-       (define-tag-group group))
-     recorded-groups)
+   (every (lambda (group) (define-tag-group group)) recorded-groups)
    (interpret-markup layout props m))

private_includes/base/title_with_category_images.ily

@@ -26,50 +26,25 @@
 
 #(define pdf-encode (@@ (lily framework-ps) pdf-encode))
 % PDF tags
-% Erzeugt ein PDF-Lesezeichen (Outline-Eintrag) auf der aktuellen Seite.
-% count = Anzahl der direkten Unterpunkte, die (in Seitenreihenfolge) direkt
-%   nachfolgen. 0 = Blatt-Eintrag (kein /Count), >0 = aufgeklappt,
-%   <0 = zugeklappt (Betrag = Anzahl direkter Kinder).
-#(define (make-pdf-toc-stencil title count)
+#(define-markup-command (title-to-pdf-toc layout props title) (string?)
   (if (string-null? title)
      empty-stencil
      (ly:make-stencil
       (list 'embedded-ps
              (ly:format
-              "[~a/Action /GoTo /View [/XYZ -4 currentpagedevice /PageSize get 1 get 4 add null] /Title (~a) /OUT pdfmark"
-              (if (= count 0) "" (ly:format "/Count ~a " count))
-              (pdf-encode title)))
+              "[/Action /GoTo /View [/XYZ -4 currentpagedevice /PageSize get 1 get 4 add null] /Title (~a) /OUT pdfmark" (pdf-encode title)))
       empty-interval empty-interval
       ;'(0 . 0) '(0 . 0)
       )))
 
-% Einzelner (Blatt-)Eintrag im PDF-Inhaltsverzeichnis.
-#(define-markup-command (title-to-pdf-toc layout props title) (string?)
-  (make-pdf-toc-stencil title 0))
-
-% Kapitel-Eintrag mit verschachtelten Unterpunkten.
-% count = Anzahl der direkt nachfolgenden Einträge, die diesem Kapitel
-%   untergeordnet werden sollen (positiv = aufgeklappt, negativ = zugeklappt).
-#(define-markup-command (chapter-to-pdf-toc layout props count title) (integer? string?)
-  (make-pdf-toc-stencil title count))
-
 #(define-markup-command (build-full-title layout props right)(boolean?)
    (interpret-markup layout (prepend-alist-chain 'songfilename (chain-assoc-get 'header:songfilename props "") props)
      (let* ((title (chain-assoc-get 'header:title props ""))
             (starttext (chain-assoc-get 'header:starttext props #f))
             (pdfbookmark (if starttext (string-append starttext " | " title) title))
-            (chaptertitle (chain-assoc-get 'header:chaptertitle props #f))
-            (chaptercount (chain-assoc-get 'header:chaptercount props 0))
             (title-markup (ly:output-def-lookup layout (if right 'oddTitleLineMarkup 'evenTitleLineMarkup))))
      (if title
-       ;; Ist dieses Lied das erste eines Kapitels, wird der Kapitel-Eintrag
-       ;; unmittelbar vor dem Lied-Eintrag ausgegeben, damit die pdfmark-/OUT-
-       ;; Reihenfolge (Elternteil vor Kindern) im PDF-Stream garantiert stimmt.
-       ;; Eingebettete Lieder (embedded_songs.ily) folgen direkt nach dem Lied.
-       (if (and (string? chaptertitle) (not (string-null? chaptertitle)))
-         (markup #:chapter-to-pdf-toc chaptercount chaptertitle
-                 #:title-to-pdf-toc pdfbookmark #:embedded-songs-to-pdf-toc title-markup)
-         (markup #:title-to-pdf-toc pdfbookmark #:embedded-songs-to-pdf-toc title-markup))
+       (markup #:title-to-pdf-toc pdfbookmark title-markup)
        make-null-markup)
      )))
 

private_includes/base/verses_with_chords.ily

@@ -249,13 +249,6 @@ Chord_lyrics_spacing_engraver =
          (lyrics-seen-since-break #f)
          (have-a-rest #f)
          (stanza #f)
-         ; Akkord auf einer Skip-Silbe "_" nach Wortende soll über die folgende Silbe
-         (word-continues #f)
-         (continuation-this-step #f)
-         (lyric-skip-this-step #f)
-         (syllable-this-step #f)
-         (chord-this-step #f)
-         (chord-on-lyric-skip #f)
          (place-at-right-edge
           (lambda (grob anchor padding)
             (let ((anchor-width (interval-length (ly:grob-extent anchor anchor X))))
@@ -263,25 +256,6 @@ Chord_lyrics_spacing_engraver =
               (ly:grob-set-property! grob 'X-offset (+ padding anchor-width))
               ))))
      (make-engraver
-      ((start-translation-timestep engraver)
-       (set! continuation-this-step #f)
-       (set! lyric-skip-this-step #f)
-       (set! syllable-this-step #f)
-       (set! chord-this-step #f)
-       )
-      ((stop-translation-timestep engraver)
-       (if (and chord-on-lyric-skip (not (eq? chord-on-lyric-skip chord-this-step)))
-           (begin
-             (if (and syllable-this-step (not chord-this-step))
-                 (begin
-                   (ly:grob-set-parent! chord-on-lyric-skip X syllable-this-step)
-                   (ly:grob-set-property! chord-on-lyric-skip 'X-offset 0)
-                   (ly:grob-set-property! chord-on-lyric-skip 'extra-spacing-width '(+inf.0 . -inf.0))
-                   (set! lyric-width-since-last-chord (interval-length (ly:grob-extent syllable-this-step syllable-this-step X)))))
-             (set! chord-on-lyric-skip #f)))
-       (if syllable-this-step
-           (set! word-continues continuation-this-step))
-       )
       (listeners
        ((multi-measure-rest-event engraver event)
         (set! have-a-rest #t)
@@ -289,19 +263,8 @@ Chord_lyrics_spacing_engraver =
        ((rest-event engraver event)
         (set! have-a-rest #t)
         )
-       ((hyphen-event engraver event)
-        (set! continuation-this-step #t)
-        )
-       ((extender-event engraver event)
-        (set! continuation-this-step #t)
-        )
        ((lyric-event engraver event)
         (set! have-a-rest #f)
-        ; "_" wird zu " " und erzeugt keine LyricText
-        (if (equal? (ly:event-property event 'text) " ")
-            (begin
-              (set! lyric-skip-this-step #t)
-              (set! chord-on-lyric-skip #f)))
         (set! music-columns-for-last-syllable 0)
         )
        ((break-event engraver event)
@@ -311,7 +274,6 @@ Chord_lyrics_spacing_engraver =
         (set! last-printed-chord #f)
         (set! chord-width-since-last-lyric 0)
         (set! lyrics-seen-since-break #f)
-        (set! chord-on-lyric-skip #f)
         ))
       (acknowledgers
        ((musical-paper-column-interface this-engraver grob source-engraver)
@@ -332,7 +294,6 @@ Chord_lyrics_spacing_engraver =
                     (ly:grob-set-property! grob 'X-offset gap-for-starting-rest)
                     )))
             )
-        (set! syllable-this-step grob)
         (set! last-lyric-syllable grob)
         (set! chord-width-since-last-lyric 0)
         (set! lyrics-seen-since-break #t)
@@ -360,9 +321,6 @@ Chord_lyrics_spacing_engraver =
                                              (cons (car (ly:grob-property last-lyric-syllable 'extra-spacing-width '(0 . 0))) (+ chord-gap chord-overwidth)))
                       )
               (set! lyric-width-since-last-chord (* (if last-lyric-syllable (interval-length (ly:grob-extent last-lyric-syllable last-lyric-syllable X)) 0) (- 1 (/ 1.0 music-columns-for-last-syllable))))
-              (set! chord-this-step grob)
-              (if (and lyric-skip-this-step (not have-a-rest) (not word-continues))
-                  (set! chord-on-lyric-skip grob))
               (set! last-printed-chord grob)
               (set! last-lyric-syllable #f)
               )

private_includes/book/book_include.ily

@@ -119,7 +119,7 @@ width may require additional tweaking.)"
 
 
 includeSong =
-#(define-void-function (filename) (string?)
+#(define-void-function (parser location filename) (string?)
      #{
      \bookOutputName #filename
      #}
@@ -130,47 +130,32 @@ includeSong =
         (acons label additional-page-numbers additional-page-switch-label-list))
       (set! song-list
         (acons (string->symbol filename)
-          `(
-            (label . ,label)
-            (header . ,HEADER)
-            (music . ,MUSIC)
-            (layout . ,LAYOUT)
-            (text-pages . ,(map (lambda (text)
+          (acons 'label label
+            (acons 'header HEADER
+              (acons 'music MUSIC
+                (acons 'layout LAYOUT
+                  (acons 'text-pages
+                    (map (lambda (text)
                       #{ \markuplist \setsongfilename $filename $text #})
-                      TEXT_PAGES))
-          )
+                      TEXT_PAGES)
+                    '())))))
           song-list))
     ))
 
 blankpage =
-#(define-void-function () ()
+#(define-void-function (parser location) ()
     (set! song-list
       (acons 'emptyPage
         '()
         song-list)))
 
 imagepage =
-#(define-void-function (xsize filename) (number? string?)
+#(define-void-function (parser location xsize filename) (number? string?)
     (set! song-list
       (acons 'imagePage
-        `((xsize . ,xsize)
-          (filename . ,filename))
+        (acons 'xsize xsize (acons 'filename filename '()))
         song-list)))
 
-markuppage =
-#(define-void-function (mkup) (markup?)
-    (set! song-list
-      (acons 'markupPage
-        `((markup . ,mkup))
-        song-list)))
-
-#(define chapters '())
-
-songsChapter =
-#(define-void-function (title) (string?)
-    (set! chapters
-      (cons (cons title (length song-list)) chapters)))
-
 #(define-markup-command (pagecenter layout props stuff)(markup?)
    (interpret-markup layout props
      (let ((halfpaperheight (/ (ly:output-def-lookup layout 'paper-height) 2))
@@ -179,90 +164,16 @@ songsChapter =
    )))
 
 songs =
-#(define-void-function () ()
- (let* ((ordered (reverse song-list))
-        (total (length ordered))
-        ;; Ein Lied erzeugt nur dann einen PDF-Outline-Eintrag (/OUT), wenn
-        ;; title oder starttext gesetzt sind (siehe build-full-title). Nur solche
-        ;; Lieder duerfen als Kapitel-Kinder gezaehlt werden -- sonst wird die
-        ;; /Count zu hoch und der erste Folgeeintrag (z.B. ein spaeteres Kapitel)
-        ;; rutscht faelschlich als Kind mit hinein.
-        ;; Eingebettete Lieder (embedded_songs.ily) haben jeweils ein eigenes
-        ;; Lesezeichen, daher die Anzahl statt eines Booleans.
-        (bookmark-count
-          (lambda (e)
-            (if (or (eq? (car e) 'emptyPage)
-                    (eq? (car e) 'imagePage)
-                    (eq? (car e) 'markupPage))
-                0
-                (let* ((headermodule (ly:book-header (assq-ref (cdr e) 'header)))
-                       (vars (extract-and-check-vars-from-module headermodule '(title starttext))))
-                  (+ (if (or (assq-ref vars 'title) (assq-ref vars 'starttext)) 1 0)
-                     (count song-pdf-bookmark-title (embedded-songs-of-header headermodule)))))))
-        (count-bookmark-songs
-          (lambda (start end)
-            (let loop ((i 0) (l ordered) (c 0))
-              (cond ((or (null? l) (>= i end)) c)
-                    ((< i start) (loop (+ i 1) (cdr l) c))
-                    (else (loop (+ i 1) (cdr l) (+ c (bookmark-count (car l)))))))))
-        ;; chapters: (title . start-index). start-index = Anzahl der song-list-
-        ;; Eintraege beim Aufruf von songsChapter = Index in `ordered`, ab dem
-        ;; das Kapitel beginnt.
-        (chapters-asc (sort chapters (lambda (a b) (< (cdr a) (cdr b)))))
-        ;; pending: aufsteigende Liste von (start title count); count = Anzahl
-        ;; der Lesezeichen-Lieder von diesem Kapitel bis zum Beginn des naechsten.
-        (pending
-          (let loop ((chs chapters-asc) (acc '()))
-            (if (null? chs)
-                (reverse acc)
-                (let* ((title (caar chs))
-                       (start (cdar chs))
-                       (end (if (null? (cdr chs)) total (cdadr chs)))
-                       (cnt (count-bookmark-songs start end)))
-                  (loop (cdr chs) (cons (list start title cnt) acc))))))
-        ;; Aktuell aktives Kapitel (Titel-String) waehrend des Durchlaufs. Wird
-        ;; gesetzt, sobald ein Kapitel aktiviert (aus `pending` entfernt) wird --
-        ;; egal ob auf einer Seite (chapter-prefixed-markup) oder auf dem ersten
-        ;; Song. Jeder danach folgende Song erhaelt dieses Kapitel als
-        ;; chapterref-Header-Feld, woraus toc_include.ily den Kapitel-Index baut.
-        (current-chapter #f)
-        ;; Stellt einer beliebigen Seite (markup-/image-/emptyPage) den Kapitel-
-        ;; Eintrag (chapter-to-pdf-toc) bei, falls an Position `this-index` ein
-        ;; Kapitel faellig ist, und entfernt es aus `pending`. So fuehrt die
-        ;; Kapitel-Referenz zur ersten Seite nach dem \songsChapter -- egal
-        ;; welcher Seitentyp das ist. Der Eintrag wird als unsichtbares Overlay
-        ;; (\combine) beigelegt, damit er das Seitenlayout nicht veraendert;
-        ;; \with-dimensions gibt dem sonst extent-losen pdfmark einen minimalen
-        ;; Extent, damit er auch auf leeren Seiten nicht verworfen wird.
-        (chapter-prefixed-markup
-          (lambda (this-index base-markup)
-            (if (and (pair? pending) (<= (car (car pending)) this-index))
-                (let ((cnt (caddr (car pending)))
-                      (title (cadr (car pending))))
-                  (set! pending (cdr pending))
-                  (set! current-chapter title)
-                  (make-combine-markup
-                    base-markup
-                    (make-with-dimensions-markup '(0 . 0) '(0 . 0.1)
-                      (make-chapter-to-pdf-toc-markup cnt title))))
-                base-markup)))
-        (index 0))
+#(define-void-function (parser location) ()
  (for-each (lambda (songitems)
-   (let ((this-index index))
-     (set! index (+ index 1))
    (ly:book-add-bookpart! (ly:parser-lookup '$current-book)
     (let ((filename (car songitems))
           (songvars (cdr songitems)))
       (if (eq? filename 'emptyPage)
-            #{ \bookpart { \markup { $(chapter-prefixed-markup this-index (make-null-markup)) } } #}
-        (if (eq? filename 'markupPage)
-            ;; Kapitelanfang auf einer markuppage: Kapitel-Eintrag wird dieser
-            ;; Seite beigelegt (siehe chapter-prefixed-markup).
-            #{ \bookpart { \markup { $(chapter-prefixed-markup this-index (assq-ref songvars 'markup)) } } #}
+          #{ \bookpart { \markup { \null } } #}
       (if (eq? filename 'imagePage)
-            (let* ((xsize (assq-ref songvars 'xsize))
-                   (filename (ly:format "~a/~a" imagePagePath (assq-ref songvars 'filename)))
-                   (img-markup #{ \markup { \pagecenter { \epsfile #X #xsize #filename } } #}))
+          (let ((xsize (assq-ref songvars 'xsize))
+                (filename (ly:format "~a/~a" imagePagePath (assq-ref songvars 'filename))))
           #{ \bookpart {
                \paper {
                  %{
@@ -276,57 +187,30 @@ songs =
                  last-bottom-spacing = #'((basic-distance . 0) (minimum-distance . 0) (padding . 0))
                  page-count = 1
               }
-                \markup { $(chapter-prefixed-markup this-index img-markup) }
+              \markup { \pagecenter { \epsfile #X #xsize #filename } }
           } #}
           )
-            ;; Ist ein Kapitel faellig (Start <= aktuelle Position) und dies ein
-            ;; echtes Lied, wird die Kapitelinfo an dieses Lied gehaengt und aus
-            ;; `pending` entfernt.
           (let* ((newnumber (+ 1 song-number))
-                   (chaptertitle (if (and (pair? pending) (<= (car (car pending)) this-index))
-                                     (cadr (car pending)) #f))
-                   (chaptercount (if chaptertitle (caddr (car pending)) 0))
-                   ;; Startet das Kapitel erst auf diesem Song (nicht schon auf
-                   ;; einer vorangehenden Seite), wird current-chapter jetzt
-                   ;; gesetzt und pending entfernt -- vor dem Bau des Headers,
-                   ;; damit chapterref bereits das neue Kapitel enthaelt.
-                   (_ (if chaptertitle
-                          (begin (set! current-chapter chaptertitle)
-                                 (set! pending (cdr pending)))))
                  (header #{ \bookpart { $(assq-ref songvars 'header) \header {
                    songfilename = $(symbol->string filename)
                    myindexlabel = #(assq-ref songvars 'label)
                    songnumber = #(number->string newnumber)
-                     chaptertitle = #chaptertitle
-                     chaptercount = #chaptercount
-                     chapterref = #current-chapter
                  } } #})
                  (music (assq-ref songvars 'music))
                  (layout (assq-ref songvars 'layout))
                  (text-pages (assq-ref songvars 'text-pages))
-                   (label (assq-ref songvars 'label))
-                   (toc-music (header-module-to-toc! (ly:book-header header) label)))
+                 (label (assq-ref songvars 'label)))
             (set! song-number newnumber)
-            ;; Eingebettete Lieder: eigene Liednummer, gleiche Seite (label)
-            (for-each
-              (lambda (song)
-                (let ((tocheader (make-module)))
-                  (set! song-number (+ 1 song-number))
-                  (ly:module-copy tocheader song)
-                  (module-define! tocheader 'songnumber (number->string song-number))
-                  (module-define! tocheader 'chapterref current-chapter)
-                  (header-module-to-toc! tocheader label)))
-              (embedded-songs-of-header (ly:book-header header)))
             #{
               \bookpart {
                 $header
-                $toc-music
-                \score { $music \layout { $layout songfilename = $(symbol->string filename) } }
+                \headerToTOC #header #label
+                \score { $music \layout { $layout } }
                 $(add-text-pages text-pages)
               }
-            #}))))))))
-   ordered
-   )))
+            #}))))))
+   (reverse song-list)
+   ))
 
 #(define (boernel-stats)
    (let (

private_includes/book/toc_include.ily

@@ -132,37 +132,6 @@
                 author-index-hash)
               (lambda (a b) (string-ci<? (car a) (car b))))))))
 
-% code for chapter index
-% Anders als bei Kategorien/Autoren ergibt sich die Kapitelzugehoerigkeit nicht
-% aus dem Song-Header, sondern aus dem \songsChapter, das dem Song vorangeht
-% (in book_include.ily als Header-Feld chapterref an jeden Song gehaengt).
-% Die Kapitel behalten hier ihre Auftritts-Reihenfolge (nicht alphabetisch),
-% ebenso die Songs innerhalb eines Kapitels ihre Song-Reihenfolge.
-#(define*-public (add-chapter-index-item! chapter markup-symbol textoptions #:optional label) #f)
-#(define-public (chapter-index-items) #f)
-
-#(let ((chapter-index-hash (make-hash-table))
-       (chapter-order '()))
-   (set! add-chapter-index-item!
-   (lambda* (chapter markup-symbol textoptions #:optional (label (gensym "index")))
-     (let* ((chaptersym (string->symbol chapter))
-            (existing (hashq-ref chapter-index-hash chaptersym #f))
-            (chapterlist (or existing
-                           (begin
-                             (set! chapter-order (cons chaptersym chapter-order))
-                             (list (list label 'indexChapterMarkup `(((combine-with-next . #t) (rawtext . ,chapter))))))))
-            )
-       (hashq-set! chapter-index-hash chaptersym
-         (cons (list label markup-symbol textoptions) chapterlist)))
-       (make-music 'EventChord
-         'page-marker #t
-         'page-label label
-         'elements (list (make-music 'LabelEvent
-         'page-label label)))))
-   (set! chapter-index-items (lambda ()
-          (append-map (lambda (chaptersym) (reverse (hashq-ref chapter-index-hash chaptersym (list))))
-            (reverse chapter-order)))))
-
 
 #(define-markup-command (with-link-symbol-ref layout props symbol arg)
    (symbol? markup?)
@@ -246,11 +215,6 @@
         (make-null-markup))
     \vspace #.4
   }
-  indexChapterMarkup = \markup \override #'(baseline-skip . 1.5) \left-column {
-    \vspace #1
-    \sans \bold \fontsize #3 \fromproperty #'index:text
-    \vspace #.4
-  }
 }
 
 #(define (prepare-item-markup items layout)
@@ -283,8 +247,7 @@
     (let ((items (case index-type
             ((alphabetical) index-items)
             ((categories) category-index-items)
-            ((authors) author-index-items)
-            ((chapters) chapter-index-items)))
+            ((authors) author-index-items)))
           (title (interpret-markup layout props title-markup)))
       (cons title
       (interpret-markup-list layout props
@@ -304,27 +267,36 @@ indexSection =
    (add-index-item! 'indexSectionMarkup (prepend-alist-chain 'combine-with-next #t (prepend-alist-chain 'rawtext text '())) sorttext))
 
 #(define (extract-and-check-vars-from-header bookheader varlist)
-  (extract-and-check-vars-from-module (ly:book-header bookheader) varlist))
+  (let* ((headervars (hash-map->list cons (struct-ref (ly:book-header bookheader) 0)))
+         (extract-var-and-check (lambda (headervar)
+           (let* ((variableref (assoc-ref headervars headervar))
+                  (extracted (if variableref (variable-ref variableref) #f)))
+              (if (and extracted (not (and (string? extracted) (string-null? extracted)))) extracted #f)))))
+    (map (lambda (varsymbol)
+      (cons varsymbol (extract-var-and-check varsymbol))
+    ) varlist)))
 
-#(define (header-module-to-toc! headermodule label)
+headerToTOC = #(define-music-function (parser location header label) (ly:book? symbol?)
     (define (all-author-ids authors)
       (let ((poetIds (find-author-ids-by 'text authors))
             (translatorIds (find-author-ids-by 'translation authors))
             (versePoetData (find-author-id-with-part-numbers 'verse authors))
             (composerIds (find-author-ids-by 'melody authors))
             (verseComposerData (find-author-id-with-part-numbers 'meloverse authors))
-            (refComposerIds (find-author-ids-by 'meloref authors))
             (voiceComposerData (find-author-id-with-part-numbers 'voice authors))
             (compositionIds (find-author-ids-by 'composition authors))
             (adaptionIds (find-author-ids-by 'adaption authors))
             (bridgeIds (find-author-ids-by 'bridge authors))
-            (interludeIds (find-author-ids-by 'interlude authors)))
-        (delete-duplicates
-          (append poetIds translatorIds (map car versePoetData) composerIds (map car verseComposerData) refComposerIds (map car voiceComposerData) compositionIds adaptionIds bridgeIds interludeIds))
+            (interludeIds (find-author-ids-by 'interlude authors))
+            (realAuthorIds (map car AUTHOR_DATA)))
+        (lset-intersection
+          equal?
+          realAuthorIds
+          (append poetIds translatorIds (map car versePoetData) composerIds (map car verseComposerData) (map car voiceComposerData) compositionIds adaptionIds bridgeIds interludeIds))
     ))
     (let*
       (
-       (extractedheadervars (extract-and-check-vars-from-module headermodule '(title starttext alttitle categorytitle categories authors songnumber chapterref)))
+       (extractedheadervars (extract-and-check-vars-from-header header '(title starttext alttitle categorytitle categories authors songnumber)))
        (title (assq-ref extractedheadervars 'title))
        (starttext (assq-ref extractedheadervars 'starttext))
        (alttitle (assq-ref extractedheadervars 'alttitle))
@@ -332,14 +304,12 @@ indexSection =
        (categories (assq-ref extractedheadervars 'categories))
        (authors (assq-ref extractedheadervars 'authors))
        (songnumber (assq-ref extractedheadervars 'songnumber))
-       (chapterref (assq-ref extractedheadervars 'chapterref))
        (textoptions (lambda (text alternative) `(((rawtext . ,text) (alternative . ,alternative) (songnumber . ,songnumber)))))
        (add-to-toc! (lambda (toctitle alternative)
                       (add-index-item! 'indexItemMarkup (textoptions toctitle alternative) toctitle label)))
        )
            (if categories (add-category-index-item! (string-tokenize categories) 'indexItemMarkup (textoptions (if categorytitle categorytitle title) #f) label))
            (if authors (add-author-index-item! (all-author-ids authors) 'indexItemMarkup (textoptions (if categorytitle categorytitle title) #f) label))
-           (if chapterref (add-chapter-index-item! chapterref 'indexItemMarkup (textoptions (if categorytitle categorytitle title) #f) label))
            (if starttext (add-to-toc! starttext #t))
            (if alttitle
                (if (list? alttitle)
@@ -350,9 +320,6 @@ indexSection =
            (if title (add-to-toc! title #f) #{ #})
     ))
 
-headerToTOC = #(define-music-function (parser location header label) (ly:book? symbol?)
-  (header-module-to-toc! (ly:book-header header) label))
-
 
 %% https://github.com/NalaGinrut/guile-csv/blob/master/csv/csv.scm
 
@@ -398,8 +365,11 @@ headerToTOC = #(define-music-function (parser location header label) (ly:book? s
          (para-lines (map cleanup-whitespaces para-strings)))
     (string-join para-lines "\n")))
   (define (generate-toc-csv labelPageTable)
-    (define (song-line filename page-number headermodule)
-            (let* ((extractedheadervars (extract-and-check-vars-from-module headermodule
+    (let ((song-lines (map (lambda (song)
+            (let* ((filename (symbol->string (car song)))
+                   (songvars (cdr song))
+                   (page-number (number->string (assoc-get (assq-ref songvars 'label) labelPageTable)))
+                   (extractedheadervars (extract-and-check-vars-from-header (assq-ref songvars 'header)
                       '(title starttext alttitle categorytitle categories authors year_text year_melody year_translation year_composition year_adaption infotext translation pronunciation copyright source)))
                    (headervar-or-empty (lambda (varsym)
                      (let ((extracted (assq-ref extractedheadervars varsym)))
@@ -410,7 +380,6 @@ headerToTOC = #(define-music-function (parser location header label) (ly:book? s
                    (versePoetData (find-author-id-with-part-numbers 'verse authors))
                    (composerIds (find-author-ids-by 'melody authors))
                    (verseComposerData (find-author-id-with-part-numbers 'meloverse authors))
-                   (refComposerIds (find-author-ids-by 'meloref authors))
                    (voiceComposerData (find-author-id-with-part-numbers 'voice authors))
                    (compositionIds (find-author-ids-by 'composition authors))
                    (adaptionTextIds (find-author-ids-by 'adaption_text authors))
@@ -432,7 +401,7 @@ headerToTOC = #(define-music-function (parser location header label) (ly:book? s
                   (headervar-or-empty 'categories)
                   (format-authors (append poetIds adaptionTextIds (map car versePoetData)))
                   (format-authors translatorIds)
-                  (format-authors (append composerIds compositionIds adaptionMusicIds bridgeIds interludeIds (map car voiceComposerData) (map car verseComposerData) refComposerIds))
+                  (format-authors (append composerIds compositionIds adaptionMusicIds bridgeIds interludeIds (map car voiceComposerData) (map car verseComposerData)))
                   (headervar-or-empty 'year_text)
                   (headervar-or-empty 'year_melody)
                   (headervar-or-empty 'year_translation)
@@ -445,16 +414,7 @@ headerToTOC = #(define-music-function (parser location header label) (ly:book? s
                   (format-info-paragraphs (headervar-or-empty 'translation))
                   (format-info-paragraphs (headervar-or-empty 'pronunciation))
               ))))
-    ;; Eingebettete Lieder (embedded_songs.ily) bekommen eigene Zeilen mit
-    ;; Dateiname und Seite des Hauptlieds.
-    (let ((song-lines (append-map (lambda (song)
-            (let* ((filename (symbol->string (car song)))
-                   (songvars (cdr song))
-                   (page-number (assoc-get (assq-ref songvars 'label) labelPageTable))
-                   (headermodule (ly:book-header (assq-ref songvars 'header))))
-              (map (lambda (module) (song-line filename page-number module))
-                   (cons headermodule (embedded-songs-of-header headermodule)))))
-            (alist-delete 'markupPage (alist-delete 'imagePage (alist-delete 'emptyPage song-list))))))
+            (alist-delete 'imagePage (alist-delete 'emptyPage song-list)))))
     (call-with-output-file "toc.csv"
       (lambda (port)
        (csv-write (cons '(
@@ -484,6 +444,6 @@ headerToTOC = #(define-music-function (parser location header label) (ly:book? s
   ; we use a delayed stencil to have all the page references available
   (ly:make-stencil
     `(delay-stencil-evaluation
-      ,(delay (let* ((table (ly:output-def-lookup layout 'label-page-string-table)))
+      ,(delay (let* ((table (ly:output-def-lookup layout 'label-absolute-page-table)))
         (generate-toc-csv (if (list? table) table '()))
         empty-stencil)))))

public_includes/layout_bottom.ily

@@ -1,17 +1,10 @@
 MUSIC = { \transposable #TRANSPOSITION \MUSIC }
 
-%% Eingebettete Lieder (siehe embedded_songs.ily) im Header des Hauptlieds
-%% vermerken, daraus bauen Footer, PDF-Lesezeichen und Verzeichnisse.
-#(if (and (pair? EMBEDDED_SONGS) (ly:book? HEADER) (ly:book-header HEADER))
-  (module-define! (ly:book-header HEADER) 'embeddedsongs EMBEDDED_SONGS))
-
 LAYOUT = \layout {
   \LAYOUT
   #(customized-layout LAYOUT)
 }
 
-#(customize-embedded-score-layouts! (list TEXT TEXT_PAGES))
-
 verselayout = \layout {
   \LAYOUT
   \context {
@@ -86,12 +79,9 @@ TEXT = \markuplist {
     (let ((output-name (ly:parser-output-name)))
       (set! chordpro-current-filename output-name))
 
-    ;; Try to extract metadata from the HEADER (falls back to basicSongInfo)
-    (let ((header-module (if (and (ly:book? HEADER) (ly:book-header HEADER))
-                             (ly:book-header HEADER)
-                             (and (defined? 'basicSongInfo) basicSongInfo))))
-      (when header-module
-        (let* ((header-alist (ly:module->alist header-module))
+    ;; Try to extract metadata from basicSongInfo \header block
+    (when (defined? 'basicSongInfo)
+      (let* ((header-alist (ly:module->alist basicSongInfo))
              (title (assoc-ref header-alist 'title))
              (authors (assoc-ref header-alist 'authors)))
         (when title
@@ -100,7 +90,7 @@ TEXT = \markuplist {
                     (markup->string title)
                     (if (string? title) title "Untitled"))))
         (when authors
-            (set! chordpro-header-authors authors))))))
+          (set! chordpro-header-authors authors)))))
 
   (add-score #{
     \score {