Following on from this old thread...

https://lists.gnu.org/archive/html/lilypond-user/2019-10/msg00405.html

... I'm using Harm's fantastic code to align/attach Stems to a Glissando line.

However, I've come across a problem with the code which in relation to 
MultiMeasureRests. Namely, writing a MMR which will appear on the same system 
as the Glissando (or some other situations) results in an error:

ERROR: In procedure ly:item-get-column: Wrong type argument in position 1 (expecting 
Item): #<Grob Spanner >

Attached is Harm's original code with a few lines added to the example (at line 
595) which demonstrate the problem.

Many thanks,

Mark

\version "2.19.83"

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%
%% GLISSANDO WITH STEMS
%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

#(define (glissando-and-stems pad-y)
"Returns the unchanged @code{Glissando}, @code{Stem}s from passed
@code{NoteColumn}s are recreated to start at the glissando-line.  @var{pad-y}
may provide a padding-value.
A @code{Flag} is moved to fit again with the new @code{Stem}.
@code{Script} at a passed @code{NoteColumn} is moved to sit at note-head-side.
Inner @code{Beam}s are recreated to be parallel to the glissando-line, unless
an override for @code{Beam.details.beamed-glissando-stem-positions}, expecting
a number-pair, is suppled.  This is prefered.
"
;; Glissando has no pointer to the covered NoteColumns, because in most
;; traditional music NoteColumns are *not* skipped.
;; Thus reading those NoteColumns is inconvenient...
  (lambda (grob)
    (let ((gliss-stil (ly:grob-property grob 'stencil)))
      (if (not (ly:stencil? gliss-stil))
          ;; Warn if no Glissando.stencil is present, do nothing else
          (ly:warning "No stencil for ~a found, stopping here" grob)
          (let* (
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 ;; some generals
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 (sys (ly:grob-system grob))
                 (layout (ly:grob-layout grob))
                 (blot (ly:output-def-lookup layout 'blot-diameter))
                 (staff-space (ly:staff-symbol-staff-space grob))
                 (line-thickness (ly:staff-symbol-line-thickness grob))
                 (half-line-thick (/ line-thickness 2))
                 (grob-thickness (ly:grob-property grob 'thickness 1))
                 (gliss-thick (* line-thickness grob-thickness))
                 ;; We use original not grob here to avoid not catching some
                 ;; elements for broken glissando.
                 (original (ly:grob-original grob))
                 (left-bound (ly:spanner-bound original LEFT))
                 (right-bound (ly:spanner-bound original RIGHT))
                 (left-bound-when (grob::when left-bound))
                 (right-bound-when (grob::when right-bound))
                 ;; Glissando-stencil extents
                 (gliss-stil-x-ext (ly:stencil-extent gliss-stil X))
                 (gliss-stil-y-ext (ly:stencil-extent gliss-stil Y))
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 ;; Glissando-slope
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 ;; The actual used glissando-gradient (calculated below) is
                 ;; influenced by positive or negative slope.
                 ;;
                 ;; Simple slope could be retrieved by comparing Y-left/right.
                 ;; We need X-left lateron, so we see no real need for
                 ;; simplification here.
                 (left-bound-info (ly:grob-property grob 'left-bound-info))
                 (X-left (assoc-get 'X left-bound-info))
                 (Y-left (assoc-get 'Y left-bound-info))
                 (right-bound-info (ly:grob-property grob 'right-bound-info))
                 (X-right (assoc-get 'X right-bound-info))
                 (Y-right (assoc-get 'Y right-bound-info))
                 (gliss-slope (/ (- Y-right Y-left) (- X-right X-left)))
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 ;; Glissando-gradient
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 ;; Using the previous found X/Y-left/right would lead to wrong
                 ;; results for a broken spanner, thus we use the stencil's
                 ;; extent, choosing the relevant car/cdr relying on the
                 ;; previous calculated slope.
                 (gliss-left-x (car gliss-stil-x-ext))
                 (gliss-right-x (cdr gliss-stil-x-ext))
                 (gliss-left-y
                   (if (positive? gliss-slope)
                       (car gliss-stil-y-ext)
                       (cdr gliss-stil-y-ext)))
                 (gliss-right-y
                   (if (positive? gliss-slope)
                       (cdr gliss-stil-y-ext)
                       (car gliss-stil-y-ext)))
                 (gliss-gradient
                   (/
                     (+ (- gliss-right-y gliss-left-y)
                        (* (if (positive? gliss-slope) -1 +1) gliss-thick))
                     (- gliss-right-x gliss-left-x)))
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 ;; NoteColumns passed by Glissando
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 ;; If the glissando starts/ends with a note which is beamed
                 ;; already/further, include the relevant
                 ;; left/right-bound-NoteColumn.
                 ;;
                 ;; Therefore we look at the Stem of grob's left/right-bound.
                 ;; Include, if present and beamed.
                 (include-me?
                   (lambda (stem)
                     (and (ly:grob? stem)
                          (ly:grob? (ly:grob-object stem 'beam)))))
                 (sys-elts-array (ly:grob-object sys 'all-elements))
                 ;; Filter for every inner (skipped) NoteColumn
                 (inner-ncs
                   (filter
                     (lambda (elt)
                       (let (;; Going for `ly:grob-relative-coordinate´ disturbs
                             ;; vertical spacing, thus we sort/filter using
                             ;; `grob::when´
                             (elt-when (grob::when elt)))
                         (and
                           (grob::has-interface elt 'note-column-interface)
                           (ly:grob-property elt 'glissando-skip #f)
                           (ly:moment<? left-bound-when elt-when)
                           (not (moment<=? right-bound-when elt-when)))))
                     (ly:grob-array->list sys-elts-array)))
                 ;; left/right-bound stem
                 (left-bound-stem
                   (ly:grob-object (ly:spanner-bound grob LEFT) 'stem))
                 (right-bound-stem
                   (ly:grob-object (ly:spanner-bound grob RIGHT) 'stem))
                 ;; Probably take left/right-bound-NoteColumn into account
                 (ncs
                   (append
                     (if (include-me? left-bound-stem)
                         (list (ly:grob-parent left-bound-stem X))
                         '())
                     (if (include-me? right-bound-stem)
                         (list (ly:grob-parent right-bound-stem X))
                         '())
                     inner-ncs))
                 ;; All Stems of the relevant NoteColumns
                 (stems
                   (map
                     (lambda (nc) (ly:grob-object nc 'stem))
                     ncs))
                 (stem-x-coord-proc
                   (lambda (nc)
                     (ly:grob-relative-coordinate
                       (ly:grob-object nc 'stem) sys X)))
                 (stems-x-coords
                   (map stem-x-coord-proc ncs))
                 (left-padding (assoc-get 'padding left-bound-info))

                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 ;; Intersection-points of Glissando and Stems
                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                 (gliss-stem-intersections
                   (map
                     (lambda (stem-x-coord)
                       (cons
                         ;; For further coding of the "stemmed-glissando" the
                         ;; car (representing the X-coordinate) of the here
                         ;; calculated pair is not needed. We let it in here to
                         ;; gain the possibility to add the cross-stencils for
                         ;; debugging (see below).
                         (+
                            (- stem-x-coord X-left)
                            (- gliss-left-x left-padding)
                            ;; TODO Is half-line-thick really what we want here?
                            ;;      Postponed, because we don't really need this
                            half-line-thick)
                         (+
                            ;; Calculate and add the Y-value of the glissando at
                            ;; the given stem: we multiply the distance
                            ;; from gliss-start to stem (modified by
                            ;; left-padding) with the gradient.
                            ;; NB The result is relative to zero-staff-line.
                            (*
                               gliss-gradient
                               (- stem-x-coord X-left left-padding))
                            ;; Add the relevant value of Glissando's Y-extent:
                            ;; If Glissando points down, use top Y-extent,
                            ;; if it points up use bottom Y-extent.
                            ;; Both corrected by half gliss-thick.
                            (if (negative? gliss-gradient)
                                (- (cdr gliss-stil-y-ext) (/ gliss-thick 2))
                                (+ (car gliss-stil-y-ext) (/ gliss-thick 2))))))
                     stems-x-coords)))

            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;;
            ;; For conveniance/debugging
            ;;
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;; Add cross-stencils where Stem and Glissando intersect
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;(define*
            ;  (make-cross-stencil coords #:optional (thick 0.1) (sz 0.2))
            ;  (ly:stencil-add
            ;    (make-line-stencil
            ;      thick
            ;      (- (car coords) sz)
            ;      (- (cdr coords) sz)
            ;      (+ (car coords) sz)
            ;      (+ (cdr coords) sz))
            ;    (make-line-stencil
            ;      thick
            ;      (- (car coords) sz)
            ;      (+ (cdr coords) sz)
            ;      (+ (car coords) sz)
            ;      (- (cdr coords) sz))))
            ;
            ;  (ly:grob-set-property! grob 'stencil
            ;    (apply ly:stencil-add
            ;      (ly:grob-property grob 'stencil)
            ;        (map make-cross-stencil gliss-stem-intersections)))


            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;; Color passed note-heads
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;(for-each
            ;  (lambda (nh)
            ;    (ly:grob-set-property! nh 'transparent #f)
            ;    (ly:grob-set-property! nh 'stencil (ly:note-head::print nh))
            ;    (ly:grob-set-property! nh 'color cyan))
            ;  (append-map
            ;    (lambda (nc)
            ;      (ly:grob-array->list (ly:grob-object nc 'note-heads)))
            ;    ncs))

            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;; Color left/right bound
            ;;;;;;;;;;;;;;;;;;;;;;
            ;(ly:grob-set-property! left-bound 'color red)
            ;(ly:grob-set-property! right-bound 'color green)

            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;;
            ;;  Recreate Stem.stencil to match the glissando
            ;;  Move Flag
            ;;  Move Script
            ;;  Recreate Beam.stencil, probably relying on user-specifications
            ;;
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
            ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

            (for-each
              (lambda (gsi stem)
                (let* (
                  (stem-y-ext (ly:grob-extent stem stem Y))
                  (stem-dir (ly:grob-property stem 'direction))
                  (pap-col (ly:item-get-column stem))
                  (pap-col-elts-array (ly:grob-object pap-col 'elements))
                  (scripts
                    (filter
                      (lambda (elt)
                        (grob::has-interface elt 'script-interface))
                      (ly:grob-array->list pap-col-elts-array)))
                  (beam (ly:grob-object stem 'beam))
                  (beamed-stems
                    (if (ly:grob? beam)
                        (ly:grob-array->list (ly:grob-object beam 'stems))
                        #f))
                  ;; Get the the shortest duration of a Beam with mixed
                  ;; durations. We go for the maximum of duration-log
                  (beamed-stems-max-dur
                    (if beamed-stems
                        (apply
                          max
                          (map
                            (lambda (stem)
                              (ly:grob-property stem 'duration-log))
                            beamed-stems))
                        #f))
                  ;; Calculate beam-gradient, if beam is present
                  ;;
                  ;; Get a possible user-override for
                  ;; Beam.details.beamed-glissando-stem-positions
                  (beam-details
                    (if (ly:grob? beam)
                        (ly:grob-property beam 'details)
                        #f))
                  (beamed-glissando-stem-positions
                    (if beam-details
                        (assoc-get
                          'beamed-glissando-stem-positions
                          beam-details
                          #f)
                        #f))
                  (beam-x-positions
                    (if (ly:grob? beam)
                        (ly:grob-property beam 'X-positions)
                        #f))
                  ;; Calculate beam-gradient, but only if the user
                  ;; specified an override for
                  ;; Beam.details.beamed-glissando-stem-positions
                  (beam-gradient
                    (if beamed-glissando-stem-positions
                        (/
                           (- (cdr beamed-glissando-stem-positions)
                              (car beamed-glissando-stem-positions))
                           (- (cdr beam-x-positions)
                              (car beam-x-positions)))
                        #f))
                  ;; If details.beamed-glissando-stem-positions is set,
                  ;; the usual calculation (further below) of the stem's
                  ;; length will fail.
                  ;; Thus we need to calculate some values to have the
                  ;; beamed stems fit into said beam. These values are
                  ;; stored together with their Stem-grob in an alist and
                  ;; referenced below.
                  (beamed-stem-corrs
                    (if beamed-glissando-stem-positions
                        (let* ((beamed-ncs
                                 (map
                                   (lambda (stem) (ly:grob-parent stem X))
                                   beamed-stems))
                               (x-coords
                                 (map stem-x-coord-proc beamed-ncs))
                               (x-coord-diffs
                                 (map
                                   (lambda (coord)
                                     (- coord (car x-coords)))
                                   x-coords))
                               (corrs
                                 (map
                                   (lambda (stem coord)
                                     (cons stem (* coord beam-gradient)))
                                   beamed-stems
                                   x-coord-diffs)))
                          corrs)
                        0))
                  (gliss-details
                    (ly:grob-property grob 'details))
                  (new-stem-y-ext
                    (ordered-cons
                      (+ (cdr gsi)
                         (* stem-dir
                            ;; If the glissando starts/ends with a note
                            ;; which is beamed already/further, don't
                            ;; apply pad-y to this stem.
                            (if (or (equal? stem left-bound-stem)
                                    (equal? stem right-bound-stem))
                                0
                                pad-y)))
                      (if beamed-glissando-stem-positions
                          ;; If a Beam is present *and*
                          ;; beamed-glissando-stem-positions is set, use
                          ;; the car of it for the initial Stem and add the
                          ;; values of beamed-stem-corrs as appropriate.
                          (+ (car beamed-glissando-stem-positions)
                             (assoc-get stem beamed-stem-corrs))
                          ;; Otherwise calculate the Stems independently,
                          ;; aiming at Beams parallel to the glissando
                          ;; and else equal stem-lengths for equal
                          ;; durations.
                          ;; Rely on `beamed-lengths´ and `lengths´ from
                          ;; Stem.details for it, so a user-override is
                          ;; respected.
                          (let* ((stem-details
                                   (ly:grob-property stem 'details)))
                            (+
                               (*
                                  stem-dir
                                  staff-space
                                  (if (and beamed-stems-max-dur
                                           (member stem beamed-stems))
                                      ;; For beamed Stems we always add the
                                      ;; same value to warrant parallel Beam
                                      ;; and Glissando. For Beams with
                                      ;; mixed durations we look at their
                                      ;; shortest duration, i.e. the maximum
                                      ;; of the stems duration-logs and take
                                      ;; this value for further calculation
                                      (let*
                                        ((beamed-lengths
                                           (assoc-get
                                             'beamed-lengths
                                             stem-details
                                             ;; default:
                                             '(3.26 3.5 3.6)))
                                         (intlog
                                           (ly:intlog2
                                             (denominator
                                               (duration-log-factor
                                                 beamed-stems-max-dur))))
                                         (stem-length
                                           (if (> intlog 4)
                                               (last beamed-lengths)
                                               (list-ref
                                                 beamed-lengths (- intlog 3)))))
                                       ;; TODO little clumsy here...
                                       ;; probably use other Stem.details like:
                                       ;; - beamed-minimum-free-lengths
                                       ;; - beamed-extreme-minimum-free-lengths
                                       ;; - stem-shorten
                                       ;; as well.
                                       (+ stem-length
                                          ;; My choice - Harm
                                          (* 0.5 (- intlog 3))))
                                      ;; For unbeamed Stems of 8th notes and
                                      ;; shorter we add some value relying on
                                      ;; their duration-log
                                      (let*
                                        ((unbeamed-lengths
                                           (assoc-get
                                             'lengths
                                             stem-details
                                             ;; default
                                             '(3.5 3.5 3.5 4.25 5.0 6.0)))
                                         (stem-dur-log
                                           (ly:grob-property
                                             stem 'duration-log))
                                         (intlog
                                           (ly:intlog2
                                             (denominator
                                               (duration-log-factor
                                                 stem-dur-log))))
                                         (stem-length
                                           (cond
                                             ((= intlog 1)
                                               (car unbeamed-lengths))
                                             ((<= intlog
                                                  (1+
                                                     (length unbeamed-lengths)))
                                               (list-ref
                                                 unbeamed-lengths
                                                 (- intlog 2)))
                                             (else (last unbeamed-lengths)))))
                                       stem-length)))
                               (cdr gsi)
                               (* stem-dir pad-y))))))
                  (flag (ly:grob-object stem 'flag))
                  (flag-stil
                    (if (ly:grob? flag)
                        (ly:grob-property flag 'stencil #f)
                        #f)))

                  ;;;;;;;;;;;
                  ;; recreate Beam.stencil
                  ;;;;;;;;;;;
                  ;; Relies on new setting of 'positions derived from
                  ;;  new-stem-y-ext.
                  ;; Renewing quantized-positions is needed to get the stencil
                  ;; correct.
                  ;; The new beam is always parallel to the glissando, unless a
                  ;; user-override takes priority.

                  (if (ly:grob? beam)
                      (begin
                        (ly:grob-set-property! beam 'positions
                          (if beamed-glissando-stem-positions
                              beamed-glissando-stem-positions
                              ;; TODO below results in resetting Beam.positions
                              ;; with every stem of the Beam.
                              ;; How to simplify?
                              (cons
                                (if (equal? stem (car beamed-stems))
                                    (if (positive? stem-dir)
                                        (cdr new-stem-y-ext)
                                        (car new-stem-y-ext))
                                    (car (ly:grob-property beam 'positions)))
                                (if (equal? stem (last beamed-stems))
                                    (if (positive? stem-dir)
                                        (cdr new-stem-y-ext)
                                        (car new-stem-y-ext))
                                    (cdr (ly:grob-property beam 'positions))))))
                        (ly:grob-set-property! beam 'quantized-positions
                          (ly:beam::set-stem-lengths beam))
                        (ly:grob-set-property!
                          beam 'stencil (ly:beam::print beam))))

                  ;;;;;;;;;;;
                  ;; move scripts according to new Stem.stencil below
                  ;;;;;;;;;;;
                  ;; Remark: Script will be positioned always at NoteHead-side,
                  ;; never at Stem-side

                  (if (pair? scripts)
                      (for-each
                        (lambda (i script)
                          (let* ((script-stil
                                   (ly:grob-property script 'stencil))
                                 (script-y-off
                                   (ly:grob-property script 'Y-offset))
                                 (script-padding
                                   (ly:grob-property script 'padding)))
                            ;; TODO Scripts should avoid staff-lines!
                            ;;      Special-case some scripts?
                            (ly:grob-set-property! script 'stencil
                              (ly:stencil-translate-axis
                                (ly:grob-property script 'stencil)
                                (+
                                   ;; move script to zero-line
                                   (- script-y-off)
                                   ;; move script to glissando-line
                                   (cdr gsi)
                                   ;; Apply one staff-space padding for each
                                   ;; script.
                                   ;; NB There are probably multiple ones per
                                   ;; NoteColumn
                                   (* i staff-space stem-dir -1)
                                   (* script-padding stem-dir -1))
                                Y))))
                        (iota (length scripts) 1 1)
                        scripts))

                  ;;;;;;;;;;;
                  ;; move Flag.stencil according to new Stem.stencil below
                  ;;;;;;;;;;;

                  (if flag-stil
                      (ly:grob-set-property! flag 'stencil
                        (ly:stencil-translate-axis
                          flag-stil
                          (if (positive? stem-dir)
                              (- (cdr new-stem-y-ext) (cdr stem-y-ext))
                              (- (car new-stem-y-ext) (car stem-y-ext)))
                          Y)))

                  ;;;;;;;;;;;
                  ;; recreate a new Stem.stencil
                  ;;;;;;;;;;;

                  (ly:grob-set-property! stem 'stencil
                    (ly:round-filled-box
                      (ly:grob-extent stem stem X)
                      new-stem-y-ext
                      blot))))
              gliss-stem-intersections
              stems))))))

%% Mmmh, the namings are misleading. The \arpeggio together with the applied
%% `glissando-and-stems´ do the job. The two following definitions are merely
%% helpers.
startStemmedGlissando = {
  \temporary \override NoteColumn.glissando-skip = ##t
  \temporary \override NoteHead.stem-attachment = #'(0 . 0)
  %% making NoteHeads transparent, rather than outputting point-stencil
  %% makes for better spacing
  %\temporary \override NoteHead.stencil = #point-stencil
  \temporary \override NoteHead.transparent = ##t
  \temporary \override NoteHead.no-ledgers = ##t
  \temporary \override Accidental.stencil = ##f
  %% Do we need the line below?
  %\temporary \override Stem.no-stem-extend = ##t
}

stopStemmedGlissando = {
  \revert NoteColumn.glissando-skip
  \revert NoteHead.stem-attachment
  %\revert NoteHead.stencil
  \revert NoteHead.transparent
  \revert NoteHead.no-ledgers
  \revert Accidental.stencil
  %\revert Stem.no-stem-extend
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% EXAMPLES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

#(ly:message
"\tSome TODOS for stemmed Glissando:
\t- What about Dots in skipped NoteColumns, make them invisible?
\t- Should we add other defaults for Stem.lengths/beamed-lengths?
\t- Some minor TODOs inline...\n")

%% Not essential, only to ease testings
multipleTransposes =
#(define-music-function (parser location m music)(ly:music? ly:music?)
   (music-clone m
    'elements
    (map (lambda (pitch)
          (ly:music-property #{ \transpose c $pitch $music #} 'element))
         (event-chord-pitches m))))

\paper { ragged-right = ##f }

% {

tst-I =
\transpose b b'
\new Staff {
  \voiceTwo
  \override Glissando.breakable = ##t
  \override Glissando.after-line-breaking = #(glissando-and-stems 0)
  b1\glissando
  \startStemmedGlissando
  \noBreak
  b2 b4 b
  \override Stem.details.beamed-lengths = #'(2.26 2.5 2.6)
  \repeat unfold 4 { c'16 d'32*2 d'64*4 e'128*8-> f' }
  \revert Stem.details.beamed-lengths
  \repeat unfold 4 { c'16 d' e' f' }
  \noBreak
  \repeat unfold 4 { c'16 d' e' f' }
  \noBreak
  g'2.
  \stopStemmedGlissando
  a'1
  %% a single MultiMeasureRest causes no problem
  %% but anything after a MMR, or a multiplied MMR results in:
  %%   ERROR: In procedure ly:item-get-column: Wrong type argument in position 
1 (expecting Item): #<Grob Spanner >
  %% note that the MultiMeasureRest is not connected to or within the Glissando
  %% each of these lines triggers the error
  % R1 c1
  % R1*2
  % c4 4 4 4 R1 c1
  %% these lines work fine
  % R1
  % R1 \break R1
  % R1 \break c1
}


\score { \tst-I \layout { ragged-right = ##t \autoBeamOff } }

\score { \tst-I \layout { ragged-right = ##f \autoBeamOn } }
%}
% {
{
  \override Glissando.breakable = ##t
  \override Glissando.after-line-breaking = #(glissando-and-stems 0)
  r2.
  \once \override Beam.details.beamed-glissando-stem-positions = #'(4 . 8)
  b8
  b8\glissando
  \startStemmedGlissando
  \repeat unfold 4 { c'16 d' e' f' }
  \break
  \repeat unfold 4 { c'16 d' e' f' }
  \break
  \repeat unfold 2 { c'16 d' e' f' }
  %% The Glissando ends in the middle of some beamed notes.
  %% `glissando-and-stems´ is not smart enough to deal with this situation, thus
  %% some manual intervenrion is needed.
  \once \override Beam.details.beamed-glissando-stem-positions = #'(3 . 3.2)
  a' a'
  \stopStemmedGlissando
  a' a'
}
%}

% {
\transpose c c'
{
  \voiceTwo
  \override Glissando.after-line-breaking = #(glissando-and-stems 0)
%  \override Glissando.breakable = ##t
  c''4\glissando
  \startStemmedGlissando
  %% For automatic Beams, set the values carefully
  \once \override Beam.details.beamed-glissando-stem-positions = #'(-4 . -8)
  b'8-.
  b'->
  \repeat unfold 4 bes'32-.
  %% For manual Beams set the direction accordingly.
  \once \override Beam.details.beamed-glissando-stem-positions = #'(4 . 8)
  bes'8-.^[
  a'64*8-_
  aes']-.---\prall
%  \break
  \stemUp g'2
  \stopStemmedGlissando
  fis2
}
%}

mus = {
  c''4\glissando
  \startStemmedGlissando
  b'8-.
  \noBeam
  b'->
  bes'-.
  \noBeam
  \override Stem.details.beamed-lengths =
    #'(
       3.26  ;; 8
       3.5   ;; 16
       3.6  ;; 32 etc
       )
  bes'8-.[
  a'64*8-_
  aes']-.---\prall
  %\break
  g'2
  \stopStemmedGlissando
  fis'2
}

% {
\multipleTransposes {
        c, d, e,  f, g,
        a, b,
        c d e f
        g a b
}
{
  \override NoteHead.layer = -1000
  \override Glissando.breakable = ##t
  \override Glissando.after-line-breaking = #(glissando-and-stems 0)
  \mus
}
%}

--
Mark Knoop

Reply via email to