scm/define-music-display-methods.scm

   1 ;;; define-music-display-methods.scm -- data for displaying music
   2 ;;; expressions using LilyPond notation.
   3 ;;;
   4 ;;; Copyright (C) 2005--2012 Nicolas Sceaux  <nicolas.sceaux@free.fr>
   5 ;;;
   6
   7 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   8 ;;;
   9 ;;; Display method implementation
  10 ;;;
  11
  12 (define-module (scm display-lily))
  13
  14 ;;;
  15 ;;; Scheme forms
  16 ;;;
  17 (define (scheme-expr->lily-string scm-arg)
  18   (cond ((or (number? scm-arg)
  19              (string? scm-arg)
  20              (boolean? scm-arg))
  21          (format #f "~s" scm-arg))
  22         ((or (symbol? scm-arg)
  23              (list? scm-arg))
  24          (format #f "'~s" scm-arg))
  25         ((procedure? scm-arg)
  26          (format #f "~a"
  27                  (or (procedure-name scm-arg)
  28                      (with-output-to-string
  29                        (lambda ()
  30                          (pretty-print (procedure-source scm-arg)))))))
  31         (else
  32          (format #f "~a"
  33                  (with-output-to-string
  34                    (lambda ()
  35                      (display-scheme-music scm-arg)))))))
  36 ;;;
  37 ;;; Markups
  38 ;;;
  39
  40 (define-public (markup->lily-string markup-expr)
  41   "Return a string describing, in LilyPond syntax, the given markup
  42 expression."
  43   (define (proc->command proc)
  44     (let ((cmd-markup (symbol->string (procedure-name proc))))
  45       (substring cmd-markup 0 (- (string-length cmd-markup)
  46                                  (string-length "-markup")))))
  47   (define (arg->string arg)
  48     (cond ((string? arg)
  49            (format #f "~s" arg))
  50           ((markup? arg) ;; a markup
  51            (markup->lily-string-aux arg))
  52           ((and (pair? arg) (every markup? arg)) ;; a markup list
  53            (format #f "{~{ ~a~}}" (map-in-order markup->lily-string-aux arg)))
  54           (else          ;; a scheme argument
  55            (format #f "#~a" (scheme-expr->lily-string arg)))))
  56   (define (markup->lily-string-aux expr)
  57     (if (string? expr)
  58         (format #f "~s" expr)
  59         (let ((cmd (car expr))
  60               (args (cdr expr)))
  61           (if (eqv? cmd simple-markup) ;; a simple markup
  62               (format #f "~s" (car args))
  63               (format #f "\\~a~{ ~a~}"
  64                       (proc->command cmd)
  65                       (map-in-order arg->string args))))))
  66   (cond ((string? markup-expr)
  67          (format #f "~s" markup-expr))
  68         ((eqv? (car markup-expr) simple-markup)
  69          (format #f "~s" (second markup-expr)))
  70         (else
  71          (format #f "\\markup ~a"
  72                  (markup->lily-string-aux markup-expr)))))
  73
  74 ;;;
  75 ;;; pitch names
  76 ;;;
  77
  78 ;; It is a pity that there is no rassoc in Scheme.
  79 (define* (rassoc item alist #:optional (test equal?))
  80   (do ((alist alist (cdr alist))
  81        (result #f result))
  82       ((or result (null? alist)) result)
  83     (if (and (car alist) (test item (cdar alist)))
  84         (set! result (car alist)))))
  85
  86 (define-public (note-name->lily-string ly-pitch parser)
  87   ;; here we define a custom pitch= function, since we do not want to
  88   ;; test whether octaves are also equal. (otherwise, we would be using equal?)
  89   (define (pitch= pitch1 pitch2)
  90     (and (= (ly:pitch-notename pitch1) (ly:pitch-notename pitch2))
  91          (= (ly:pitch-alteration pitch1) (ly:pitch-alteration pitch2))))
  92   (let ((result (rassoc ly-pitch (ly:parser-lookup parser 'pitchnames) pitch=)))
  93     (if result
  94         (car result)
  95         #f)))
  96
  97 (define-public (octave->lily-string pitch)
  98   (let ((octave (ly:pitch-octave pitch)))
  99     (cond ((>= octave 0)
 100            (make-string (1+ octave) #\'))
 101           ((< octave -1)
 102            (make-string (1- (* -1 octave)) #\,))
 103           (else ""))))
 104
 105 ;;;
 106 ;;; durations
 107 ;;;
 108 (define*-public (duration->lily-string ly-duration #:key (prev-duration (*previous-duration*))
 109                         (force-duration (*force-duration*))
 110                         (time-factor-numerator (*time-factor-numerator*))
 111                         (time-factor-denominator (*time-factor-denominator*))
 112                         remember)
 113   (if remember (*previous-duration* ly-duration))
 114   (let ((log2    (ly:duration-log ly-duration))
 115         (dots    (ly:duration-dot-count ly-duration))
 116         (num+den (ly:duration-factor ly-duration)))
 117     (if (or force-duration (not prev-duration) (not (equal? ly-duration prev-duration)))
 118         (string-append (case log2
 119                          ((-1) "\\breve")
 120                          ((-2) "\\longa")
 121                          ((-3) "\\maxima")
 122                          (else (number->string (expt 2 log2))))
 123                        (make-string dots #\.)
 124                        (let ((num? (not (or (= 1 (car num+den))
 125                                             (and time-factor-numerator
 126                                                  (= (car num+den) time-factor-numerator)))))
 127                              (den? (not (or (= 1 (cdr num+den))
 128                                             (and time-factor-denominator
 129                                                  (= (cdr num+den) time-factor-denominator))))))
 130                          (cond (den?
 131                                 (format #f "*~a/~a" (car num+den) (cdr num+den)))
 132                                (num?
 133                                 (format #f "*~a" (car num+den)))
 134                                (else ""))))
 135         "")))
 136
 137 ;;;
 138 ;;; post events
 139 ;;;
 140
 141 (define (post-event? m)
 142   (music-is-of-type? m 'post-event))
 143
 144 (define* (event-direction->lily-string event #:optional (required #t))
 145   (let ((direction (ly:music-property event 'direction)))
 146     (cond ((or (not direction) (null? direction) (= CENTER direction))
 147            (if required "-" ""))
 148           ((= UP direction) "^")
 149           ((= DOWN direction) "_")
 150           (else ""))))
 151
 152 (define-macro (define-post-event-display-method type vars direction-required str)
 153   `(define-display-method ,type ,vars
 154      (format #f "~a~a"
 155              (event-direction->lily-string ,(car vars) ,direction-required)
 156              ,str)))
 157
 158 (define-macro (define-span-event-display-method type vars direction-required str-start str-stop)
 159   `(define-display-method ,type ,vars
 160      (format #f "~a~a"
 161              (event-direction->lily-string ,(car vars) ,direction-required)
 162              (if (= START (ly:music-property ,(car vars) 'span-direction))
 163                  ,str-start
 164                  ,str-stop))))
 165
 166 (define-display-method HyphenEvent (event parser)
 167   " --")
 168 (define-display-method ExtenderEvent (event parser)
 169   " __")
 170 (define-display-method TieEvent (event parser)
 171   " ~")
 172 (define-display-method BeamForbidEvent (event parser)
 173   "\\noBeam")
 174 (define-display-method StringNumberEvent (event parser)
 175   (format #f "\\~a" (ly:music-property event 'string-number)))
 176
 177
 178 (define-display-method TremoloEvent (event parser)
 179   (let ((tremolo-type (ly:music-property event 'tremolo-type)))
 180     (format #f ":~a" (if (= 0 tremolo-type)
 181                          ""
 182                          tremolo-type))))
 183
 184 (define-post-event-display-method ArticulationEvent (event parser) #t
 185   (let ((articulation  (ly:music-property event 'articulation-type)))
 186     (case (string->symbol articulation)
 187       ((marcato) "^")
 188       ((stopped) "+")
 189       ((tenuto)  "-")
 190       ((staccatissimo) "|")
 191       ((accent) ">")
 192       ((staccato) ".")
 193       ((portato) "_")
 194       (else (format #f "\\~a" articulation)))))
 195
 196 (define-post-event-display-method FingeringEvent (event parser) #t
 197   (ly:music-property event 'digit))
 198
 199 (define-post-event-display-method TextScriptEvent (event parser) #t
 200   (markup->lily-string (ly:music-property event 'text)))
 201
 202 (define-post-event-display-method MultiMeasureTextEvent (event parser) #t
 203   (markup->lily-string (ly:music-property event 'text)))
 204
 205 (define-post-event-display-method BendAfterEvent (event parser) #t
 206   (format #f "\\bendAfter #~a" (ly:music-property event 'delta-step)))
 207
 208 (define-post-event-display-method HarmonicEvent (event parser) #f "\\harmonic")
 209 (define-post-event-display-method GlissandoEvent (event parser) #t "\\glissando")
 210 (define-post-event-display-method ArpeggioEvent (event parser) #t "\\arpeggio")
 211 (define-post-event-display-method AbsoluteDynamicEvent (event parser) #f
 212   (format #f "\\~a" (ly:music-property event 'text)))
 213
 214 (define-post-event-display-method StrokeFingerEvent (event parser) #t
 215   (format #f "\\rightHandFinger #~a" (ly:music-property event 'digit)))
 216
 217 (define-span-event-display-method BeamEvent (event parser) #f "[" "]")
 218 (define-span-event-display-method SlurEvent (event parser) #f "(" ")")
 219 (define-span-event-display-method CrescendoEvent (event parser) #f "\\<" "\\!")
 220 (define-span-event-display-method DecrescendoEvent (event parser) #f "\\>" "\\!")
 221 (define-span-event-display-method EpisemaEvent (event parser) #f "\\episemInitium" "\\episemFinis")
 222 (define-span-event-display-method PhrasingSlurEvent (event parser) #f "\\(" "\\)")
 223 (define-span-event-display-method SustainEvent (event parser) #f "\\sustainOn" "\\sustainOff")
 224 (define-span-event-display-method SostenutoEvent (event parser) #f "\\sostenutoOn" "\\sostenutoOff")
 225 (define-span-event-display-method TextSpanEvent (event parser) #f "\\startTextSpan" "\\stopTextSpan")
 226 (define-span-event-display-method TrillSpanEvent (event parser) #f "\\startTrillSpan" "\\stopTrillSpan")
 227 (define-span-event-display-method StaffSpanEvent (event parser) #f "\\startStaff" "\\stopStaff")
 228 (define-span-event-display-method NoteGroupingEvent (event parser) #f "\\startGroup" "\\stopGroup")
 229 (define-span-event-display-method UnaCordaEvent (event parser) #f "\\unaCorda" "\\treCorde")
 230
 231 ;;;
 232 ;;; Graces
 233 ;;;
 234
 235 (define-display-method GraceMusic (expr parser)
 236   (format #f "\\grace ~a"
 237           (music->lily-string (ly:music-property expr 'element) parser)))
 238
 239 ;; \acciaccatura \appoggiatura \grace
 240 ;; TODO: it would be better to compare ?start and ?stop
 241 ;; with startAppoggiaturaMusic and stopAppoggiaturaMusic,
 242 ;; using a custom music equality predicate.
 243 (define-extra-display-method GraceMusic (expr parser)
 244   "Display method for appoggiatura."
 245   (with-music-match (expr (music
 246                            'GraceMusic
 247                            element (music
 248                                     'SequentialMusic
 249                                     elements (?start
 250                                               ?music
 251                                               ?stop))))
 252     ;; we check whether ?start and ?stop look like
 253     ;; startAppoggiaturaMusic stopAppoggiaturaMusic
 254     (and (with-music-match (?start (music
 255                                     'SequentialMusic
 256                                     elements ((music
 257                                                'SkipEvent
 258                                                duration (ly:make-duration 0 0 0 1)
 259                                                articulations
 260                                                ((music
 261                                                  'SlurEvent
 262                                                  span-direction START))))))
 263             #t)
 264          (with-music-match (?stop (music
 265                                    'SequentialMusic
 266                                    elements ((music
 267                                               'SkipEvent
 268                                               duration (ly:make-duration 0 0 0 1)
 269                                               articulations
 270                                               ((music
 271                                                 'SlurEvent
 272                                                 span-direction STOP))))))
 273             (format #f "\\appoggiatura ~a" (music->lily-string ?music parser))))))
 274
 275
 276 (define-extra-display-method GraceMusic (expr parser)
 277   "Display method for acciaccatura."
 278   (with-music-match (expr (music
 279                            'GraceMusic
 280                            element (music
 281                                     'SequentialMusic
 282                                     elements (?start
 283                                               ?music
 284                                               ?stop))))
 285     ;; we check whether ?start and ?stop look like
 286     ;; startAcciaccaturaMusic stopAcciaccaturaMusic
 287     (and (with-music-match (?start (music
 288                                     'SequentialMusic
 289                                     elements ((music
 290                                                'SkipEvent
 291                                                duration (ly:make-duration 0 0 0 1)
 292                                                articulations
 293                                                ((music
 294                                                  'SlurEvent
 295                                                  span-direction START)))
 296                                               (music
 297                                                'ContextSpeccedMusic
 298                                                element (music
 299                                                         'OverrideProperty
 300                                                         grob-property-path '(stroke-style)
 301                                                         grob-value "grace"
 302                                                         symbol 'Flag)))))
 303            #t)
 304          (with-music-match (?stop (music
 305                                    'SequentialMusic
 306                                    elements ((music
 307                                               'ContextSpeccedMusic
 308                                               element (music
 309                                                        'RevertProperty
 310                                                        grob-property-path '(stroke-style)
 311                                                        symbol 'Flag))
 312
 313                                              (music
 314                                               'SkipEvent
 315                                               duration (ly:make-duration 0 0 0 1)
 316                                               articulations
 317                                               ((music
 318                                                 'SlurEvent
 319                                                 span-direction STOP))))))
 320            (format #f "\\acciaccatura ~a" (music->lily-string ?music parser))))))
 321
 322 (define-extra-display-method GraceMusic (expr parser)
 323   "Display method for grace."
 324   (with-music-match (expr (music
 325                            'GraceMusic
 326                            element (music
 327                                     'SequentialMusic
 328                                     elements (?start
 329                                               ?music
 330                                               ?stop))))
 331     ;; we check whether ?start and ?stop look like
 332     ;; startGraceMusic stopGraceMusic
 333     (and (null? (ly:music-property ?start 'elements))
 334          (null? (ly:music-property ?stop 'elements))
 335          (format #f "\\grace ~a" (music->lily-string ?music parser)))))
 336
 337 ;;;
 338 ;;; Music sequences
 339 ;;;
 340
 341 (define-display-method SequentialMusic (seq parser)
 342   (let ((force-line-break (and (*force-line-break*)
 343                                ;; hm
 344                                (> (length (ly:music-property seq 'elements))
 345                                   (*max-element-number-before-break*))))
 346         (elements (ly:music-property seq 'elements))
 347         (chord? (make-music-type-predicate 'EventChord))
 348         (note-or-chord? (make-music-type-predicate 'EventChord 'NoteEvent
 349                                                    'LyricEvent 'RestEvent
 350                                                    'ClusterNoteEvent))
 351         (cluster? (make-music-type-predicate 'ClusterNoteEvent))
 352         (note? (make-music-type-predicate 'NoteEvent)))
 353     (format #f "~a~a{~v%~v_~{~a~^ ~}~v%~v_}"
 354             (if (any (lambda (e)
 355                        (or (cluster? e)
 356                            (and (chord? e)
 357                                 (any cluster? (ly:music-property e 'elements)))))
 358                      elements)
 359                 "\\makeClusters "
 360                 "")
 361             (if (*explicit-mode*)
 362                 ;; if the sequence contains EventChord which contains figures ==> figuremode
 363                 ;; if the sequence contains EventChord which contains lyrics ==> lyricmode
 364                 ;; if the sequence contains EventChord which contains drum notes ==> drummode
 365                 (cond ((any (lambda (chord)
 366                               (any (make-music-type-predicate 'BassFigureEvent)
 367                                    (ly:music-property chord 'elements)))
 368                             (filter chord? elements))
 369                        "\\figuremode ")
 370                       ((any (lambda (chord)
 371                               (any (make-music-type-predicate 'LyricEvent)
 372                                    (cons chord
 373                                          (ly:music-property chord 'elements))))
 374                             (filter note-or-chord? elements))
 375                        "\\lyricmode ")
 376                       ((any (lambda (chord)
 377                               (any (lambda (event)
 378                                      (and (note? event)
 379                                           (not (null? (ly:music-property event 'drum-type)))))
 380                                    (cons chord
 381                                          (ly:music-property chord 'elements))))
 382                             (filter note-or-chord? elements))
 383                        "\\drummode ")
 384                       (else ;; TODO: other modes?
 385                        ""))
 386                 "")
 387             (if force-line-break 1 0)
 388             (if force-line-break (+ 2 (*indent*)) 1)
 389             (parameterize ((*indent* (+ 2 (*indent*))))
 390                           (map-in-order (lambda (music)
 391                                           (music->lily-string music parser))
 392                                         elements))
 393             (if force-line-break 1 0)
 394             (if force-line-break (*indent*) 1))))
 395
 396 (define-display-method SimultaneousMusic (sim parser)
 397   (parameterize ((*indent* (+ 3 (*indent*))))
 398     (format #f "<< ~{~a ~}>>"
 399             (map-in-order (lambda (music)
 400                             (music->lily-string music parser))
 401                           (ly:music-property sim 'elements)))))
 402
 403 (define-extra-display-method SimultaneousMusic (expr parser)
 404   "If `sim' is an \afterGrace expression, return \"\\afterGrace ...\".
 405 Otherwise, return #f."
 406   ;; TODO: do something with afterGraceFraction?
 407   (with-music-match (expr (music 'SimultaneousMusic
 408                                  elements (?before-grace
 409                                            (music 'SequentialMusic
 410                                                   elements ((music 'SkipMusic)
 411                                                             (music 'GraceMusic
 412                                                                    element ?grace))))))
 413     (format #f "\\afterGrace ~a ~a"
 414             (music->lily-string ?before-grace parser)
 415             (music->lily-string ?grace parser))))
 416
 417 ;;;
 418 ;;; Chords
 419 ;;;
 420
 421 (define-display-method EventChord (chord parser)
 422   ;; event_chord : command_element
 423   ;;               | note_chord_element
 424
 425   ;; TODO : tagged post_events
 426   ;; post_events : ( post_event | tagged_post_event )*
 427   ;; tagged_post_event: '-' \tag embedded_scm post_event
 428
 429   (let* ((elements (append (ly:music-property chord 'elements)
 430                            (ly:music-property chord 'articulations)))
 431          (chord-repeat (ly:music-property chord 'duration)))
 432     (call-with-values
 433         (lambda ()
 434           (partition (lambda (m) (music-is-of-type? m 'rhythmic-event))
 435                      elements))
 436       (lambda (chord-elements other-elements)
 437         (cond ((pair? chord-elements)
 438                ;; note_chord_element :
 439                ;; '<' (notepitch | drumpitch)* '>" duration post_events
 440                (let ((duration (duration->lily-string (ly:music-property
 441                                                        (car chord-elements)
 442                                                        'duration)
 443                                                       #:remember #t)))
 444                  ;; Format duration first so that it does not appear on
 445                  ;; chord elements
 446                  (format #f "< ~{~a ~}>~a~:{~:[-~;~]~a~^ ~}"
 447                          (map-in-order (lambda (music)
 448                                          (music->lily-string music parser))
 449                                        chord-elements)
 450                          duration
 451                          (map-in-order (lambda (music)
 452                                          (list
 453                                           (post-event? music)
 454                                           (music->lily-string music parser)))
 455                                        other-elements))))
 456               ((ly:duration? chord-repeat)
 457                (let ((duration (duration->lily-string chord-repeat
 458                                                       #:remember #t)))
 459                  (format #f "q~a~:{~:[-~;~]~a~^ ~}"
 460                          duration
 461                          (map-in-order (lambda (music)
 462                                          (list
 463                                           (post-event? music)
 464                                           (music->lily-string music parser)))
 465                                        other-elements))))
 466
 467               ((and (= 1 (length other-elements))
 468                     (not (post-event? (car other-elements))))
 469                (format #f (music->lily-string (car other-elements) parser)))
 470               (else
 471                (format #f "< >~:{~:[-~;~]~a~^ ~}"
 472                        (map-in-order (lambda (music)
 473                                        (list
 474                                         (post-event? music)
 475                                         (music->lily-string music parser)))
 476                                      other-elements))))))))
 477
 478 (define-display-method MultiMeasureRestMusic (mmrest parser)
 479   (format #f "R~a~{~a~^ ~}"
 480           (duration->lily-string (ly:music-property mmrest 'duration)
 481                                  #:remember #t)
 482           (map-in-order (lambda (music)
 483                           (music->lily-string music parser))
 484                         (ly:music-property mmrest 'articulations))))
 485
 486 (define-display-method SkipMusic (skip parser)
 487   (format #f "\\skip ~a" (duration->lily-string (ly:music-property skip 'duration) #:force-duration #t)))
 488
 489 (define-display-method OttavaMusic (ottava parser)
 490   (format #f "\\ottava #~a" (ly:music-property ottava 'ottava-number)))
 491
 492 ;;;
 493 ;;; Notes, rests, skips...
 494 ;;;
 495
 496 (define (simple-note->lily-string event parser)
 497   (format #f "~a~a~a~a~a~a~{~a~}" ; pitchname octave !? octave-check duration optional_rest articulations
 498           (note-name->lily-string (ly:music-property event 'pitch) parser)
 499           (octave->lily-string (ly:music-property event 'pitch))
 500           (let ((forced (ly:music-property event 'force-accidental))
 501                 (cautionary (ly:music-property event 'cautionary)))
 502             (cond ((and (not (null? forced))
 503                         forced
 504                         (not (null? cautionary))
 505                         cautionary)
 506                    "?")
 507                   ((and (not (null? forced)) forced) "!")
 508                   (else "")))
 509           (let ((octave-check (ly:music-property event 'absolute-octave)))
 510             (if (not (null? octave-check))
 511                 (format #f "=~a" (cond ((>= octave-check 0)
 512                                         (make-string (1+ octave-check) #\'))
 513                                        ((< octave-check -1)
 514                                         (make-string (1- (* -1 octave-check)) #\,))
 515                                        (else "")))
 516                 ""))
 517           (duration->lily-string (ly:music-property event 'duration)
 518                                  #:remember #t)
 519           (if ((make-music-type-predicate 'RestEvent) event)
 520               "\\rest" "")
 521           (map-in-order (lambda (event)
 522                           (music->lily-string event parser))
 523                         (ly:music-property event 'articulations))))
 524
 525 (define-display-method NoteEvent (note parser)
 526   (cond ((not (null? (ly:music-property note 'pitch))) ;; note
 527          (simple-note->lily-string note parser))
 528         ((not (null? (ly:music-property note 'drum-type))) ;; drum
 529          (format #f "~a~a" (ly:music-property note 'drum-type)
 530                  (duration->lily-string (ly:music-property note 'duration)
 531                                         #:remember #t)))
 532         (else ;; unknown?
 533          "")))
 534
 535 (define-display-method ClusterNoteEvent (note parser)
 536   (simple-note->lily-string note parser))
 537
 538 (define-display-method RestEvent (rest parser)
 539   (if (not (null? (ly:music-property rest 'pitch)))
 540       (simple-note->lily-string rest parser)
 541       (string-append "r" (duration->lily-string (ly:music-property rest 'duration)
 542                                                 #:remember #t))))
 543
 544 (define-display-method MultiMeasureRestEvent (rest parser)
 545   (string-append "R" (duration->lily-string (ly:music-property rest 'duration)
 546                                             #:remember #t)))
 547
 548 (define-display-method SkipEvent (rest parser)
 549   (string-append "s" (duration->lily-string (ly:music-property rest 'duration)
 550                                             #:remember #t)))
 551
 552 (define-display-method RepeatedChord (chord parser)
 553   (music->lily-string (ly:music-property chord 'element) parser))
 554
 555 (define-display-method MarkEvent (mark parser)
 556   (let ((label (ly:music-property mark 'label)))
 557     (if (null? label)
 558         "\\mark \\default"
 559         (format #f "\\mark ~a" (markup->lily-string label)))))
 560
 561 (define-display-method KeyChangeEvent (key parser)
 562   (let ((pitch-alist (ly:music-property key 'pitch-alist))
 563         (tonic (ly:music-property key 'tonic)))
 564     (if (or (null? pitch-alist)
 565             (null? tonic))
 566         "\\key \\default"
 567         (let ((c-pitch-alist (ly:transpose-key-alist pitch-alist
 568                                                      (ly:pitch-diff (ly:make-pitch 0 0 0) tonic))))
 569           (format #f "\\key ~a \\~a~a"
 570                   (note-name->lily-string (ly:music-property key 'tonic) parser)
 571                   (any (lambda (mode)
 572                          (if (and parser
 573                                   (equal? (ly:parser-lookup parser mode) c-pitch-alist))
 574                              (symbol->string mode)
 575                              #f))
 576                        '(major minor ionian locrian aeolian mixolydian lydian phrygian dorian))
 577                   (new-line->lily-string))))))
 578
 579 (define-display-method RelativeOctaveCheck (octave parser)
 580   (let ((pitch (ly:music-property octave 'pitch)))
 581     (format #f "\\octaveCheck ~a~a"
 582             (note-name->lily-string pitch parser)
 583             (octave->lily-string pitch))))
 584
 585 (define-display-method VoiceSeparator (sep parser)
 586   "\\\\")
 587
 588 (define-display-method LigatureEvent (ligature parser)
 589   (if (= START (ly:music-property ligature 'span-direction))
 590       "\\["
 591       "\\]"))
 592
 593 (define-display-method BarCheck (check parser)
 594   (format #f "|~a" (new-line->lily-string)))
 595
 596 (define-display-method PesOrFlexaEvent (expr parser)
 597   "\\~")
 598
 599 (define-display-method BassFigureEvent (figure parser)
 600   (let ((alteration (ly:music-property figure 'alteration))
 601         (fig (ly:music-property figure 'figure))
 602         (bracket-start (ly:music-property figure 'bracket-start))
 603         (bracket-stop (ly:music-property figure 'bracket-stop)))
 604
 605     (format #f "~a~a~a~a"
 606             (if (null? bracket-start) "" "[")
 607             (cond ((null? fig) "_")
 608                   ((markup? fig) (second fig)) ;; fig: (<number-markup> "number")
 609                   (else fig))
 610             (if (null? alteration)
 611                 ""
 612                 (cond
 613                   ((= alteration DOUBLE-FLAT) "--")
 614                   ((= alteration FLAT) "-")
 615                   ((= alteration NATURAL) "!")
 616                   ((= alteration SHARP) "+")
 617                   ((= alteration DOUBLE-SHARP) "++")
 618                   (else "")))
 619             (if (null? bracket-stop) "" "]"))))
 620
 621 (define-display-method LyricEvent (lyric parser)
 622   (format "~a~{~a~^ ~}"
 623           (let ((text (ly:music-property lyric 'text)))
 624             (if (or (string? text)
 625                     (eqv? (first text) simple-markup))
 626                 ;; a string or a simple markup
 627                 (let ((string (if (string? text)
 628                                   text
 629                                   (second text))))
 630                   (if (string-match "(\"| |[0-9])" string)
 631                       ;; TODO check exactly in which cases double quotes should be used
 632                       (format #f "~s" string)
 633                       string))
 634                 (markup->lily-string text)))
 635           (map-in-order (lambda (m) (music->lily-string m parser))
 636                         (ly:music-property lyric 'articulations))))
 637
 638 (define-display-method BreathingEvent (event parser)
 639   "\\breathe")
 640
 641 ;;;
 642 ;;; Staff switches
 643 ;;;
 644
 645 (define-display-method AutoChangeMusic (m parser)
 646   (format #f "\\autochange ~a"
 647           (music->lily-string (ly:music-property m 'element) parser)))
 648
 649 (define-display-method ContextChange (m parser)
 650   (format #f "\\change ~a = \"~a\""
 651           (ly:music-property m 'change-to-type)
 652           (ly:music-property m 'change-to-id)))
 653
 654 ;;;
 655
 656 (define-display-method TimeScaledMusic (times parser)
 657   (let* ((num (ly:music-property times 'numerator))
 658          (den (ly:music-property times 'denominator))
 659          (nd-gcd (gcd num den)))
 660     (parameterize ((*force-line-break* #f)
 661                    (*time-factor-numerator* (/ num nd-gcd))
 662                    (*time-factor-denominator* (/ den nd-gcd)))
 663       (format #f "\\times ~a/~a ~a"
 664               num
 665               den
 666               (music->lily-string (ly:music-property times 'element) parser)))))
 667
 668 (define-display-method RelativeOctaveMusic (m parser)
 669   (music->lily-string (ly:music-property m 'element) parser))
 670
 671 (define-display-method TransposedMusic (m parser)
 672   (music->lily-string (ly:music-property m 'element) parser))
 673
 674 ;;;
 675 ;;; Repeats
 676 ;;;
 677
 678 (define-display-method AlternativeEvent (alternative parser) "")
 679
 680 (define (repeat->lily-string expr repeat-type parser)
 681   (format #f "\\repeat ~a ~a ~a ~a"
 682           repeat-type
 683           (ly:music-property expr 'repeat-count)
 684           (music->lily-string (ly:music-property expr 'element) parser)
 685           (let ((alternatives (ly:music-property expr 'elements)))
 686             (if (null? alternatives)
 687                 ""
 688                 (format #f "\\alternative { ~{~a ~}}"
 689                         (map-in-order (lambda (music)
 690                                         (music->lily-string music parser))
 691                                       alternatives))))))
 692
 693 (define-display-method VoltaRepeatedMusic (expr parser)
 694   (repeat->lily-string expr "volta" parser))
 695
 696 (define-display-method UnfoldedRepeatedMusic (expr parser)
 697   (repeat->lily-string expr "unfold" parser))
 698
 699 (define-display-method PercentRepeatedMusic (expr parser)
 700   (repeat->lily-string expr "percent" parser))
 701
 702 (define-display-method TremoloRepeatedMusic (expr parser)
 703   (let* ((count (ly:music-property expr 'repeat-count))
 704          (dots (if (= 0 (modulo count 3)) 0 1))
 705          (shift (- (log2 (if (= 0 dots)
 706                              (/ (* count 2) 3)
 707                              count))))
 708          (element (ly:music-property expr 'element))
 709          (den-mult 1))
 710     (if (eqv? (ly:music-property element 'name) 'SequentialMusic)
 711         (begin
 712           (set! shift (1- shift))
 713           (set! den-mult (length (ly:music-property element 'elements)))))
 714     (music-map (lambda (m)
 715                  (let ((duration (ly:music-property m 'duration)))
 716                    (if (ly:duration? duration)
 717                        (let* ((dlog (ly:duration-log duration))
 718                               (ddots (ly:duration-dot-count duration))
 719                               (dfactor (ly:duration-factor duration))
 720                               (dnum (car dfactor))
 721                               (dden (cdr dfactor)))
 722                          (set! (ly:music-property m 'duration)
 723                                (ly:make-duration (- dlog shift)
 724                                                  ddots ;;(- ddots dots) ; ????
 725                                                  dnum
 726                                                  (/ dden den-mult))))))
 727                  m)
 728                element)
 729     (format #f "\\repeat tremolo ~a ~a"
 730             count
 731             (music->lily-string element parser))))
 732
 733 ;;;
 734 ;;; Contexts
 735 ;;;
 736
 737 (define-display-method ContextSpeccedMusic (expr parser)
 738   (let ((id    (ly:music-property expr 'context-id))
 739         (create-new (ly:music-property expr 'create-new))
 740         (music (ly:music-property expr 'element))
 741         (operations (ly:music-property expr 'property-operations))
 742         (ctype (ly:music-property expr 'context-type)))
 743     (format #f "~a ~a~a~a ~a"
 744             (if (and (not (null? create-new)) create-new)
 745                 "\\new"
 746                 "\\context")
 747             ctype
 748             (if (null? id)
 749                 ""
 750                 (format #f " = ~s" id))
 751             (if (null? operations)
 752                 ""
 753                 (format #f " \\with {~{~a~}~%~v_}"
 754                         (parameterize ((*indent* (+ (*indent*) 2)))
 755                           (map (lambda (op)
 756                                  (format #f "~%~v_\\~a ~s"
 757                                          (*indent*)
 758                                          (first op)
 759                                          (second op)))
 760                                operations))
 761                         (*indent*)))
 762             (parameterize ((*current-context* ctype))
 763               (music->lily-string music parser)))))
 764
 765 ;; special cases: \figures \lyrics \drums
 766 (define-extra-display-method ContextSpeccedMusic (expr parser)
 767   (with-music-match (expr (music 'ContextSpeccedMusic
 768                                  create-new #t
 769                                  property-operations ?op
 770                                  context-type ?context-type
 771                                  element ?sequence))
 772     (if (null? ?op)
 773         (parameterize ((*explicit-mode* #f))
 774           (case ?context-type
 775             ((FiguredBass)
 776              (format #f "\\figures ~a" (music->lily-string ?sequence parser)))
 777             ((Lyrics)
 778              (format #f "\\lyrics ~a" (music->lily-string ?sequence parser)))
 779             ((DrumStaff)
 780              (format #f "\\drums ~a" (music->lily-string ?sequence parser)))
 781             (else
 782              #f)))
 783         #f)))
 784
 785 ;;; Context properties
 786
 787 (define-extra-display-method ContextSpeccedMusic (expr parser)
 788   (let ((element (ly:music-property expr 'element))
 789         (property-tuning? (make-music-type-predicate 'PropertySet
 790                                                      'PropertyUnset
 791                                                      'OverrideProperty
 792                                                      'RevertProperty))
 793         (sequence? (make-music-type-predicate 'SequentialMusic)))
 794     (if (and (ly:music? element)
 795              (or (property-tuning? element)
 796                  (and (sequence? element)
 797                       (every property-tuning? (ly:music-property element 'elements)))))
 798         (parameterize ((*current-context* (ly:music-property expr 'context-type)))
 799           (music->lily-string element parser))
 800         #f)))
 801
 802 (define (property-value->lily-string arg parser)
 803   (cond ((ly:music? arg)
 804          (music->lily-string arg parser))
 805         ((string? arg)
 806          (format #f "#~s" arg))
 807         ((markup? arg)
 808          (markup->lily-string arg))
 809         (else
 810          (format #f "#~a" (scheme-expr->lily-string arg)))))
 811
 812 (define-display-method PropertySet (expr parser)
 813   (let ((property (ly:music-property expr 'symbol))
 814         (value (ly:music-property expr 'value))
 815         (once (ly:music-property expr 'once)))
 816     (format #f "~a\\set ~a~a = ~a~a"
 817             (if (and (not (null? once)))
 818                 "\\once "
 819                 "")
 820             (if (eqv? (*current-context*) 'Bottom)
 821                 ""
 822                 (format #f "~a . " (*current-context*)))
 823             property
 824             (property-value->lily-string value parser)
 825             (new-line->lily-string))))
 826
 827 (define-display-method PropertyUnset (expr parser)
 828   (format #f "\\unset ~a~a~a"
 829           (if (eqv? (*current-context*) 'Bottom)
 830               ""
 831               (format #f "~a . " (*current-context*)))
 832           (ly:music-property expr 'symbol)
 833           (new-line->lily-string)))
 834
 835 ;;; Layout properties
 836
 837 (define-display-method OverrideProperty (expr parser)
 838   (let* ((symbol          (ly:music-property expr 'symbol))
 839          (properties   (ly:music-property expr 'grob-property-path
 840                                              (list (ly:music-property expr 'grob-property))))
 841          (value   (ly:music-property expr 'grob-value))
 842          (once    (ly:music-property expr 'once)))
 843
 844     (format #f "~a\\override ~a~a #'~a = ~a~a"
 845             (if (or (null? once)
 846                     (not once))
 847                 ""
 848                 "\\once ")
 849             (if (eqv? (*current-context*) 'Bottom)
 850                 ""
 851                 (format #f "~a . " (*current-context*)))
 852             symbol
 853             (if (null? (cdr properties))
 854                 (car properties)
 855                 properties)
 856             (property-value->lily-string value parser)
 857             (new-line->lily-string))))
 858
 859 (define-display-method RevertProperty (expr parser)
 860   (let* ((symbol (ly:music-property expr 'symbol))
 861          (properties (ly:music-property expr 'grob-property-path
 862                                              (list (ly:music-property expr 'grob-property)))))
 863     (format #f "\\revert ~a~a #'~a~a"
 864             (if (eqv? (*current-context*) 'Bottom)
 865                 ""
 866                 (format #f "~a . " (*current-context*)))
 867             symbol
 868             (if (null? (cdr properties))
 869                 (car properties)
 870                 properties)
 871             (new-line->lily-string))))
 872
 873 (define-display-method TimeSignatureMusic (expr parser)
 874   (let* ((num (ly:music-property expr 'numerator))
 875          (den (ly:music-property expr 'denominator))
 876          (structure (ly:music-property expr 'beat-structure)))
 877     (if (null? structure)
 878         (format #f
 879                 "\\time ~a/~a~a"
 880                 num den
 881                 (new-line->lily-string))
 882         (format #f
 883                 "\\time #'~a ~a/~a~a"
 884                 structure num den
 885                 (new-line->lily-string)))))
 886
 887 ;;; \melisma and \melismaEnd
 888 (define-extra-display-method ContextSpeccedMusic (expr parser)
 889   "If expr is a melisma, return \"\\melisma\", otherwise, return #f."
 890   (with-music-match (expr (music 'ContextSpeccedMusic
 891                                  element (music 'PropertySet
 892                                                 value #t
 893                                                 symbol 'melismaBusy)))
 894     "\\melisma"))
 895
 896 (define-extra-display-method ContextSpeccedMusic (expr parser)
 897   "If expr is a melisma end, return \"\\melismaEnd\", otherwise, return #f."
 898   (with-music-match (expr (music 'ContextSpeccedMusic
 899                                  element (music 'PropertyUnset
 900                                                 symbol 'melismaBusy)))
 901     "\\melismaEnd"))
 902
 903 ;;; \tempo
 904 (define-extra-display-method SequentialMusic (expr parser)
 905   (with-music-match (expr (music 'SequentialMusic
 906                                  elements ((music 'TempoChangeEvent
 907                                                   text ?text
 908                                                   tempo-unit ?unit
 909                                                   metronome-count ?count)
 910                                            (music 'ContextSpeccedMusic
 911                                                   element (music 'PropertySet
 912                                                                  symbol 'tempoWholesPerMinute)))))
 913     (format #f "\\tempo ~{~a~a~}~a = ~a~a"
 914             (if (markup? ?text)
 915                 (list (markup->lily-string ?text) " ")
 916                 '())
 917             (duration->lily-string ?unit #:force-duration #t)
 918             (if (pair? ?count)
 919                 (format #f "~a ~~ ~a" (car ?count) (cdr ?count))
 920                 ?count)
 921             (new-line->lily-string))))
 922
 923 (define-display-method TempoChangeEvent (expr parser)
 924   (let ((text (ly:music-property expr 'text)))
 925     (format #f "\\tempo ~a~a"
 926             (markup->lily-string text)
 927             (new-line->lily-string))))
 928
 929 ;;; \clef
 930 (define clef-name-alist #f)
 931 (define-public (memoize-clef-names clefs)
 932   "Initialize @code{clef-name-alist}, if not already set."
 933   (if (not clef-name-alist)
 934       (set! clef-name-alist
 935             (map (lambda (name+vals)
 936                    (cons (cdr name+vals)
 937                          (car name+vals)))
 938                  clefs))))
 939
 940 (define-extra-display-method ContextSpeccedMusic (expr parser)
 941   "If @var{expr} is a clef change, return \"\\clef ...\".
 942 Otherwise, return @code{#f}."
 943   (with-music-match (expr (music 'ContextSpeccedMusic
 944                                  context-type 'Staff
 945                                  element (music 'SequentialMusic
 946                                                 elements ((music 'PropertySet
 947                                                                  value ?clef-glyph
 948                                                                  symbol 'clefGlyph)
 949                                                           (music 'PropertySet
 950                                                                  symbol 'middleCClefPosition)
 951                                                           (music 'PropertySet
 952                                                                  value ?clef-position
 953                                                                  symbol 'clefPosition)
 954                                                           (music 'PropertySet
 955                                                                  value ?clef-octavation
 956                                                                  symbol 'clefOctavation)
 957                                                           (music 'ApplyContext
 958                                                                  procedure ly:set-middle-C!)))))
 959     (let ((clef-name (assoc-get (list ?clef-glyph ?clef-position 0)
 960                                 clef-name-alist)))
 961       (if clef-name
 962           (format #f "\\clef \"~a~{~a~a~}\"~a"
 963                   clef-name
 964                   (cond ((= 0 ?clef-octavation)
 965                          (list "" ""))
 966                         ((> ?clef-octavation 0)
 967                          (list "^" (1+ ?clef-octavation)))
 968                         (else
 969                          (list "_" (- 1 ?clef-octavation))))
 970                   (new-line->lily-string))
 971           #f))))
 972
 973 ;;; \bar
 974 (define-extra-display-method ContextSpeccedMusic (expr parser)
 975   "If `expr' is a bar, return \"\\bar ...\".
 976 Otherwise, return #f."
 977   (with-music-match (expr (music 'ContextSpeccedMusic
 978                                  context-type 'Timing
 979                                  element (music 'PropertySet
 980                                                 value ?bar-type
 981                                                 symbol 'whichBar)))
 982     (format #f "\\bar \"~a\"~a" ?bar-type (new-line->lily-string))))
 983
 984 ;;; \partial
 985 (define-extra-display-method ContextSpeccedMusic (expr parser)
 986   "If `expr' is a partial measure, return \"\\partial ...\".
 987 Otherwise, return #f."
 988   (with-music-match (expr (music
 989                            'ContextSpeccedMusic
 990                            element (music
 991                                     'ContextSpeccedMusic
 992                                     context-type 'Timing
 993                                     element (music
 994                                              'PartialSet
 995                                              partial-duration ?duration))))
 996
 997     (and ?duration
 998          (format #f "\\partial ~a"
 999                  (duration->lily-string ?duration #:force-duration #t)))))
1000
1001 ;;;
1002 ;;;
1003
1004 (define-display-method ApplyOutputEvent (applyoutput parser)
1005   (let ((proc (ly:music-property applyoutput 'procedure))
1006         (ctx  (ly:music-property applyoutput 'context-type)))
1007     (format #f "\\applyOutput #'~a #~a"
1008             ctx
1009             (or (procedure-name proc)
1010                 (with-output-to-string
1011                   (lambda ()
1012                     (pretty-print (procedure-source proc))))))))
1013
1014 (define-display-method ApplyContext (applycontext parser)
1015   (let ((proc (ly:music-property applycontext 'procedure)))
1016     (format #f "\\applyContext #~a"
1017             (or (procedure-name proc)
1018                 (with-output-to-string
1019                   (lambda ()
1020                     (pretty-print (procedure-source proc))))))))
1021
1022 ;;; \partcombine
1023 (define-display-method PartCombineMusic (expr parser)
1024   (format #f "\\partcombine ~{~a ~}"
1025           (map-in-order (lambda (music)
1026                           (music->lily-string music parser))
1027                         (ly:music-property expr 'elements))))
1028
1029 (define-extra-display-method PartCombineMusic (expr parser)
1030   (with-music-match (expr (music 'PartCombineMusic
1031                                  elements ((music 'UnrelativableMusic
1032                                                   element (music 'ContextSpeccedMusic
1033                                                                  context-id "one"
1034                                                                  context-type 'Voice
1035                                                                  element ?sequence1))
1036                                            (music 'UnrelativableMusic
1037                                                   element (music 'ContextSpeccedMusic
1038                                                                  context-id "two"
1039                                                                  context-type 'Voice
1040                                                                  element ?sequence2)))))
1041     (format #f "\\partcombine ~a~a~a"
1042             (music->lily-string ?sequence1 parser)
1043             (new-line->lily-string)
1044             (music->lily-string ?sequence2 parser))))
1045
1046 (define-display-method UnrelativableMusic (expr parser)
1047   (music->lily-string (ly:music-property expr 'element) parser))
1048
1049 ;;; Cue notes
1050 (define-display-method QuoteMusic (expr parser)
1051   (or (with-music-match (expr (music
1052                                'QuoteMusic
1053                                quoted-voice-direction ?quoted-voice-direction
1054                                quoted-music-name ?quoted-music-name
1055                                quoted-context-id "cue"
1056                                quoted-context-type 'Voice
1057                                element ?music))
1058         (format #f "\\cueDuring #~s #~a ~a"
1059                 ?quoted-music-name
1060                 ?quoted-voice-direction
1061                 (music->lily-string ?music parser)))
1062       (format #f "\\quoteDuring #~s ~a"
1063               (ly:music-property expr 'quoted-music-name)
1064               (music->lily-string (ly:music-property expr 'element) parser))))
1065
1066 ;;;
1067 ;;; Breaks
1068 ;;;
1069 (define-display-method LineBreakEvent (expr parser)
1070   (if (null? (ly:music-property expr 'break-permission))
1071       "\\noBreak"
1072       "\\break"))
1073
1074 (define-display-method PageBreakEvent (expr parser)
1075   (if (null? (ly:music-property expr 'break-permission))
1076       "\\noPageBreak"
1077       "\\pageBreak"))
1078
1079 (define-display-method PageTurnEvent (expr parser)
1080   (if (null? (ly:music-property expr 'break-permission))
1081       "\\noPageTurn"
1082       "\\pageTurn"))
1083
1084 (define-extra-display-method EventChord (expr parser)
1085   (with-music-match (expr (music 'EventChord
1086                             elements ((music 'LineBreakEvent
1087                                              break-permission 'force)
1088                                       (music 'PageBreakEvent
1089                                              break-permission 'force))))
1090     "\\pageBreak"))
1091
1092 (define-extra-display-method EventChord (expr parser)
1093   (with-music-match (expr (music 'EventChord
1094                             elements ((music 'LineBreakEvent
1095                                              break-permission 'force)
1096                                       (music 'PageBreakEvent
1097                                              break-permission 'force)
1098                                       (music 'PageTurnEvent
1099                                              break-permission 'force))))
1100     "\\pageTurn"))
1101
1102 ;;;
1103 ;;; Lyrics
1104 ;;;
1105
1106 ;;; \lyricsto
1107 (define-display-method LyricCombineMusic (expr parser)
1108   (format #f "\\lyricsto ~s ~a"
1109           (ly:music-property expr 'associated-context)
1110           (parameterize ((*explicit-mode* #f))
1111             (music->lily-string (ly:music-property expr 'element) parser))))
1112
1113 ;; \addlyrics
1114 (define-extra-display-method SimultaneousMusic (expr parser)
1115   (with-music-match (expr (music 'SimultaneousMusic
1116                                  elements ((music 'ContextSpeccedMusic
1117                                                   context-id ?id
1118                                                   context-type 'Voice
1119                                                   element ?note-sequence)
1120                                            (music 'ContextSpeccedMusic
1121                                                   context-type 'Lyrics
1122                                                   create-new #t
1123                                                   element (music 'LyricCombineMusic
1124                                                                  associated-context ?associated-id
1125                                                                  element ?lyric-sequence)))))
1126     (if (string=? ?id ?associated-id)
1127         (format #f "~a~a \\addlyrics ~a"
1128                 (music->lily-string ?note-sequence parser)
1129                 (new-line->lily-string)
1130                 (parameterize ((*explicit-mode* #f))
1131                   (music->lily-string ?lyric-sequence parser)))
1132         #f)))
1133
1134 ;; Silence internal event sent at end of each lyrics block
1135 (define-display-method CompletizeExtenderEvent (expr parser)
1136   "")