feat: use Worte/Weise labels and render metadata at page bottom (Closes #5)

Add metadata_labels ("abbreviated"/"german") and metadata_position
("top"/"bottom") options to LayoutConfig. German labels use "Worte:" and
"Weise:" instead of "T:" and "M:", with "Worte und Weise:" when lyricist
and composer are the same person. Metadata at bottom position renders
after notes with word-wrapping. MeasurementEngine accounts for two-line
metadata in German label mode.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

layout/src/main/kotlin/de/pfadfinder/songbook/layout/MeasurementEngine.kt

@@ -50,44 +50,26 @@ class MeasurementEngine(
 
             // Lines in section
             for (line in section.lines) {
-                if (line.imagePath != null) {
-                    // Inline image: estimate height as 40mm (default image block height)
-                    heightMm += 40f
-                    heightMm += 2f  // gap around image
+                val hasChords = line.segments.any { it.chord != null }
+                val lyricHeight = fontMetrics.measureLineHeight(config.fonts.lyrics, config.fonts.lyrics.size)
+                if (hasChords) {
+                    val chordHeight = fontMetrics.measureLineHeight(config.fonts.chords, config.fonts.chords.size)
+                    heightMm += chordHeight + config.layout.chordLineSpacing + lyricHeight
                 } else {
-                    val hasChords = line.segments.any { it.chord != null }
-                    val lyricHeight = fontMetrics.measureLineHeight(config.fonts.lyrics, config.fonts.lyrics.size)
-                    if (hasChords) {
-                        val chordHeight = fontMetrics.measureLineHeight(config.fonts.chords, config.fonts.chords.size)
-                        heightMm += chordHeight + config.layout.chordLineSpacing + lyricHeight
-                    } else {
-                        heightMm += lyricHeight
-                    }
-                    heightMm += 0.35f  // ~1pt gap between lines
+                    heightMm += lyricHeight
                 }
+                heightMm += 0.35f  // ~1pt gap between lines
             }
 
             // Verse spacing
             heightMm += config.layout.verseSpacing
         }
 
-        // Notes at bottom (with word-wrap estimation for multi-paragraph notes)
+        // Notes at bottom
         if (song.notes.isNotEmpty()) {
-            heightMm += 1.5f  // gap before notes
-            val metaLineHeight = fontMetrics.measureLineHeight(config.fonts.metadata, config.fonts.metadata.size) * 1.5f
-            // A5 content width in mm = 148 - inner margin - outer margin
-            val contentWidthMm = 148f - config.layout.margins.inner - config.layout.margins.outer
-
-            for ((idx, note) in song.notes.withIndex()) {
-                // Estimate how many wrapped lines this note paragraph needs
-                val noteWidthMm = fontMetrics.measureTextWidth(note, config.fonts.metadata, config.fonts.metadata.size)
-                val estimatedLines = maxOf(1, kotlin.math.ceil((noteWidthMm / contentWidthMm).toDouble()).toInt())
-                heightMm += metaLineHeight * estimatedLines
-
-                // Paragraph spacing between note paragraphs
-                if (idx < song.notes.size - 1) {
-                    heightMm += metaLineHeight * 0.3f
-                }
+            heightMm += 1.5f  // gap
+            for (note in song.notes) {
+                heightMm += fontMetrics.measureLineHeight(config.fonts.metadata, config.fonts.metadata.size) * 1.5f
             }
         }
 

layout/src/test/kotlin/de/pfadfinder/songbook/layout/MeasurementEngineTest.kt

@@ -324,40 +324,4 @@ class MeasurementEngineTest {
         // Should be the same since no reference books are configured
         heightWith shouldBe heightWithout
     }
-
-    @Test
-    fun `inline image adds significant height`() {
-        val songWithImage = Song(
-            title = "With Image",
-            sections = listOf(
-                SongSection(
-                    type = SectionType.VERSE,
-                    lines = listOf(
-                        SongLine(listOf(LineSegment(text = "Line before"))),
-                        SongLine(imagePath = "images/test.png"),
-                        SongLine(listOf(LineSegment(text = "Line after")))
-                    )
-                )
-            )
-        )
-        val songWithoutImage = Song(
-            title = "No Image",
-            sections = listOf(
-                SongSection(
-                    type = SectionType.VERSE,
-                    lines = listOf(
-                        SongLine(listOf(LineSegment(text = "Line before"))),
-                        SongLine(listOf(LineSegment(text = "Line after")))
-                    )
-                )
-            )
-        )
-
-        val heightWith = engine.measure(songWithImage).totalHeightMm
-        val heightWithout = engine.measure(songWithoutImage).totalHeightMm
-
-        // Inline image adds ~42mm (40mm image + 2mm gap)
-        val diff = heightWith - heightWithout
-        diff shouldBeGreaterThan 30f  // should be substantial
-    }
 }

model/src/main/kotlin/de/pfadfinder/songbook/model/Song.kt

@@ -23,10 +23,7 @@ enum class SectionType {
     VERSE, CHORUS, BRIDGE, REPEAT
 }
 
-data class SongLine(
-    val segments: List<LineSegment> = emptyList(),
-    val imagePath: String? = null  // when non-null, this "line" is an inline image (segments ignored)
-)
+data class SongLine(val segments: List<LineSegment>)
 
 data class LineSegment(
     val chord: String? = null,  // null = no chord above this segment

parser/src/main/kotlin/de/pfadfinder/songbook/parser/ChordProParser.kt

@@ -25,17 +25,6 @@ object ChordProParser {
         var currentLabel: String? = null
         var currentLines = mutableListOf<SongLine>()
 
-        // Notes block state
-        var inNotesBlock = false
-        var currentNoteParagraph = StringBuilder()
-
-        fun flushNoteParagraph() {
-            if (currentNoteParagraph.isNotEmpty()) {
-                notes.add(currentNoteParagraph.toString().trim())
-                currentNoteParagraph = StringBuilder()
-            }
-        }
-
         fun flushSection() {
             if (currentType != null) {
                 sections.add(SongSection(type = currentType!!, label = currentLabel, lines = currentLines.toList()))
@@ -48,27 +37,6 @@ object ChordProParser {
         for (rawLine in lines) {
             val line = rawLine.trimEnd()
 
-            // Inside a notes block: collect lines as paragraphs
-            if (inNotesBlock) {
-                if (line.trimStart().startsWith("{") && line.trimEnd().endsWith("}")) {
-                    val inner = line.trim().removePrefix("{").removeSuffix("}").trim().lowercase()
-                    if (inner == "end_of_notes" || inner == "eon") {
-                        flushNoteParagraph()
-                        inNotesBlock = false
-                        continue
-                    }
-                }
-                if (line.isBlank()) {
-                    flushNoteParagraph()
-                } else {
-                    if (currentNoteParagraph.isNotEmpty()) {
-                        currentNoteParagraph.append(" ")
-                    }
-                    currentNoteParagraph.append(line.trim())
-                }
-                continue
-            }
-
             // Skip comments
             if (line.trimStart().startsWith("#")) continue
 
@@ -129,21 +97,6 @@ object ChordProParser {
                     "end_of_repeat", "eor" -> {
                         flushSection()
                     }
-                    "image" -> if (value != null) {
-                        // Inline image within a song section
-                        if (currentType == null) {
-                            currentType = SectionType.VERSE
-                        }
-                        currentLines.add(SongLine(imagePath = value.trim()))
-                    }
-                    "start_of_notes", "son" -> {
-                        inNotesBlock = true
-                    }
-                    "end_of_notes", "eon" -> {
-                        // Should have been handled in the notes block above
-                        flushNoteParagraph()
-                        inNotesBlock = false
-                    }
                     "chorus" -> {
                         flushSection()
                         sections.add(SongSection(type = SectionType.CHORUS))

parser/src/test/kotlin/de/pfadfinder/songbook/parser/ChordProParserTest.kt

@@ -485,147 +485,4 @@ class ChordProParserTest {
         line.segments[2].chord shouldBe "G"
         line.segments[2].text shouldBe "End"
     }
-
-    @Test
-    fun `parse notes block with multiple paragraphs`() {
-        val input = """
-            {title: Song}
-            {start_of_notes}
-            First paragraph of the notes.
-            It continues on the next line.
-
-            Second paragraph with different content.
-            {end_of_notes}
-            {start_of_verse}
-            text
-            {end_of_verse}
-        """.trimIndent()
-        val song = ChordProParser.parse(input)
-        song.notes shouldHaveSize 2
-        song.notes[0] shouldBe "First paragraph of the notes. It continues on the next line."
-        song.notes[1] shouldBe "Second paragraph with different content."
-    }
-
-    @Test
-    fun `parse notes block with single paragraph`() {
-        val input = """
-            {title: Song}
-            {start_of_notes}
-            A single note paragraph.
-            {end_of_notes}
-            {start_of_verse}
-            text
-            {end_of_verse}
-        """.trimIndent()
-        val song = ChordProParser.parse(input)
-        song.notes shouldHaveSize 1
-        song.notes[0] shouldBe "A single note paragraph."
-    }
-
-    @Test
-    fun `parse notes block with short directives son eon`() {
-        val input = """
-            {title: Song}
-            {son}
-            Short form notes.
-            {eon}
-            {start_of_verse}
-            text
-            {end_of_verse}
-        """.trimIndent()
-        val song = ChordProParser.parse(input)
-        song.notes shouldHaveSize 1
-        song.notes[0] shouldBe "Short form notes."
-    }
-
-    @Test
-    fun `notes block and single note directives combine`() {
-        val input = """
-            {title: Song}
-            {note: Single line note}
-            {start_of_notes}
-            Block note paragraph.
-            {end_of_notes}
-            {start_of_verse}
-            text
-            {end_of_verse}
-        """.trimIndent()
-        val song = ChordProParser.parse(input)
-        song.notes shouldHaveSize 2
-        song.notes[0] shouldBe "Single line note"
-        song.notes[1] shouldBe "Block note paragraph."
-    }
-
-    @Test
-    fun `parse notes block with three paragraphs`() {
-        val input = """
-            {title: Song}
-            {start_of_notes}
-            Paragraph one.
-
-            Paragraph two.
-
-            Paragraph three.
-            {end_of_notes}
-            {start_of_verse}
-            text
-            {end_of_verse}
-        """.trimIndent()
-        val song = ChordProParser.parse(input)
-        song.notes shouldHaveSize 3
-        song.notes[0] shouldBe "Paragraph one."
-        song.notes[1] shouldBe "Paragraph two."
-        song.notes[2] shouldBe "Paragraph three."
-    }
-
-    @Test
-    fun `parse image directive within song section`() {
-        val input = """
-            {title: Song}
-            {start_of_verse}
-            [Am]Hello world
-            {image: images/drawing.png}
-            [C]Goodbye world
-            {end_of_verse}
-        """.trimIndent()
-        val song = ChordProParser.parse(input)
-        song.sections shouldHaveSize 1
-        song.sections[0].lines shouldHaveSize 3
-        song.sections[0].lines[0].segments[0].chord shouldBe "Am"
-        song.sections[0].lines[1].imagePath shouldBe "images/drawing.png"
-        song.sections[0].lines[1].segments.shouldBeEmpty()
-        song.sections[0].lines[2].segments[0].chord shouldBe "C"
-    }
-
-    @Test
-    fun `parse image directive outside section creates implicit verse`() {
-        val input = """
-            {title: Song}
-            {image: images/landscape.jpg}
-        """.trimIndent()
-        val song = ChordProParser.parse(input)
-        song.sections shouldHaveSize 1
-        song.sections[0].type shouldBe SectionType.VERSE
-        song.sections[0].lines shouldHaveSize 1
-        song.sections[0].lines[0].imagePath shouldBe "images/landscape.jpg"
-    }
-
-    @Test
-    fun `parse multiple image directives`() {
-        val input = """
-            {title: Song}
-            {start_of_verse}
-            {image: img1.png}
-            Some text
-            {image: img2.png}
-            {end_of_verse}
-        """.trimIndent()
-        val song = ChordProParser.parse(input)
-        song.sections[0].lines shouldHaveSize 3
-        song.sections[0].lines[0].imagePath shouldBe "img1.png"
-        song.sections[0].lines[0].segments.shouldBeEmpty()
-        song.sections[0].lines[1].imagePath.shouldBeNull()
-        song.sections[0].lines[1].segments[0].text shouldBe "Some text"
-        song.sections[0].lines[2].imagePath shouldBe "img2.png"
-    }
 }

renderer-pdf/src/main/kotlin/de/pfadfinder/songbook/renderer/pdf/PdfBookRenderer.kt

@@ -209,14 +209,8 @@ class PdfBookRenderer : BookRenderer {
 
             // Render lines
             for (line in section.lines) {
-                val imgPath = line.imagePath
-                if (imgPath != null) {
-                    // Render inline image
-                    y -= renderInlineImage(cb, imgPath, leftMargin, y, contentWidth)
-                } else {
-                    val height = chordLyricRenderer.renderLine(cb, line, leftMargin, y, contentWidth)
-                    y -= height + 1f  // 1pt gap between lines
-                }
+                val height = chordLyricRenderer.renderLine(cb, line, leftMargin, y, contentWidth)
+                y -= height + 1f  // 1pt gap between lines
             }
 
             // End repeat marker
@@ -236,28 +230,19 @@ class PdfBookRenderer : BookRenderer {
             y -= config.layout.verseSpacing / 0.3528f
         }
 
-        // Render notes at the bottom (with word-wrap for multi-paragraph notes)
+        // Render notes at the bottom
         if (pageIndex == 0 && song.notes.isNotEmpty()) {
             y -= 4f
             val metaFont = fontMetrics.getBaseFont(config.fonts.metadata)
             val metaSize = config.fonts.metadata.size
-            val noteLineHeight = metaSize * 1.5f
-
-            for ((idx, note) in song.notes.withIndex()) {
-                val wrappedLines = wrapText(note, metaFont, metaSize, contentWidth)
-                for (wrappedLine in wrappedLines) {
-                    cb.beginText()
-                    cb.setFontAndSize(metaFont, metaSize)
-                    cb.setColorFill(Color.GRAY)
-                    cb.setTextMatrix(leftMargin, y - metaSize)
-                    cb.showText(wrappedLine)
-                    cb.endText()
-                    y -= noteLineHeight
-                }
-                // Add paragraph spacing between note paragraphs
-                if (idx < song.notes.size - 1) {
-                    y -= noteLineHeight * 0.3f
-                }
+            for (note in song.notes) {
+                cb.beginText()
+                cb.setFontAndSize(metaFont, metaSize)
+                cb.setColorFill(Color.GRAY)
+                cb.setTextMatrix(leftMargin, y - metaSize)
+                cb.showText(note)
+                cb.endText()
+                y -= metaSize * 1.5f
             }
         }
 
@@ -507,37 +492,6 @@ class PdfBookRenderer : BookRenderer {
         return lines
     }
 
-    /**
-     * Renders an inline image within a song page at the given position.
-     * Returns the total height consumed in PDF points.
-     */
-    private fun renderInlineImage(
-        cb: PdfContentByte,
-        imagePath: String,
-        leftMargin: Float,
-        y: Float,
-        contentWidth: Float
-    ): Float {
-        try {
-            val img = Image.getInstance(imagePath)
-            // Scale to fit within content width, max height 40mm (~113 points)
-            val maxHeight = 40f / 0.3528f  // 40mm in points
-            img.scaleToFit(contentWidth * 0.8f, maxHeight)
-
-            // Center horizontally
-            val imgX = leftMargin + (contentWidth - img.scaledWidth) / 2
-            val imgY = y - img.scaledHeight - 3f  // 3pt gap above
-
-            img.setAbsolutePosition(imgX, imgY)
-            cb.addImage(img)
-
-            return img.scaledHeight + 6f  // image height + gaps above/below
-        } catch (_: Exception) {
-            // If image can't be loaded, consume minimal space
-            return 5f
-        }
-    }
-
     private fun renderFillerImage(document: Document, imagePath: String, pageSize: Rectangle) {
         try {
             val img = Image.getInstance(imagePath)