%% ChordPro Export Engraver %% ========================= %% Single engraver in Score context that collects all data #(use-modules (ice-9 format)) #(use-modules (srfi srfi-1)) %% Per-Song-Store %% ============== %% Der gesamte Sammel-Zustand liegt in einer Struktur pro Lied, gekeyt ueber %% den Liednamen (Buch: songfilename aus \setsongfilename bzw. includeSong; %% Einzellied: ly:parser-output-name). So koennen mehrere Lieder in einem %% Durchlauf (Liederbuch) getrennt gesammelt und geschrieben werden. %% %% Bewusst KEIN srfi-9-Record: Im Buch wird diese Datei pro Lied erneut %% evaluiert (jedes Lied inkludiert base_config -> all.ily), und srfi-9- %% Typen sind generativ -- alte Instanzen wuerden mit neu definierten %% Accessoren kollidieren. Hashtabelle + Prozedur-Accessoren sind gegen %% Re-Evaluation robust; der Store selbst ueberlebt sie per defined?-Idiom. #(define chordpro-song-store (if (defined? 'chordpro-song-store) chordpro-song-store (make-hash-table))) #(define (chordpro-make-song key) (let ((song (make-hash-table))) (hashq-set! song 'key key) ;; Alle Sammel-Listen werden in umgekehrter Reihenfolge aufgebaut (cons) (hashq-set! song 'syllables '()) (hashq-set! song 'chords '()) (hashq-set! song 'breaks '()) (hashq-set! song 'stanza-numbers '()) ;; Format: (moment verse-idx text direction) fuer Inline-Marker wie repStart/repStop (hashq-set! song 'inline-texts '()) ;; Zaehlt mit jedem \chordlyrics-Score des Lieds hoch (hashq-set! song 'verse-index 0) ;; Dokumentreihenfolge pro Vers: (idx seq pos sub). Die Interpretation ;; der Textseiten laeuft in umgekehrter Dokumentreihenfolge, bei ;; mehrspaltigen \group-verses zusaetzlich verschraenkt -- seq/pos ;; stellen die Quellreihenfolge wieder her (siehe ;; chordpro-song-ordered-verse-indices), sub ordnet Sub-Verse aus ;; Marker-Splits hinter ihren Elternvers. (hashq-set! song 'verse-order '()) ;; Akkorde, die {define:}-Direktiven brauchen (hashq-set! song 'minor-chords '()) (hashq-set! song 'b-chords '()) (hashq-set! song 'h-chords '()) (hashq-set! song 'accidental-chords '()) (hashq-set! song 'title #f) (hashq-set! song 'authors #f) ;; Weitere ChordPro-Metadaten-Direktiven, aus dem Header/der Musik des ;; Liedes befuellt (siehe chordpro-register-song-metadata) -- alle #f, ;; wenn nicht ermittelbar, dann wird die jeweilige Direktive weggelassen. (hashq-set! song 'copyright #f) (hashq-set! song 'year #f) (hashq-set! song 'key-signature #f) (hashq-set! song 'time #f) (hashq-set! song 'tempo #f) ;; Schreibschutz: jedes Lied wird nur einmal geschrieben (hashq-set! song 'written #f) song)) #(define (chordpro-song-key s) (hashq-ref s 'key)) #(define (chordpro-song-syllables s) (hashq-ref s 'syllables)) #(define (set-chordpro-song-syllables! s v) (hashq-set! s 'syllables v)) #(define (chordpro-song-chords s) (hashq-ref s 'chords)) #(define (set-chordpro-song-chords! s v) (hashq-set! s 'chords v)) #(define (chordpro-song-breaks s) (hashq-ref s 'breaks)) #(define (set-chordpro-song-breaks! s v) (hashq-set! s 'breaks v)) #(define (chordpro-song-stanza-numbers s) (hashq-ref s 'stanza-numbers)) #(define (set-chordpro-song-stanza-numbers! s v) (hashq-set! s 'stanza-numbers v)) #(define (chordpro-song-inline-texts s) (hashq-ref s 'inline-texts)) #(define (set-chordpro-song-inline-texts! s v) (hashq-set! s 'inline-texts v)) #(define (chordpro-song-verse-index s) (hashq-ref s 'verse-index)) #(define (set-chordpro-song-verse-index! s v) (hashq-set! s 'verse-index v)) #(define (chordpro-song-verse-order s) (hashq-ref s 'verse-order)) #(define (set-chordpro-song-verse-order! s v) (hashq-set! s 'verse-order v)) #(define (chordpro-song-minor-chords s) (hashq-ref s 'minor-chords)) #(define (set-chordpro-song-minor-chords! s v) (hashq-set! s 'minor-chords v)) #(define (chordpro-song-b-chords s) (hashq-ref s 'b-chords)) #(define (set-chordpro-song-b-chords! s v) (hashq-set! s 'b-chords v)) #(define (chordpro-song-h-chords s) (hashq-ref s 'h-chords)) #(define (set-chordpro-song-h-chords! s v) (hashq-set! s 'h-chords v)) #(define (chordpro-song-accidental-chords s) (hashq-ref s 'accidental-chords)) #(define (set-chordpro-song-accidental-chords! s v) (hashq-set! s 'accidental-chords v)) #(define (chordpro-song-title s) (hashq-ref s 'title)) #(define (set-chordpro-song-title! s v) (hashq-set! s 'title v)) #(define (chordpro-song-authors s) (hashq-ref s 'authors)) #(define (set-chordpro-song-authors! s v) (hashq-set! s 'authors v)) #(define (chordpro-song-copyright s) (hashq-ref s 'copyright)) #(define (set-chordpro-song-copyright! s v) (hashq-set! s 'copyright v)) #(define (chordpro-song-year s) (hashq-ref s 'year)) #(define (set-chordpro-song-year! s v) (hashq-set! s 'year v)) #(define (chordpro-song-key-signature s) (hashq-ref s 'key-signature)) #(define (set-chordpro-song-key-signature! s v) (hashq-set! s 'key-signature v)) #(define (chordpro-song-time s) (hashq-ref s 'time)) #(define (set-chordpro-song-time! s v) (hashq-set! s 'time v)) #(define (chordpro-song-tempo s) (hashq-ref s 'tempo)) #(define (set-chordpro-song-tempo! s v) (hashq-set! s 'tempo v)) #(define (chordpro-song-written s) (hashq-ref s 'written)) #(define (set-chordpro-song-written! s v) (hashq-set! s 'written v)) #(define (chordpro-get-song key) "Store-Eintrag zu key holen, bei Bedarf frisch anlegen." (or (hash-ref chordpro-song-store key) (let ((song (chordpro-make-song key))) (hash-set! chordpro-song-store key song) song))) %% Einzellied-Fallback fuer den Song-Key; layout_bottom setzt ihn auf %% (ly:parser-output-name). Im Buch kommt der Key stattdessen aus den %% Markup-Props (\setsongfilename), weil der geklonte Parser nur den %% Buchnamen kennt. #(define chordpro-default-song-key #f) #(define (chordpro-resolve-song-key props) "Song-Key aus Markup-Props (Buch) oder dem Einzellied-Fallback." (let ((from-props (and props (chain-assoc-get 'songfilename props #f)))) (cond ((and (string? from-props) (not (string-null? from-props))) from-props) (chordpro-default-song-key) (else "output")))) %% Lied, in dessen Store der Collector-Engraver gerade schreibt. Wird von %% \chordlyrics vor der (synchronen) Score-Interpretation gesetzt. #(define chordpro-active-song-key #f) %% Props des laufenden \chordlyrics-Aufrufs -- der Collector loest damit %% Markup-Silben (\updown u.ae.) auf, deren \tag-Sichtbarkeit an %% tags-to-keep/tags-to-remove aus umgebenden \keep-with-tag haengt. #(define chordpro-active-props #f) %% Dokumentreihenfolge: \group-verses nimmt sich pro Aufruf eine %% Sequenznummer und stempelt seine Verse mit (seq . pos) in die Props; %% \chordlyrics ausserhalb einer Gruppe nimmt sich selbst eine Nummer. %% Da die Interpretation in umgekehrter Dokumentreihenfolge laeuft, %% ergibt seq absteigend + pos aufsteigend die Quellreihenfolge. #(define chordpro-doc-seq-counter (if (defined? 'chordpro-doc-seq-counter) chordpro-doc-seq-counter 0)) #(define chordpro-active-doc-order #f) %% Verse-Indizes eines Lieds in Dokumentreihenfolge (fuer Writer/Export). #(define (chordpro-song-ordered-verse-indices song) (let* ((order-alist (chordpro-song-verse-order song)) (order-of (lambda (idx) (or (assv idx order-alist) (list idx 0 0 0))))) (sort (iota (chordpro-song-verse-index song)) (lambda (a b) (let ((oa (order-of a)) (ob (order-of b))) ;; seq absteigend, pos aufsteigend, sub aufsteigend, ;; Fallback: idx absteigend (cond ((not (= (cadr oa) (cadr ob))) (> (cadr oa) (cadr ob))) ((not (= (caddr oa) (caddr ob))) (< (caddr oa) (caddr ob))) ((not (= (cadddr oa) (cadddr ob))) (< (cadddr oa) (cadddr ob))) (else (> a b)))))))) %% Titel/Autoren aus basicSongInfo in den Store uebernehmen. Einzellied: %% layout_bottom nach dem Parsen; Buch: includeSong direkt nach dem Parsen %% des Lieds (basicSongInfo haelt dann genau dieses Lied). %% Musikalische Metadaten (Takt/Tonart/Tempo) kommen aus music->data-alist %% (data_extractor.ily) -- dieselbe Extraktion wie fuer den YAML-Export, %% nur zusaetzlich fuer ChordPro in dessen Notation umgewandelt. #(define (chordpro-register-song-metadata key) (when (defined? 'basicSongInfo) (let* ((header-alist (ly:module->alist basicSongInfo)) (title (assoc-ref header-alist 'title)) (authors (assoc-ref header-alist 'authors)) (copyright (assoc-ref header-alist 'copyright)) (year (or (assoc-ref header-alist 'year_text) (assoc-ref header-alist 'year_melody))) (music-alist (and (defined? 'MUSIC) (ly:music? MUSIC) (music->data-alist MUSIC))) (song (chordpro-get-song key))) (when title (set-chordpro-song-title! song (cond ((markup? title) (markup->string title)) ((string? title) title) (else #f)))) (when authors (set-chordpro-song-authors! song authors)) (when (and (string? copyright) (not (string-null? copyright))) (set-chordpro-song-copyright! song copyright)) (when (and (string? year) (not (string-null? year))) (set-chordpro-song-year! song year)) (when music-alist (let ((key-str (assoc-ref music-alist 'key)) (time-str (assoc-ref music-alist 'time)) (tempo-str (assoc-ref music-alist 'tempo))) (when key-str (set-chordpro-song-key-signature! song (lilypond-key->chordpro-key key-str))) (when time-str (set-chordpro-song-time! song time-str)) (when tempo-str (let ((bpm (chordpro-tempo-number tempo-str))) (when bpm (set-chordpro-song-tempo! song bpm))))))))) %% Configuration (set by layout_bottom.ily or song file) %% Aktivierbar wie yaml-export-enabled durch Definieren der Variable vor %% dem Laden der Includes. #(define chordpro-export-enabled (if (defined? 'chordpro-export-enabled) chordpro-export-enabled #f)) %% Helper function to convert German minor chord notation to standard major form %% Used for generating {define:} directives #(define (german-minor-to-major-form chord-str) "Convert lowercase German minor chords (e.g., 'a7', 'fis') to standard form (e.g., 'Am7', 'Fism')" (if (or (not (string? chord-str)) (string-null? chord-str)) chord-str (let* ((first-char (string-ref chord-str 0))) (if (char-lower-case? first-char) ;; It's a minor chord - capitalize first letter and add 'm' after accidentals (let* ((rest-str (if (> (string-length chord-str) 1) (substring chord-str 1) "")) ;; Find where to insert 'm': after 'is' or 'es' if present, otherwise right after root (insert-pos (cond ((string-prefix? "is" rest-str) 2) ((string-prefix? "es" rest-str) 2) (else 0))) (before-m (substring rest-str 0 insert-pos)) (after-m (substring rest-str insert-pos))) (string-append (string (char-upcase first-char)) before-m "m" after-m)) ;; Already uppercase - return as is chord-str)))) %% Helper function to convert German accidentals to international format #(define (german-accidentals-to-international chord-str) "Convert German 'is' to '#' and 'es' to 'b' (e.g., 'fis' -> 'F#', 'as' -> 'Ab')" (if (or (not (string? chord-str)) (string-null? chord-str)) chord-str (let* ((first-char (string-ref chord-str 0)) (rest-str (if (> (string-length chord-str) 1) (substring chord-str 1) "")) ;; Check for 'is' (sharp) or 'es' (flat) (has-is (string-prefix? "is" rest-str)) (has-es (string-prefix? "es" rest-str)) ;; Convert root note (root-upper (string (char-upcase first-char))) ;; Process accidentals and rest (processed-rest (cond (has-is ; fis -> F#, cis -> C# (string-append "#" (substring rest-str 2))) (has-es ; as -> Ab, es -> Eb (string-append "b" (substring rest-str 2))) (else rest-str)))) ;; Special case: if it's a minor chord (lowercase), add 'm' after accidental (if (char-lower-case? first-char) ;; Minor: add 'm' after accidental (if (or has-is has-es) (string-append root-upper (substring processed-rest 0 1) "m" (substring processed-rest 1)) (string-append root-upper "m" processed-rest)) ;; Major: just return converted (string-append root-upper processed-rest))))) %% Helper function to convert B/b chords to Bb/Bbm form for {define:} directives #(define (german-b-to-bb-form chord-str) "Convert B/b chords to Bb/Bbm format (e.g., 'B7' -> 'Bb7', 'b' -> 'Bbm', 'b7' -> 'Bbm7')" (if (or (not (string? chord-str)) (string-null? chord-str)) chord-str (let ((first-char (string-ref chord-str 0))) (cond ;; Uppercase B -> Bb + rest ((char=? first-char #\B) (string-append "Bb" (substring chord-str 1))) ;; Lowercase b -> Bbm + rest (it's b-minor) ((char=? first-char #\b) (let ((rest-str (if (> (string-length chord-str) 1) (substring chord-str 1) ""))) (string-append "Bbm" rest-str))) (else chord-str))))) %% Helper function to convert H/h chords to B/Bm form for {define:} directives #(define (german-h-to-b-form chord-str) "Convert H/h chords to B/Bm format (e.g., 'H7' -> 'B7', 'h' -> 'Bm', 'h7' -> 'Bm7')" (if (or (not (string? chord-str)) (string-null? chord-str)) chord-str (let ((first-char (string-ref chord-str 0))) (cond ;; Uppercase H -> B + rest ((char=? first-char #\H) (string-append "B" (substring chord-str 1))) ;; Lowercase h -> Bm + rest (it's h-minor) ((char=? first-char #\h) (let ((rest-str (if (> (string-length chord-str) 1) (substring chord-str 1) ""))) (string-append "Bm" rest-str))) (else chord-str))))) %% Helper function to track minor/B/H/accidental chords and return original #(define (track-and-return-chord song chord-str) "Track chords that need {define:} directives (per song) and return original." (if (or (not (string? chord-str)) (string-null? chord-str)) chord-str (let* ((first-char (string-ref chord-str 0)) (rest-str (if (> (string-length chord-str) 1) (substring chord-str 1) "")) (has-is (string-prefix? "is" rest-str)) (has-es (string-prefix? "es" rest-str)) (has-accidental (or has-is has-es)) (add-unique! (lambda (getter setter!) (unless (member chord-str (getter song)) (setter! song (cons chord-str (getter song))))))) (cond ;; H/h chords (German H = English B) ((or (char=? first-char #\H) (char=? first-char #\h)) (add-unique! chordpro-song-h-chords set-chordpro-song-h-chords!)) ;; B/b chords (German B = English Bb) ((or (char=? first-char #\B) (char=? first-char #\b)) (add-unique! chordpro-song-b-chords set-chordpro-song-b-chords!)) ;; Chords with accidentals (is/es) (has-accidental (add-unique! chordpro-song-accidental-chords set-chordpro-song-accidental-chords!)) ;; Other lowercase chords (minor without B/H/accidentals) ((char-lower-case? first-char) (add-unique! chordpro-song-minor-chords set-chordpro-song-minor-chords!))) ;; Always return original chord-str))) %% Helper function to convert chord music object to chord name string #(define (music-to-chord-name chord-music) "Extract pitches from a chord music object and convert to German chord name" (if (not chord-music) "" (let* ((pitches (music-pitches chord-music))) (if (or (not pitches) (null? pitches)) "" ; No pitches found (let* (;; Use ignatzek chord naming with German root names (chord-markup ((chord-name:name-markup 'deutsch) pitches #f #f #f)) ;; Convert markup to string (chord-str (if (markup? chord-markup) (markup->string chord-markup) "")) ;; Remove spaces (cleaned (string-delete #\space chord-str))) cleaned))))) %% Helper function to normalize multiple spaces to single space #(define (normalize-spaces str) "Replace multiple consecutive spaces with a single space" (let loop ((chars (string->list str)) (result '()) (prev-was-space #f)) (if (null? chars) (list->string (reverse result)) (let ((char (car chars))) (if (char=? char #\space) (if prev-was-space ;; Skip this space (loop (cdr chars) result #t) ;; Keep this space (loop (cdr chars) (cons char result) #t)) ;; Not a space (loop (cdr chars) (cons char result) #f)))))) %% Helper function to extract chord names from markup, handling \altChord format #(define (extract-chord-names-from-markup markup) "Extract chord names from markup, handling complex structures like \altChord which produces 'B(Gm)' format" (let* ((raw-str (cond ((string? markup) markup) ((markup? markup) (markup->string markup)) ((pair? markup) (extract-chord-names-from-markup (car markup))) (else (format #f "~a" markup)))) ;; Remove all spaces (clean-str (string-delete #\space raw-str))) ;; Check if this is an altChord format: "B(Gm)" or similar (if (string-index clean-str #\() ;; Multiple chords: split by parentheses (let* ((open-paren (string-index clean-str #\()) (close-paren (string-index clean-str #\))) (first-chord (substring clean-str 0 open-paren)) (second-chord (if (and open-paren close-paren) (substring clean-str (+ open-paren 1) close-paren) ""))) ;; Format as:[B][(Gm)] - first chord normal, second in parens (string-append first-chord "][(" second-chord ")")) ;; Single chord: return as is clean-str))) %% Helper function to format stanza label for ChordPro #(define (format-chordpro-stanza-label stanza-type stanza-numbers) "Generate ChordPro label based on stanza type and optional numbers" (let* ((has-numbers (and stanza-numbers (not (null? stanza-numbers)))) (numbers-string (if has-numbers (string-join (map (lambda (n) (format #f "~a" n)) stanza-numbers) ", ") ""))) (cond ((eq? stanza-type 'ref) (if has-numbers (format #f (if (defined? 'refStringWithNumbers) refStringWithNumbers "Ref. ~a:") numbers-string) (if (defined? 'refString) refString "Ref.:"))) ((eq? stanza-type 'bridge) (if has-numbers (format #f (if (defined? 'bridgeStringWithNumbers) bridgeStringWithNumbers "Bridge ~a:") numbers-string) (if (defined? 'bridgeString) bridgeString "Bridge:"))) (else #f)))) %% Single engraver in Score context #(define ChordPro_score_collector (lambda (context) (let ((song #f) (pending-syllable #f) (this-verse-index #f) (doc-seq 0) (doc-pos 0) (sub-counter 0)) ;; pending-syllable: (moment text verse-idx) (define (save-pending! has-hyphen) (when pending-syllable (set-chordpro-song-syllables! song (cons (list (car pending-syllable) (cadr pending-syllable) has-hyphen (caddr pending-syllable)) (chordpro-song-syllables song))) (set! pending-syllable #f))) (define (record-verse-order! idx) (set-chordpro-song-verse-order! song (cons (list idx doc-seq doc-pos sub-counter) (chordpro-song-verse-order song)))) (make-engraver ;; Initialize - called when engraver is created (once per \chordlyrics) ((initialize engraver) ;; \chordlyrics hat den aktiven Song-Key vor der Interpretation gesetzt; ;; jeder \chordlyrics-Score ist ein Vers dieses Lieds. (set! song (chordpro-get-song (or chordpro-active-song-key "output"))) (set! this-verse-index (chordpro-song-verse-index song)) (set-chordpro-song-verse-index! song (+ this-verse-index 1)) (let ((order (or chordpro-active-doc-order (cons 0 0)))) (set! doc-seq (car order)) (set! doc-pos (cdr order))) (record-verse-order! this-verse-index)) ;; Event listeners (listeners ;; LyricEvent from Lyrics context ((lyric-event engraver event) (let* ((raw-text (ly:event-property event 'text)) ;; Markup-Silben (z.B. \updown) mit den Props des ;; chordlyrics-Aufrufs zu Strings aufloesen -- erst dabei ;; entscheidet sich die \tag-Sichtbarkeit. (text (cond ((string? raw-text) raw-text) ((markup? raw-text) (markup->string raw-text #:props (or chordpro-active-props '()))) (else #f))) (moment (ly:context-current-moment context))) (when (string? text) ;; Save previous syllable if any (it had no hyphen) (save-pending! #f) ;; Store new syllable as pending (with THIS instance's verse index) (set! pending-syllable (list moment text this-verse-index))))) ;; HyphenEvent from Lyrics context ((hyphen-event engraver event) (save-pending! #t)) ;; BreakEvent - store break moment ((break-event engraver event) (let ((moment (ly:context-current-moment context))) ;; Store break with this instance's verse index (set-chordpro-song-breaks! song (cons (cons moment this-verse-index) (chordpro-song-breaks song)))))) ;; Acknowledge grobs from child contexts (acknowledgers ;; StanzaNumber grobs to extract stanza type and text ((stanza-number-interface engraver grob source-engraver) (let* ((details (ly:grob-property grob 'details '())) (custom-realstanza (ly:assoc-get 'custom-realstanza details #f)) (stanza-type (ly:assoc-get 'custom-stanza-type details 'verse)) ;; \override-stanza ueberschreibt die GEDRUCKTEN Nummern ;; (z.B. "Ref. 4:" statt "Ref. 1, 4:") -- die zaehlen. (stanza-numbers (or (ly:assoc-get 'custom-stanzanumber-override details #f) (ly:assoc-get 'custom-stanza-numbers details '()))) ;; Check for custom inline text (e.g., repStart/repStop with direction) (custom-inline-text (ly:assoc-get 'custom-inline-text details #f)) (custom-inline-direction (ly:assoc-get 'custom-inline-direction details CENTER)) ;; Try to read stanza text from multiple sources: ;; 1. From the grob's text property (stanza-text-from-grob (ly:grob-property grob 'text #f)) ;; 2. From the Lyrics context's stanza property (lyrics-context (ly:translator-context source-engraver)) (stanza-text-from-context (if lyrics-context (ly:context-property lyrics-context 'stanza #f) #f)) ;; Use context property if available, otherwise grob property (stanza-markup (or stanza-text-from-context stanza-text-from-grob)) ;; For ref/bridge, always use format-chordpro-stanza-label ;; For verse, extract from markup (includes roman numerals if \romanStanza was used) (stanza-text (if (or (eq? stanza-type 'ref) (eq? stanza-type 'bridge)) (format-chordpro-stanza-label stanza-type stanza-numbers) (if (markup? stanza-markup) (markup->string stanza-markup) (if stanza-markup (format #f "~a" stanza-markup) #f)))) (existing (assoc this-verse-index (chordpro-song-stanza-numbers song))) (moment (ly:context-current-moment (ly:translator-context source-engraver))) (direction (ly:grob-property grob 'direction CENTER))) ;; If custom-inline-text is set, always collect it as inline text (regardless of realstanza) ;; This allows repStart/repStop to be collected even when combined with real stanza numbers (when custom-inline-text (set-chordpro-song-inline-texts! song (cons (list moment this-verse-index custom-inline-text custom-inline-direction) (chordpro-song-inline-texts song)))) ;; If this is NOT a real stanza marker (custom-realstanza not set or ##f), ;; collect it as inline text with direction info (when (and (not custom-realstanza) (not custom-inline-text)) (if (and (string? stanza-markup) (not existing)) ;; Ein direktes \set stanza = "..." (String, kein Markup) ;; am Versanfang ist ein echtes Label (z.B. "2.b"), keine ;; Dekoration -- als weiches Stanza-Label uebernehmen ;; (realstanza #f), nicht in den Verskoerper. (set-chordpro-song-stanza-numbers! song (cons (list this-verse-index stanza-markup 'verse #f) (chordpro-song-stanza-numbers song))) (when stanza-text ; Only if there's text to display (set-chordpro-song-inline-texts! song (cons (list moment this-verse-index stanza-text direction) (chordpro-song-inline-texts song)))))) ;; Store or update stanza info for this verse (only if it's a real stanza marker) ;; Entry format: (verse-idx stanza-text stanza-type realstanza-flag numbers) (when custom-realstanza (let* ((existing-text (and existing (cadr existing))) (existing-type (and existing (caddr existing))) (existing-realstanza (and existing (> (length existing) 3) (cadddr existing))) (existing-numbers (or (and existing (> (length existing) 4) (list-ref existing 4)) '())) ;; Reprint desselben Markers (Strophennummer am Zeilen- ;; umbruch erneut gedruckt, ggf. als Nummern-Obermenge ;; wie #(stanza 2 3) nach Strophe 2) setzt den Vers ;; fort; vgl. merge-reprinted im data_extractor. (same-marker? (and existing-realstanza (or (and (string? existing-text) (string? stanza-text) (string=? existing-text stanza-text)) (and (eq? existing-type stanza-type) (pair? existing-numbers) (every (lambda (n) (member n stanza-numbers)) existing-numbers)))))) (cond ;; Kein Eintrag: neu anlegen ((not existing) (set-chordpro-song-stanza-numbers! song (cons (list this-verse-index stanza-text stanza-type custom-realstanza stanza-numbers) (chordpro-song-stanza-numbers song)))) ;; Weicher Eintrag (\set stanza) oder Reprint: aktualisieren, ;; Text echter Marker nicht ueberschreiben ((or (not existing-realstanza) same-marker?) (set-chordpro-song-stanza-numbers! song (map (lambda (entry) (if (= (car entry) this-verse-index) (list (car entry) (if existing-realstanza existing-text (or stanza-text existing-text)) stanza-type #t (if existing-realstanza existing-numbers stanza-numbers)) entry)) (chordpro-song-stanza-numbers song)))) ;; ANDERER echter Marker im selben \chordlyrics (z.B. ;; Refrain nach der Strophe): neuen logischen Vers beginnen. ;; Alles ab hier (inkl. einer im selben Timestep schon ;; angefallenen Silbe) gehoert zum neuen Vers. (else (let ((old-idx this-verse-index) (split-idx (chordpro-song-verse-index song))) (set-chordpro-song-verse-index! song (+ split-idx 1)) (set! sub-counter (+ sub-counter 1)) (set! this-verse-index split-idx) (record-verse-order! split-idx) ;; Die erste Silbe des neuen Abschnitts faellt in ;; denselben Timestep wie der Marker und wurde ggf. ;; schon gesammelt (pending oder -- bei Trennstrich -- ;; bereits gespeichert): dem neuen Vers zuschlagen. (when (and pending-syllable (ly:moment=? (car pending-syllable) moment)) (set! pending-syllable (list moment (cadr pending-syllable) split-idx))) (let retag ((rest (chordpro-song-syllables song)) (acc '())) (if (and (pair? rest) (= (cadddr (car rest)) old-idx) (ly:moment=? (car (car rest)) moment)) (retag (cdr rest) (cons (list (car (car rest)) (cadr (car rest)) (caddr (car rest)) split-idx) acc)) (set-chordpro-song-syllables! song (append (reverse acc) rest)))) (let retag ((rest (chordpro-song-chords song)) (acc '())) (if (and (pair? rest) (= (caddr (car rest)) old-idx) (ly:moment=? (car (car rest)) moment)) (retag (cdr rest) (cons (list (car (car rest)) (cadr (car rest)) split-idx (cadddr (car rest))) acc)) (set-chordpro-song-chords! song (append (reverse acc) rest)))) (set-chordpro-song-stanza-numbers! song (cons (list split-idx stanza-text stanza-type custom-realstanza stanza-numbers) (chordpro-song-stanza-numbers song)))))))))) ; closes stanza-number-interface ;; ChordName grobs from ChordNames context ;; Store grob reference - visibility will be recorded by ChordPro_chord_visibility_recorder ((chord-name-interface engraver grob source-engraver) (let* ((moment (ly:context-current-moment context)) ;; Get details property to check for altChord (details (ly:grob-property grob 'details '())) (alt-main-name (assoc-get 'alt-chord-main-name details #f)) (alt-alt-name (assoc-get 'alt-chord-alt-name details #f)) ;; Extract chord name (chord-name-final (if (and alt-main-name alt-alt-name) ;; This is an altChord - use the pre-extracted names (let ((main (track-and-return-chord song alt-main-name)) (alt (track-and-return-chord song alt-alt-name))) ;; Check if main is empty - if so, only output alt in parens (if (string-null? main) (string-append "[(" alt ")]") ; Only alt chord: [(D7)] ;; Format as: [B][(Gm)] (complete with all brackets) (string-append "[" main "][(" alt ")]"))) ;; Normal chord - extract from markup text (let* ((chord-text (ly:grob-property grob 'text)) (chord-names-str (extract-chord-names-from-markup chord-text)) ;; Check if it contains "][(": multiple chords (shouldn't happen anymore) (has-bracket (string-index chord-names-str #\]))) (if has-bracket ;; Multiple chords from old logic: manually split and process (let* ((bracket-pos (string-index chord-names-str #\])) (first-part (substring chord-names-str 0 bracket-pos)) (rest (substring chord-names-str bracket-pos)) (open-pos (string-index rest #\()) (close-pos (string-index rest #\))) (second-part (if (and open-pos close-pos) (substring rest (+ open-pos 1) close-pos) "")) (first-converted (track-and-return-chord song first-part)) (second-converted (track-and-return-chord song second-part))) (string-append first-converted "][(" second-converted ")")) ;; Single chord: just track and return original (track-and-return-chord song chord-names-str)))))) ;; Store grob reference along with chord data (unless empty) ;; Format: (moment chord-name verse-index grob) ;; Filter out completely empty chords, but convert ][(X) to [(X)] (let ((processed-chord-name (cond ;; Empty chord ((or (string-null? chord-name-final) (string=? chord-name-final "") (string=? chord-name-final "][")) #f) ; Filter out ;; Pattern ][(X) - empty main, only alt in parens: convert to [(X)] ((string-prefix? "][(" chord-name-final) ;; ][(D7) → [(D7)] (let* ((inner (substring chord-name-final 3 (- (string-length chord-name-final) 1)))) (string-append "[(" inner ")]"))) ;; Normal chord (else chord-name-final)))) (when processed-chord-name (set-chordpro-song-chords! song (cons (list moment processed-chord-name this-verse-index grob) (chordpro-song-chords song))))))) ;; LyricText grobs to get stanza number ((lyric-syllable-interface engraver grob source-engraver) (let* ((stanza-grob (ly:grob-property grob 'stanza #f)) ;; Get the Lyrics context from the source engraver (lyrics-context (ly:translator-context source-engraver)) (stanza-context (if lyrics-context (ly:context-property lyrics-context 'stanza #f) #f)) (stanza-value (or stanza-grob stanza-context))) (when stanza-value ;; Only update existing stanza entries (don't create new ones) ;; New entries should only be created by stanza-number-interface (let* ((existing (assoc this-verse-index (chordpro-song-stanza-numbers song))) (existing-text (if existing (cadr existing) #f)) (stanza-text (if (markup? stanza-value) (markup->string stanza-value) (format #f "~a" stanza-value)))) ;; Only update if entry exists and existing text is empty/false and new text is non-empty (when (and existing (not (and (string? existing-text) (not (string-null? existing-text)))) (string? stanza-text) (not (string-null? stanza-text))) ;; Update existing entry with text (keep type and realstanza flag) (set-chordpro-song-stanza-numbers! song (map (lambda (entry) (if (= (car entry) this-verse-index) (list (car entry) (or existing-text stanza-text) ; Keep existing text if present (caddr entry) ; Keep stanza-type (if (> (length entry) 3) (cadddr entry) #f)) ; Keep realstanza-flag if exists entry)) (chordpro-song-stanza-numbers song)))))))) ; schließt lyric-syllable-interface ) ; schließt acknowledgers ;; End of timestep ((stop-translation-timestep engraver) (save-pending! #f)) ;; Finalize - just save leftovers, don't filter chords yet ;; (Filtering happens in chordpro-write-song where grob properties are final) ((finalize engraver) ;; Save any remaining pending syllable (save-pending! #f)))))) %% Helper functions to format and write ChordPro #(define (chordpro-format-song song) "Format one song's collected engraver data as a ChordPro string." (let* ((num-verses (chordpro-song-verse-index song)) ;; Reverse all lists (they were collected in reverse order) (syllables (reverse (chordpro-song-syllables song))) (chords (reverse (chordpro-song-chords song))) (breaks (reverse (chordpro-song-breaks song))) (stanza-numbers (chordpro-song-stanza-numbers song)) (inline-texts (chordpro-song-inline-texts song)) (write-defines (lambda (chord-list convert) (for-each (lambda (chord) (display (format #f "{define: ~a copy ~a}\n" chord (convert chord)))) (reverse chord-list))))) (with-output-to-string (lambda () ;; Write metadata (display (format #f "{title: ~a}\n" (or (chordpro-song-title song) "Untitled"))) (when (chordpro-song-authors song) (for-each (lambda (name) (display (format #f "{artist: ~a}\n" name))) (chordpro-all-author-names (chordpro-song-authors song))) (for-each (lambda (name) (display (format #f "{composer: ~a}\n" name))) (chordpro-authors-by-role 'melody (chordpro-song-authors song))) (for-each (lambda (name) (display (format #f "{lyricist: ~a}\n" name))) (chordpro-authors-by-role 'text (chordpro-song-authors song)))) (when (chordpro-song-copyright song) (display (format #f "{copyright: ~a}\n" (chordpro-song-copyright song)))) (when (chordpro-song-year song) (display (format #f "{year: ~a}\n" (chordpro-song-year song)))) (when (chordpro-song-key-signature song) (display (format #f "{key: ~a}\n" (chordpro-song-key-signature song)))) (when (chordpro-song-time song) (display (format #f "{time: ~a}\n" (chordpro-song-time song)))) (when (chordpro-song-tempo song) (display (format #f "{tempo: ~a}\n" (chordpro-song-tempo song)))) ;; {define:} directives: minor chords (lowercase German), B/b (German B = ;; English Bb), H/h (German H = English B), accidentals (is/es -> #/b) (unless (null? (chordpro-song-minor-chords song)) (newline)) (write-defines (chordpro-song-minor-chords song) german-minor-to-major-form) (write-defines (chordpro-song-b-chords song) german-b-to-bb-form) (write-defines (chordpro-song-h-chords song) german-h-to-b-form) (write-defines (chordpro-song-accidental-chords song) german-accidentals-to-international) (newline) ;; Verse in Dokumentreihenfolge schreiben (for-each (lambda (verse-idx) ;; Get syllables, chords and breaks for this verse (let* ((verse-syllables (filter (lambda (s) (= (cadddr s) verse-idx)) syllables)) (verse-chords-raw (filter (lambda (c) (and (list? c) (>= (length c) 3) (= (caddr c) verse-idx))) chords)) ;; Simple filtering: remove repeated consecutive chords (verse-chords (let filter-repeats ((chords-left verse-chords-raw) (last-chord #f) (result '())) (if (null? chords-left) (reverse result) (let* ((chord (car chords-left)) (chord-name (cadr chord))) (if (equal? chord-name last-chord) ;; Skip repeated chord (filter-repeats (cdr chords-left) last-chord result) ;; Include new chord (filter-repeats (cdr chords-left) chord-name (cons (list (car chord) chord-name (caddr chord)) result))))))) (verse-breaks (filter (lambda (b) (= (cdr b) verse-idx)) breaks)) (verse-inline-texts (filter (lambda (r) (= (cadr r) verse-idx)) (reverse inline-texts))) ;; Get stanza info (number, type, and realstanza flag) for this verse (stanza-entry (find (lambda (s) (= (car s) verse-idx)) stanza-numbers)) (stanza-num (if stanza-entry (cadr stanza-entry) #f)) (stanza-type (if stanza-entry (caddr stanza-entry) 'verse)) (realstanza (if stanza-entry (cadddr stanza-entry) #f)) ;; Determine ChordPro directive based on type (start-directive (cond ((eq? stanza-type 'ref) "start_of_chorus") ((eq? stanza-type 'bridge) "start_of_bridge") (else "start_of_verse"))) (end-directive (cond ((eq? stanza-type 'ref) "end_of_chorus") ((eq? stanza-type 'bridge) "end_of_bridge") (else "end_of_verse")))) (when (not (null? verse-syllables)) ;; If realstanza is ##t, output with ChordPro directives ;; Otherwise, just output the text (e.g., for repStartWithTag/repStopWithTag) (if realstanza (begin (if (and stanza-num (not (string-null? stanza-num))) (display (format #f "{~a: label=\"~a\"}\n" start-directive stanza-num)) (display (format #f "{~a}\n" start-directive))) (display (format-verse-as-chordpro verse-syllables verse-chords verse-breaks verse-inline-texts)) (display (format #f "\n{~a}\n\n" end-directive))) (begin ;; For non-real stanzas, just output stanza marker as comment if present (when (and stanza-num (not (string-null? stanza-num))) (display (format #f "# ~a\n" stanza-num))) (display (format-verse-as-chordpro verse-syllables verse-chords verse-breaks verse-inline-texts)) (display "\n\n")))))) (chordpro-song-ordered-verse-indices song)))))) %% Schreibt ein Lied als eigene .cho-Datei (Einzellied-/Pro-Song-Modus). #(define (chordpro-write-song song) "Write one song's ChordPro file from its collected engraver data" (let ((output-file (string-append (chordpro-song-key song) ".cho"))) (with-output-to-file output-file (lambda () (display (chordpro-format-song song)))))) #(define (format-verse-as-chordpro syllables chords breaks inline-texts) "Format one verse as ChordPro text with line breaks. Chords are placed at syllable boundaries, not word boundaries. Inline texts (𝄆 𝄇 etc.) are inserted based on their direction property." (let* (;; Get break moments (break-moments (sort (map (lambda (b) (ly:moment-main (car b))) breaks) <)) ;; Map each chord to the nearest following syllable (chord-to-syllable-map (map-chords-to-syllables chords syllables)) ;; Sort inline texts by moment (sorted-inline-texts (sort inline-texts (lambda (a b) (ly:moment (ly:moment-main (car c)) syl-moment)) syl-chords)) ;; Filter suffix chords: only keep those where NO line break exists between syllable and chord ;; If a break is between the syllable and chord, the chord belongs to the next line (suffix-chords (filter (lambda (c) (let ((chord-moment (ly:moment-main (car c)))) ;; Keep chord if no break exists, or if break is not between syl and chord (or (null? breaks-left) (let ((next-break (car breaks-left))) ;; Only keep if break is AFTER the chord (or before/at syllable) ;; Reject if: syl-moment < next-break <= chord-moment (not (and (> next-break syl-moment) (<= next-break chord-moment))))))) suffix-chords-all)) ;; Collect chords that were filtered out - they belong to the next line (next-line-chords (filter (lambda (c) (let ((chord-moment (ly:moment-main (car c)))) (and (not (null? breaks-left)) (let ((next-break (car breaks-left))) (and (> next-break syl-moment) (<= next-break chord-moment)))))) suffix-chords-all)) ;; Create chord prefix: add space after chord if it plays on a rest (before syllable) (chord-prefix (if (null? prefix-chords) "" (string-join (map (lambda (c) (let* ((chord-moment (ly:moment-main (car c))) (chord-name (cadr c)) ;; Check if chord plays before syllable (on a rest) (on-rest? (< chord-moment syl-moment)) ;; Check if chord already has brackets (has-brackets (string-prefix? "[" chord-name))) (if has-brackets ;; Already has brackets - just add space if needed (if on-rest? (string-append chord-name " ") chord-name) ;; Add brackets (if on-rest? (string-append "[" chord-name "] ") (string-append "[" chord-name "]"))))) prefix-chords) ""))) ;; Create chord suffix for chords that play after the syllable (on rests) (chord-suffix (if (null? suffix-chords) "" (string-join (map (lambda (c) (let ((chord-name (cadr c))) ;; Check if chord already has brackets (e.g., "[(D7)]") (if (string-prefix? "[" chord-name) chord-name ; Already has brackets (string-append "[" chord-name "]")))) suffix-chords) ""))) ;; Check for line break (next-syl-moment (if (null? rest-syls) 999999 (ly:moment-main (car (car rest-syls))))) (break-here (and (not (null? breaks-left)) (let ((next-break (car breaks-left))) (and (> next-break syl-moment) (<= next-break next-syl-moment)))))) ;; Check for inline texts at this syllable position (let* ((inline-result (let collect-inlines ((inls inlines-left) (collected '())) (if (or (null? inls) (let ((inl-entry (car inls))) (> (ly:moment-main (car inl-entry)) syl-moment))) (list (reverse collected) inls) (collect-inlines (cdr inls) (cons (car inls) collected))))) (inlines-to-insert (car inline-result)) (new-inlines-left (cadr inline-result)) ;; Separate by direction: LEFT texts go before, RIGHT texts go after (before-texts (filter (lambda (i) (eqv? (cadddr i) LEFT)) inlines-to-insert)) (after-texts (filter (lambda (i) (eqv? (cadddr i) RIGHT)) inlines-to-insert))) ;; If this is the start of a new line and we have pending chords from the previous line (when (and (null? current-line) (not (null? pending-line-chords))) ;; If we're continuing a word (current-word-parts not empty), add chords as infix ;; Otherwise add them as a separate word-like element (if (not (null? current-word-parts)) ;; Add pending chords as infix to the last word part (let* ((last-part (car current-word-parts)) (rest-parts (cdr current-word-parts)) (pending-chord-str (string-join (map (lambda (c) (let ((chord-name (cadr c))) (if (string-prefix? "[" chord-name) chord-name ; Already has brackets (string-append "[" chord-name "]")))) pending-line-chords) ""))) (set! current-word-parts (cons (string-append last-part pending-chord-str) rest-parts))) ;; No word continuation - add as separate element (let ((pending-chord-str (string-join (map (lambda (c) (let ((chord-name (cadr c))) (if (string-prefix? "[" chord-name) chord-name ; Already has brackets (string-append "[" chord-name "]")))) pending-line-chords) ""))) (set! current-line (cons pending-chord-str current-line))))) ;; Insert texts that should appear BEFORE the syllable (direction = LEFT) (for-each (lambda (inline-text) (set! current-line (cons (caddr inline-text) current-line))) before-texts) ;; Track word start (when (null? current-word-parts) (set! word-start-moment syl-moment)) ;; Add text to current word only if syllable is not empty (not a lyric extender _) ;; Handle chords: if we're continuing a word (current-word-parts not empty), ;; prefix chords should be inserted between syllables as infixes (without trailing space) (unless (string-null? syl-text) (if (null? current-word-parts) ;; First syllable of word: use prefix as normal (set! current-word-parts (cons (string-append chord-prefix syl-text) current-word-parts)) ;; Continuation of word: insert prefix chord between previous syllable and this one (begin ;; Append prefix chord to the LAST syllable (strip trailing space from chord-prefix for infix use) (unless (string-null? chord-prefix) (let* ((last-part (car current-word-parts)) (rest-parts (cdr current-word-parts)) ;; Remove trailing space from chord-prefix if present (chord-infix (if (string-suffix? " " chord-prefix) (substring chord-prefix 0 (- (string-length chord-prefix) 1)) chord-prefix))) (set! current-word-parts (cons (string-append last-part chord-infix) rest-parts)))) ;; Add current syllable (set! current-word-parts (cons syl-text current-word-parts))))) ;; Always collect suffix chords (even from extenders), they'll be output at word end (unless (string-null? chord-suffix) (set! pending-word-suffix-chords (cons chord-suffix pending-word-suffix-chords))) ;; Complete word only if: no hyphen AND syllable has text (not an extender) (when (and (not has-hyphen) (not (string-null? syl-text))) (if (null? current-word-parts) ;; No word parts (shouldn't happen) - just output suffix chords if any (unless (null? pending-word-suffix-chords) (set! current-line (cons (string-concatenate (reverse pending-word-suffix-chords)) current-line)) (set! pending-word-suffix-chords '())) ;; Normal word completion with all collected suffix chords (let ((word-with-suffix (if (null? pending-word-suffix-chords) (string-concatenate (reverse current-word-parts)) (string-append (string-concatenate (reverse current-word-parts)) (string-concatenate (reverse pending-word-suffix-chords)))))) (set! current-line (cons word-with-suffix current-line)) (set! current-word-parts '()) (set! pending-word-suffix-chords '())))) (for-each (lambda (inline-text) (set! current-line (cons (caddr inline-text) current-line))) after-texts) ;; If break here, complete line (word parts continue on next line) (if break-here (begin (set! lines (cons (reverse current-line) lines)) (set! current-line '()) (process-syllables rest-syls (+ syl-idx 1) (cdr breaks-left) new-inlines-left next-line-chords)) (process-syllables rest-syls (+ syl-idx 1) breaks-left new-inlines-left '()))))) ;; Format all lines and normalize multiple spaces (string-join (map (lambda (line-words) (let ((line (string-join line-words " "))) (normalize-spaces line))) (reverse lines)) "\n")))) #(define (map-chords-to-syllables chords syllables) "For each chord, find the nearest following syllable. If no following syllable within tolerance, use the last preceding syllable. Returns list of (chord-moment chord-name syllable-index)" (let ((tolerance (ly:make-moment 1/4))) (filter-map (lambda (chord-entry) (let* ((chord-moment (car chord-entry)) (chord-name (cadr chord-entry)) ;; Find syllables that start AT or AFTER this chord (within tolerance) (candidate-syllables-forward (filter-map (lambda (syl-entry syl-idx) (let* ((syl-moment (car syl-entry)) (diff (ly:moment-sub syl-moment chord-moment))) ;; Syllable must start at or after chord, within tolerance (if (and (not (ly:moment= 0 (ly:moment<=? diff tolerance)) (list diff syl-idx) #f))) syllables (iota (length syllables))))) ; syllable indices ;; If no forward match, try to find the last syllable BEFORE the chord (if (not (null? candidate-syllables-forward)) ;; Pick the closest following syllable (smallest diff) (let* ((sorted (sort candidate-syllables-forward (lambda (a b) (ly:moment 0) (if (ly:moment= 0) ;; and within tolerance (let ((valid (and (not (ly:moment= 0 (ly:moment<=? diff tolerance)))) (if (and valid (or (not best-diff) (ly:momentstring in data_extractor.ily) in ChordPro-Tonart-Notation um %% (z.B. "Dm", "Eb"). Nutzt dieselbe internationale Notenlogik wie die %% {define:}-Direktiven, aber auf die BARE Note angewendet statt auf einen %% vollen Akkordnamen -- Dur/Moll steht hier als eigenes Wort, nicht als %% Gross-/Kleinschreibung wie bei Akkorden aus \chordmode. #(define (lilypond-key->chordpro-key key-string) (let* ((parts (string-split key-string #\space)) (note (car parts)) (minor? (string=? (cadr parts) "minor")) (first-char (string-ref note 0)) (rest (if (> (string-length note) 1) (substring note 1) ""))) (string-append (cond ((char=? first-char #\h) "B") ; deutsches H = engl. B ((and (char=? first-char #\b) (string-null? rest)) "Bb") ; deutsches b = engl. Bb (else (string (char-upcase first-char)))) (cond ((string=? rest "is") "#") ; fis/cis/... = Kreuz ((member note '("es" "as")) "b") ; unregelmaessig: es=Eb, as=Ab ((string=? rest "es") "b") ; des/ges/ces = regulaeres -es (else "")) (if minor? "m" "")))) %% Extrahiert die BPM-Zahl aus einem tempo-music->string-Ergebnis wie %% "4 = 130" oder "Allegro (4 = 130)"; #f bei reinem Text-Tempo ("Allegro", %% kein Metronomwert) oder wenn tempo-string selbst #f ist. Bei Bereichen %% ("4. = 60-70") wird die erste Zahl genommen. #(define (chordpro-tempo-number tempo-string) (and tempo-string (let ((match (ly:regex-exec (ly:make-regex "=\\s*([0-9]+)") tempo-string))) (and match (ly:regex-match-substring match 1))))) %% Define markup command for delayed ChordPro write BEFORE modifying TEXT_PAGES %% Uses delay-stencil-evaluation to write after all engraver data is collected #(define-markup-command (chordpro-delayed-write layout props) () #:category other "Invisible markup that writes one song's ChordPro file during stencil evaluation (after all engraver data is collected). The song is identified at interpretation time: in books via the songfilename markup prop (\\setsongfilename), standalone via the chordpro-default-song-key fallback." (let ((key (chordpro-resolve-song-key props))) (ly:make-stencil `(delay-stencil-evaluation ,(delay (begin (when (and (defined? 'chordpro-export-enabled) chordpro-export-enabled) (let ((song (hash-ref chordpro-song-store key))) (when (and song (not (chordpro-song-written song)) (> (chordpro-song-verse-index song) 0)) (chordpro-write-song song) (set-chordpro-song-written! song #t)))) empty-stencil))))))