Adds an ID property to grobs.

[lilypond.git] / scm / define-music-display-methods.scm

diff --git a/scm/define-music-display-methods.scm b/scm/define-music-display-methods.scm
index 3ecfce5aaf1cdffce6a962576f3454bb8d996011..259c0ccaaebbb42e2c8eaeec3051ddedd7512249 100644 (file)
--- a/scm/define-music-display-methods.scm
+++ b/scm/define-music-display-methods.scm
@@ -1,7 +1,7 @@
 ;;; define-music-display-methods.scm -- data for displaying music
 ;;; expressions using LilyPond notation.
 ;;;
-;;; Copyright (C) 2005--2011 Nicolas Sceaux  <nicolas.sceaux@free.fr>
+;;; Copyright (C) 2005--2012 Nicolas Sceaux  <nicolas.sceaux@free.fr>
 ;;;
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -16,7 +16,8 @@
 ;;;
 (define (scheme-expr->lily-string scm-arg)
   (cond ((or (number? scm-arg)
-            (string? scm-arg))
+             (string? scm-arg)
+             (boolean? scm-arg))
         (format #f "~s" scm-arg))
        ((or (symbol? scm-arg)
             (list? scm-arg))
@@ -328,7 +329,7 @@ expression."
                                                        'OverrideProperty
                                                        grob-property-path '(stroke-style)
                                                        grob-value "grace"
-                                                       symbol 'Stem)))))
+                                                       symbol 'Flag)))))
           #t)
         (with-music-match (?stop (music
                                   'SequentialMusic
@@ -337,7 +338,7 @@ expression."
                                              element (music
                                                       'RevertProperty
                                                       grob-property-path '(stroke-style)
-                                                      symbol 'Stem))
+                                                      symbol 'Flag))
                                             (music
                                              'EventChord
                                              elements ((music
@@ -376,7 +377,7 @@ expression."
        (chord? (make-music-type-predicate 'EventChord))
        (cluster? (make-music-type-predicate 'ClusterNoteEvent))
        (note? (make-music-type-predicate 'NoteEvent)))
-    (format #f "~a~a{~v%~v_~{~a ~}~v%~v_}"
+    (format #f "~a~a{~v%~v_~{~a~^ ~}~v%~v_}"
            (if (any (lambda (e)
                       (and (chord? e)
                            (any cluster? (ly:music-property e 'elements))))
@@ -414,7 +415,7 @@ expression."
                                          (music->lily-string music parser))
                                        elements))
            (if force-line-break 1 0)
-           (if force-line-break (*indent*) 0))))
+           (if force-line-break (*indent*) 1))))
 
 (define-display-method SimultaneousMusic (sim parser)
   (parameterize ((*indent* (+ 3 (*indent*))))
@@ -466,11 +467,13 @@ Otherwise, return #f."
                 ;; as a note_chord_element to prevent spurious output, e.g.,
                 ;; \displayLilyMusic < c-1\4 >8 -> c-1\48
                 (null? (filter post-event?
-                               (ly:music-property (car simple-elements) 'articulations))))
+                               (ly:music-property (car simple-elements) 'articulations)))
+                ;; same for simple_element with \tweak
+                (null? (ly:music-property (car simple-elements) 'tweaks)))
            ;; simple_element : note | figure | rest | mmrest | lyric_element | skip
            (let* ((simple-element (car simple-elements))
                   (duration (ly:music-property simple-element 'duration))
-                  (lily-string (format #f "~a~a~a~{~a ~}"
+                  (lily-string (format #f "~a~a~a~{~a~^ ~}"
                                        (music->lily-string simple-element parser)
                                        (duration->lily-string duration)
                                        (if (and ((make-music-type-predicate 'RestEvent) simple-element)
@@ -488,7 +491,7 @@ Otherwise, return #f."
                  (post-events (filter post-event? elements)))
              (if (not (null? chord-elements))
                  ;; note_chord_element : '<' (notepitch | drumpitch)* '>" duration post_events
-                 (let ((lily-string (format #f "< ~{~a ~}>~a~{~a ~}"
+                 (let ((lily-string (format #f "< ~{~a ~}>~a~{~a~^ ~}"
                                             (map-in-order (lambda (music)
                                                             (music->lily-string music parser))
                                                           chord-elements)
@@ -500,13 +503,13 @@ Otherwise, return #f."
                    (*previous-duration* (ly:music-property (car chord-elements) 'duration))
                    lily-string)
                  ;; command_element
-                 (format #f "~{~a ~}" (map-in-order (lambda (music)
+                 (format #f "~{~a~^ ~}" (map-in-order (lambda (music)
                                                       (music->lily-string music parser))
                                                     elements))))))))
 
 (define-display-method MultiMeasureRestMusic (mmrest parser)
   (let* ((dur (ly:music-property mmrest 'duration))
-        (ly (format #f "R~a~{~a ~}"
+        (ly (format #f "R~a~{~a~^ ~}"
                     (duration->lily-string dur)
                     (map-in-order (lambda (music)
                                     (music->lily-string music parser))
@@ -694,6 +697,8 @@ Otherwise, return #f."
 ;;; Repeats
 ;;;
 
+(define-display-method AlternativeEvent (alternative parser) "")
+
 (define (repeat->lily-string expr repeat-type parser)
   (format #f "\\repeat ~a ~a ~a ~a"
          repeat-type
@@ -853,10 +858,8 @@ Otherwise, return #f."
 
 (define-display-method OverrideProperty (expr parser)
   (let* ((symbol         (ly:music-property expr 'symbol))
-        (property-path   (ly:music-property expr 'grob-property-path))
-        (properties      (if (pair? property-path)
-                             property-path
-                             (list (ly:music-property expr 'grob-property))))
+        (properties   (ly:music-property expr 'grob-property-path
+                                             (list (ly:music-property expr 'grob-property))))
         (value   (ly:music-property expr 'grob-value))
         (once    (ly:music-property expr 'once)))
 
@@ -876,8 +879,9 @@ Otherwise, return #f."
            (new-line->lily-string))))
 
 (define-display-method RevertProperty (expr parser)
-  (let ((symbol (ly:music-property expr 'symbol))
-       (properties (ly:music-property expr 'grob-property-path)))
+  (let* ((symbol (ly:music-property expr 'symbol))
+         (properties (ly:music-property expr 'grob-property-path
+                                             (list (ly:music-property expr 'grob-property)))))
     (format #f "\\revert ~a~a #'~a~a"
            (if (eqv? (*current-context*) 'Bottom)
                ""
@@ -898,8 +902,8 @@ Otherwise, return #f."
                 num den
                 (new-line->lily-string))
         (format #f
-                "#(set-time-signature ~a ~a '~a)~a"
-                num den structure
+                "\\time #'~a ~a/~a~a" 
+                structure num den
                 (new-line->lily-string)))))
 
 ;;; \melisma and \melismaEnd