Change \note markup command to get a duration

python/musicexp.py

 # -*- coding: utf-8 -*-
 import inspect
 import sys
 import string
 import re
 import math
 import lilylib as ly
 import warnings
 import utilities
 
@@ skipping 603 matching lines @@
             else:
                 num = "#f"
             if self.display_denominator:
                 den = self.display_denominator
             else:
                 den = "#f"
             base_number_function = "(tuplet-number::non-default-tuplet-fraction-text %s %s)" % (den, num)
 
 
         if self.display_type == "actual" and self.normal_type:
-            # Obtain the note duration in scheme-mode, i.e. \longa as \\longa
-            base_duration = self.normal_type.ly_expression (None, True)
-            func ("\\once \\override TupletNumber.text = #(tuplet-number::append-note-wrapper %s \"%s\")" %
+            base_duration = self.normal_type.lisp_expression ()
+            func ("\\once \\override TupletNumber.text = #(tuplet-number::append-note-wrapper %s %s)" %
                 (base_number_function, base_duration))
             func.newline ()
         elif self.display_type == "both": # TODO: Implement this using actual_type and normal_type!
             if self.display_number == None:
                 func ("\\once \\omit TupletNumber")
                 func.newline ()
             elif self.display_number == "both":
-                den_duration = self.normal_type.ly_expression (None, True)
+                den_duration = self.normal_type.lisp_expression ()
                 # If we don't have an actual type set, use the normal duration!
                 if self.actual_type:
-                    num_duration = self.actual_type.ly_expression (None, True)
+                    num_duration = self.actual_type.lisp_expression ()
                 else:
                     num_duration = den_duration
                 if (self.display_denominator or self.display_numerator):
-                    func ("\\once \\override TupletNumber.text = #(tuplet-number::non-default-fraction-with-notes %s \"%s\" %s \"%s\")" %
+                    func ("\\once \\override TupletNumber.text = #(tuplet-number::non-default-fraction-with-notes %s %s %s %s)" %
                                 (self.display_denominator, den_duration,
                                  self.display_numerator, num_duration))
                     func.newline ()
                 else:
-                    func ("\\once \\override TupletNumber.text = #(tuplet-number::fraction-with-notes \"%s\" \"%s\")" %
+                    func ("\\once \\override TupletNumber.text = #(tuplet-number::fraction-with-notes %s %s)" %
                                 (den_duration, num_duration))
                     func.newline ()
         else:
             if self.display_number == None:
                 func ("\\once \\omit TupletNumber")
                 func.newline ()
             elif self.display_number == "both":
                 func ("\\once \\override TupletNumber.text = #%s" % base_number_function)
                 func.newline ()
 
@@ skipping 1331 matching lines @@
     def set_new_duration (self, dur):
         self.newduration = dur
     def set_beats_per_minute (self, beats):
         self.beats = beats
     def set_parentheses (self, parentheses):
         self.parentheses = parentheses
     def wait_for_note (self):
         return False
     def duration_to_markup (self, dur):
         if dur:
-            # Generate the markup to print the note, use scheme mode for
-            # ly_expression to get longa and not \longa (which causes an error)
-            return "\\general-align #Y #DOWN \\smaller \\note #\"%s\" #UP" % dur.ly_expression(None, True)
+            # Generate the markup to print the note
+            return "\\general-align #Y #DOWN \\smaller \\note {%s} #UP" % dur.ly_expression ()
         else:
             return ''
     def tempo_markup_template (self):
         return "\\mark\\markup { \\fontsize #-2 \\line { %s } }"
     def ly_expression (self):
         res = ''
         if not self.baseduration:
             return res
         if self.beats:
             if self.parentheses:
@@ skipping 498 matching lines @@
     expr = test_expr()
     expr.set_start (Rational (0))
     print expr.ly_expression()
     start = Rational (0, 4)
     stop = Rational (4, 2)
     def sub(x, start=start, stop=stop):
         ok = x.start >= start and x.start + x.get_length() <= stop
         return ok
 
     print expr.lisp_sub_expression(sub)