X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=ly%2Fmusic-functions-init.ly;h=cbba26a65256a366e3c2793cebb641e91d18266b;hb=e8d5061834a5a658c5ffd078237e9cd660069a7d;hp=9e5d3c223b8c32db59a70585bd2bdf7f8478c278;hpb=c39d188d28fdc84cef8cbaea7b8d6e2fb718c30f;p=lilypond.git

diff --git a/ly/music-functions-init.ly b/ly/music-functions-init.ly
index 9e5d3c223b..cbba26a652 100644
--- a/ly/music-functions-init.ly
+++ b/ly/music-functions-init.ly
@@ -2,7 +2,7 @@
 
 %%%% This file is part of LilyPond, the GNU music typesetter.
 %%%%
-%%%% Copyright (C) 2003--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
+%%%% Copyright (C) 2003--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
 %%%%                          Jan Nieuwenhuizen <janneke@gnu.org>
 %%%%
 %%%% LilyPond is free software: you can redistribute it and/or modify
@@ -27,7 +27,7 @@
 
 %% need SRFI-1 for filter; optargs for lambda*
 #(use-modules (srfi srfi-1)
-	      (ice-9 optargs))
+              (ice-9 optargs))
 
 %% TODO: using define-music-function in a .scm causes crash.
 
@@ -63,22 +63,22 @@ afterGrace =
 #(define-music-function (parser location main grace) (ly:music? ly:music?)
    (_i "Create @var{grace} note(s) after a @var{main} music expression.")
    (let ((main-length (ly:music-length main))
-	 (fraction  (ly:parser-lookup parser 'afterGraceFraction)))
+         (fraction  (ly:parser-lookup parser 'afterGraceFraction)))
      (make-simultaneous-music
       (list
        main
        (make-sequential-music
-	(list
+        (list
 
-	 (make-music 'SkipMusic
-		     'duration (ly:make-duration
-				0 0
-				(* (ly:moment-main-numerator main-length)
-				   (car fraction))
-				(* (ly:moment-main-denominator main-length)
-				   (cdr fraction))))
-	 (make-music 'GraceMusic
-		     'element grace)))))))
+         (make-music 'SkipMusic
+                     'duration (ly:make-duration
+                                0 0
+                                (* (ly:moment-main-numerator main-length)
+                                   (car fraction))
+                                (* (ly:moment-main-denominator main-length)
+                                   (cdr fraction))))
+         (make-music 'GraceMusic
+                     'element grace)))))))
 
 
 %% music identifiers not allowed at top-level,
@@ -88,10 +88,10 @@ allowPageTurn =
    (_i "Allow a page turn. May be used at toplevel (ie between scores or
 markups), or inside a score.")
    (make-music 'EventChord
-	       'page-marker #t
-	       'page-turn-permission 'allow
-	       'elements (list (make-music 'PageTurnEvent
-					   'break-permission 'allow))))
+               'page-marker #t
+               'page-turn-permission 'allow
+               'elements (list (make-music 'PageTurnEvent
+                                           'break-permission 'allow))))
 
 alterBroken =
 #(define-music-function (parser location property arg item)
@@ -133,18 +133,18 @@ appendToTag =
    (_i "Append @var{more} to the @code{elements} of all music
 expressions in @var{music} that are tagged with @var{tag}.")
    (music-map (lambda (m)
-		(if (memq tag (ly:music-property m 'tags))
-		    (set! (ly:music-property m 'elements)
-			  (append (ly:music-property m 'elements)
-				  (list more))))
-		m)
-	      music))
+                (if (memq tag (ly:music-property m 'tags))
+                    (set! (ly:music-property m 'elements)
+                          (append (ly:music-property m 'elements)
+                                  (list more))))
+                m)
+              music))
 
 applyContext =
 #(define-music-function (parser location proc) (procedure?)
    (_i "Modify context properties with Scheme procedure @var{proc}.")
    (make-music 'ApplyContext
-	       'procedure proc))
+               'procedure proc))
 
 applyMusic =
 #(define-music-function (parser location func music) (procedure? ly:music?)
@@ -155,8 +155,8 @@ applyOutput =
 #(define-music-function (parser location ctx proc) (symbol? procedure?)
    (_i "Apply function @code{proc} to every layout object in context @code{ctx}")
    (make-music 'ApplyOutputEvent
-	       'procedure proc
-	       'context-type ctx))
+               'procedure proc
+               'context-type ctx))
 
 appoggiatura =
 #(def-grace-function startAppoggiaturaMusic stopAppoggiaturaMusic
@@ -198,9 +198,9 @@ balloonText =
 #(define-event-function (parser location offset text) (number-pair? markup?)
    (_i "Attach @var{text} at @var{offset} (use like @code{\\tweak})")
    (make-music 'AnnotateOutputEvent
-	       'X-offset (car offset)
-	       'Y-offset (cdr offset)
-	       'text text))
+               'X-offset (car offset)
+               'Y-offset (cdr offset)
+               'text text))
 
 bar =
 #(define-music-function (parser location type) (string?)
@@ -213,13 +213,13 @@ barNumberCheck =
 #(define-music-function (parser location n) (integer?)
    (_i "Print a warning if the current bar number is not @var{n}.")
    (make-music 'ApplyContext
-	       'procedure
-	       (lambda (c)
-		 (let ((cbn (ly:context-property c 'currentBarNumber)))
-		   (if (and  (number? cbn) (not (= cbn n)))
-		       (ly:input-warning location
-					 "Barcheck failed got ~a expect ~a"
-					 cbn n))))))
+               'procedure
+               (lambda (c)
+                 (let ((cbn (ly:context-property c 'currentBarNumber)))
+                   (if (and  (number? cbn) (not (= cbn n)))
+                       (ly:input-warning location
+                                         "Barcheck failed got ~a expect ~a"
+                                         cbn n))))))
 
 beamExceptions =
 #(define-scheme-function (parser location music) (ly:music?)
@@ -233,7 +233,7 @@ bendAfter =
 #(define-event-function (parser location delta) (real?)
    (_i "Create a fall or doit of pitch interval @var{delta}.")
    (make-music 'BendAfterEvent
-	       'delta-step delta))
+               'delta-step delta))
 
 bookOutputName =
 #(define-void-function (parser location newfilename) (string?)
@@ -253,15 +253,7 @@ bookOutputSuffix =
 breathe =
 #(define-music-function (parser location) ()
    (_i "Insert a breath mark.")
-   (make-music 'BreathingEvent
-     'midi-length
-     (lambda (len context)
-       ;;Shorten by half, or by up to a second, but always by a power of 2
-       (let* ((desired (min (ly:moment-main (seconds->moment 1 context))
-                            (* (ly:moment-main len) 1/2)))
-              (scale (inexact->exact (ceiling (/ (log desired) (log 1/2)))))
-              (breath (ly:make-moment (expt 1/2 scale))))
-         (ly:moment-sub (ly:make-moment (ly:moment-main len)) breath)))))
+   (make-music 'BreathingEvent))
 
 clef =
 #(define-music-function (parser location type) (string?)
@@ -287,7 +279,7 @@ as @code{\\compoundMeter #'((3 2 8))} or shorter
                         (ly:moment-main-denominator mlen))))
   #{
     \once \override Timing.TimeSignature.stencil = #(lambda (grob)
-      (grob-interpret-markup grob (format-compound-time args)))
+      (grob-interpret-markup grob (make-compound-meter-markup args)))
     \set Timing.timeSignatureFraction = #timesig
     \set Timing.baseMoment = #beat
     \set Timing.beatStructure = #beatGrouping
@@ -322,11 +314,11 @@ cueDuring =
    (_i "Insert contents of quote @var{what} corresponding to @var{main-music},
 in a CueVoice oriented by @var{dir}.")
    (make-music 'QuoteMusic
-	       'element main-music
-	       'quoted-context-type 'CueVoice
-	       'quoted-context-id "cue"
-	       'quoted-music-name what
-	       'quoted-voice-direction dir))
+               'element main-music
+               'quoted-context-type 'CueVoice
+               'quoted-context-id "cue"
+               'quoted-music-name what
+               'quoted-voice-direction dir))
 
 cueDuringWithClef =
 #(define-music-function
@@ -334,12 +326,12 @@ cueDuringWithClef =
    (_i "Insert contents of quote @var{what} corresponding to @var{main-music},
 in a CueVoice oriented by @var{dir}.")
    (make-music 'QuoteMusic
-	       'element main-music
-	       'quoted-context-type 'CueVoice
-	       'quoted-context-id "cue"
-	       'quoted-music-name what
-	       'quoted-music-clef clef
-	       'quoted-voice-direction dir))
+               'element main-music
+               'quoted-context-type 'CueVoice
+               'quoted-context-id "cue"
+               'quoted-music-name what
+               'quoted-music-clef clef
+               'quoted-voice-direction dir))
 
 
 
@@ -377,18 +369,18 @@ endSpanners =
    (_i "Terminate the next spanner prematurely after exactly one note
 without the need of a specific end spanner.")
    (let* ((start-span-evs (filter (lambda (ev)
-				    (equal? (ly:music-property ev 'span-direction)
-					    START))
-				  (extract-typed-music music 'span-event)))
-	  (stop-span-evs
-	   (map (lambda (m)
-		  (music-clone m 'span-direction STOP))
+                                    (equal? (ly:music-property ev 'span-direction)
+                                            START))
+                                  (extract-typed-music music 'span-event)))
+          (stop-span-evs
+           (map (lambda (m)
+                  (music-clone m 'span-direction STOP))
                 start-span-evs))
-	  (end-ev-chord (make-music 'EventChord
-				    'elements stop-span-evs))
-	  (total (make-music 'SequentialMusic
-			     'elements (list music
-					     end-ev-chord))))
+          (end-ev-chord (make-music 'EventChord
+                                    'elements stop-span-evs))
+          (total (make-music 'SequentialMusic
+                             'elements (list music
+                                             end-ev-chord))))
      total))
 
 eventChords =
@@ -402,14 +394,14 @@ featherDurations=
 #(define-music-function (parser location factor argument) (ly:moment? ly:music?)
    (_i "Adjust durations of music in @var{argument} by rational @var{factor}.")
    (let ((orig-duration (ly:music-length argument))
-	 (multiplier (ly:make-moment 1 1)))
+         (multiplier (ly:make-moment 1 1)))
 
      (for-each
       (lambda (mus)
-	(if (< 0 (ly:moment-main-denominator (ly:music-length mus)))
-	    (begin
-	      (ly:music-compress mus multiplier)
-	      (set! multiplier (ly:moment-mul factor multiplier)))))
+        (if (< 0 (ly:moment-main-denominator (ly:music-length mus)))
+            (begin
+              (ly:music-compress mus multiplier)
+              (set! multiplier (ly:moment-mul factor multiplier)))))
       (extract-named-music argument '(EventChord NoteEvent RestEvent SkipEvent)))
      (ly:music-compress
       argument
@@ -449,12 +441,12 @@ Like with @code{\\tweak}, if you use a footnote on a following
 post-event, the @code{\\footnote} command itself needs to be attached
 to the preceding note or rest as a post-event with @code{-}.")
    (let ((mus (make-music
-	       'FootnoteEvent
-	       'X-offset (car offset)
-	       'Y-offset (cdr offset)
-	       'automatically-numbered (not mark)
-	       'text (or mark (make-null-markup))
-	       'footnote-text footnote)))
+               'FootnoteEvent
+               'X-offset (car offset)
+               'Y-offset (cdr offset)
+               'automatically-numbered (not mark)
+               'text (or mark (make-null-markup))
+               'footnote-text footnote)))
      #{ \once \tweak footnote-music #mus #item #}))
 
 grace =
@@ -467,8 +459,8 @@ grobdescriptions =
 in the format of @code{all-grob-descriptions}.")
    (ly:make-context-mod
     (map (lambda (p)
-	   (list 'assign (car p) (list (cdr p))))
-	 descriptions)))
+           (list 'assign (car p) (ly:make-grob-properties (cdr p))))
+         descriptions)))
 
 harmonicByFret = #(define-music-function (parser location fret music) (number? ly:music?)
   (_i "Convert @var{music} into mixed harmonics; the resulting notes resemble
@@ -537,38 +529,35 @@ instrumentSwitch =
    (_i "Switch instrument to @var{name}, which must be predefined with
 @code{\\addInstrumentDefinition}.")
    (let* ((handle (assoc name instrument-definitions))
-	  (instrument-def (if handle (cdr handle) '())))
+          (instrument-def (if handle (cdr handle) '())))
 
      (if (not handle)
-	 (ly:input-warning location "No such instrument: ~a" name))
+         (ly:input-warning location "No such instrument: ~a" name))
      (context-spec-music
       (make-music 'SimultaneousMusic
-		  'elements
-		  (map (lambda (kv)
-			 (make-property-set
-			  (car kv)
-			  (cdr kv)))
-		       instrument-def))
+                  'elements
+                  (map (lambda (kv)
+                         (make-property-set
+                          (car kv)
+                          (cdr kv)))
+                       instrument-def))
       'Staff)))
 
 
 
 keepWithTag =
-#(define-music-function (parser location tag music)
+#(define-music-function (parser location tags music)
    (symbol-list-or-symbol? ly:music?)
-   (_i "Include only elements of @var{music} that are either untagged
-or tagged with one of the tags in @var{tag}.  @var{tag} may be either
-a single symbol or a list of symbols.")
+   (_i "Include only elements of @var{music} that are tagged with one
+of the tags in @var{tags}.  @var{tags} may be either a single symbol
+or a list of symbols.
+
+Each tag may be declared as a member of at most one tag group (defined
+with @code{\\tagGroup}).  If none of a @var{music} element's tags
+share a tag group with one of the specified @var{tags}, the element is
+retained.")
    (music-filter
-    (if (symbol? tag)
-        (lambda (m)
-          (let ((music-tags (ly:music-property m 'tags)))
-            (or (null? music-tags)
-                (memq tag music-tags))))
-        (lambda (m)
-          (let ((music-tags (ly:music-property m 'tags)))
-            (or (null? music-tags)
-                (any (lambda (t) (memq t music-tags)) tag)))))
+    (tags-keep-predicate tags)
     music))
 
 key =
@@ -577,16 +566,16 @@ key =
    (_i "Set key to @var{tonic} and scale @var{pitch-alist}.
 If both are null, just generate @code{KeyChangeEvent}.")
    (cond ((null? tonic) (make-music 'KeyChangeEvent))
-	 ((null? pitch-alist)
-	  (ly:parser-error parser (_ "second argument must be pitch list")
-			   location)
-	  (make-music 'SequentialMusic 'void #t))
-	 (else
-	  (ly:music-transpose
-	   (make-music 'KeyChangeEvent
-		'tonic (ly:make-pitch 0 0 0)
-		'pitch-alist pitch-alist)
-	   tonic))))
+         ((null? pitch-alist)
+          (ly:parser-error parser (_ "second argument must be pitch list")
+                           location)
+          (make-music 'SequentialMusic 'void #t))
+         (else
+          (ly:music-transpose
+           (make-music 'KeyChangeEvent
+                'tonic (ly:make-pitch 0 0 0)
+                'pitch-alist pitch-alist)
+           tonic))))
 
 killCues =
 #(define-music-function (parser location music) (ly:music?)
@@ -594,9 +583,9 @@ killCues =
    (music-map
     (lambda (mus)
       (if (and (string? (ly:music-property mus 'quoted-music-name))
-	       (string=? (ly:music-property mus 'quoted-context-id "") "cue"))
-	  (ly:music-property mus 'element)
-	  mus))
+               (string=? (ly:music-property mus 'quoted-context-id "") "cue"))
+          (ly:music-property mus 'element)
+          mus))
     music))
 
 
@@ -605,10 +594,10 @@ label =
 #(define-music-function (parser location label) (symbol?)
    (_i "Create @var{label} as a bookmarking label.")
    (make-music 'EventChord
-	       'page-marker #t
-	       'page-label label
-	       'elements (list (make-music 'LabelEvent
-					   'page-label label))))
+               'page-marker #t
+               'page-label label
+               'elements (list (make-music 'LabelEvent
+                                           'page-label label))))
 
 
 language =
@@ -633,26 +622,135 @@ languageRestore =
 
 
 magnifyMusic =
-#(define-music-function (parser location mag mus) (number? ly:music?)
-   (_i "Magnify the notation of @var{mus} without changing the
-staff-size, using @var{mag} as a size factor.  Stems, beams, and
-horizontal spacing are adjusted automatically.")
+#(define-music-function (parser location mag music) (positive? ly:music?)
+   (_i "Magnify the notation of @var{music} without changing the
+staff-size, using @var{mag} as a size factor.  Stems, beams,
+slurs, ties, and horizontal spacing are adjusted automatically.")
+
+   ;; these props are NOT allowed to shrink below default size
+   (define unshrinkable-props
+     '(
+       ;; stems
+       (Stem thickness)
+
+       ;; slurs
+       (Slur line-thickness)
+       (Slur thickness)
+       (PhrasingSlur line-thickness)
+       (PhrasingSlur thickness)
+
+       ;; ties
+       (Tie line-thickness)
+       (Tie thickness)
+       (LaissezVibrerTie line-thickness)
+       (LaissezVibrerTie thickness)
+       (RepeatTie line-thickness)
+       (RepeatTie thickness)
+       ))
+
+   ;; these props ARE allowed to shrink below default size
+   (define shrinkable-props
+     (let ((baseline-skip-props
+             (find-named-props 'baseline-skip all-grob-descriptions))
+           (word-space-props
+             (find-named-props 'word-space all-grob-descriptions)))
+       (append
+         baseline-skip-props
+         word-space-props
+         '(
+           ;; TODO: uncomment spacing-increment here once Issue 3987 is fixed
+           ;; override at the 'Score level
+           ;(SpacingSpanner spacing-increment)
+
+           ;; lengths and heights
+           (Beam length-fraction)
+           (Stem length-fraction)
+           (Stem beamlet-default-length)
+           (Stem double-stem-separation)
+           (Slur height-limit)
+           (Slur minimum-length)
+           (PhrasingSlur height-limit)
+           (PhrasingSlur minimum-length)
+
+           ;; Beam.beam-thickness is dealt with separately below
+           ))))
+   #{
+     \context Bottom {
+       %% TODO: uncomment \newSpacingSection once Issue 3990 is fixed
+       %\newSpacingSection
+       #(scale-fontSize 'magnifyMusic mag)
+       #(scale-props    'magnifyMusic mag #f unshrinkable-props)
+       #(scale-props    'magnifyMusic mag #t shrinkable-props)
+       #(scale-beam-thickness mag)
+
+       #music
+
+       %% TODO: uncomment \newSpacingSection once Issue 3990 is fixed
+       %\newSpacingSection
+       %% reverse engineer the former fontSize value instead of using \unset
+       #(revert-fontSize 'magnifyMusic mag)
+       #(revert-props    'magnifyMusic mag (append unshrinkable-props
+                                                   shrinkable-props
+                                                   '((Beam beam-thickness))))
+     }
+   #})
+
+magnifyStaff =
+#(define-music-function (parser location mag) (positive?)
+   (_i "Change the size of the staff, adjusting notation size and
+horizontal spacing automatically, using @var{mag} as a size factor.")
+
+   ;; these props are NOT allowed to shrink below default size
+   (define unshrinkable-props
+     '((StaffSymbol thickness)))
+
+   ;; these props ARE allowed to shrink below default size
+   (define shrinkable-props
+     (let* ((baseline-skip-props
+              (find-named-props 'baseline-skip all-grob-descriptions))
+            (word-space-props
+              (find-named-props 'word-space all-grob-descriptions))
+            (space-alist-props
+              (find-named-props 'space-alist all-grob-descriptions)))
+       (append
+         baseline-skip-props
+         word-space-props
+         space-alist-props
+         '(
+           ;; override at the 'Score level
+           (SpacingSpanner spacing-increment)
+
+           (StaffSymbol staff-space)
+           (BarLine kern)
+           (BarLine segno-kern)
+           (BarLine hair-thickness)
+           (BarLine thick-thickness)
+           (Stem beamlet-default-length)
+           (Stem double-stem-separation)
+           ))))
+
    #{
-     \set fontSize = #(magnification->font-size mag)
-     % gives beam-thickness=0.48 when mag=1 (like default),
-     % gives beam-thickness=0.35 when mag=0.63 (like CueVoice)
-     \temporary \override Beam.beam-thickness = #(+ 119/925 (* mag 13/37))
-     \temporary \override Beam.length-fraction = #mag
-     \temporary \override Stem.length-fraction = #mag
-     \temporary \override Stem.thickness = #(* 1.3 (max 1 mag))
-     \temporary \override Score.SpacingSpanner.spacing-increment = #(* 1.2 mag)
-     #mus
-     \set fontSize = 0
-     \revert Beam.beam-thickness
-     \revert Beam.length-fraction
-     \revert Stem.length-fraction
-     \revert Stem.thickness
-     \revert Score.SpacingSpanner.spacing-increment
+     \stopStaff
+
+     %% revert settings from last time
+     %% (but only if \magnifyStaff has already been used
+     %% and the staff magnification is changing)
+     #(revert-fontSize 'magnifyStaff mag)
+     #(revert-props    'magnifyStaff mag (append unshrinkable-props
+                                                 shrinkable-props))
+
+     %% scale settings
+     %% (but only if staff magnification is changing
+     %% and does not equal 1)
+     #(scale-fontSize 'magnifyStaff mag)
+     #(scale-props    'magnifyStaff mag #f unshrinkable-props)
+     #(scale-props    'magnifyStaff mag #t shrinkable-props)
+
+     %% this might cause problems until Issue 3990 is fixed
+     \newSpacingSection
+
+     \startStaff
+     \set Staff.magnifyStaffValue = #mag
    #})
 
 makeClusters =
@@ -690,16 +788,16 @@ mark =
    (parser location label) ((scheme? '()))
   "Make the music for the \\mark command."
   (let* ((set (and (integer? label)
-		   (context-spec-music (make-property-set 'rehearsalMark label)
-				      'Score)))
-	 (ev (make-music 'MarkEvent
-			 'origin location)))
+                   (context-spec-music (make-property-set 'rehearsalMark label)
+                                      'Score)))
+         (ev (make-music 'MarkEvent
+                         'origin location)))
 
     (if set
-	(make-sequential-music (list set ev))
-	(begin
-	  (set! (ly:music-property ev 'label) label)
-	  ev))))
+        (make-sequential-music (list set ev))
+        (begin
+          (set! (ly:music-property ev 'label) label)
+          ev))))
 
 musicMap =
 #(define-music-function (parser location proc mus) (procedure? ly:music?)
@@ -713,20 +811,20 @@ noPageBreak =
    (_i "Forbid a page break.  May be used at toplevel (i.e., between scores or
 markups), or inside a score.")
    (make-music 'EventChord
-	       'page-marker #t
-	       'page-break-permission 'forbid
-	       'elements (list (make-music 'PageBreakEvent
-					   'break-permission '()))))
+               'page-marker #t
+               'page-break-permission 'forbid
+               'elements (list (make-music 'PageBreakEvent
+                                           'break-permission '()))))
 
 noPageTurn =
 #(define-music-function (location parser) ()
    (_i "Forbid a page turn.  May be used at toplevel (i.e., between scores or
 markups), or inside a score.")
    (make-music 'EventChord
-	       'page-marker #t
-	       'page-turn-permission 'forbid
-	       'elements (list (make-music 'PageTurnEvent
-					   'break-permission '()))))
+               'page-marker #t
+               'page-turn-permission 'forbid
+               'elements (list (make-music 'PageTurnEvent
+                                           'break-permission '()))))
 
 
 
@@ -814,7 +912,7 @@ ottava =
 #(define-music-function (parser location octave) (integer?)
    (_i "Set the octavation.")
    (make-music 'OttavaMusic
-	       'ottava-number octave))
+               'ottava-number octave))
 
 overrideTimeSignatureSettings =
 #(define-music-function
@@ -826,7 +924,7 @@ for time signatures of @var{time-signature} to have settings
 of @var{base-moment}, @var{beat-structure}, and @var{beam-exceptions}.")
 
    ;; TODO -- add warning if largest value of grouping is
-   ;;	    greater than time-signature.
+   ;;       greater than time-signature.
   (let ((setting (make-setting base-moment beat-structure beam-exceptions)))
     (override-time-signature-setting time-signature setting)))
 
@@ -865,28 +963,28 @@ pageBreak =
    (_i "Force a page break.  May be used at toplevel (i.e., between scores or
 markups), or inside a score.")
    (make-music 'EventChord
-	       'page-marker #t
-	       'line-break-permission 'force
-	       'page-break-permission 'force
-	       'elements (list (make-music 'LineBreakEvent
-					   'break-permission 'force)
-			       (make-music 'PageBreakEvent
-					   'break-permission 'force))))
+               'page-marker #t
+               'line-break-permission 'force
+               'page-break-permission 'force
+               'elements (list (make-music 'LineBreakEvent
+                                           'break-permission 'force)
+                               (make-music 'PageBreakEvent
+                                           'break-permission 'force))))
 
 pageTurn =
 #(define-music-function (location parser) ()
    (_i "Force a page turn between two scores or top-level markups.")
    (make-music 'EventChord
-	       'page-marker #t
-	       'line-break-permission 'force
-	       'page-break-permission 'force
-	       'page-turn-permission 'force
-	       'elements (list (make-music 'LineBreakEvent
-					   'break-permission 'force)
-			       (make-music 'PageBreakEvent
-					   'break-permission 'force)
-			       (make-music 'PageTurnEvent
-					   'break-permission 'force))))
+               'page-marker #t
+               'line-break-permission 'force
+               'page-break-permission 'force
+               'page-turn-permission 'force
+               'elements (list (make-music 'LineBreakEvent
+                                           'break-permission 'force)
+                               (make-music 'PageBreakEvent
+                                           'break-permission 'force)
+                               (make-music 'PageTurnEvent
+                                           'break-permission 'force))))
 
 parallelMusic =
 #(define-void-function (parser location voice-ids music) (list? ly:music?)
@@ -910,100 +1008,101 @@ Example:
   C = { e e | f f | }
 @end verbatim
 ")
+   (define voice-count (length voice-ids))
    (define (bar-check? m)
      "Checks whether m is a bar check."
      (eq? (ly:music-property m 'name) 'BarCheck))
+   (define (recurse-and-split-list lst)
+     "Return either a list of music lists split along barchecks, or @code{#f}."
+     (if (any bar-check? lst)
+         (let* ((voices (apply circular-list (make-list voice-count '())))
+                (current-voices voices)
+                (current-sequence '()))
+           ;;
+           ;; utilities
+           (define (push-music m)
+             "Push the music expression into the current sequence"
+             (set! current-sequence (cons m current-sequence)))
+           (define (change-voice)
+             "Store the previously built sequence into the current voice and
+change to the following voice."
+             (set-car! current-voices
+                       (cons (reverse! current-sequence)
+                             (car current-voices)))
+             (set! current-sequence '())
+             (set! current-voices (cdr current-voices)))
+           (for-each (lambda (m)
+                       (let ((split? (recurse-and-split m)))
+                         (if split?
+                             (for-each
+                              (lambda (m)
+                                (push-music m)
+                                (change-voice))
+                              split?)
+                             (begin
+                               (push-music m)
+                               (if (bar-check? m) (change-voice))))))
+                     lst)
+           (if (pair? current-sequence) (change-voice))
+           ;; un-circularize `voices' and reorder the voices
+           (set! voices (map reverse!
+                             (list-head voices voice-count)))
+           ;; check sequence length
+           (apply for-each (lambda seqs
+                             (define (seq-len seq)
+                               (reduce ly:moment-add
+                                       (ly:make-moment 0)
+                                       (map ly:music-length seq)))
+                             (let ((moment-reference (seq-len (car seqs))))
+                               (for-each (lambda (seq)
+                                           (if (not (equal? (seq-len seq)
+                                                            moment-reference))
+                                               (ly:music-warning
+                                                (if (pair? seq)
+                                                    (last seq)
+                                                    (caar seqs))
+                                                (_ "Bars in parallel music don't have the same length"))))
+                                         seqs)))
+                  voices)
+           (map concatenate! voices))
+         (let ((deeper (map recurse-and-split lst)))
+           (and (any pair? deeper)
+                (apply zip (map
+                            (lambda (m split)
+                              (or split
+                                  (ly:music-deep-copy (make-list voice-count m))))
+                            lst deeper))))))
    (define (recurse-and-split music)
      "This returns either a list of music split along barchecks, or
 @code{#f}."
-     (let ((elt (ly:music-property music 'element))
-           (elts (ly:music-property music 'elements)))
-       (cond ((ly:music? elt)
-              (let ((lst (recurse-and-split elt)))
-                (and lst
-                     (map
-                      (lambda (x)
-                        (let ((res (music-clone music 'element x)))
-                          (if (ly:input-location?
-                               (ly:music-property x 'origin))
-                              (set! (ly:music-property res 'origin)
-                                    (ly:music-property x 'origin)))
-                          res))
-                      lst))))
-             ((any bar-check? elts)
-              (let* ((voices (apply circular-list
-                                    (make-list (length voice-ids)
-                                               '())))
-                     (current-voices voices)
-                     (current-sequence '()))
-                ;;
-                ;; utilities
-                (define (push-music m)
-                  "Push the music expression into the current sequence"
-                  (set! current-sequence (cons m current-sequence)))
-                (define (change-voice)
-                  "Stores the previously built sequence into the current voice and
-       change to the following voice."
-                  (set-car! current-voices
-                            (cons (reverse! current-sequence)
-                                  (car current-voices)))
-                  (set! current-sequence '())
-                  (set! current-voices (cdr current-voices)))
-                (for-each (lambda (m)
-                            (let ((split? (recurse-and-split m)))
-                              (if split?
-                                  (for-each
-                                   (lambda (m)
-                                     (push-music m)
-                                     (change-voice))
-                                   split?)
-                                  (begin
-                                    (push-music m)
-                                    (if (bar-check? m) (change-voice))))))
-                          elts)
-                (if (pair? current-sequence) (change-voice))
-                ;; un-circularize `voices' and reorder the voices
-
-                (set! voices (map reverse!
-                                  (list-head voices (length voice-ids))))
-
-                ;; check sequence length
-                (apply for-each (lambda seqs
-                                  (define (seq-len seq)
-                                    (reduce ly:moment-add
-                                            (ly:make-moment 0)
-                                            (map ly:music-length seq)))
-                                  (let ((moment-reference (seq-len (car seqs))))
-                                    (for-each (lambda (seq)
-                                                (if (not (equal? (seq-len seq)
-                                                                 moment-reference))
-                                                    (ly:music-warning
-                                                     (if (pair? seq)
-                                                         (last seq)
-                                                         (caar seqs))
-                                                     (_ "Bars in parallel music don't have the same length"))))
-                                              seqs)))
-                       voices)
-                (map
-                 (lambda (lst)
-                   (set! lst (concatenate! lst))
-                   (let ((res (music-clone music 'elements lst)))
-                     (if (and (pair? lst)
-                              (ly:input-location? (ly:music-property
-                                                   (car lst)
-                                                   'origin)))
-                         (set! (ly:music-property res 'origin)
-                               (ly:music-property (car lst) 'origin)))
-                     res))
-                 voices)))
-             (else #f))))
+     (let* ((elt (ly:music-property music 'element))
+            (elts (ly:music-property music 'elements))
+            (split-elt (and (ly:music? elt) (recurse-and-split elt)))
+            (split-elts (and (pair? elts) (recurse-and-split-list elts))))
+       (and (or split-elt split-elts)
+            (map
+             (lambda (e es)
+               (apply music-clone music
+                      (append
+                       ;; reassigning the origin of the parent only
+                       ;; makes sense if the first expression in the
+                       ;; result is from a distributed origin
+                       (let ((origin
+                              (if (ly:music? elt)
+                                  (and (ly:music? e) (ly:music-property e 'origin #f))
+                                  (and (pair? es) (ly:music-property (car es) 'origin #f)))))
+                         (if origin (list 'origin origin) '()))
+                       (if (ly:music? e) (list 'element e) '())
+                       (if (pair? es) (list 'elements es) '()))))
+             (or split-elt (circular-list #f))
+             (or split-elts (circular-list #f))))))
    (let ((voices (recurse-and-split music)))
      (if voices
          ;;
          ;; bind voice identifiers to the voices
          (for-each (lambda (voice-id voice)
                      (ly:parser-define! parser voice-id voice))
-	  voice-ids voices)
+                   voice-ids voices)
          (ly:music-warning music
                            (_ "ignoring parallel music without barchecks")))))
 
@@ -1015,43 +1114,61 @@ parenthesize =
        ;; arg is an EventChord -> set the parenthesize property
        ;; on all child notes and rests
        (for-each
-	(lambda (ev)
-	  (if (or (memq 'note-event (ly:music-property ev 'types))
-		  (memq 'rest-event (ly:music-property ev 'types)))
-	      (set! (ly:music-property ev 'parenthesize) #t)))
-	(ly:music-property arg 'elements))
+        (lambda (ev)
+          (if (or (memq 'note-event (ly:music-property ev 'types))
+                  (memq 'rest-event (ly:music-property ev 'types)))
+              (set! (ly:music-property ev 'parenthesize) #t)))
+        (ly:music-property arg 'elements))
        ;; No chord, simply set property for this expression:
        (set! (ly:music-property arg 'parenthesize) #t))
    arg)
 
 partcombine =
-#(define-music-function (parser location part1 part2) (ly:music? ly:music?)
-   (_i "Take the music in @var{part1} and @var{part2} and typeset so
-that they share a staff.")
-   (make-part-combine-music parser
-                            (list part1 part2) #f))
+#(define-music-function (parser location chord-range part1 part2)
+   ((number-pair? '(0 . 8)) ly:music? ly:music?)
+   (_i "Take the music in @var{part1} and @var{part2} and return
+a music expression containing simultaneous voices, where @var{part1}
+and @var{part2} are combined into one voice where appropriate.
+Optional @var{chord-range} sets the distance in steps between notes
+that may be combined into a chord or unison.")
+   #{ \context Staff <<
+        \context Voice = "one" \with { \voiceOne } {}
+        \context Voice = "two" \with { \voiceTwo } {}
+        \context Voice = "shared" {}
+        #(make-part-combine-music parser (list part1 part2) #f chord-range)
+      >> #} )
 
 partcombineUp =
-#(define-music-function (parser location part1 part2) (ly:music? ly:music?)
+#(define-music-function (parser location chord-range part1 part2)
+   ((number-pair? '(0 . 8)) ly:music? ly:music?)
    (_i "Take the music in @var{part1} and @var{part2} and typeset so
 that they share a staff with stems directed upward.")
-   (make-part-combine-music parser
-                            (list part1 part2) UP))
+   #{ \context Staff <<
+        \context Voice = "one" \with { \voiceOne } {}
+        \context Voice = "two" \with { \voiceThree } {}
+        \context Voice = "shared" \with { \voiceOne } {}
+        #(make-part-combine-music parser (list part1 part2) UP chord-range)
+      >> #} )
 
 partcombineDown =
-#(define-music-function (parser location part1 part2) (ly:music? ly:music?)
+#(define-music-function (parser location chord-range part1 part2)
+   ((number-pair? '(0 . 8)) ly:music? ly:music?)
    (_i "Take the music in @var{part1} and @var{part2} and typeset so
 that they share a staff with stems directed downward.")
-   (make-part-combine-music parser
-                            (list part1 part2) DOWN))
+   #{ \context Staff <<
+        \context Voice = "one" \with { \voiceFour } {}
+        \context Voice = "two" \with { \voiceTwo } {}
+        \context Voice = "shared" \with { \voiceTwo } {}
+        #(make-part-combine-music parser (list part1 part2) DOWN chord-range)
+      >> #} )
 
 partcombineForce =
-#(define-music-function (location parser type once) (symbol-or-boolean? boolean?)
+#(define-music-function (location parser type once) (boolean-or-symbol? boolean?)
    (_i "Override the part-combiner.")
    (make-music 'EventChord
-	       'elements (list (make-music 'PartCombineForceEvent
-					   'forced-type type
-					   'once once))))
+               'elements (list (make-music 'PartCombineForceEvent
+                                           'forced-type type
+                                           'once once))))
 partcombineApart = \partcombineForce #'apart ##f
 partcombineApartOnce = \partcombineForce #'apart ##t
 partcombineChords = \partcombineForce #'chords ##f
@@ -1073,9 +1190,9 @@ partial =
   ;; ensure \partial still works if the Timing_translator is moved
     (descend-to-context
      (context-spec-music (make-music 'PartialSet
-				     'origin location
-				     'duration dur)
-			 'Timing)
+                                     'origin location
+                                     'duration dur)
+                         'Timing)
      'Score))
 
 pitchedTrill =
@@ -1085,7 +1202,7 @@ pitchedTrill =
    (_i "Print a trill with @var{main-note} as the main note of the trill and
 print @var{secondary-note} as a stemless note head in parentheses.")
    (let* ((get-notes (lambda (ev-chord)
-		       (extract-named-music ev-chord 'NoteEvent)))
+                       (extract-named-music ev-chord 'NoteEvent)))
           (sec-note-events (get-notes secondary-note))
           (trill-events (extract-named-music main-note 'TrillSpanEvent)))
      (if (pair? sec-note-events)
@@ -1112,11 +1229,11 @@ pushToTag =
    (_i "Add @var{more} to the front of @code{elements} of all music
 expressions in @var{music} that are tagged with @var{tag}.")
    (music-map (lambda (m)
-		(if (memq tag (ly:music-property m 'tags))
-		    (set! (ly:music-property m 'elements)
-			  (cons more (ly:music-property m 'elements))))
-		m)
-	      music))
+                (if (memq tag (ly:music-property m 'tags))
+                    (set! (ly:music-property m 'elements)
+                          (cons more (ly:music-property m 'elements))))
+                m)
+              music))
 
 quoteDuring =
 #(define-music-function (parser location what main-music) (string? ly:music?)
@@ -1148,22 +1265,16 @@ omitted, the first note in @var{music} is given in absolute pitch.")
                                   (ly:pitch-steps (ly:make-pitch 1 0))
                                   2))))
    (make-music 'RelativeOctaveMusic
-	       'element music))
+               'element music))
 
 removeWithTag =
-#(define-music-function (parser location tag music)
+#(define-music-function (parser location tags music)
    (symbol-list-or-symbol? ly:music?)
    (_i "Remove elements of @var{music} that are tagged with one of the
-tags in @var{tag}.  @var{tag} may be either a single symbol or a list
+tags in @var{tags}.  @var{tags} may be either a single symbol or a list
 of symbols.")
    (music-filter
-    (if (symbol? tag)
-        (lambda (m)
-          (not (memq tag (ly:music-property m 'tags))))
-        (lambda (m)
-          (let ((music-tags (ly:music-property m 'tags)))
-            (or (null? music-tags)
-                (not (any (lambda (t) (memq t music-tags)) tag))))))
+    (tags-remove-predicate tags)
     music))
 
 resetRelativeOctave =
@@ -1203,7 +1314,7 @@ scaleDurations =
    (fraction? ly:music?)
    (_i "Multiply the duration of events in @var{music} by @var{fraction}.")
    (ly:music-compress music
-		      (ly:make-moment (car fraction) (cdr fraction))))
+                      (ly:make-moment (car fraction) (cdr fraction))))
 
 settingsFrom =
 #(define-scheme-function (parser location ctx music)
@@ -1214,44 +1325,44 @@ a context modification duplicating their effect.")
    (let ((mods (ly:make-context-mod)))
      (define (musicop m)
        (if (music-is-of-type? m 'layout-instruction-event)
-	   (ly:add-context-mod
-	    mods
-	    (case (ly:music-property m 'name)
-	      ((PropertySet)
-	       (list 'assign
-		     (ly:music-property m 'symbol)
-		     (ly:music-property m 'value)))
-	      ((PropertyUnset)
-	       (list 'unset
-		     (ly:music-property m 'symbol)))
-	      ((OverrideProperty)
-	       (cons* 'push
-		      (ly:music-property m 'symbol)
-		      (ly:music-property m 'grob-value)
+           (ly:add-context-mod
+            mods
+            (case (ly:music-property m 'name)
+              ((PropertySet)
+               (list 'assign
+                     (ly:music-property m 'symbol)
+                     (ly:music-property m 'value)))
+              ((PropertyUnset)
+               (list 'unset
+                     (ly:music-property m 'symbol)))
+              ((OverrideProperty)
+               (cons* 'push
+                      (ly:music-property m 'symbol)
+                      (ly:music-property m 'grob-value)
                       (cond
                        ((ly:music-property m 'grob-property #f) => list)
                        (else
                         (ly:music-property m 'grob-property-path)))))
-	      ((RevertProperty)
-	       (cons* 'pop
-		      (ly:music-property m 'symbol)
+              ((RevertProperty)
+               (cons* 'pop
+                      (ly:music-property m 'symbol)
                       (cond
                        ((ly:music-property m 'grob-property #f) => list)
                        (else
                         (ly:music-property m 'grob-property-path)))))))
-	   (case (ly:music-property m 'name)
-	     ((ApplyContext)
-	      (ly:add-context-mod mods
-				  (list 'apply
-					(ly:music-property m 'procedure))))
-	     ((ContextSpeccedMusic)
-	      (if (or (not ctx)
-		      (eq? ctx (ly:music-property m 'context-type)))
-		  (musicop (ly:music-property m 'element))))
-	     (else
-	      (let ((callback (ly:music-property m 'elements-callback)))
-		(if (procedure? callback)
-		    (for-each musicop (callback m))))))))
+           (case (ly:music-property m 'name)
+             ((ApplyContext)
+              (ly:add-context-mod mods
+                                  (list 'apply
+                                        (ly:music-property m 'procedure))))
+             ((ContextSpeccedMusic)
+              (if (or (not ctx)
+                      (eq? ctx (ly:music-property m 'context-type)))
+                  (musicop (ly:music-property m 'element))))
+             (else
+              (let ((callback (ly:music-property m 'elements-callback)))
+                (if (procedure? callback)
+                    (for-each musicop (callback m))))))))
      (musicop music)
      mods))
 
@@ -1334,7 +1445,7 @@ skip =
 #(define-music-function (parser location dur) (ly:duration?)
   (_i "Skip forward by @var{dur}.")
   (make-music 'SkipMusic
-	      'duration dur))
+              'duration dur))
 
 
 slashedGrace =
@@ -1349,7 +1460,7 @@ the `parameters' assoc list.")
    #{
      \overrideProperty Score.NonMusicalPaperColumn.line-break-system-details
      #(list (cons 'alignment-extra-space (cdr (assoc 'system-stretch parameters)))
-	     (cons 'system-Y-extent (cdr (assoc 'system-Y-extent parameters))))
+             (cons 'system-Y-extent (cdr (assoc 'system-Y-extent parameters))))
    #})
 
 styledNoteHeads =
@@ -1359,18 +1470,25 @@ styledNoteHeads =
    (style-note-heads heads style music))
 
 tag =
-#(define-music-function (parser location tag music) (symbol-list-or-symbol? ly:music?)
-   (_i "Tag the following @var{music} with @var{tag} and return the
-result, by adding the single symbol or symbol list @var{tag} to the
+#(define-music-function (parser location tags music) (symbol-list-or-symbol? ly:music?)
+   (_i "Tag the following @var{music} with @var{tags} and return the
+result, by adding the single symbol or symbol list @var{tags} to the
 @code{tags} property of @var{music}.")
 
    (set!
     (ly:music-property music 'tags)
-    ((if (symbol? tag) cons append)
-     tag
+    ((if (symbol? tags) cons append)
+     tags
      (ly:music-property music 'tags)))
    music)
 
+tagGroup =
+#(define-void-function (parser location tags) (symbol-list?)
+   (_i "Define a tag group comprising the symbols in the symbol list
+@var{tags}.  Tag groups must not overlap.")
+   (let ((err (define-tag-group tags)))
+     (if err (ly:parser-error parser err location))))
+
 temporary =
 #(define-music-function (parser location music)
    (ly:music?)
@@ -1427,9 +1545,9 @@ times =
    (fraction? ly:music?)
    (_i "Scale @var{music} in time by @var{fraction}.")
   (make-music 'TimeScaledMusic
-  	      'element (ly:music-compress music (ly:make-moment (car fraction) (cdr fraction)))
-  	      'numerator (car fraction)
-  	      'denominator (cdr fraction)))
+              'element (ly:music-compress music (ly:make-moment (car fraction) (cdr fraction)))
+              'numerator (car fraction)
+              'denominator (cdr fraction)))
 
 transpose =
 #(define-music-function
@@ -1447,19 +1565,19 @@ transposedCueDuring =
 
    (_i "Insert notes from the part @var{what} into a voice called @code{cue},
 using the transposition defined by @var{pitch}.  This happens
-simultaneously with @var{main-music}, which is usually a rest.	The
+simultaneously with @var{main-music}, which is usually a rest.  The
 argument @var{dir} determines whether the cue notes should be notated
 as a first or second voice.")
 
    (make-music 'QuoteMusic
-	       'element main-music
-	       'quoted-context-type 'CueVoice
-	       'quoted-context-id "cue"
-	       'quoted-music-name what
-	       'quoted-voice-direction dir
+               'element main-music
+               'quoted-context-type 'CueVoice
+               'quoted-context-id "cue"
+               'quoted-music-name what
+               'quoted-voice-direction dir
                ;; following is inverse of instrumentTransposition for
                ;; historical reasons
-	       'quoted-transposition pitch))
+               'quoted-transposition pitch))
 
 transposition =
 #(define-music-function (parser location pitch) (ly:pitch?)