Tablature: proper support for tie/slur- and tie/glissando-constellations

scm/tablature.scm

 ;;;; This file is part of LilyPond, the GNU music typesetter.
 ;;;;
 ;;;; Copyright (C) 2009--2010 Marc Hohl <marc@hohlart.de>
 ;;;;
 ;;;; LilyPond is free software: you can redistribute it and/or modify
 ;;;; it under the terms of the GNU General Public License as published by
 ;;;; the Free Software Foundation, either version 3 of the License, or
 ;;;; (at your option) any later version.
 ;;;;
 ;;;; LilyPond is distributed in the hope that it will be useful,
@@ skipping 157 matching lines @@
           ;; get the font-size from victim (=TabNoteHead) to handle
           ;; grace notes properly
           (ly:grob-set-property! grob 'font-size
                                  (ly:grob-property victim 'font-size))
           (ly:grob-set-property! grob 'padding 0)
           ;; apply whiteout to each element of the list
           (map stencil-whiteout
                (parentheses-item::calc-parenthesis-stencils grob)))
         (parentheses-item::calc-parenthesis-stencils grob))))
 
+;; helper functions for making tab note heads (in)visible
+(define (hide-tab-note-head grob)

[Neil Puttock, 2010/09/16 21:14:19]

This is a bit of a misnomer, since it indirectly makes some heads visible later.
 It would be better if you could avoid hiding such notes rather than hiding
them, then making them visible.

+  (ly:grob-set-property! grob 'transparent #t)
+  (ly:grob-set-property! grob 'whiteout #f)

[Neil Puttock, 2010/09/16 21:14:19]

can remove this

+  (ly:grob-set-nested-property! grob '(details tied-to) #t))

[Neil Puttock, 2010/09/16 21:14:19]

This doesn't belong in 'details since it's set beyond the user's control: it
only makes sense as an internal property, so should be defined separately

+
+(define (show-tab-note-head grob)
+  (ly:grob-set-property! grob 'transparent #f)
+  (ly:grob-set-property! grob 'whiteout #t)

[Neil Puttock, 2010/09/16 21:14:19]

can remove this

+  (ly:grob-set-property! grob 'stencil
+                         (lambda (grob)
+                           (parenthesize-tab-note-head grob))))
+
 ;; the handler for ties in tablature; according to TabNoteHead #'details,
 ;; the 'tied to' note is handled differently after a line break
 (define-public (tie::handle-tab-note-head grob)
   (let* ((original (ly:grob-original grob))
          (tied-tab-note-head (ly:spanner-bound grob RIGHT))
          (siblings (if (ly:grob? original)
                        (ly:spanner-broken-into original) '())))
 
     (if (and (>= (length siblings) 2)
              (eq? (car (last-pair siblings)) grob))
         ;; tie is split -> get TabNoteHead #'details
         (let* ((details (ly:grob-property tied-tab-note-head 'details))
                (tied-properties (assoc-get 'tied-properties details '()))
                (tab-note-head-parenthesized (assoc-get 'parenthesize tied-properties #t))
                ;; we need the begin-of-line entry in the 'break-visibility vector
                (tab-note-head-visible
                 (vector-ref (assoc-get 'break-visibility
                                        tied-properties #(#f #f #t)) 2)))
 
           (if tab-note-head-visible
               ;; tab note head is visible
               (if tab-note-head-parenthesized
                   (ly:grob-set-property! tied-tab-note-head 'stencil
                                          (lambda (grob)
                                            (parenthesize-tab-note-head grob))))
               ;; tab note head is invisible
-              (begin
-                (ly:grob-set-property! tied-tab-note-head 'transparent #t)
-                (ly:grob-set-property! tied-tab-note-head 'whiteout #f))))
+              (hide-tab-note-head tied-tab-note-head)))
 
         ;; tie is not split -> make fret number invisible
-        (begin
-          (ly:grob-set-property! tied-tab-note-head 'transparent #t)
-          (ly:grob-set-property! tied-tab-note-head 'whiteout #f)))))
+        (hide-tab-note-head tied-tab-note-head))))
+
+
 
 ;; repeat ties occur within alternatives in a repeat construct;
 ;; TabNoteHead #'details handles the appearance in this case
 (define-public (repeat-tie::handle-tab-note-head grob)
   (let* ((tied-tab-note-head (ly:grob-object grob 'note-head))
          (details (ly:grob-property tied-tab-note-head 'details))
          (repeat-tied-properties (assoc-get 'repeat-tied-properties details '()))
          (tab-note-head-visible (assoc-get 'note-head-visible repeat-tied-properties #t))
          (tab-note-head-parenthesized (assoc-get 'parenthesize repeat-tied-properties #t)))
 
     (if tab-note-head-visible
         ;; tab note head is visible
         (if tab-note-head-parenthesized
             (ly:grob-set-property! tied-tab-note-head 'stencil
                                    (lambda (grob)
                                      (parenthesize-tab-note-head grob))))
         ;; tab note head is invisible
-        (begin
-          (ly:grob-set-property! tied-tab-note-head 'transparent #t)
-          (ly:grob-set-property! tied-tab-note-head 'whiteout #f)))))
+        (hide-tab-note-head tied-tab-note-head))))
 
 ;; the slurs should not be too far apart from the corresponding fret number, so
-;; we move the slur towards the TabNoteHeads:
+;; we move the slur towards the TabNoteHeads; moreover, if the left fret number is
+;; "tied-to", we'll set it in parentheses:
 (define-public (slur::draw-tab-slur grob)
   ;; TODO: use a less "brute-force" method to decrease
   ;; the distance between the slur ends and the fret numbers
-  (let* ((staff-space (ly:staff-symbol-staff-space grob))
+  (let* ((original (ly:grob-original grob))
+         (left-bound (ly:spanner-bound original LEFT))
+         (left-tab-note-head (ly:grob-property left-bound 'cause))
+         (details (ly:grob-property left-tab-note-head 'details))
+         (tied-to (assoc-get 'tied-to details #f))
+         (staff-space (ly:staff-symbol-staff-space grob))
          (control-points (ly:grob-property grob 'control-points))
          (new-control-points (map
                               (lambda (p)
                                 (cons (car p)
                                       (- (cdr p)
                                          (* staff-space
                                             (ly:grob-property grob 'direction)
                                             0.35))))
                               control-points)))
 
     (ly:grob-set-property! grob 'control-points new-control-points)
+    (if tied-to (show-tab-note-head left-tab-note-head))
     (ly:slur::print grob)))
 
+;; The glissando routine works similarly to the slur routine; if the
+;; fret number is "tied to", it should become visible again.
+(define-public (glissando::draw-tab-glissando grob)
+  (let* ((original (ly:grob-original grob))
+         (left-tab-note-head (ly:spanner-bound original LEFT))
+         (details (ly:grob-property left-tab-note-head 'details))
+         (tied-to (assoc-get 'tied-to details #f))
+         (control-points (ly:grob-property grob 'control-points)))

[Neil Puttock, 2010/09/16 21:14:19]

remove

+
+    (if tied-to

[Neil Puttock, 2010/09/16 21:14:19]

(and tied-to
     (show-tab-note-head left-tab-note-head)

+        (begin
+          (show-tab-note-head left-tab-note-head)
+          ;; increase left padding to avoid collision between
+          ;; closing parenthesis and glissando line
+          (ly:grob-set-nested-property! grob '(bound-details left padding) 0.75)))

[Neil Puttock, 2010/09/16 21:14:19]

this won't happen for tied notes after a break unless you explicitly set
'tied-to outside `hide-tab-note-head'

+    (ly:line-spanner::print grob)))
+
 ;; for \tabFullNotation, the stem tremolo beams are too big in comparison to
 ;; normal staves; this wrapper function scales accordingly:
 (define-public (stem-tremolo::calc-tab-width grob)
   (let ((width (ly:stem-tremolo::calc-width grob))
         (staff-space (ly:staff-symbol-staff-space grob)))
     (/ width staff-space)))