X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=scm%2Ftranslation-functions.scm;h=d373da0eebcc0079c2e0c8d0e76a747ceba38742;hb=537496fcf66026b5e982661d65539985d5a5fb73;hp=365f6883d1c1cd1e328d8ed3ca1a177809a4ab2a;hpb=f903aa1415bac953e1b3f700a17c1e7ffc7f93ad;p=lilypond.git

diff --git a/scm/translation-functions.scm b/scm/translation-functions.scm
index 365f6883d1..d373da0eeb 100644
--- a/scm/translation-functions.scm
+++ b/scm/translation-functions.scm
@@ -1,16 +1,31 @@
-;;;; translation-functions.scm --
+;;;; This file is part of LilyPond, the GNU music typesetter.
 ;;;;
-;;;;  source file of the GNU LilyPond music typesetter
-;;;; 
-;;;; (c) 1998--2009 Han-Wen Nienhuys <hanwen@xs4all.nl>
+;;;; (c) 1998--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
 ;;;;		     Jan Nieuwenhuizen <janneke@gnu.org>
+;;;;
+;;;; 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,
+;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;;; GNU General Public License for more details.
+;;;;
+;;;; You should have received a copy of the GNU General Public License
+;;;; along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; metronome marks
 
-(define-public (format-metronome-markup text dur count context)
-  (let* ((hide-note (eq? #t (ly:context-property context 'tempoHideNote))))
+(define-public (format-metronome-markup event context)
+  (let ((hide-note (ly:context-property context 'tempoHideNote #f))
+	(text (ly:event-property event 'text))
+	(dur (ly:event-property event 'tempo-unit))
+	(count (ly:event-property event 'metronome-count)))
+
     (metronome-markup text dur count hide-note)))
 
 (define-public (metronome-markup text dur count hide-note)
@@ -20,14 +35,27 @@
 						     (ly:duration-dot-count dur)
 						     1))
 			#f))
-         (note-markup (if (and (not hide-note) (number? count) (> count 0) )
+	 (count-markup (cond ((number? count)
+			      (if (> count 0)
+				  (make-simple-markup (number->string count))
+				  #f))
+			     ((pair? count)
+			      (make-concat-markup
+			       (list
+				(make-simple-markup (number->string (car count)))
+				(make-simple-markup " ")
+				(make-simple-markup "–")
+				(make-simple-markup " ")
+				(make-simple-markup (number->string (cdr count))))))
+			     (else #f)))
+         (note-markup (if (and (not hide-note) count-markup)
 			  (make-concat-markup
 			   (list
 			    (make-general-align-markup Y DOWN note-mark)
 			    (make-simple-markup " ")
 			    (make-simple-markup "=")
 			    (make-simple-markup " ")
-			    (make-simple-markup (number->string count))))
+			    count-markup))
 			  #f))
          (text-markup (if (not (null? text))
 			  (make-bold-markup text)
@@ -169,39 +197,277 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; fret diagrams
 
-(define-public (determine-frets context grob notes string-numbers)
-  
-  (define (ensure-number a b)
-    (if (number? a)
-	a
-	b))
+(define (create-fretboard context grob placement-list)
+  "Convert @var{placement-list} into a fretboard @var{grob}."
+
+  (let* ((tunings (ly:context-property context 'stringTunings))
+	 (my-string-count (length tunings))
+	 (details (ly:grob-property grob 'fret-diagram-details)))
 
-  (define (string-frets->dot-placement string-frets string-count)
-    (let* ((desc (list->vector
-		  (map (lambda (x) (list 'mute  (1+ x)))
-		       (iota string-count)))))
+    ;; Add string-count from string-tunings to fret-diagram-details.
+    (set! (ly:grob-property grob 'fret-diagram-details)
+            (acons 'string-count my-string-count details))
+    ;; Create the dot-placement list for the grob
+    (set! (ly:grob-property grob 'dot-placement-list) placement-list)))
+
+(define-public
+  (determine-frets context notes specified-info . rest)
+  "Determine string numbers and frets for playing @var{notes}
+as a chord, given specified information @var{specified-info}.
+@var{specified-info} is a list with two list elements,
+specified strings @code{defined-strings} and
+specified fingerings @code{defined-fingers}.  Only a fingering of@tie{}0
+will affect the fret selection, as it specifies an open string.
+If @code{defined-strings} is @code{'()}, the context property
+@code{defaultStrings} will be used as a list of defined strings.
+Will look for predefined fretboards if @code{predefinedFretboardTable}
+is not @code {#f}.  If @var{rest} is present, it contains the
+@code{FretBoard} grob, and a fretboard will be
+created.  Otherwise, a list of @code{(string fret finger)} lists will
+be returned."
+
+  ;;  helper functions
+
+  (define (string-frets->placement-list string-frets string-count)
+    "Convert @var{string-frets} to @code{fret-diagram-verbose}
+dot placement entries."
+    (let* ((placements (list->vector
+                        (map (lambda (x) (list 'mute  x))
+		             (iota string-count 1)))))
 
       (for-each (lambda (sf)
 		  (let* ((string (car sf))
 			 (fret (cadr sf))
 			 (finger (caddr sf)))
-
-		    (vector-set! 
-		     desc (1- string)
-		     (if (= 0 fret)
-			 (list 'open string)
-			 (if finger
-			     (list 'place-fret string fret finger)
-			     (list 'place-fret string fret))))))
+		    (vector-set!
+                      placements
+		      (1- string)
+		      (if (= 0 fret)
+                          (list 'open string)
+			  (if finger
+			      (list 'place-fret string fret finger)
+			      (list 'place-fret string fret))))))
 		string-frets)
+      (vector->list placements)))
+
+  (define (placement-list->string-frets placement-list)
+    "Convert @var{placement-list} to string-fret list."
+    (map (lambda (x) (if (eq? (car x) 'place-fret)
+                         (cdr x)
+                         (list (cadr x) 0)))
+         (filter (lambda (l) (or (eq? (car l) 'place-fret)
+                                 (eq? (car l) 'open)))
+                 placement-list)))
+
+  (define (entry-count art-list)
+    "Count the number of entries in a list of articulations."
+    (length (filter (lambda (x) (not (null? x)))
+                    art-list)))
+
+  (define (determine-frets-and-strings
+	    notes
+	    defined-strings
+	    defined-fingers
+	    minimum-fret
+	    maximum-stretch
+	    tuning)
+    "Determine the frets and strings used to play the notes in
+@var{notes}, given @var{defined-strings} and @var{defined-fingers}
+along with @var{minimum-fret}, @var{maximum-stretch}, and
+@var{tuning}.  Returns a list of @code{(string fret finger) lists."
+
+    (define specified-frets '())
+    (define free-strings (iota (length tuning) 1))
+
+    (define (calc-fret pitch string tuning)
+      "Calculate the fret to play @var{pitch} on @var{string} with
+@var{tuning}."
+      (- (ly:pitch-semitones pitch) (ly:pitch-semitones (list-ref tuning (1- string)))))
+
+    (define (note-pitch note)
+      "Get the pitch (in semitones) from @var{note}."
+      (ly:event-property note 'pitch))
+
+    (define (note-finger ev)
+      "Get the fingering from @var{ev}.  Return @var{#f}
+if no fingering is present."
+      (let* ((articulations (ly:event-property ev 'articulations))
+	     (finger-found #f))
+	(map (lambda (art)
+	       (let* ((num (ly:event-property art 'digit)))
+
+		 (if (and (eq? 'fingering-event (ly:event-property art 'class))
+			  (number? num)
+			  (> num 0))
+		   (set! finger-found num))))
+	     articulations)
+	finger-found))
+
+    (define (string-number event)
+      "Get the string-number from @var{event}.  Return @var{#f}
+if no string-number is present."
+      (let ((num (ly:event-property event 'string-number)))
+	(if (number? num)
+	  num
+	  #f)))
+
+    (define (delete-free-string string)
+      (if (number? string)
+	(set! free-strings
+	  (delete string free-strings))))
+
+    (define (close-enough fret)
+      "Decide if @var{fret} is acceptable, given the already used frets."
+      (if (null? specified-frets)
+	#t
+	(reduce
+	  (lambda (x y)
+	    (and x y))
+	  #t
+	  (map (lambda (specced-fret)
+		 (or (eq? 0 specced-fret)
+                     (eq? 0 fret)
+		     (>= maximum-stretch (abs (- fret specced-fret)))))
+	       specified-frets))))
+
+    (define (string-qualifies string pitch)
+      "Can @var{pitch} be played on @var{string}, given already placed
+notes?"
+      (let* ((fret (calc-fret pitch string tuning)))
+	(and (or (eq? fret 0) (>= fret minimum-fret))
+	     (close-enough fret))))
+
+    (define (open-string string pitch)
+      "Is @var{pitch} and open-string note on @var{string}, given
+the current tuning?"
+      (let* ((fret (calc-fret pitch string tuning)))
+	(eq? fret 0)))
+
+    (define (set-fret! pitch-entry string finger)
+      (let ((this-fret (calc-fret (car pitch-entry)
+				  string
+				  tuning)))
+	(if (< this-fret 0)
+	  (ly:warning (_ "Negative fret for pitch ~a on string ~a")
+		      (car pitch-entry) string))
+	(delete-free-string string)
+        (set! specified-frets (cons this-fret specified-frets))
+        (list-set! string-fret-fingers
+                   (cdr pitch-entry)
+                   (list string this-fret finger))))
+
+    (define (kill-note! string-fret-fingers note-index)
+      (list-set! string-fret-fingers note-index (list #f #t)))
+
+    (define string-fret-fingers
+             (map (lambda (string finger)
+                    (if (null? finger)
+                        (list string #f)
+                        (list string #f finger)))
+                  defined-strings defined-fingers))
+
+    ;;; body of determine-frets-and-strings
+    (let* ((pitch-alist (apply (lambda (mylist)
+                                 (let ((index -1))
+                                   (map (lambda (note)
+                                          (begin
+                                            (set! index (1+ index))
+                                            (cons (note-pitch note)
+                                                  index)))
+                                        mylist)))
+                               notes '()))
+           (pitches (map note-pitch notes)))
+
+      ;; handle notes with strings assigned and fingering of 0
+      (for-each
+        (lambda (pitch-entry string-fret-finger)
+	  (let* ((string (list-ref string-fret-finger 0))
+                 (finger (if (eq? (length string-fret-finger) 3)
+                             (list-ref string-fret-finger 2)
+                             '()))
+                 (pitch (car pitch-entry))
+                 (digit (if (null? finger)
+	          	    #f
+		            finger)))
+	    (if (or (not (null? string))
+		    (eq? digit 0))
+	        (if (eq? digit 0)
+                    ;; here we handle fingers of 0 -- open strings
+	            (let ((fit-string
+		            (find (lambda (string)
+			            (open-string string pitch))
+			          free-strings)))
+		      (if fit-string
+                          (set-fret! pitch-entry fit-string #f)
+		          (ly:warning (_ "No open string for pitch ~a")
+				      pitch)))
+                    ;; here we handle assigned strings
+	            (let ((this-fret
+                            (calc-fret pitch string tuning))
+		          (handle-negative
+		            (ly:context-property context
+					         'handleNegativeFrets
+					         'recalculate)))
+		      (cond ((or (>= this-fret 0)
+			         (eq? handle-negative 'include))
+                             (set-fret! pitch-entry string finger))
+		            ((eq? handle-negative 'recalculate)
+			     (begin
+                               (ly:warning
+                                 (_ "Requested string for pitch requires negative fret: string ~a pitch ~a")
+                                 string
+                                 pitch)
+			       (ly:warning (_ "Ignoring string request and recalculating."))
+                               (list-set! string-fret-fingers
+                                          (cdr pitch-entry)
+                                          (if (null? finger)
+                                              (list '() #f)
+                                              (list '() #f finger)))))
+		            ((eq? handle-negative 'ignore)
+			     (begin
+                               (ly:warning
+                                 (_ "Requested string for pitch requires negative fret: string ~a pitch ~a")
+                                 string
+                                 pitch)
+			       (ly:warning (_ "Ignoring note in tablature."))
+                               (kill-note! string-fret-fingers
+                                           (cdr pitch-entry))))))))))
+        pitch-alist string-fret-fingers)
+    ;; handle notes without strings assigned -- sorted by pitch, so
+    ;; we need to use the alist to have the note number available
+    (for-each
+      (lambda (pitch-entry)
+	(let* ((string-fret-finger (list-ref string-fret-fingers
+                                             (cdr pitch-entry)))
+               (string (list-ref string-fret-finger 0))
+               (finger (if (eq? (length string-fret-finger) 3)
+                           (list-ref string-fret-finger 2)
+                           '()))
+               (pitch (car pitch-entry))
+               (fit-string
+	         (find (lambda (string)
+	        	 (string-qualifies string pitch))
+		       free-strings)))
+          (if (not (list-ref string-fret-finger 1))
+	      (if fit-string
+                  (set-fret! pitch-entry fit-string finger)
+	          (begin
+                    (ly:warning (_ "No string for pitch ~a (given frets ~a)")
+		                pitch
+                                specified-frets)
+                    (kill-note! string-fret-fingers
+                                (cdr pitch-entry)))))))
+      (sort pitch-alist (lambda (pitch-entry-a pitch-entry-b)
+                          (ly:pitch<? (car pitch-entry-b)
+                                      (car pitch-entry-a)))))
+    string-fret-fingers)) ;; end of determine-frets-and-strings
 
-      (vector->list desc)))
-    
   (define (get-predefined-fretboard predefined-fret-table tuning pitches)
-;   (_i "Search through @var{predefined-fret-table} looking for a predefined
-;fretboard with a key of @var{(tuning . pitches)}.  The search will check
-;both up and down an octave in order to accomodate transposition of the
-;chords.")
+    "Search through @var{predefined-fret-table} looking for a predefined
+fretboard with a key of @var{(tuning . pitches)}.  The search will check
+both up and down an octave in order to accomodate transposition of the
+chords.  Returns a placement-list."
+
     (define (get-fretboard key)
       (let ((hash-handle
 	     (hash-get-handle predefined-fret-table key)))
@@ -209,184 +475,98 @@
 	    (cdr hash-handle)  ; return table entry
 	    '())))
 
+    ;; body of get-predefined-fretboard
     (let ((test-fretboard (get-fretboard (cons tuning pitches))))
       (if (not (null? test-fretboard))
 	  test-fretboard
-	  (let ((test-fretboard 
+	  (let ((test-fretboard
 		 (get-fretboard
 		  (cons tuning (map (lambda (x) (shift-octave x 1)) pitches)))))
 	    (if (not (null? test-fretboard))
 		test-fretboard
-		(get-fretboard 
+		(get-fretboard
 		 (cons tuning (map (lambda (x) (shift-octave x -1))
 				   pitches))))))))
 
-;; body.
-  (let* ((tunings (ly:context-property context 'stringTunings))
-	 (my-string-count (length tunings))
-	 (details (ly:grob-property grob 'fret-diagram-details))
-	 (predefined-frets
-	  (ly:context-property context 'predefinedDiagramTable)) 
-	 (minimum-fret (ensure-number
-			(ly:context-property context 'minimumFret) 0))
-	 (max-stretch (ensure-number
-		       (ly:context-property context 'maximumFretStretch) 4))
-	 (string-frets (determine-frets-mf notes string-numbers
-					   minimum-fret max-stretch
-					   tunings))
-	 (pitches (map (lambda (x) (ly:event-property x 'pitch)) notes)))
+  ;; body of determine-frets
+  (let* ((predefined-fret-table
+	  (ly:context-property context 'predefinedDiagramTable))
+         (tunings (ly:context-property context 'stringTunings))
+         (string-count (length tunings))
+         (grob (if (null? rest) '() (car rest)))
+	 (pitches (map (lambda (x) (ly:event-property x 'pitch)) notes))
+         (defined-strings (map (lambda (x)
+                                 (if (null? x)
+                                     x
+                                     (ly:event-property x 'string-number)))
+                               (car specified-info)))
+         (defined-fingers (map (lambda (x)
+                                 (if (null? x)
+                                     x
+                                     (ly:event-property x 'digit)))
+                               (cadr specified-info)))
+         (default-strings (ly:context-property context 'defaultStrings '()))
+         (strings-used (if (and (zero? (entry-count defined-strings))
+                                (not (zero? (entry-count default-strings))))
+                           default-strings
+                           defined-strings))
+         (predefined-fretboard
+          (if predefined-fret-table
+              (get-predefined-fretboard
+               predefined-fret-table
+               tunings
+               pitches)
+              '())))
+     (if (null? predefined-fretboard)
+         (let ((string-frets
+                (determine-frets-and-strings
+                 notes
+                 strings-used
+                 defined-fingers
+                 (ly:context-property context 'minimumFret 0)
+                 (ly:context-property context 'maximumFretStretch 4)
+                 tunings)))
+            (if (null? grob)
+                string-frets
+                (create-fretboard
+                 context grob (string-frets->placement-list
+                                (filter (lambda (entry)
+                                          (car entry))
+                                        string-frets)
+                                string-count))))
+         (if (null? grob)
+             (placement-list->string-frets predefined-fretboard)
+             (create-fretboard context grob predefined-fretboard)))))
 
-    (set! (ly:grob-property grob 'fret-diagram-details)
-
-          (if (null? details)
-              (acons 'string-count (length tunings) '())
-              (acons 'string-count (length tunings) details)))
-
-    (set! (ly:grob-property grob 'dot-placement-list)
-	  (if predefined-frets
-	      (let ((predefined-fretboard 
-		     (get-predefined-fretboard
-                      predefined-frets
-                      tunings
-                      pitches)))
-		(if (null? predefined-fretboard)
-		    (string-frets->dot-placement 
-		     string-frets my-string-count)  ;no predefined diagram
-		    predefined-fretboard)) ;found default diagram
-	      (string-frets->dot-placement string-frets my-string-count)))))
-
-(define-public (determine-frets-mf notes string-numbers
-				   minimum-fret max-stretch
-				   tunings)
-
-  (define (calc-fret pitch string tuning)
-    (- (ly:pitch-semitones pitch) (list-ref tuning (1- string))))
-
-  (define (note-pitch a)
-    (ly:event-property a 'pitch))
-
-  (define (note-pitch>? a b)
-    (ly:pitch<? (note-pitch b)
-		(note-pitch a)))
-
-  (define (note-finger ev)
-    (let* ((articulations (ly:event-property ev 'articulations))
-	   (finger-found #f))
-
-      (map (lambda (art)
-	     (let* ((num (ly:event-property art 'digit)))
-
-	       (if (and (eq? 'fingering-event (ly:event-property art 'class))
-			(number? num))
-		   (set! finger-found num))))
-	   articulations)
-
-      finger-found))
-
-  (define (note-string ev)
-    (let* ((articulations (ly:event-property ev 'articulations))
-	   (string-found #f))
-
-      (map (lambda (art)
-	     (let* ((num (ly:event-property art 'string-number)))
-
-	       (if (number? num)
-		   (set! string-found num))))
-	   articulations)
-
-      string-found))
-
-  (define (del-string string)
-    (if (number? string)
-	(set! free-strings
-	      (delete string free-strings))))
-
-  (define specified-frets '())
-  (define free-strings '())
-  
-  (define (close-enough fret)
-    (reduce
-     (lambda (x y)
-       (and x y))
-     #t
-     (map (lambda (specced-fret)
-	    (> max-stretch (abs (- fret specced-fret))))
-	  specified-frets)))
-
-  (define (string-qualifies string pitch)
-    (let* ((fret (calc-fret pitch string tunings)))
-      (and (>= fret minimum-fret)
-	   (close-enough fret))))
-
-  (define string-fret-fingering-tuples '())
-  (define (set-fret note string)
-    (set! string-fret-fingering-tuples
-	  (cons (list string
-		      (calc-fret (ly:event-property note 'pitch)
-				 string tunings)
-		      (note-finger note))
-		string-fret-fingering-tuples))
-    (del-string string))
-
-
-  ;;; body.
-  (set! specified-frets
-	(filter identity (map
-			  (lambda (note)
-			    (if (note-string note)
-				(calc-fret (note-pitch note)
-					   (note-string note) tunings)
-				#f))
-			  notes)))
-
-  (set! free-strings (map 1+ (iota (length tunings))))
-
-  (for-each (lambda (note)
-	      (del-string (note-string note)))
-	    notes)
-
-
-  (for-each
-   (lambda (note)
-     (if (note-string note)
-	 (set-fret note (note-string note))
-	 (let* ((fit-string (find (lambda (string) 
-				    (string-qualifies string (note-pitch note)))
-				  free-strings)))
-	   (if fit-string
-	       (set-fret note fit-string)
-	       (ly:warning "No string for pitch ~a (given frets ~a)" 
-                           (note-pitch note)
-			   specified-frets)))))
-   (sort notes note-pitch>?))
-
-  string-fret-fingering-tuples)
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; tablature
 
-;; The TabNoteHead tablatureFormat callback.
-;; Compute the text grob-property
-(define-public (fret-number-tablature-format string context event)
-  (let* ((tuning (ly:context-property context 'stringTunings))
-	 (pitch (ly:event-property event 'pitch))
-	 (is-harmonic (apply
-		       functional-or
-		       (map
-			(lambda (ev)
-			  (eq? 'harmonic-event (ly:event-property ev 'class)))
-			(ly:event-property event 'articulations)))))
-
-    (make-whiteout-markup
-     (make-vcenter-markup
-      (format
-       "~a"
-       (- (ly:pitch-semitones pitch)
-	  (list-ref tuning
-		    ;; remove 1 because list index starts at 0
-		    ;;and guitar string at 1.
-		    (1- string))))))))
+;; The TabNoteHead tablatureFormat callbacks.
+
+;; Calculate the fret from pitch and string number as letter
+;; The fret letter is taken from 'fretLabels if present
+(define-public (fret-letter-tablature-format
+                context string-number fret-number)
+ (let ((labels (ly:context-property context 'fretLabels)))
+  (make-vcenter-markup
+   (cond
+    ((= 0 (length labels))
+     (string (integer->char (+ fret-number (char->integer #\a)))))
+    ((and (<= 0 fret-number) (< fret-number (length labels)))
+     (list-ref labels fret-number))
+    (else
+     (ly:warning (_ "No label for fret ~a (on string ~a);
+only ~a fret labels provided")
+                fret-number string-number (length labels))
+     ".")))))
+
+;; Display the fret number as a number
+(define-public (fret-number-tablature-format
+                context string-number fret-number)
+  (make-vcenter-markup
+    (format #f "~a" fret-number)))
 
 ;; The 5-string banjo has got a extra string, the fifth (duh), which
 ;; starts at the fifth fret on the neck.  Frets on the fifth string
@@ -394,26 +574,36 @@
 ;;   the "first fret" on the fifth string is really the sixth fret
 ;;   on the banjo neck.
 ;; We solve this by defining a new fret-number-tablature function:
-(define-public (fret-number-tablature-format-banjo string context event)
-  (let* ((tuning (ly:context-property context 'stringTunings))
-	 (pitch (ly:event-property event 'pitch)))
-
-    (make-whiteout-markup
-     (make-vcenter-markup
-      (let ((fret (- (ly:pitch-semitones pitch) (list-ref tuning (1- string)))))
-	(number->string (cond
-			 ((and (> fret 0) (= string 5))
-			  (+ fret 5))
-			 (else fret))))))))
-
+(define-public (fret-number-tablature-format-banjo
+                context string-number fret-number)
+ (make-vcenter-markup
+  (number->string (cond
+                   ((and (> fret-number 0) (= string-number 5))
+                    (+ fret-number 5))
+                   (else fret-number)))))
+
+;;  Tab note head staff position functions
+;;
+;;  Define where in the staff to display a given string.  Some forms of
+;;  tablature put the tab note heads in the spaces, rather than on the
+;;  lines
+
+(define-public (tablature-position-on-lines context string-number)
+ (let* ((string-tunings (ly:context-property context 'stringTunings))
+        (string-count (length string-tunings))
+        (string-one-topmost (ly:context-property context 'stringOneTopmost))
+        (staff-line (- (* 2 string-number) string-count 1)))
+  (if string-one-topmost
+      (- staff-line)
+      staff-line)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; bar numbers
 
-(define-public ((every-nth-bar-number-visible n) barnum)
+(define-public ((every-nth-bar-number-visible n) barnum mp)
   (= 0 (modulo barnum n)))
 
-(define-public ((modulo-bar-number-visible n m) barnum)
+(define-public ((modulo-bar-number-visible n m) barnum mp)
   (and (> barnum 1) (= m (modulo barnum n))))
 
 (define-public ((set-bar-number-visibility n) tr)
@@ -421,9 +611,44 @@
     (ly:context-set-property! tr 'barNumberVisibility
 			      (modulo-bar-number-visible n (modulo bn n)))))
 
-(define-public (first-bar-number-invisible barnum) (> barnum 1))
-
-(define-public (all-bar-numbers-visible barnum) #t)
+(define-public (first-bar-number-invisible barnum mp)
+  (> barnum 1))
+
+(define-public (first-bar-number-invisible-save-broken-bars barnum mp)
+  (or (> barnum 1)
+      (> (ly:moment-main-numerator mp) 0)))
+
+(define-public (first-bar-number-invisible-and-no-parenthesized-bar-numbers barnum mp)
+  (and (> barnum 1)
+       (= (ly:moment-main-numerator mp) 0)))
+
+(define-public (robust-bar-number-function barnum measure-pos alt-number context)
+  (define (get-number-and-power an pow)
+    (if (<= an alt-number)
+        (get-number-and-power (+ an (expt 26 (1+ pow))) (1+ pow))
+        (cons (+ alt-number (- (expt 26 pow) an)) (1- pow))))
+  (define (make-letter so-far an pow)
+    (if (< pow 0)
+      so-far
+      (let ((pos (modulo (quotient an (expt 26 pow)) 26)))
+        (make-letter (string-append so-far
+                                    (substring "abcdefghijklmnopqrstuvwxyz"
+                                               pos
+                                               (1+ pos)))
+                   an
+                   (1- pow)))))
+  (let* ((number-and-power (get-number-and-power 0 0))
+         (begin-measure (= 0 (ly:moment-main-numerator measure-pos)))
+         (maybe-open-parenthesis (if begin-measure "" "("))
+         (maybe-close-parenthesis (if begin-measure "" ")")))
+    (markup (string-append maybe-open-parenthesis
+                           (number->string barnum)
+                           (make-letter ""
+                                        (car number-and-power)
+                                        (cdr number-and-power))
+                           maybe-close-parenthesis))))
+
+(define-public (all-bar-numbers-visible barnum mp) #t)
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;