X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=python%2Fmusicexp.py;h=a564f29ce500700a9c1bd34a783800ee69d11377;hb=0200dabbc6e9bfa91c38f1199a2cdf9bfb43d026;hp=9d9ea96dc674ea70817a04c21ee856863d1ce418;hpb=ab6bcd4eab25e0f42e8819d0c62a903e5caa3b39;p=lilypond.git diff --git a/python/musicexp.py b/python/musicexp.py index 9d9ea96dc6..a564f29ce5 100644 --- a/python/musicexp.py +++ b/python/musicexp.py @@ -1,3 +1,4 @@ +# -*- coding: utf-8 -*- import inspect import sys import string @@ -12,16 +13,13 @@ from rational import Rational previous_pitch = None relative_pitches = False -def warning (str): - ly.stderr_write ((_ ("warning: %s") % str) + "\n") - def escape_instrument_string (input_string): retstring = string.replace (input_string, "\"", "\\\"") if re.match ('.*[\r\n]+.*', retstring): rx = re.compile (r'[\n\r]+') strings = rx.split (retstring) - retstring = "\\markup { \\column { " + retstring = "\\markup { \\center-column { " for s in strings: retstring += "\\line {\"" + s + "\"} " retstring += "} }" @@ -41,10 +39,9 @@ class Output_printer: """A class that takes care of formatting (eg.: indenting) a Music expression as a .ly file. - + """ - ## TODO: support for \relative. - + def __init__ (self): self._line = '' self._indent = 4 @@ -57,19 +54,19 @@ class Output_printer: def set_file (self, file): self._file = file - + def dump_version (self): self.newline () self.print_verbatim ('\\version "@TOPLEVEL_VERSION@"') self.newline () - + def get_indent (self): return self._nesting * self._indent - + def override (self): last = self._output_state_stack[-1] self._output_state_stack.append (last.copy()) - + def add_factor (self, factor): self.override() self._output_state_stack[-1].factor *= factor @@ -87,21 +84,21 @@ class Output_printer: def unformatted_output (self, str): # don't indent on \< and indent only once on << - self._nesting += ( str.count ('<') - - str.count ('\<') - str.count ('<<') + self._nesting += ( str.count ('<') + - str.count ('\<') - str.count ('<<') + str.count ('{') ) self._nesting -= ( str.count ('>') - str.count ('\>') - str.count ('>>') - str.count ('->') - str.count ('_>') - str.count ('^>') + str.count ('}') ) self.print_verbatim (str) - + def print_duration_string (self, str): if self._last_duration == str: return - + self.unformatted_output (str) - + def add_word (self, str): if (len (str) + 1 + len (self._line) > self._line_len): self.newline() @@ -111,7 +108,7 @@ class Output_printer: self._line += ' ' self.unformatted_output (str) self._skipspace = False - + def newline (self): self._file.write (self._line + '\n') self._line = ' ' * self._indent * self._nesting @@ -119,10 +116,10 @@ class Output_printer: def skipspace (self): self._skipspace = True - + def __call__(self, arg): self.dump (arg) - + def dump (self, str): if self._skipspace: self._skipspace = False @@ -144,7 +141,7 @@ class Duration: self.duration_log = 0 self.dots = 0 self.factor = Rational (1) - + def lisp_expression (self): return '(ly:make-duration %d %d %d %d)' % (self.duration_log, self.dots, @@ -173,14 +170,14 @@ class Duration: str += '*%d' % factor.numerator () return str - + def print_ly (self, outputter): str = self.ly_expression (self.factor / outputter.duration_factor ()) outputter.print_duration_string (str) - + def __repr__(self): return self.ly_expression() - + def copy (self): d = Duration () d.dots = self.dots @@ -201,14 +198,35 @@ class Duration: return base * dot_fact * self.factor +# implement the midi command line option '-m' and '--midi' +# if TRUE add midi-block to .ly file (see below) +def set_create_midi (option): + global midi_option + midi_option = option + +def get_create_midi (): + try: + return midi_option + except: + return False # Implement the different note names for the various languages def pitch_generic (pitch, notenames, accidentals): str = notenames[pitch.step] - if pitch.alteration < 0: - str += accidentals[0] * (-pitch.alteration) + halftones = int (pitch.alteration) + if halftones < 0: + str += accidentals[0] * (-halftones) elif pitch.alteration > 0: - str += accidentals[3] * (pitch.alteration) + str += accidentals[3] * (halftones) + # Handle remaining fraction to pitch.alteration (for microtones) + if (halftones != pitch.alteration): + if None in accidentals[1:3]: + ly.warning (_ ("Language does not support microtones contained in the piece")) + else: + try: + str += {-0.5: accidentals[1], 0.5: accidentals[2]}[pitch.alteration-halftones] + except KeyError: + ly.warning (_ ("Language does not support microtones contained in the piece")) return str def pitch_general (pitch): @@ -230,7 +248,7 @@ def pitch_norsk (pitch): return pitch_deutsch (pitch) def pitch_svenska (pitch): - str = pitch_generic (pitch, ['c', 'd', 'e', 'f', 'g', 'a', 'h'], ['ess', '', '', 'iss']) + str = pitch_generic (pitch, ['c', 'd', 'e', 'f', 'g', 'a', 'h'], ['ess', None, None, 'iss']) return str.replace ('hess', 'b').replace ('aes', 'as').replace ('ees', 'es') def pitch_italiano (pitch): @@ -241,11 +259,11 @@ def pitch_catalan (pitch): return pitch_italiano (pitch) def pitch_espanol (pitch): - str = pitch_generic (pitch, ['do', 're', 'mi', 'fa', 'sol', 'la', 'si'], ['b', '', '', 's']) + str = pitch_generic (pitch, ['do', 're', 'mi', 'fa', 'sol', 'la', 'si'], ['b', None, None, 's']) return str def pitch_vlaams (pitch): - str = pitch_generic (pitch, ['do', 're', 'mi', 'fa', 'sol', 'la', 'si'], ['b', '', '', 'k']) + str = pitch_generic (pitch, ['do', 're', 'mi', 'fa', 'sol', 'la', 'si'], ['b', None, None, 'k']) return str def set_pitch_language (language): @@ -271,7 +289,8 @@ class Pitch: self.alteration = 0 self.step = 0 self.octave = 0 - + self._force_absolute_pitch = False + def __repr__(self): return self.ly_expression() @@ -281,7 +300,7 @@ class Pitch: c.step += interval.step c.octave += interval.octave c.normalize () - + target_st = self.semitones() + interval.semitones() c.alteration += target_st - c.semitones() return c @@ -302,7 +321,7 @@ class Pitch: p = Pitch () p.alteration = self.alteration p.step = self.step - p.octave = self.octave + p.octave = self.octave return p def steps (self): @@ -310,8 +329,8 @@ class Pitch: def semitones (self): return self.octave * 12 + [0,2,4,5,7,9,11][self.step] + self.alteration - - def ly_step_expression (self): + + def ly_step_expression (self): return pitch_generating_function (self) def absolute_pitch (self): @@ -340,32 +359,32 @@ class Pitch: def ly_expression (self): str = self.ly_step_expression () - if relative_pitches: + if relative_pitches and not self._force_absolute_pitch: str += self.relative_pitch () else: str += self.absolute_pitch () return str - + def print_ly (self, outputter): outputter (self.ly_expression()) - + class Music: def __init__ (self): self.parent = None self.start = Rational (0) self.comment = '' self.identifier = None - + def get_length(self): return Rational (0) - + def get_properties (self): return '' - + def has_children (self): return False - + def get_index (self): if self.parent: return self.parent.elements.index (self) @@ -373,12 +392,12 @@ class Music: return None def name (self): return self.__class__.__name__ - + def lisp_expression (self): name = self.name() props = self.get_properties () - + return "(make-music '%s %s)" % (name, props) def set_start (self, start): @@ -395,20 +414,20 @@ class Music: if not text: return - + if text == '\n': printer.newline () return - + lines = string.split (text, '\n') for l in lines: if l: printer.unformatted_output ('% ' + l) printer.newline () - + def print_with_identifier (self, printer): - if self.identifier: + if self.identifier: printer ("\\%s" % self.identifier) else: self.print_ly (printer) @@ -445,13 +464,86 @@ class RelativeMusic (MusicWrapper): previous_pitch = self.basepitch if not previous_pitch: previous_pitch = Pitch () - func ('\\relative %s%s' % (pitch_generating_function (previous_pitch), + func ('\\relative %s%s' % (pitch_generating_function (previous_pitch), previous_pitch.absolute_pitch ())) MusicWrapper.print_ly (self, func) relative_pitches = prev_relative_pitches class TimeScaledMusic (MusicWrapper): + def __init__ (self): + MusicWrapper.__init__ (self) + self.numerator = 1 + self.denominator = 1 + self.display_number = "actual" # valid values "actual" | "both" | None + # Display the basic note length for the tuplet: + self.display_type = None # value values "actual" | "both" | None + self.display_bracket = "bracket" # valid values "bracket" | "curved" | None + self.actual_type = None # The actually played unit of the scaling + self.normal_type = None # The basic unit of the scaling + self.display_numerator = None + self.display_denominator = None + def print_ly (self, func): + if self.display_bracket == None: + func ("\\once \\override TupletBracket #'stencil = ##f") + func.newline () + elif self.display_bracket == "curved": + ly.warning (_ ("Tuplet brackets of curved shape are not correctly implemented")) + func ("\\once \\override TupletBracket #'stencil = #ly:slur::print") + func.newline () + + base_number_function = {None: "#f", + "actual": "tuplet-number::calc-denominator-text", + "both": "tuplet-number::calc-fraction-text"}.get (self.display_number, None) + # If we have non-standard numerator/denominator, use our custom function + if self.display_number == "actual" and self.display_denominator: + base_number_function = "(tuplet-number::non-default-tuplet-denominator-text %s)" % self.display_denominator + elif self.display_number == "both" and (self.display_denominator or self.display_numerator): + if self.display_numerator: + num = self.display_numerator + 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_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 \\override TupletNumber #'stencil = ##f") + func.newline () + elif self.display_number == "both": + den_duration = self.normal_type.ly_expression (None, True) + # 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) + 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\")" % + (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\")" % + (den_duration, num_duration)) + func.newline () + else: + if self.display_number == None: + func ("\\once \\override TupletNumber #'stencil = ##f") + func.newline () + elif self.display_number == "both": + func ("\\once \\override TupletNumber #'text = #%s" % base_number_function) + func.newline () + func ('\\times %d/%d ' % (self.numerator, self.denominator)) func.add_factor (Rational (self.numerator, self.denominator)) @@ -466,7 +558,7 @@ class NestedMusic(Music): def append (self, what): if what: self.elements.append (what) - + def has_children (self): return self.elements @@ -474,7 +566,7 @@ class NestedMusic(Music): assert elt.parent == None assert succ == None or succ in self.elements - + idx = 0 if succ: idx = self.elements.index (succ) @@ -488,7 +580,7 @@ class NestedMusic(Music): self.elements.insert (idx, elt) elt.parent = self - + def get_properties (self): return ("'elements (list %s)" % string.join (map (lambda x: x.lisp_expression(), @@ -509,10 +601,10 @@ class NestedMusic(Music): def delete_element (self, element): assert element in self.elements - + self.elements.remove (element) element.parent = None - + def set_start (self, start): self.start = start for e in self.elements: @@ -522,13 +614,13 @@ class NestedMusic(Music): r = Music.find_first (self, predicate) if r: return r - + for e in self.elements: r = e.find_first (predicate) if r: return r return None - + class SequentialMusic (NestedMusic): def get_last_event_chord (self): value = None @@ -555,15 +647,15 @@ class SequentialMusic (NestedMusic): printer ('}') if newline: printer.newline() - + def lisp_sub_expression (self, pred): name = self.name() props = self.get_subset_properties (pred) - + return "(make-music '%s %s)" % (name, props) - + def set_start (self, start): for e in self.elements: e.set_start (start) @@ -582,7 +674,7 @@ class RepeatedMusic: self.music = SequentialMusic () self.music.elements = music else: - warning (_ ("unable to set the music %(music)s for the repeat %(repeat)s") % \ + ly.warning (_ ("unable to set the music %(music)s for the repeat %(repeat)s") % \ {'music':music, 'repeat':self}) def add_ending (self, music): self.endings.append (music) @@ -591,7 +683,7 @@ class RepeatedMusic: if self.music: self.music.print_ly (printer) else: - warning (_ ("encountered repeat without body")) + ly.warning (_ ("encountered repeat without body")) printer.dump ('{}') if self.endings: printer.dump ('\\alternative {') @@ -665,12 +757,12 @@ class Paper: self.print_length_field (printer, "paper-width", self.page_width) self.print_length_field (printer, "paper-height", self.page_height) self.print_length_field (printer, "top-margin", self.top_margin) - self.print_length_field (printer, "botton-margin", self.bottom_margin) + self.print_length_field (printer, "bottom-margin", self.bottom_margin) self.print_length_field (printer, "left-margin", self.left_margin) # TODO: maybe set line-width instead of right-margin? self.print_length_field (printer, "right-margin", self.right_margin) # TODO: What's the corresponding setting for system_left_margin and - # system_right_margin in Lilypond? + # system_right_margin in LilyPond? self.print_length_field (printer, "between-system-space", self.system_distance) self.print_length_field (printer, "page-top-space", self.top_system_distance) @@ -706,6 +798,7 @@ class Layout: class ChordEvent (NestedMusic): def __init__ (self): NestedMusic.__init__ (self) + self.after_grace_elements = None self.grace_elements = None self.grace_type = None def append_grace (self, element): @@ -713,6 +806,16 @@ class ChordEvent (NestedMusic): if not self.grace_elements: self.grace_elements = SequentialMusic () self.grace_elements.append (element) + def append_after_grace (self, element): + if element: + if not self.after_grace_elements: + self.after_grace_elements = SequentialMusic () + self.after_grace_elements.append (element) + + def has_elements (self): + return [e for e in self.elements if + isinstance (e, NoteEvent) or isinstance (e, RestEvent)] != [] + def get_length (self): l = Rational (0) @@ -735,10 +838,13 @@ class ChordEvent (NestedMusic): rest_events = [e for e in self.elements if isinstance (e, RhythmicEvent) and not isinstance (e, NoteEvent)] - + other_events = [e for e in self.elements if not isinstance (e, RhythmicEvent)] + if self.after_grace_elements: + printer ('\\afterGrace {') + if self.grace_elements and self.elements: if self.grace_type: printer ('\\%s' % self.grace_type) @@ -746,7 +852,16 @@ class ChordEvent (NestedMusic): printer ('\\grace') # don't print newlines after the { and } braces self.grace_elements.print_ly (printer, False) - # Print all overrides and other settings needed by the + elif self.grace_elements: # no self.elements! + ly.warning (_ ("Grace note with no following music: %s") % self.grace_elements) + if self.grace_type: + printer ('\\%s' % self.grace_type) + else: + printer ('\\grace') + self.grace_elements.print_ly (printer, False) + printer ('{}') + + # Print all overrides and other settings needed by the # articulations/ornaments before the note for e in other_events: e.print_before_note (printer) @@ -760,7 +875,7 @@ class ChordEvent (NestedMusic): pitches = [] basepitch = None for x in note_events: - pitches.append (x.pitch.ly_expression ()) + pitches.append (x.chord_element_ly ()) if not basepitch: basepitch = previous_pitch printer ('<%s>' % string.join (pitches)) @@ -770,15 +885,19 @@ class ChordEvent (NestedMusic): duration.print_ly (printer) else: pass - + for e in other_events: e.print_ly (printer) for e in other_events: e.print_after_note (printer) + if self.after_grace_elements: + printer ('}') + self.after_grace_elements.print_ly (printer, False) + self.print_comment (printer) - + class Partial (Music): def __init__ (self): Music.__init__ (self) @@ -792,9 +911,9 @@ class BarLine (Music): Music.__init__ (self) self.bar_number = 0 self.type = None - + def print_ly (self, printer): - bar_symbol = { 'regular': "|", 'dotted': ":", 'dashed': ":", + bar_symbol = { 'regular': "|", 'dotted': ":", 'dashed': "dashed", 'heavy': "|", 'light-light': "||", 'light-heavy': "|.", 'heavy-light': ".|", 'heavy-heavy': ".|.", 'tick': "'", 'short': "'", 'none': "" }.get (self.type, None) @@ -844,13 +963,13 @@ class SpanEvent (Event): class SlurEvent (SpanEvent): def print_before_note (self, printer): - command = {'dotted': '\\slurDotted', + command = {'dotted': '\\slurDotted', 'dashed' : '\\slurDashed'}.get (self.line_type, '') if command and self.span_direction == -1: printer.dump (command) def print_after_note (self, printer): # reset non-solid slur types! - command = {'dotted': '\\slurSolid', + command = {'dotted': '\\slurSolid', 'dashed' : '\\slurSolid'}.get (self.line_type, '') if command and self.span_direction == -1: printer.dump (command) @@ -877,7 +996,7 @@ class BracketSpannerEvent (SpanEvent): def print_before_note (self, printer): if self.span_direction == -1: printer.dump ('\[') - # the the bracket after the last note + # the bracket after the last note def print_after_note (self, printer): if self.span_direction == 1: printer.dump ('\]') @@ -893,7 +1012,11 @@ class OctaveShiftEvent (SpanEvent): self.span_type = {'up': 1, 'down': -1}.get (type, 0) def ly_octave_shift_indicator (self): # convert 8/15 to lilypond indicators (+-1/+-2) - value = {8: 1, 15: 2}.get (self.size, 0) + try: + value = {8: 1, 15: 2}[self.size] + except KeyError: + ly.warning (_ ("Invalid octave shift size found: %s. Using no shift.") % self.size) + value = 0 # negative values go up! value *= -1*self.span_type return value @@ -902,7 +1025,7 @@ class OctaveShiftEvent (SpanEvent): value = '' if dir: value = '\ottava #%s' % dir - return { + return { -1: value, 1: '\ottava #0'}.get (self.span_direction, '') @@ -918,10 +1041,10 @@ class GlissandoEvent (SpanEvent): style= { "dashed" : "dashed-line", "dotted" : "dotted-line", - "wavy" : "zigzag" + "wavy" : "zigzag" }. get (self.line_type, None) if style: - printer.dump ("\once \override Glissando #'style = #'%s" % style) + printer.dump ("\\once \\override Glissando #'style = #'%s" % style) def ly_expression (self): return {-1: '\\glissando', 1:''}.get (self.span_direction, '') @@ -960,10 +1083,10 @@ class HairpinEvent (SpanEvent): return '\!' else: return {1: '\<', -1: '\>'}.get (self.span_type, '') - + def ly_expression (self): return self.hairpin_to_ly () - + def print_ly (self, printer): val = self.hairpin_to_ly () if val: @@ -1099,13 +1222,54 @@ class FretEvent (MarkupEvent): else: return '' + +class FunctionWrapperEvent (Event): + def __init__ (self, function_name = None): + Event.__init__ (self) + self.function_name = function_name + def pre_note_ly (self, is_chord_element): + if self.function_name: + return "\\%s" % self.function_name + else: + return '' + def pre_chord_ly (self): + return '' + def ly_expression (self): + if self.function_name: + return "\\%s" % self.function_name + else: + return '' + +class ParenthesizeEvent (FunctionWrapperEvent): + def __init__ (self): + FunctionWrapperEvent.__init__ (self, "parenthesize") + +class NotestyleEvent (Event): + def __init__ (self): + Event.__init__ (self) + self.style = None + self.filled = None + def pre_chord_ly (self): + if self.style: + return "\\once \\override NoteHead #'style = #%s" % self.style + else: + return '' + def pre_note_ly (self, is_chord_element): + if self.style and is_chord_element: + return "\\tweak #'style #%s" % self.style + else: + return '' + def ly_expression (self): + return self.pre_chord_ly () + + class ChordPitch: def __init__ (self): self.alteration = 0 self.step = 0 def __repr__(self): return self.ly_expression() - def ly_expression (self): + def ly_expression (self): return pitch_generating_function (self) class ChordModification: @@ -1167,9 +1331,9 @@ class TremoloEvent (ArticulationEvent): class BendEvent (ArticulationEvent): def __init__ (self): Event.__init__ (self) - self.alter = 0 + self.alter = None def ly_expression (self): - if self.alter: + if self.alter != None: return "-\\bendAfter #%s" % self.alter else: return '' @@ -1178,25 +1342,46 @@ class RhythmicEvent(Event): def __init__ (self): Event.__init__ (self) self.duration = Duration() - + self.associated_events = [] + + def add_associated_event (self, ev): + if ev: + self.associated_events.append (ev) + + def pre_chord_ly (self): + return [ev.pre_chord_ly () for ev in self.associated_events] + + def pre_note_ly (self, is_chord_element): + return [ev.pre_note_ly (is_chord_element) for ev in self.associated_events] + + def ly_expression_pre_note (self, is_chord_element): + res = string.join (self.pre_note_ly (is_chord_element), ' ') + if res != '': + res = res + ' ' + return res + def get_length (self): return self.duration.get_length() - + def get_properties (self): return ("'duration %s" % self.duration.lisp_expression ()) - + class RestEvent (RhythmicEvent): def __init__ (self): RhythmicEvent.__init__ (self) self.pitch = None + def ly_expression (self): + res = self.ly_expression_pre_note (False) if self.pitch: - return "%s%s\\rest" % (self.pitch.ly_expression (), self.duration.ly_expression ()) + return res + "%s%s\\rest" % (self.pitch.ly_expression (), self.duration.ly_expression ()) else: return 'r%s' % self.duration.ly_expression () - + def print_ly (self, printer): + for ev in self.associated_events: + ev.print_ly (printer) if self.pitch: self.pitch.print_ly (printer) self.duration.print_ly (printer) @@ -1207,7 +1392,7 @@ class RestEvent (RhythmicEvent): class SkipEvent (RhythmicEvent): def ly_expression (self): - return 's%s' % self.duration.ly_expression () + return 's%s' % self.duration.ly_expression () class NoteEvent(RhythmicEvent): def __init__ (self): @@ -1216,17 +1401,17 @@ class NoteEvent(RhythmicEvent): self.drum_type = None self.cautionary = False self.forced_accidental = False - + def get_properties (self): str = RhythmicEvent.get_properties (self) - + if self.pitch: str += self.pitch.lisp_expression () elif self.drum_type: str += "'drum-type '%s" % self.drum_type return str - + def pitch_mods (self): excl_question = '' if self.cautionary: @@ -1235,17 +1420,31 @@ class NoteEvent(RhythmicEvent): excl_question += '!' return excl_question - + def ly_expression (self): + # obtain all stuff that needs to be printed before the note: + res = self.ly_expression_pre_note (True) if self.pitch: - return '%s%s%s' % (self.pitch.ly_expression (), + return res + '%s%s%s' % (self.pitch.ly_expression (), self.pitch_mods(), self.duration.ly_expression ()) elif self.drum_type: - return '%s%s' (self.drum_type, + return res + '%s%s' (self.drum_type, self.duration.ly_expression ()) + def chord_element_ly (self): + # obtain all stuff that needs to be printed before the note: + res = self.ly_expression_pre_note (True) + if self.pitch: + return res + '%s%s' % (self.pitch.ly_expression (), + self.pitch_mods()) + elif self.drum_type: + return res + '%s%s' (self.drum_type) + + def print_ly (self, printer): + for ev in self.associated_events: + ev.print_ly (printer) if self.pitch: self.pitch.print_ly (printer) printer (self.pitch_mods ()) @@ -1257,28 +1456,77 @@ class NoteEvent(RhythmicEvent): class KeySignatureChange (Music): def __init__ (self): Music.__init__ (self) - self.scale = [] - self.tonic = Pitch() + self.tonic = None self.mode = 'major' - + self.non_standard_alterations = None + + def format_non_standard_alteration (self, a): + alter_dict = { -2: ",DOUBLE-FLAT", + -1.5: ",THREE-Q-FLAT", + -1: ",FLAT", + -0.5: ",SEMI-FLAT", + 0: ",NATURAL", + 0.5: ",SEMI-SHARP", + 1: ",SHARP", + 1.5: ",THREE-Q-SHARP", + 2: ",DOUBLE-SHARP"} + try: + accidental = alter_dict[a[1]] + except KeyError: + ly.warning (_ ("Unable to convert alteration %s to a lilypond expression") % a[1]) + return '' + if len (a) == 2: + return "( %s . %s )" % (a[0], accidental) + elif len (a) == 3: + return "(( %s . %s ) . %s )" % (a[2], a[0], accidental) + else: + return '' + def ly_expression (self): - return '\\key %s \\%s' % (self.tonic.ly_step_expression (), + if self.tonic: + return '\\key %s \\%s' % (self.tonic.ly_step_expression (), self.mode) - - def lisp_expression (self): - pairs = ['(%d . %d)' % (i , self.scale[i]) for i in range (0,7)] - scale_str = ("'(%s)" % string.join (pairs)) - - return """ (make-music 'KeyChangeEvent - 'pitch-alist %s) """ % scale_str + elif self.non_standard_alterations: + alterations = [self.format_non_standard_alteration (a) for + a in self.non_standard_alterations] + return "\\set Staff.keyAlterations = #`(%s)" % string.join (alterations, " ") + else: + return '' class TimeSignatureChange (Music): def __init__ (self): Music.__init__ (self) - self.fraction = (4,4) + self.fractions = [4,4] + self.style = None + def format_fraction (self, frac): + if isinstance (frac, list): + l = [self.format_fraction (f) for f in frac] + return "(" + string.join (l, " ") + ")" + else: + return "%s" % frac + def ly_expression (self): - return '\\time %d/%d ' % self.fraction - + st = '' + # Print out the style if we have ome, but the '() should only be + # forced for 2/2 or 4/4, since in all other cases we'll get numeric + # signatures anyway despite the default 'C signature style! + is_common_signature = self.fractions in ([2,2], [4,4], [4,2]) + if self.style: + if self.style == "common": + st = "\\defaultTimeSignature" + elif (self.style != "'()"): + st = "\\once \\override Staff.TimeSignature #'style = #%s " % self.style + elif (self.style != "'()") or is_common_signature: + st = "\\numericTimeSignature" + + # Easy case: self.fractions = [n,d] => normal \time n/d call: + if len (self.fractions) == 2 and isinstance (self.fractions[0], int): + return st + '\\time %d/%d ' % tuple (self.fractions) + elif self.fractions: + return st + "\\compoundMeter #'%s" % self.format_fraction (self.fractions) + else: + return st + '' + class ClefChange (Music): def __init__ (self): Music.__init__ (self) @@ -1300,6 +1548,8 @@ class ClefChange (Music): ('F', 4): "bass", ('F', 5): "subbass", ("percussion", 2): "percussion", + # Workaround: MuseScore uses PERC instead of percussion + ("PERC", 2): "percussion", ("TAB", 5): "tab"}.get ((self.type, self.position), None) def ly_expression (self): return '\\clef "%s%s"' % (self.clef_name (), self.octave_modifier ()) @@ -1309,7 +1559,7 @@ class ClefChange (Music): "C": ("clefs.C", 0, 0), "F": ("clefs.F", 2, 6), } - + def lisp_expression (self): try: (glyph, pos, c0) = self.clef_dict[self.type] @@ -1327,6 +1577,13 @@ class ClefChange (Music): """ % (glyph, pos, c0) return clefsetting +class Transposition (Music): + def __init__ (self): + Music.__init__ (self) + self.pitch = None + def ly_expression (self): + self.pitch._force_absolute_pitch = True + return '\\transposition %s' % self.pitch.ly_expression () class StaffChange (Music): def __init__ (self, staff): @@ -1338,6 +1595,26 @@ class StaffChange (Music): else: return '' +class SetEvent (Music): + def __init__ (self, contextprop, value): + Music.__init__ (self) + self.context_prop = contextprop + self.value = value + def ly_expression (self): + if self.value: + return "\\set %s = %s" % (self.context_prop, self.value) + else: + return '' + +class StaffLinesEvent (Music): + def __init__ (self, lines): + Music.__init__ (self) + self.lines = lines + def ly_expression (self): + if (self.lines > 0): + return "\\stopStaff \\override Staff.StaffSymbol #'line-count = #%s \\startStaff" % self.lines + else: + return "\\stopStaff \\revert Staff.StaffSymbol #'line-count \\startStaff" class TempoMark (Music): def __init__ (self): @@ -1358,7 +1635,7 @@ class TempoMark (Music): return False def duration_to_markup (self, dur): if dur: - # Generate the markup to print the note, use scheme mode for + # 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) else: @@ -1461,6 +1738,14 @@ class MultiMeasureRest(Music): return 'R%s' % self.duration.ly_expression () +class Break (Music): + def __init__ (self, tp="break"): + Music.__init__ (self) + self.type = tp + def print_ly (self, printer): + if self.type: + printer.dump ("\\%s" % self.type) + class StaffGroup: def __init__ (self, command = "StaffGroup"): self.stafftype = command @@ -1471,6 +1756,7 @@ class StaffGroup: self.spanbar = None self.children = [] self.is_group = True + self.context_modifications = [] # part_information is a list with entries of the form # [staffid, voicelist] # where voicelist is a list with entries of the form @@ -1487,37 +1773,59 @@ class StaffGroup: for c in self.children: c.set_part_information (part_name, staves_info) + def add_context_modification (self, modification): + self.context_modifications.append (modification) + def print_ly_contents (self, printer): for c in self.children: if c: c.print_ly (printer) - def print_ly_overrides (self, printer): + def needs_with (self): needs_with = False needs_with |= self.spanbar == "no" needs_with |= self.instrument_name != None needs_with |= self.short_instrument_name != None needs_with |= (self.symbol != None) and (self.symbol != "bracket") + return needs_with + def print_ly_context_mods (self, printer): + if self.instrument_name or self.short_instrument_name: + printer.dump ("\\consists \"Instrument_name_engraver\"") + if self.spanbar == "no": + printer.dump ("\\override SpanBar #'transparent = ##t") + brack = {"brace": "SystemStartBrace", + "none": "SystemStartBar", + "line": "SystemStartSquare"}.get (self.symbol, None) + if brack: + printer.dump ("systemStartDelimiter = #'%s" % brack) + + def print_ly_overrides (self, printer): + needs_with = self.needs_with () | (len (self.context_modifications) > 0); if needs_with: printer.dump ("\\with {") - if self.instrument_name or self.short_instrument_name: - printer.dump ("\\consists \"Instrument_name_engraver\"") - if self.spanbar == "no": - printer.dump ("\\override SpanBar #'transparent = ##t") - brack = {"brace": "SystemStartBrace", - "none": "f", - "line": "SystemStartSquare"}.get (self.symbol, None) - if brack: - printer.dump ("systemStartDelimiter = #'%s" % brack) + self.print_ly_context_mods (printer) + for m in self.context_modifications: + printer.dump (m) printer.dump ("}") + def print_ly_chords (self,printer): + try: + for [staff_id, voices] in self.part_information: + for [v, lyrics, figuredbass, chordnames] in voices: + if chordnames: + printer ('\context ChordNames = "%s" \\%s' % (chordnames, chordnames)) + printer.newline () + except TypeError: + return + def print_ly (self, printer): + self.print_ly_chords (printer) if self.stafftype: printer.dump ("\\new %s" % self.stafftype) self.print_ly_overrides (printer) printer.dump ("<<") printer.newline () if self.stafftype and self.instrument_name: - printer.dump ("\\set %s.instrumentName = %s" % (self.stafftype, + printer.dump ("\\set %s.instrumentName = %s" % (self.stafftype, escape_instrument_string (self.instrument_name))) printer.newline () if self.stafftype and self.short_instrument_name: @@ -1538,7 +1846,9 @@ class Staff (StaffGroup): self.voice_command = "Voice" self.substafftype = None - def print_ly_overrides (self, printer): + def needs_with (self): + return False + def print_ly_context_mods (self, printer): pass def print_ly_contents (self, printer): @@ -1549,12 +1859,6 @@ class Staff (StaffGroup): sub_staff_type = self.stafftype for [staff_id, voices] in self.part_information: - # Chord names need to come before the staff itself! - for [v, lyrics, figuredbass, chordnames] in voices: - if chordnames: - printer ('\context ChordNames = "%s" \\%s' % (chordnames, chordnames)) - - # now comes the real staff definition: if staff_id: printer ('\\context %s = "%s" << ' % (sub_staff_type, staff_id)) else: @@ -1594,9 +1898,9 @@ class TabStaff (Staff): if self.string_tunings or self.tablature_format: printer.dump ("\\with {") if self.string_tunings: - printer.dump ("stringTunings = #'(") + printer.dump ("stringTunings = #`(") for i in self.string_tunings: - printer.dump ("%s" % i.semitones ()) + printer.dump (",%s" % i.lisp_expression ()) printer.dump (")") if self.tablature_format: printer.dump ("tablatureFormat = #%s" % self.tablature_format) @@ -1617,7 +1921,7 @@ class DrumStaff (Staff): class RhythmicStaff (Staff): def __init__ (self, command = "RhythmicStaff"): Staff.__init__ (self, command) - + class Score: def __init__ (self): self.contents = None @@ -1625,12 +1929,13 @@ class Score: def set_contents (self, contents): self.contents = contents - + def set_part_information (self, part_id, staves_info): if self.contents: self.contents.set_part_information (part_id, staves_info) def print_ly (self, printer): + self.create_midi = get_create_midi () printer.dump ("\\score {"); printer.newline () if self.contents: @@ -1657,8 +1962,8 @@ def test_pitch (): down = Pitch () down.step = -4 down.normalize () - - + + print bflat.semitones() print bflat.transposed (fifth), bflat.transposed (fifth).transposed (fifth) print bflat.transposed (fifth).transposed (fifth).transposed (fifth) @@ -1683,7 +1988,7 @@ def test_printer (): m.append (make_note ()) m.append (make_note ()) - + t = TimeScaledMusic () t.numerator = 2 t.denominator = 3 @@ -1694,14 +1999,14 @@ def test_printer (): m.append (make_tup ()) m.append (make_tup ()) m.append (make_tup ()) - + printer = Output_printer() m.print_ly (printer) printer.newline () - + def test_expr (): m = SequentialMusic() - l = 2 + l = 2 evc = ChordEvent() n = NoteEvent() n.duration.duration_log = l @@ -1719,7 +2024,7 @@ def test_expr (): evc = ChordEvent() n = NoteEvent() n.duration.duration_log = l - n.pitch.step = 2 + n.pitch.step = 2 evc.insert_around (None, n, 0) m.insert_around (None, evc, 0) @@ -1734,7 +2039,7 @@ def test_expr (): n = KeySignatureChange() n.tonic=tonic.copy() n.scale = [0, 0, -2, 0, 0,-2,-2] - + evc.insert_around (None, n, 0) m.insert_around (None, evc, 0) @@ -1745,7 +2050,7 @@ if __name__ == '__main__': test_printer () raise 'bla' test_pitch() - + expr = test_expr() expr.set_start (Rational (0)) print expr.ly_expression() @@ -1754,6 +2059,6 @@ if __name__ == '__main__': 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)