scripts/musicxml2ly.py

   1 #!@TARGET_PYTHON@
   2 # -*- coding: utf-8 -*-
   3 import optparse
   4 import sys
   5 import re
   6 import os
   7 import string
   8 import codecs
   9 import zipfile
  10 import StringIO
  11
  12 """
  13 @relocate-preamble@
  14 """
  15
  16 import lilylib as ly
  17 _ = ly._
  18
  19 import musicxml
  20 import musicexp
  21
  22 from rational import Rational
  23
  24 # Store command-line options in a global variable, so we can access them everythwere
  25 options = None
  26
  27 class Conversion_Settings:
  28     def __init__(self):
  29        self.ignore_beaming = False
  30
  31 conversion_settings = Conversion_Settings ()
  32 # Use a global variable to store the setting needed inside a \layout block.
  33 # whenever we need to change a setting or add/remove an engraver, we can access
  34 # this layout and add the corresponding settings
  35 layout_information = musicexp.Layout ()
  36
  37 def progress (str):
  38     ly.stderr_write (str + '\n')
  39     sys.stderr.flush ()
  40
  41 def error_message (str):
  42     ly.stderr_write (str + '\n')
  43     sys.stderr.flush ()
  44
  45 needed_additional_definitions = []
  46 additional_definitions = {
  47
  48   "snappizzicato": """#(define-markup-command (snappizzicato layout props) ()
  49   (interpret-markup layout props
  50     (markup #:stencil
  51       (ly:stencil-translate-axis
  52         (ly:stencil-add
  53           (make-circle-stencil 0.7 0.1 #f)
  54           (ly:make-stencil
  55             (list 'draw-line 0.1 0 0.1 0 1)
  56             '(-0.1 . 0.1) '(0.1 . 1)))
  57         0.7 X))))""",
  58
  59   "eyeglasses": """eyeglassesps = #"0.15 setlinewidth
  60       -0.9 0 translate
  61       1.1 1.1 scale
  62       1.2 0.7 moveto
  63       0.7 0.7 0.5 0 361 arc
  64       stroke
  65       2.20 0.70 0.50 0 361 arc
  66       stroke
  67       1.45 0.85 0.30 0 180 arc
  68       stroke
  69       0.20 0.70 moveto
  70       0.80 2.00 lineto
  71       0.92 2.26 1.30 2.40 1.15 1.70 curveto
  72       stroke
  73       2.70 0.70 moveto
  74       3.30 2.00 lineto
  75       3.42 2.26 3.80 2.40 3.65 1.70 curveto
  76       stroke"
  77 eyeglasses =  \markup { \with-dimensions #'(0 . 4.4) #'(0 . 2.5) \postscript #eyeglassesps }""",
  78
  79   "tuplet-note-wrapper": """      % a formatter function, which is simply a wrapper around an existing
  80       % tuplet formatter function. It takes the value returned by the given
  81       % function and appends a note of given length.
  82   #(define-public ((tuplet-number::append-note-wrapper function note) grob)
  83     (let* ((txt (if function (function grob) #f)))
  84       (if txt
  85         (markup txt #:fontsize -5 #:note note UP)
  86         (markup #:fontsize -5 #:note note UP)
  87       )
  88     )
  89   )""",
  90
  91   "tuplet-non-default-denominator": """#(define ((tuplet-number::non-default-tuplet-denominator-text denominator) grob)
  92   (number->string (if denominator
  93                       denominator
  94                       (ly:event-property (event-cause grob) 'denominator))))
  95 """,
  96
  97   "tuplet-non-default-fraction": """#(define ((tuplet-number::non-default-tuplet-fraction-text denominator numerator) grob)
  98     (let* ((ev (event-cause grob))
  99            (den (if denominator denominator (ly:event-property ev 'denominator)))
 100            (num (if numerator numerator (ly:event-property ev 'numerator))))
 101        (format "~a:~a" den num)))
 102 """
 103
 104 }
 105
 106 def round_to_two_digits (val):
 107     return round (val * 100) / 100
 108
 109 def extract_paper_information (tree):
 110     paper = musicexp.Paper ()
 111     defaults = tree.get_maybe_exist_named_child ('defaults')
 112     if not defaults:
 113         return None
 114     tenths = -1
 115     scaling = defaults.get_maybe_exist_named_child ('scaling')
 116     if scaling:
 117         mm = scaling.get_named_child ('millimeters')
 118         mm = string.atof (mm.get_text ())
 119         tn = scaling.get_maybe_exist_named_child ('tenths')
 120         tn = string.atof (tn.get_text ())
 121         tenths = mm / tn
 122         paper.global_staff_size = mm * 72.27 / 25.4
 123     # We need the scaling (i.e. the size of staff tenths for everything!
 124     if tenths < 0:
 125         return None
 126
 127     def from_tenths (txt):
 128         return round_to_two_digits (string.atof (txt) * tenths / 10)
 129     def set_paper_variable (varname, parent, element_name):
 130         el = parent.get_maybe_exist_named_child (element_name)
 131         if el: # Convert to cm from tenths
 132             setattr (paper, varname, from_tenths (el.get_text ()))
 133
 134     pagelayout = defaults.get_maybe_exist_named_child ('page-layout')
 135     if pagelayout:
 136         # TODO: How can one have different margins for even and odd pages???
 137         set_paper_variable ("page_height", pagelayout, 'page-height')
 138         set_paper_variable ("page_width", pagelayout, 'page-width')
 139
 140         pmargins = pagelayout.get_named_children ('page-margins')
 141         for pm in pmargins:
 142             set_paper_variable ("left_margin", pm, 'left-margin')
 143             set_paper_variable ("right_margin", pm, 'right-margin')
 144             set_paper_variable ("bottom_margin", pm, 'bottom-margin')
 145             set_paper_variable ("top_margin", pm, 'top-margin')
 146
 147     systemlayout = defaults.get_maybe_exist_named_child ('system-layout')
 148     if systemlayout:
 149         sl = systemlayout.get_maybe_exist_named_child ('system-margins')
 150         if sl:
 151             set_paper_variable ("system_left_margin", sl, 'left-margin')
 152             set_paper_variable ("system_right_margin", sl, 'right-margin')
 153         set_paper_variable ("system_distance", systemlayout, 'system-distance')
 154         set_paper_variable ("top_system_distance", systemlayout, 'top-system-distance')
 155
 156     stafflayout = defaults.get_named_children ('staff-layout')
 157     for sl in stafflayout:
 158         nr = getattr (sl, 'number', 1)
 159         dist = sl.get_named_child ('staff-distance')
 160         #TODO: the staff distance needs to be set in the Staff context!!!
 161
 162     # TODO: Finish appearance?, music-font?, word-font?, lyric-font*, lyric-language*
 163     appearance = defaults.get_named_child ('appearance')
 164     if appearance:
 165         lws = appearance.get_named_children ('line-width')
 166         for lw in lws:
 167             # Possible types are: beam, bracket, dashes,
 168             #    enclosure, ending, extend, heavy barline, leger,
 169             #    light barline, octave shift, pedal, slur middle, slur tip,
 170             #    staff, stem, tie middle, tie tip, tuplet bracket, and wedge
 171             tp = lw.type
 172             w = from_tenths (lw.get_text  ())
 173             # TODO: Do something with these values!
 174         nss = appearance.get_named_children ('note-size')
 175         for ns in nss:
 176             # Possible types are: cue, grace and large
 177             tp = ns.type
 178             sz = from_tenths (ns.get_text ())
 179             # TODO: Do something with these values!
 180         # <other-appearance> elements have no specified meaning
 181
 182     rawmusicfont = defaults.get_named_child ('music-font')
 183     if rawmusicfont:
 184         # TODO: Convert the font
 185         pass
 186     rawwordfont = defaults.get_named_child ('word-font')
 187     if rawwordfont:
 188         # TODO: Convert the font
 189         pass
 190     rawlyricsfonts = defaults.get_named_children ('lyric-font')
 191     for lyricsfont in rawlyricsfonts:
 192         # TODO: Convert the font
 193         pass
 194
 195     return paper
 196
 197
 198
 199 # score information is contained in the <work>, <identification> or <movement-title> tags
 200 # extract those into a hash, indexed by proper lilypond header attributes
 201 def extract_score_information (tree):
 202     header = musicexp.Header ()
 203     def set_if_exists (field, value):
 204         if value:
 205             header.set_field (field, musicxml.escape_ly_output_string (value))
 206
 207     work = tree.get_maybe_exist_named_child ('work')
 208     if work:
 209         set_if_exists ('title', work.get_work_title ())
 210         set_if_exists ('worknumber', work.get_work_number ())
 211         set_if_exists ('opus', work.get_opus ())
 212     else:
 213         movement_title = tree.get_maybe_exist_named_child ('movement-title')
 214         if movement_title:
 215             set_if_exists ('title', movement_title.get_text ())
 216
 217     identifications = tree.get_named_children ('identification')
 218     for ids in identifications:
 219         set_if_exists ('copyright', ids.get_rights ())
 220         set_if_exists ('composer', ids.get_composer ())
 221         set_if_exists ('arranger', ids.get_arranger ())
 222         set_if_exists ('editor', ids.get_editor ())
 223         set_if_exists ('poet', ids.get_poet ())
 224
 225         set_if_exists ('tagline', ids.get_encoding_software ())
 226         set_if_exists ('encodingsoftware', ids.get_encoding_software ())
 227         set_if_exists ('encodingdate', ids.get_encoding_date ())
 228         set_if_exists ('encoder', ids.get_encoding_person ())
 229         set_if_exists ('encodingdescription', ids.get_encoding_description ())
 230
 231         set_if_exists ('texidoc', ids.get_file_description ());
 232
 233         # Finally, apply the required compatibility modes
 234         # Some applications created wrong MusicXML files, so we need to
 235         # apply some compatibility mode, e.g. ignoring some features/tags
 236         # in those files
 237         software = ids.get_encoding_software_list ()
 238
 239         # Case 1: "Sibelius 5.1" with the "Dolet 3.4 for Sibelius" plugin
 240         #         is missing all beam ends => ignore all beaming information
 241         if "Dolet 3.4 for Sibelius" in software:
 242             conversion_settings.ignore_beaming = True
 243             progress (_ ("Encountered file created by Dolet 3.4 for Sibelius, containing wrong beaming information. All beaming information in the MusicXML file will be ignored"))
 244         if "Noteworthy Composer" in software:
 245             conversion_settings.ignore_beaming = True
 246             progress (_ ("Encountered file created by Noteworthy Composer's nwc2xml, containing wrong beaming information. All beaming information in the MusicXML file will be ignored"))
 247         # TODO: Check for other unsupported features
 248
 249     return header
 250
 251 class PartGroupInfo:
 252     def __init__ (self):
 253         self.start = {}
 254         self.end = {}
 255     def is_empty (self):
 256         return len (self.start) + len (self.end) == 0
 257     def add_start (self, g):
 258         self.start[getattr (g, 'number', "1")] = g
 259     def add_end (self, g):
 260         self.end[getattr (g, 'number', "1")] = g
 261     def print_ly (self, printer):
 262         error_message (_ ("Unprocessed PartGroupInfo %s encountered") % self)
 263     def ly_expression (self):
 264         error_message (_ ("Unprocessed PartGroupInfo %s encountered") % self)
 265         return ''
 266
 267 def staff_attributes_to_string_tunings (mxl_attr):
 268     details = mxl_attr.get_maybe_exist_named_child ('staff-details')
 269     if not details:
 270         return []
 271     lines = 6
 272     staff_lines = details.get_maybe_exist_named_child ('staff-lines')
 273     if staff_lines:
 274         lines = string.atoi (staff_lines.get_text ())
 275
 276     tunings = [0]*lines
 277     staff_tunings = details.get_named_children ('staff-tuning')
 278     for i in staff_tunings:
 279         p = musicexp.Pitch()
 280         line = 0
 281         try:
 282             line = string.atoi (i.line) - 1
 283         except ValueError:
 284             pass
 285         tunings[line] = p
 286
 287         step = i.get_named_child (u'tuning-step')
 288         step = step.get_text ().strip ()
 289         p.step = musicxml_step_to_lily (step)
 290
 291         octave = i.get_named_child (u'tuning-octave')
 292         octave = octave.get_text ().strip ()
 293         p.octave = int (octave) - 4
 294
 295         alter = i.get_named_child (u'tuning-alter')
 296         if alter:
 297             p.alteration = int (alter.get_text ().strip ())
 298     # lilypond seems to use the opposite ordering than MusicXML...
 299     tunings.reverse ()
 300
 301     return tunings
 302
 303
 304 def staff_attributes_to_lily_staff (mxl_attr):
 305     if not mxl_attr:
 306         return musicexp.Staff ()
 307
 308     (staff_id, attributes) = mxl_attr.items ()[0]
 309
 310     # distinguish by clef:
 311     # percussion (percussion and rhythmic), tab, and everything else
 312     clef_sign = None
 313     clef = attributes.get_maybe_exist_named_child ('clef')
 314     if clef:
 315         sign = clef.get_maybe_exist_named_child ('sign')
 316         if sign:
 317             clef_sign = {"percussion": "percussion", "TAB": "tab"}.get (sign.get_text (), None)
 318
 319     lines = 5
 320     details = attributes.get_named_children ('staff-details')
 321     for d in details:
 322         staff_lines = d.get_maybe_exist_named_child ('staff-lines')
 323         if staff_lines:
 324             lines = string.atoi (staff_lines.get_text ())
 325
 326     staff = None
 327     if clef_sign == "percussion" and lines == 1:
 328         staff = musicexp.RhythmicStaff ()
 329     elif clef_sign == "percussion":
 330         staff = musicexp.DrumStaff ()
 331         # staff.drum_style_table = ???
 332     elif clef_sign == "tab":
 333         staff = musicexp.TabStaff ()
 334         staff.string_tunings = staff_attributes_to_string_tunings (attributes)
 335         # staff.tablature_format = ???
 336     else:
 337         # TODO: Handle case with lines <> 5!
 338         staff = musicexp.Staff ()
 339
 340     return staff
 341
 342
 343 def extract_score_structure (part_list, staffinfo):
 344     score = musicexp.Score ()
 345     structure = musicexp.StaffGroup (None)
 346     score.set_contents (structure)
 347
 348     if not part_list:
 349         return structure
 350
 351     def read_score_part (el):
 352         if not isinstance (el, musicxml.Score_part):
 353             return
 354         # Depending on the attributes of the first measure, we create different
 355         # types of staves (Staff, RhythmicStaff, DrumStaff, TabStaff, etc.)
 356         staff = staff_attributes_to_lily_staff (staffinfo.get (el.id, None))
 357         if not staff:
 358             return None
 359         staff.id = el.id
 360         partname = el.get_maybe_exist_named_child ('part-name')
 361         # Finale gives unnamed parts the name "MusicXML Part" automatically!
 362         if partname and partname.get_text() != "MusicXML Part":
 363             staff.instrument_name = partname.get_text ()
 364         if el.get_maybe_exist_named_child ('part-abbreviation'):
 365             staff.short_instrument_name = el.get_maybe_exist_named_child ('part-abbreviation').get_text ()
 366         # TODO: Read in the MIDI device / instrument
 367         return staff
 368
 369     def read_score_group (el):
 370         if not isinstance (el, musicxml.Part_group):
 371             return
 372         group = musicexp.StaffGroup ()
 373         if hasattr (el, 'number'):
 374             id = el.number
 375             group.id = id
 376             #currentgroups_dict[id] = group
 377             #currentgroups.append (id)
 378         if el.get_maybe_exist_named_child ('group-name'):
 379             group.instrument_name = el.get_maybe_exist_named_child ('group-name').get_text ()
 380         if el.get_maybe_exist_named_child ('group-abbreviation'):
 381             group.short_instrument_name = el.get_maybe_exist_named_child ('group-abbreviation').get_text ()
 382         if el.get_maybe_exist_named_child ('group-symbol'):
 383             group.symbol = el.get_maybe_exist_named_child ('group-symbol').get_text ()
 384         if el.get_maybe_exist_named_child ('group-barline'):
 385             group.spanbar = el.get_maybe_exist_named_child ('group-barline').get_text ()
 386         return group
 387
 388
 389     parts_groups = part_list.get_all_children ()
 390
 391     # the start/end group tags are not necessarily ordered correctly and groups
 392     # might even overlap, so we can't go through the children sequentially!
 393
 394     # 1) Replace all Score_part objects by their corresponding Staff objects,
 395     #    also collect all group start/stop points into one PartGroupInfo object
 396     staves = []
 397     group_info = PartGroupInfo ()
 398     for el in parts_groups:
 399         if isinstance (el, musicxml.Score_part):
 400             if not group_info.is_empty ():
 401                 staves.append (group_info)
 402                 group_info = PartGroupInfo ()
 403             staff = read_score_part (el)
 404             if staff:
 405                 staves.append (staff)
 406         elif isinstance (el, musicxml.Part_group):
 407             if el.type == "start":
 408                 group_info.add_start (el)
 409             elif el.type == "stop":
 410                 group_info.add_end (el)
 411     if not group_info.is_empty ():
 412         staves.append (group_info)
 413
 414     # 2) Now, detect the groups:
 415     group_starts = []
 416     pos = 0
 417     while pos < len (staves):
 418         el = staves[pos]
 419         if isinstance (el, PartGroupInfo):
 420             prev_start = 0
 421             if len (group_starts) > 0:
 422                 prev_start = group_starts[-1]
 423             elif len (el.end) > 0: # no group to end here
 424                 el.end = {}
 425             if len (el.end) > 0: # closes an existing group
 426                 ends = el.end.keys ()
 427                 prev_started = staves[prev_start].start.keys ()
 428                 grpid = None
 429                 intersection = filter(lambda x:x in ends, prev_started)
 430                 if len (intersection) > 0:
 431                     grpid = intersection[0]
 432                 else:
 433                     # Close the last started group
 434                     grpid = staves[prev_start].start.keys () [0]
 435                     # Find the corresponding closing tag and remove it!
 436                     j = pos + 1
 437                     foundclosing = False
 438                     while j < len (staves) and not foundclosing:
 439                         if isinstance (staves[j], PartGroupInfo) and staves[j].end.has_key (grpid):
 440                             foundclosing = True
 441                             del staves[j].end[grpid]
 442                             if staves[j].is_empty ():
 443                                 del staves[j]
 444                         j += 1
 445                 grpobj = staves[prev_start].start[grpid]
 446                 group = read_score_group (grpobj)
 447                 # remove the id from both the start and end
 448                 if el.end.has_key (grpid):
 449                     del el.end[grpid]
 450                 del staves[prev_start].start[grpid]
 451                 if el.is_empty ():
 452                     del staves[pos]
 453                 # replace the staves with the whole group
 454                 for j in staves[(prev_start + 1):pos]:
 455                     group.append_staff (j)
 456                 del staves[(prev_start + 1):pos]
 457                 staves.insert (prev_start + 1, group)
 458                 # reset pos so that we continue at the correct position
 459                 pos = prev_start
 460                 # remove an empty start group
 461                 if staves[prev_start].is_empty ():
 462                     del staves[prev_start]
 463                     group_starts.remove (prev_start)
 464                     pos -= 1
 465             elif len (el.start) > 0: # starts new part groups
 466                 group_starts.append (pos)
 467         pos += 1
 468
 469     if len (staves) == 1:
 470         return staves[0]
 471     for i in staves:
 472         structure.append_staff (i)
 473     return score
 474
 475
 476 def musicxml_duration_to_lily (mxl_note):
 477     # if the note has no Type child, then that method returns None. In that case,
 478     # use the <duration> tag instead. If that doesn't exist, either -> Error
 479     dur = mxl_note.get_duration_info ()
 480     if dur:
 481         d = musicexp.Duration ()
 482         d.duration_log = dur[0]
 483         d.dots = dur[1]
 484         # Grace notes by specification have duration 0, so no time modification
 485         # factor is possible. It even messes up the output with *0/1
 486         if not mxl_note.get_maybe_exist_typed_child (musicxml.Grace):
 487             d.factor = mxl_note._duration / d.get_length ()
 488         return d
 489
 490     else:
 491         if mxl_note._duration > 0:
 492             return rational_to_lily_duration (mxl_note._duration)
 493         else:
 494             mxl_note.message (_ ("Encountered note at %s without type and duration (=%s)") % (mxl_note.start, mxl_note._duration) )
 495             return None
 496
 497
 498 def rational_to_lily_duration (rational_len):
 499     d = musicexp.Duration ()
 500
 501     rational_len.normalize_self ()
 502     d_log = {1: 0, 2: 1, 4:2, 8:3, 16:4, 32:5, 64:6, 128:7, 256:8, 512:9}.get (rational_len.denominator (), -1)
 503
 504     # Duration of the form 1/2^n or 3/2^n can be converted to a simple lilypond duration
 505     if (d_log >= 0 and rational_len.numerator() in (1,3,5,7) ):
 506         # account for the dots!
 507         d.dots = (rational_len.numerator()-1)/2
 508         d.duration_log = d_log - d.dots
 509     elif (d_log >= 0):
 510         d.duration_log = d_log
 511         d.factor = Rational (rational_len.numerator ())
 512     else:
 513         error_message (_ ("Encountered rational duration with denominator %s, "
 514                        "unable to convert to lilypond duration") %
 515                        rational_len.denominator ())
 516         # TODO: Test the above error message
 517         return None
 518
 519     return d
 520
 521 def musicxml_partial_to_lily (partial_len):
 522     if partial_len > 0:
 523         p = musicexp.Partial ()
 524         p.partial = rational_to_lily_duration (partial_len)
 525         return p
 526     else:
 527         return Null
 528
 529 # Detect repeats and alternative endings in the chord event list (music_list)
 530 # and convert them to the corresponding musicexp objects, containing nested
 531 # music
 532 def group_repeats (music_list):
 533     repeat_replaced = True
 534     music_start = 0
 535     i = 0
 536     # Walk through the list of expressions, looking for repeat structure
 537     # (repeat start/end, corresponding endings). If we find one, try to find the
 538     # last event of the repeat, replace the whole structure and start over again.
 539     # For nested repeats, as soon as we encounter another starting repeat bar,
 540     # treat that one first, and start over for the outer repeat.
 541     while repeat_replaced and i < 100:
 542         i += 1
 543         repeat_start = -1  # position of repeat start / end
 544         repeat_end = -1 # position of repeat start / end
 545         repeat_times = 0
 546         ending_start = -1 # position of current ending start
 547         endings = [] # list of already finished endings
 548         pos = 0
 549         last = len (music_list) - 1
 550         repeat_replaced = False
 551         final_marker = 0
 552         while pos < len (music_list) and not repeat_replaced:
 553             e = music_list[pos]
 554             repeat_finished = False
 555             if isinstance (e, RepeatMarker):
 556                 if not repeat_times and e.times:
 557                     repeat_times = e.times
 558                 if e.direction == -1:
 559                     if repeat_end >= 0:
 560                         repeat_finished = True
 561                     else:
 562                         repeat_start = pos
 563                         repeat_end = -1
 564                         ending_start = -1
 565                         endings = []
 566                 elif e.direction == 1:
 567                     if repeat_start < 0:
 568                         repeat_start = 0
 569                     if repeat_end < 0:
 570                         repeat_end = pos
 571                     final_marker = pos
 572             elif isinstance (e, EndingMarker):
 573                 if e.direction == -1:
 574                     if repeat_start < 0:
 575                         repeat_start = 0
 576                     if repeat_end < 0:
 577                         repeat_end = pos
 578                     ending_start = pos
 579                 elif e.direction == 1:
 580                     if ending_start < 0:
 581                         ending_start = 0
 582                     endings.append ([ending_start, pos])
 583                     ending_start = -1
 584                     final_marker = pos
 585             elif not isinstance (e, musicexp.BarLine):
 586                 # As soon as we encounter an element when repeat start and end
 587                 # is set and we are not inside an alternative ending,
 588                 # this whole repeat structure is finished => replace it
 589                 if repeat_start >= 0 and repeat_end > 0 and ending_start < 0:
 590                     repeat_finished = True
 591
 592             # Finish off all repeats without explicit ending bar (e.g. when
 593             # we convert only one page of a multi-page score with repeats)
 594             if pos == last and repeat_start >= 0:
 595                 repeat_finished = True
 596                 final_marker = pos
 597                 if repeat_end < 0:
 598                     repeat_end = pos
 599                 if ending_start >= 0:
 600                     endings.append ([ending_start, pos])
 601                     ending_start = -1
 602
 603             if repeat_finished:
 604                 # We found the whole structure replace it!
 605                 r = musicexp.RepeatedMusic ()
 606                 if repeat_times <= 0:
 607                     repeat_times = 2
 608                 r.repeat_count = repeat_times
 609                 # don't erase the first element for "implicit" repeats (i.e. no
 610                 # starting repeat bars at the very beginning)
 611                 start = repeat_start+1
 612                 if repeat_start == music_start:
 613                     start = music_start
 614                 r.set_music (music_list[start:repeat_end])
 615                 for (start, end) in endings:
 616                     s = musicexp.SequentialMusic ()
 617                     s.elements = music_list[start+1:end]
 618                     r.add_ending (s)
 619                 del music_list[repeat_start:final_marker+1]
 620                 music_list.insert (repeat_start, r)
 621                 repeat_replaced = True
 622             pos += 1
 623         # TODO: Implement repeats until the end without explicit ending bar
 624     return music_list
 625
 626
 627 # Extract the settings for tuplets from the <notations><tuplet> and the
 628 # <time-modification> elements of the note:
 629 def musicxml_tuplet_to_lily (tuplet_elt, time_modification):
 630     tsm = musicexp.TimeScaledMusic ()
 631     fraction = (1,1)
 632     if time_modification:
 633         fraction = time_modification.get_fraction ()
 634     tsm.numerator = fraction[0]
 635     tsm.denominator  = fraction[1]
 636
 637
 638     normal_type = tuplet_elt.get_normal_type ()
 639     if not normal_type and time_modification:
 640         normal_type = time_modification.get_normal_type ()
 641     if not normal_type and time_modification:
 642         note = time_modification.get_parent ()
 643         if note:
 644             normal_type = note.get_duration_info ()
 645     if normal_type:
 646         normal_note = musicexp.Duration ()
 647         (normal_note.duration_log, normal_note.dots) = normal_type
 648         tsm.normal_type = normal_note
 649
 650     actual_type = tuplet_elt.get_actual_type ()
 651     if actual_type:
 652         actual_note = musicexp.Duration ()
 653         (actual_note.duration_log, actual_note.dots) = normal_type
 654         tsm.actual_type = actual_note
 655
 656     # Obtain non-default nrs of notes from the tuplet object!
 657     tsm.display_numerator = tuplet_elt.get_normal_nr ()
 658     tsm.display_denominator = tuplet_elt.get_actual_nr ()
 659
 660
 661     if hasattr (tuplet_elt, 'bracket') and tuplet_elt.bracket == "no":
 662         tsm.display_bracket = None
 663     elif hasattr (tuplet_elt, 'line-shape') and getattr (tuplet_elt, 'line-shape') == "curved":
 664         tsm.display_bracket = "curved"
 665     else:
 666         tsm.display_bracket = "bracket"
 667
 668     display_values = {"none": None, "actual": "actual", "both": "both"}
 669     if hasattr (tuplet_elt, "show-number"):
 670         tsm.display_number = display_values.get (getattr (tuplet_elt, "show-number"), "actual")
 671     if tsm.display_number == "actual" and tsm.display_denominator:
 672         needed_additional_definitions.append ("tuplet-non-default-denominator")
 673     elif tsm.display_number == "both" and (tsm.display_numerator or tsm.display_denominator):
 674         needed_additional_definitions.append ("tuplet-non-default-fraction")
 675
 676     if hasattr (tuplet_elt, "show-type"):
 677         if getattr (tuplet_elt, "show-type") == "actual":
 678             needed_additional_definitions.append ("tuplet-note-wrapper")
 679         tsm.display_type = display_values.get (getattr (tuplet_elt, "show-type"), None)
 680
 681     return tsm
 682
 683
 684 def group_tuplets (music_list, events):
 685
 686
 687     """Collect Musics from
 688     MUSIC_LIST demarcated by EVENTS_LIST in TimeScaledMusic objects.
 689     """
 690
 691
 692     indices = []
 693     brackets = {}
 694
 695     j = 0
 696     for (ev_chord, tuplet_elt, time_modification) in events:
 697         while (j < len (music_list)):
 698             if music_list[j] == ev_chord:
 699                 break
 700             j += 1
 701         nr = 0
 702         if hasattr (tuplet_elt, 'number'):
 703             nr = getattr (tuplet_elt, 'number')
 704         if tuplet_elt.type == 'start':
 705             tuplet_object = musicxml_tuplet_to_lily (tuplet_elt, time_modification)
 706             tuplet_info = [j, None, tuplet_object]
 707             indices.append (tuplet_info)
 708             brackets[nr] = tuplet_info
 709         elif tuplet_elt.type == 'stop':
 710             bracket_info = brackets.get (nr, None)
 711             if bracket_info:
 712                 bracket_info[1] = j # Set the ending position to j
 713                 del brackets[nr]
 714
 715     new_list = []
 716     last = 0
 717     for (i1, i2, tsm) in indices:
 718         if i1 > i2:
 719             continue
 720
 721         new_list.extend (music_list[last:i1])
 722         seq = musicexp.SequentialMusic ()
 723         last = i2 + 1
 724         seq.elements = music_list[i1:last]
 725
 726         tsm.element = seq
 727
 728         new_list.append (tsm)
 729
 730     new_list.extend (music_list[last:])
 731     return new_list
 732
 733
 734 def musicxml_clef_to_lily (attributes):
 735     change = musicexp.ClefChange ()
 736     (change.type, change.position, change.octave) = attributes.get_clef_information ()
 737     return change
 738
 739 def musicxml_time_to_lily (attributes):
 740     (beats, type) = attributes.get_time_signature ()
 741
 742     change = musicexp.TimeSignatureChange()
 743     change.fraction = (beats, type)
 744
 745     return change
 746
 747 def musicxml_key_to_lily (attributes):
 748     start_pitch  = musicexp.Pitch ()
 749     (fifths, mode) = attributes.get_key_signature ()
 750     try:
 751         (n,a) = {
 752             'major'     : (0,0),
 753             'minor'     : (5,0),
 754             'ionian'    : (0,0),
 755             'dorian'    : (1,0),
 756             'phrygian'  : (2,0),
 757             'lydian'    : (3,0),
 758             'mixolydian': (4,0),
 759             'aeolian'   : (5,0),
 760             'locrian'   : (6,0),
 761             }[mode]
 762         start_pitch.step = n
 763         start_pitch.alteration = a
 764     except  KeyError:
 765         error_message (_ ("unknown mode %s, expecting 'major' or 'minor'") % mode)
 766
 767     fifth = musicexp.Pitch()
 768     fifth.step = 4
 769     if fifths < 0:
 770         fifths *= -1
 771         fifth.step *= -1
 772         fifth.normalize ()
 773
 774     for x in range (fifths):
 775         start_pitch = start_pitch.transposed (fifth)
 776
 777     start_pitch.octave = 0
 778
 779     change = musicexp.KeySignatureChange()
 780     change.mode = mode
 781     change.tonic = start_pitch
 782     return change
 783
 784 def musicxml_transpose_to_lily (attributes):
 785     transpose = attributes.get_transposition ()
 786     if not transpose:
 787         return None
 788
 789     shift = musicexp.Pitch ()
 790     octave_change = transpose.get_maybe_exist_named_child ('octave-change')
 791     if octave_change:
 792         shift.octave = string.atoi (octave_change.get_text ())
 793     chromatic_shift = string.atoi (transpose.get_named_child ('chromatic').get_text ())
 794     chromatic_shift_normalized = chromatic_shift % 12;
 795     (shift.step, shift.alteration) = [
 796         (0,0), (0,1), (1,0), (2,-1), (2,0),
 797         (3,0), (3,1), (4,0), (5,-1), (5,0),
 798         (6,-1), (6,0)][chromatic_shift_normalized];
 799
 800     shift.octave += (chromatic_shift - chromatic_shift_normalized) / 12
 801
 802     diatonic = transpose.get_maybe_exist_named_child ('diatonic')
 803     if diatonic:
 804         diatonic_step = string.atoi (diatonic.get_text ()) % 7
 805         if diatonic_step != shift.step:
 806             # We got the alter incorrect!
 807             old_semitones = shift.semitones ()
 808             shift.step = diatonic_step
 809             new_semitones = shift.semitones ()
 810             shift.alteration += old_semitones - new_semitones
 811
 812     transposition = musicexp.Transposition ()
 813     transposition.pitch = musicexp.Pitch ().transposed (shift)
 814     return transposition
 815
 816
 817 def musicxml_attributes_to_lily (attrs):
 818     elts = []
 819     attr_dispatch =  {
 820         'clef': musicxml_clef_to_lily,
 821         'time': musicxml_time_to_lily,
 822         'key': musicxml_key_to_lily,
 823         'transpose': musicxml_transpose_to_lily,
 824     }
 825     for (k, func) in attr_dispatch.items ():
 826         children = attrs.get_named_children (k)
 827         if children:
 828             elts.append (func (attrs))
 829
 830     return elts
 831
 832 class Marker (musicexp.Music):
 833     def __init__ (self):
 834         self.direction = 0
 835         self.event = None
 836     def print_ly (self, printer):
 837         ly.stderr_write (_ ("Encountered unprocessed marker %s\n") % self)
 838         pass
 839     def ly_expression (self):
 840         return ""
 841 class RepeatMarker (Marker):
 842     def __init__ (self):
 843         Marker.__init__ (self)
 844         self.times = 0
 845 class EndingMarker (Marker):
 846     pass
 847
 848 # Convert the <barline> element to musicxml.BarLine (for non-standard barlines)
 849 # and to RepeatMarker and EndingMarker objects for repeat and
 850 # alternatives start/stops
 851 def musicxml_barline_to_lily (barline):
 852     # retval contains all possible markers in the order:
 853     # 0..bw_ending, 1..bw_repeat, 2..barline, 3..fw_repeat, 4..fw_ending
 854     retval = {}
 855     bartype_element = barline.get_maybe_exist_named_child ("bar-style")
 856     repeat_element = barline.get_maybe_exist_named_child ("repeat")
 857     ending_element = barline.get_maybe_exist_named_child ("ending")
 858
 859     bartype = None
 860     if bartype_element:
 861         bartype = bartype_element.get_text ()
 862
 863     if repeat_element and hasattr (repeat_element, 'direction'):
 864         repeat = RepeatMarker ()
 865         repeat.direction = {"forward": -1, "backward": 1}.get (repeat_element.direction, 0)
 866
 867         if ( (repeat_element.direction == "forward" and bartype == "heavy-light") or
 868              (repeat_element.direction == "backward" and bartype == "light-heavy") ):
 869             bartype = None
 870         if hasattr (repeat_element, 'times'):
 871             try:
 872                 repeat.times = int (repeat_element.times)
 873             except ValueError:
 874                 repeat.times = 2
 875         repeat.event = barline
 876         if repeat.direction == -1:
 877             retval[3] = repeat
 878         else:
 879             retval[1] = repeat
 880
 881     if ending_element and hasattr (ending_element, 'type'):
 882         ending = EndingMarker ()
 883         ending.direction = {"start": -1, "stop": 1, "discontinue": 1}.get (ending_element.type, 0)
 884         ending.event = barline
 885         if ending.direction == -1:
 886             retval[4] = ending
 887         else:
 888             retval[0] = ending
 889
 890     if bartype:
 891         b = musicexp.BarLine ()
 892         b.type = bartype
 893         retval[2] = b
 894
 895     return retval.values ()
 896
 897 spanner_event_dict = {
 898     'beam' : musicexp.BeamEvent,
 899     'dashes' : musicexp.TextSpannerEvent,
 900     'bracket' : musicexp.BracketSpannerEvent,
 901     'glissando' : musicexp.GlissandoEvent,
 902     'octave-shift' : musicexp.OctaveShiftEvent,
 903     'pedal' : musicexp.PedalEvent,
 904     'slide' : musicexp.GlissandoEvent,
 905     'slur' : musicexp.SlurEvent,
 906     'wavy-line' : musicexp.TrillSpanEvent,
 907     'wedge' : musicexp.HairpinEvent
 908 }
 909 spanner_type_dict = {
 910     'start': -1,
 911     'begin': -1,
 912     'crescendo': -1,
 913     'decreschendo': -1,
 914     'diminuendo': -1,
 915     'continue': 0,
 916     'change': 0,
 917     'up': -1,
 918     'down': -1,
 919     'stop': 1,
 920     'end' : 1
 921 }
 922
 923 def musicxml_spanner_to_lily_event (mxl_event):
 924     ev = None
 925
 926     name = mxl_event.get_name()
 927     func = spanner_event_dict.get (name)
 928     if func:
 929         ev = func()
 930     else:
 931         error_message (_ ('unknown span event %s') % mxl_event)
 932
 933
 934     type = mxl_event.get_type ()
 935     span_direction = spanner_type_dict.get (type)
 936     # really check for None, because some types will be translated to 0, which
 937     # would otherwise also lead to the unknown span warning
 938     if span_direction != None:
 939         ev.span_direction = span_direction
 940     else:
 941         error_message (_ ('unknown span type %s for %s') % (type, name))
 942
 943     ev.set_span_type (type)
 944     ev.line_type = getattr (mxl_event, 'line-type', 'solid')
 945
 946     # assign the size, which is used for octave-shift, etc.
 947     ev.size = mxl_event.get_size ()
 948
 949     return ev
 950
 951 def musicxml_direction_to_indicator (direction):
 952     return { "above": 1, "upright": 1, "up": 1, "below": -1, "downright": -1, "down": -1, "inverted": -1 }.get (direction, 0)
 953
 954 def musicxml_fermata_to_lily_event (mxl_event):
 955     ev = musicexp.ArticulationEvent ()
 956     txt = mxl_event.get_text ()
 957     # The contents of the element defined the shape, possible are normal, angled and square
 958     ev.type = { "angled": "shortfermata", "square": "longfermata" }.get (txt, "fermata")
 959     if hasattr (mxl_event, 'type'):
 960       dir = musicxml_direction_to_indicator (mxl_event.type)
 961       if dir and options.convert_directions:
 962         ev.force_direction = dir
 963     return ev
 964
 965 def musicxml_arpeggiate_to_lily_event (mxl_event):
 966     ev = musicexp.ArpeggioEvent ()
 967     ev.direction = musicxml_direction_to_indicator (getattr (mxl_event, 'direction', None))
 968     return ev
 969
 970 def musicxml_nonarpeggiate_to_lily_event (mxl_event):
 971     ev = musicexp.ArpeggioEvent ()
 972     ev.non_arpeggiate = True
 973     ev.direction = musicxml_direction_to_indicator (getattr (mxl_event, 'direction', None))
 974     return ev
 975
 976 def musicxml_tremolo_to_lily_event (mxl_event):
 977     ev = musicexp.TremoloEvent ()
 978     txt = mxl_event.get_text ()
 979     if txt:
 980       ev.bars = txt
 981     else:
 982       ev.bars = "3"
 983     return ev
 984
 985 def musicxml_falloff_to_lily_event (mxl_event):
 986     ev = musicexp.BendEvent ()
 987     ev.alter = -4
 988     return ev
 989
 990 def musicxml_doit_to_lily_event (mxl_event):
 991     ev = musicexp.BendEvent ()
 992     ev.alter = 4
 993     return ev
 994
 995 def musicxml_bend_to_lily_event (mxl_event):
 996     ev = musicexp.BendEvent ()
 997     ev.alter = mxl_event.bend_alter ()
 998     return ev
 999
1000 def musicxml_caesura_to_lily_event (mxl_event):
1001     ev = musicexp.MarkupEvent ()
1002     # FIXME: default to straight or curved caesura?
1003     ev.contents = "\\musicglyph #\"scripts.caesura.straight\""
1004     ev.force_direction = 1
1005     return ev
1006
1007 def musicxml_fingering_event (mxl_event):
1008     ev = musicexp.ShortArticulationEvent ()
1009     ev.type = mxl_event.get_text ()
1010     return ev
1011
1012 def musicxml_snappizzicato_event (mxl_event):
1013     needed_additional_definitions.append ("snappizzicato")
1014     ev = musicexp.MarkupEvent ()
1015     ev.contents = "\\snappizzicato"
1016     return ev
1017
1018 def musicxml_string_event (mxl_event):
1019     ev = musicexp.NoDirectionArticulationEvent ()
1020     ev.type = mxl_event.get_text ()
1021     return ev
1022
1023 def musicxml_accidental_mark (mxl_event):
1024     ev = musicexp.MarkupEvent ()
1025     contents = { "sharp": "\\sharp",
1026       "natural": "\\natural",
1027       "flat": "\\flat",
1028       "double-sharp": "\\doublesharp",
1029       "sharp-sharp": "\\sharp\\sharp",
1030       "flat-flat": "\\flat\\flat",
1031       "flat-flat": "\\doubleflat",
1032       "natural-sharp": "\\natural\\sharp",
1033       "natural-flat": "\\natural\\flat",
1034       "quarter-flat": "\\semiflat",
1035       "quarter-sharp": "\\semisharp",
1036       "three-quarters-flat": "\\sesquiflat",
1037       "three-quarters-sharp": "\\sesquisharp",
1038     }.get (mxl_event.get_text ())
1039     if contents:
1040         ev.contents = contents
1041         return ev
1042     else:
1043         return None
1044
1045 # translate articulations, ornaments and other notations into ArticulationEvents
1046 # possible values:
1047 #   -) string  (ArticulationEvent with that name)
1048 #   -) function (function(mxl_event) needs to return a full ArticulationEvent-derived object
1049 #   -) (class, name)  (like string, only that a different class than ArticulationEvent is used)
1050 # TODO: Some translations are missing!
1051 articulations_dict = {
1052     "accent": (musicexp.ShortArticulationEvent, ">"), # or "accent"
1053     "accidental-mark": musicxml_accidental_mark,
1054     "bend": musicxml_bend_to_lily_event,
1055     "breath-mark": (musicexp.NoDirectionArticulationEvent, "breathe"),
1056     "caesura": musicxml_caesura_to_lily_event,
1057     #"delayed-turn": "?",
1058     "detached-legato": (musicexp.ShortArticulationEvent, "_"), # or "portato"
1059     "doit": musicxml_doit_to_lily_event,
1060     #"double-tongue": "?",
1061     "down-bow": "downbow",
1062     "falloff": musicxml_falloff_to_lily_event,
1063     "fingering": musicxml_fingering_event,
1064     #"fingernails": "?",
1065     #"fret": "?",
1066     #"hammer-on": "?",
1067     "harmonic": "flageolet",
1068     #"heel": "?",
1069     "inverted-mordent": "prall",
1070     "inverted-turn": "reverseturn",
1071     "mordent": "mordent",
1072     "open-string": "open",
1073     #"plop": "?",
1074     #"pluck": "?",
1075     #"pull-off": "?",
1076     #"schleifer": "?",
1077     #"scoop": "?",
1078     #"shake": "?",
1079     "snap-pizzicato": musicxml_snappizzicato_event,
1080     #"spiccato": "?",
1081     "staccatissimo": (musicexp.ShortArticulationEvent, "|"), # or "staccatissimo"
1082     "staccato": (musicexp.ShortArticulationEvent, "."), # or "staccato"
1083     "stopped": (musicexp.ShortArticulationEvent, "+"), # or "stopped"
1084     #"stress": "?",
1085     "string": musicxml_string_event,
1086     "strong-accent": (musicexp.ShortArticulationEvent, "^"), # or "marcato"
1087     #"tap": "?",
1088     "tenuto": (musicexp.ShortArticulationEvent, "-"), # or "tenuto"
1089     "thumb-position": "thumb",
1090     #"toe": "?",
1091     "turn": "turn",
1092     "tremolo": musicxml_tremolo_to_lily_event,
1093     "trill-mark": "trill",
1094     #"triple-tongue": "?",
1095     #"unstress": "?"
1096     "up-bow": "upbow",
1097     #"wavy-line": "?",
1098 }
1099 articulation_spanners = [ "wavy-line" ]
1100
1101 def musicxml_articulation_to_lily_event (mxl_event):
1102     # wavy-line elements are treated as trill spanners, not as articulation ornaments
1103     if mxl_event.get_name () in articulation_spanners:
1104         return musicxml_spanner_to_lily_event (mxl_event)
1105
1106     tmp_tp = articulations_dict.get (mxl_event.get_name ())
1107     if not tmp_tp:
1108         return
1109
1110     if isinstance (tmp_tp, str):
1111         ev = musicexp.ArticulationEvent ()
1112         ev.type = tmp_tp
1113     elif isinstance (tmp_tp, tuple):
1114         ev = tmp_tp[0] ()
1115         ev.type = tmp_tp[1]
1116     else:
1117         ev = tmp_tp (mxl_event)
1118
1119     # Some articulations use the type attribute, other the placement...
1120     dir = None
1121     if hasattr (mxl_event, 'type') and options.convert_directions:
1122         dir = musicxml_direction_to_indicator (mxl_event.type)
1123     if hasattr (mxl_event, 'placement') and options.convert_directions:
1124         dir = musicxml_direction_to_indicator (mxl_event.placement)
1125     if dir:
1126         ev.force_direction = dir
1127     return ev
1128
1129
1130
1131 def musicxml_dynamics_to_lily_event (dynentry):
1132     dynamics_available = (
1133         "ppppp", "pppp", "ppp", "pp", "p", "mp", "mf",
1134         "f", "ff", "fff", "ffff", "fp", "sf", "sff", "sp", "spp", "sfz", "rfz" )
1135     dynamicsname = dynentry.get_name ()
1136     if dynamicsname == "other-dynamics":
1137         dynamicsname = dynentry.get_text ()
1138     if not dynamicsname or dynamicsname=="#text":
1139         return
1140
1141     if not dynamicsname in dynamics_available:
1142         # Get rid of - in tag names (illegal in ly tags!)
1143         dynamicstext = dynamicsname
1144         dynamicsname = string.replace (dynamicsname, "-", "")
1145         additional_definitions[dynamicsname] = dynamicsname + \
1146               " = #(make-dynamic-script \"" + dynamicstext + "\")"
1147         needed_additional_definitions.append (dynamicsname)
1148     event = musicexp.DynamicsEvent ()
1149     event.type = dynamicsname
1150     return event
1151
1152 # Convert single-color two-byte strings to numbers 0.0 - 1.0
1153 def hexcolorval_to_nr (hex_val):
1154     try:
1155         v = int (hex_val, 16)
1156         if v == 255:
1157             v = 256
1158         return v / 256.
1159     except ValueError:
1160         return 0.
1161
1162 def hex_to_color (hex_val):
1163     res = re.match (r'#([0-9a-f][0-9a-f]|)([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])$', hex_val, re.IGNORECASE)
1164     if res:
1165         return map (lambda x: hexcolorval_to_nr (x), res.group (2,3,4))
1166     else:
1167         return None
1168
1169 def musicxml_words_to_lily_event (words):
1170     event = musicexp.TextEvent ()
1171     text = words.get_text ()
1172     text = re.sub ('^ *\n? *', '', text)
1173     text = re.sub (' *\n? *$', '', text)
1174     event.text = text
1175
1176     if hasattr (words, 'default-y') and options.convert_directions:
1177         offset = getattr (words, 'default-y')
1178         try:
1179             off = string.atoi (offset)
1180             if off > 0:
1181                 event.force_direction = 1
1182             else:
1183                 event.force_direction = -1
1184         except ValueError:
1185             event.force_direction = 0
1186
1187     if hasattr (words, 'font-weight'):
1188         font_weight = { "normal": '', "bold": '\\bold' }.get (getattr (words, 'font-weight'), '')
1189         if font_weight:
1190             event.markup += font_weight
1191
1192     if hasattr (words, 'font-size'):
1193         size = getattr (words, 'font-size')
1194         font_size = {
1195             "xx-small": '\\teeny',
1196             "x-small": '\\tiny',
1197             "small": '\\small',
1198             "medium": '',
1199             "large": '\\large',
1200             "x-large": '\\huge',
1201             "xx-large": '\\larger\\huge'
1202         }.get (size, '')
1203         if font_size:
1204             event.markup += font_size
1205
1206     if hasattr (words, 'color'):
1207         color = getattr (words, 'color')
1208         rgb = hex_to_color (color)
1209         if rgb:
1210             event.markup += "\\with-color #(rgb-color %s %s %s)" % (rgb[0], rgb[1], rgb[2])
1211
1212     if hasattr (words, 'font-style'):
1213         font_style = { "italic": '\\italic' }.get (getattr (words, 'font-style'), '')
1214         if font_style:
1215             event.markup += font_style
1216
1217     # TODO: How should I best convert the font-family attribute?
1218
1219     # TODO: How can I represent the underline, overline and line-through
1220     #       attributes in Lilypond? Values of these attributes indicate
1221     #       the number of lines
1222
1223     return event
1224
1225
1226 # convert accordion-registration to lilypond.
1227 # Since lilypond does not have any built-in commands, we need to create
1228 # the markup commands manually and define our own variables.
1229 # Idea was taken from: http://lsr.dsi.unimi.it/LSR/Item?id=194
1230 def musicxml_accordion_to_markup (mxl_event):
1231     commandname = "accReg"
1232     command = ""
1233
1234     high = mxl_event.get_maybe_exist_named_child ('accordion-high')
1235     if high:
1236         commandname += "H"
1237         command += """\\combine
1238           \\raise #2.5 \\musicglyph #\"accordion.accDot\"
1239           """
1240     middle = mxl_event.get_maybe_exist_named_child ('accordion-middle')
1241     if middle:
1242         # By default, use one dot (when no or invalid content is given). The
1243         # MusicXML spec is quiet about this case...
1244         txt = 1
1245         try:
1246           txt = string.atoi (middle.get_text ())
1247         except ValueError:
1248             pass
1249         if txt == 3:
1250             commandname += "MMM"
1251             command += """\\combine
1252           \\raise #1.5 \\musicglyph #\"accordion.accDot\"
1253           \\combine
1254           \\raise #1.5 \\translate #(cons 1 0) \\musicglyph #\"accordion.accDot\"
1255           \\combine
1256           \\raise #1.5 \\translate #(cons -1 0) \\musicglyph #\"accordion.accDot\"
1257           """
1258         elif txt == 2:
1259             commandname += "MM"
1260             command += """\\combine
1261           \\raise #1.5 \\translate #(cons 0.5 0) \\musicglyph #\"accordion.accDot\"
1262           \\combine
1263           \\raise #1.5 \\translate #(cons -0.5 0) \\musicglyph #\"accordion.accDot\"
1264           """
1265         elif not txt <= 0:
1266             commandname += "M"
1267             command += """\\combine
1268           \\raise #1.5 \\musicglyph #\"accordion.accDot\"
1269           """
1270     low = mxl_event.get_maybe_exist_named_child ('accordion-low')
1271     if low:
1272         commandname += "L"
1273         command += """\\combine
1274           \\raise #0.5 \musicglyph #\"accordion.accDot\"
1275           """
1276
1277     command += "\musicglyph #\"accordion.accDiscant\""
1278     command = "\\markup { \\normalsize %s }" % command
1279     # Define the newly built command \accReg[H][MMM][L]
1280     additional_definitions[commandname] = "%s = %s" % (commandname, command)
1281     needed_additional_definitions.append (commandname)
1282     return "\\%s" % commandname
1283
1284 def musicxml_accordion_to_ly (mxl_event):
1285     txt = musicxml_accordion_to_markup (mxl_event)
1286     if txt:
1287         ev = musicexp.MarkEvent (txt)
1288         return ev
1289     return
1290
1291
1292 def musicxml_rehearsal_to_ly_mark (mxl_event):
1293     text = mxl_event.get_text ()
1294     if not text:
1295         return
1296     # default is boxed rehearsal marks!
1297     encl = "box"
1298     if hasattr (mxl_event, 'enclosure'):
1299         encl = {"none": None, "square": "box", "circle": "circle" }.get (mxl_event.enclosure, None)
1300     if encl:
1301         text = "\\%s { %s }" % (encl, text)
1302     ev = musicexp.MarkEvent ("\\markup { %s }" % text)
1303     return ev
1304
1305 def musicxml_harp_pedals_to_ly (mxl_event):
1306     count = 0
1307     result = "\\harp-pedal #\""
1308     for t in mxl_event.get_named_children ('pedal-tuning'):
1309       alter = t.get_named_child ('pedal-alter')
1310       if alter:
1311         val = int (alter.get_text ().strip ())
1312         result += {1: "v", 0: "-", -1: "^"}.get (val, "")
1313       count += 1
1314       if count == 3:
1315         result += "|"
1316     ev = musicexp.MarkupEvent ()
1317     ev.contents = result + "\""
1318     return ev
1319
1320 def musicxml_eyeglasses_to_ly (mxl_event):
1321     needed_additional_definitions.append ("eyeglasses")
1322     return musicexp.MarkEvent ("\\eyeglasses")
1323
1324 def next_non_hash_index (lst, pos):
1325     pos += 1
1326     while pos < len (lst) and isinstance (lst[pos], musicxml.Hash_text):
1327         pos += 1
1328     return pos
1329
1330 def musicxml_metronome_to_ly (mxl_event):
1331     children = mxl_event.get_all_children ()
1332     if not children:
1333         return
1334
1335     index = -1
1336     index = next_non_hash_index (children, index)
1337     if isinstance (children[index], musicxml.BeatUnit):
1338         # first form of metronome-mark, using unit and beats/min or other unit
1339         ev = musicexp.TempoMark ()
1340         if hasattr (mxl_event, 'parentheses'):
1341             ev.set_parentheses (mxl_event.parentheses == "yes")
1342
1343         d = musicexp.Duration ()
1344         d.duration_log = musicxml.musicxml_duration_to_log (children[index].get_text ())
1345         index = next_non_hash_index (children, index)
1346         if isinstance (children[index], musicxml.BeatUnitDot):
1347             d.dots = 1
1348             index = next_non_hash_index (children, index)
1349         ev.set_base_duration (d)
1350         if isinstance (children[index], musicxml.BeatUnit):
1351             # Form "note = newnote"
1352             newd = musicexp.Duration ()
1353             newd.duration_log = musicxml.musicxml_duration_to_log (children[index].get_text ())
1354             index = next_non_hash_index (children, index)
1355             if isinstance (children[index], musicxml.BeatUnitDot):
1356                 newd.dots = 1
1357                 index = next_non_hash_index (children, index)
1358             ev.set_new_duration (newd)
1359         elif isinstance (children[index], musicxml.PerMinute):
1360             # Form "note = bpm"
1361             try:
1362                 beats = int (children[index].get_text ())
1363                 ev.set_beats_per_minute (beats)
1364             except ValueError:
1365                 pass
1366         else:
1367             error_message (_ ("Unknown metronome mark, ignoring"))
1368             return
1369         return ev
1370     else:
1371         #TODO: Implement the other (more complex) way for tempo marks!
1372         error_message (_ ("Metronome marks with complex relations (<metronome-note> in MusicXML) are not yet implemented."))
1373         return
1374
1375 # translate directions into Events, possible values:
1376 #   -) string  (MarkEvent with that command)
1377 #   -) function (function(mxl_event) needs to return a full Event-derived object
1378 #   -) (class, name)  (like string, only that a different class than MarkEvent is used)
1379 directions_dict = {
1380     'accordion-registration' : musicxml_accordion_to_ly,
1381     'coda' : (musicexp.MusicGlyphMarkEvent, "coda"),
1382 #     'damp' : ???
1383 #     'damp-all' : ???
1384     'eyeglasses': musicxml_eyeglasses_to_ly,
1385     'harp-pedals' : musicxml_harp_pedals_to_ly,
1386 #     'image' : ???
1387     'metronome' : musicxml_metronome_to_ly,
1388     'rehearsal' : musicxml_rehearsal_to_ly_mark,
1389 #     'scordatura' : ???
1390     'segno' : (musicexp.MusicGlyphMarkEvent, "segno"),
1391     'words' : musicxml_words_to_lily_event,
1392 }
1393 directions_spanners = [ 'octave-shift', 'pedal', 'wedge', 'dashes', 'bracket' ]
1394
1395 def musicxml_direction_to_lily (n):
1396     # TODO: Handle the <staff> element!
1397     res = []
1398     # placement applies to all children!
1399     dir = None
1400     if hasattr (n, 'placement') and options.convert_directions:
1401         dir = musicxml_direction_to_indicator (n.placement)
1402     dirtype_children = []
1403     # TODO: The direction-type is used for grouping (e.g. dynamics with text),
1404     #       so we can't simply flatten them out!
1405     for dt in n.get_typed_children (musicxml.DirType):
1406         dirtype_children += dt.get_all_children ()
1407
1408     for entry in dirtype_children:
1409         # backets, dashes, octave shifts. pedal marks, hairpins etc. are spanners:
1410         if entry.get_name() in directions_spanners:
1411             event = musicxml_spanner_to_lily_event (entry)
1412             if event:
1413                 res.append (event)
1414             continue
1415
1416         # now treat all the "simple" ones, that can be translated using the dict
1417         ev = None
1418         tmp_tp = directions_dict.get (entry.get_name (), None)
1419         if isinstance (tmp_tp, str): # string means MarkEvent
1420             ev = musicexp.MarkEvent (tmp_tp)
1421         elif isinstance (tmp_tp, tuple): # tuple means (EventClass, "text")
1422             ev = tmp_tp[0] (tmp_tp[1])
1423         elif tmp_tp:
1424             ev = tmp_tp (entry)
1425         if ev:
1426             # TODO: set the correct direction! Unfortunately, \mark in ly does
1427             #       not seem to support directions!
1428             res.append (ev)
1429             continue
1430
1431         if entry.get_name () == "dynamics":
1432             for dynentry in entry.get_all_children ():
1433                 ev = musicxml_dynamics_to_lily_event (dynentry)
1434                 if ev:
1435                     res.append (ev)
1436
1437     return res
1438
1439 def musicxml_frame_to_lily_event (frame):
1440     ev = musicexp.FretEvent ()
1441     ev.strings = frame.get_strings ()
1442     ev.frets = frame.get_frets ()
1443     #offset = frame.get_first_fret () - 1
1444     barre = []
1445     for fn in frame.get_named_children ('frame-note'):
1446         fret = fn.get_fret ()
1447         if fret <= 0:
1448             fret = "o"
1449         el = [ fn.get_string (), fret ]
1450         fingering = fn.get_fingering ()
1451         if fingering >= 0:
1452             el.append (fingering)
1453         ev.elements.append (el)
1454         b = fn.get_barre ()
1455         if b == 'start':
1456             barre[0] = el[0] # start string
1457             barre[2] = el[1] # fret
1458         elif b == 'stop':
1459             barre[1] = el[0] # end string
1460     if barre:
1461         ev.barre = barre
1462     return ev
1463
1464 def musicxml_harmony_to_lily (n):
1465     res = []
1466     for f in n.get_named_children ('frame'):
1467         ev = musicxml_frame_to_lily_event (f)
1468         if ev:
1469             res.append (ev)
1470     return res
1471
1472
1473 def musicxml_chordpitch_to_lily (mxl_cpitch):
1474     r = musicexp.ChordPitch ()
1475     r.alteration = mxl_cpitch.get_alteration ()
1476     r.step = musicxml_step_to_lily (mxl_cpitch.get_step ())
1477     return r
1478
1479 chordkind_dict = {
1480     'major': '5',
1481     'minor': 'm5',
1482     'augmented': 'aug5',
1483     'diminished': 'dim5',
1484         # Sevenths:
1485     'dominant': '7',
1486     'major-seventh': 'maj7',
1487     'minor-seventh': 'm7',
1488     'diminished-seventh': 'dim7',
1489     'augmented-seventh': 'aug7',
1490     'half-diminished': 'dim5m7',
1491     'major-minor': 'maj7m5',
1492         # Sixths:
1493     'major-sixth': '6',
1494     'minor-sixth': 'm6',
1495         # Ninths:
1496     'dominant-ninth': '9',
1497     'major-ninth': 'maj9',
1498     'minor-ninth': 'm9',
1499         # 11ths (usually as the basis for alteration):
1500     'dominant-11th': '11',
1501     'major-11th': 'maj11',
1502     'minor-11th': 'm11',
1503         # 13ths (usually as the basis for alteration):
1504     'dominant-13th': '13.11',
1505     'major-13th': 'maj13.11',
1506     'minor-13th': 'm13',
1507         # Suspended:
1508     'suspended-second': 'sus2',
1509     'suspended-fourth': 'sus4',
1510         # Functional sixths:
1511     # TODO
1512     #'Neapolitan': '???',
1513     #'Italian': '???',
1514     #'French': '???',
1515     #'German': '???',
1516         # Other:
1517     #'pedal': '???',(pedal-point bass)
1518     'power': '5^3',
1519     #'Tristan': '???',
1520     'other': '1',
1521     'none': None,
1522 }
1523
1524 def musicxml_chordkind_to_lily (kind):
1525     res = chordkind_dict.get (kind, None)
1526     # Check for None, since a major chord is converted to ''
1527     if res == None:
1528         error_message (_ ("Unable to convert chord type %s to lilypond.") % kind)
1529     return res
1530
1531 def musicxml_harmony_to_lily_chordname (n):
1532     res = []
1533     root = n.get_maybe_exist_named_child ('root')
1534     if root:
1535         ev = musicexp.ChordNameEvent ()
1536         ev.root = musicxml_chordpitch_to_lily (root)
1537         kind = n.get_maybe_exist_named_child ('kind')
1538         if kind:
1539             ev.kind = musicxml_chordkind_to_lily (kind.get_text ())
1540             if not ev.kind:
1541                 return res
1542         bass = n.get_maybe_exist_named_child ('bass')
1543         if bass:
1544             ev.bass = musicxml_chordpitch_to_lily (bass)
1545         inversion = n.get_maybe_exist_named_child ('inversion')
1546         if inversion:
1547             # TODO: Lilypond does not support inversions, does it?
1548
1549             # Mail from Carl Sorensen on lilypond-devel, June 11, 2008:
1550             # 4. LilyPond supports the first inversion in the form of added
1551             # bass notes.  So the first inversion of C major would be c:/g.
1552             # To get the second inversion of C major, you would need to do
1553             # e:6-3-^5 or e:m6-^5.  However, both of these techniques
1554             # require you to know the chord and calculate either the fifth
1555             # pitch (for the first inversion) or the third pitch (for the
1556             # second inversion) so they may not be helpful for musicxml2ly.
1557             inversion_count = string.atoi (inversion.get_text ())
1558             if inversion_count == 1:
1559               # TODO: Calculate the bass note for the inversion...
1560               pass
1561             pass
1562         for deg in n.get_named_children ('degree'):
1563             d = musicexp.ChordModification ()
1564             d.type = deg.get_type ()
1565             d.step = deg.get_value ()
1566             d.alteration = deg.get_alter ()
1567             ev.add_modification (d)
1568         #TODO: convert the user-symbols attribute:
1569             #major: a triangle, like Unicode 25B3
1570             #minor: -, like Unicode 002D
1571             #augmented: +, like Unicode 002B
1572             #diminished: (degree), like Unicode 00B0
1573             #half-diminished: (o with slash), like Unicode 00F8
1574         if ev and ev.root:
1575             res.append (ev)
1576
1577     return res
1578
1579 def musicxml_figured_bass_note_to_lily (n):
1580     res = musicexp.FiguredBassNote ()
1581     suffix_dict = { 'sharp' : "+",
1582                     'flat' : "-",
1583                     'natural' : "!",
1584                     'double-sharp' : "++",
1585                     'flat-flat' : "--",
1586                     'sharp-sharp' : "++",
1587                     'slash' : "/" }
1588     prefix = n.get_maybe_exist_named_child ('prefix')
1589     if prefix:
1590         res.set_prefix (suffix_dict.get (prefix.get_text (), ""))
1591     fnumber = n.get_maybe_exist_named_child ('figure-number')
1592     if fnumber:
1593         res.set_number (fnumber.get_text ())
1594     suffix = n.get_maybe_exist_named_child ('suffix')
1595     if suffix:
1596         res.set_suffix (suffix_dict.get (suffix.get_text (), ""))
1597     if n.get_maybe_exist_named_child ('extend'):
1598         # TODO: Implement extender lines (unfortunately, in lilypond you have
1599         #       to use \set useBassFigureExtenders = ##t, which turns them on
1600         #       globally, while MusicXML has a property for each note...
1601         #       I'm not sure there is a proper way to implement this cleanly
1602         #n.extend
1603         pass
1604     return res
1605
1606
1607
1608 def musicxml_figured_bass_to_lily (n):
1609     if not isinstance (n, musicxml.FiguredBass):
1610         return
1611     res = musicexp.FiguredBassEvent ()
1612     for i in n.get_named_children ('figure'):
1613         note = musicxml_figured_bass_note_to_lily (i)
1614         if note:
1615             res.append (note)
1616     dur = n.get_maybe_exist_named_child ('duration')
1617     if dur:
1618         # apply the duration to res
1619         length = Rational(int(dur.get_text()), n._divisions)*Rational(1,4)
1620         res.set_real_duration (length)
1621         duration = rational_to_lily_duration (length)
1622         if duration:
1623             res.set_duration (duration)
1624     if hasattr (n, 'parentheses') and n.parentheses == "yes":
1625         res.set_parentheses (True)
1626     return res
1627
1628 instrument_drumtype_dict = {
1629     'Acoustic Snare Drum': 'acousticsnare',
1630     'Side Stick': 'sidestick',
1631     'Open Triangle': 'opentriangle',
1632     'Mute Triangle': 'mutetriangle',
1633     'Tambourine': 'tambourine',
1634     'Bass Drum': 'bassdrum',
1635 }
1636
1637 def musicxml_note_to_lily_main_event (n):
1638     pitch  = None
1639     duration = None
1640     event = None
1641
1642     mxl_pitch = n.get_maybe_exist_typed_child (musicxml.Pitch)
1643     if mxl_pitch:
1644         pitch = musicxml_pitch_to_lily (mxl_pitch)
1645         event = musicexp.NoteEvent ()
1646         event.pitch = pitch
1647
1648         acc = n.get_maybe_exist_named_child ('accidental')
1649         if acc:
1650             # let's not force accs everywhere.
1651             event.cautionary = acc.editorial
1652
1653     elif n.get_maybe_exist_typed_child (musicxml.Unpitched):
1654         # Unpitched elements have display-step and can also have
1655         # display-octave.
1656         unpitched = n.get_maybe_exist_typed_child (musicxml.Unpitched)
1657         event = musicexp.NoteEvent ()
1658         event.pitch = musicxml_unpitched_to_lily (unpitched)
1659
1660     elif n.get_maybe_exist_typed_child (musicxml.Rest):
1661         # rests can have display-octave and display-step, which are
1662         # treated like an ordinary note pitch
1663         rest = n.get_maybe_exist_typed_child (musicxml.Rest)
1664         event = musicexp.RestEvent ()
1665         pitch = musicxml_restdisplay_to_lily (rest)
1666         event.pitch = pitch
1667
1668     elif n.instrument_name:
1669         event = musicexp.NoteEvent ()
1670         drum_type = instrument_drumtype_dict.get (n.instrument_name)
1671         if drum_type:
1672             event.drum_type = drum_type
1673         else:
1674             n.message (_ ("drum %s type unknown, please add to instrument_drumtype_dict") % n.instrument_name)
1675             event.drum_type = 'acousticsnare'
1676
1677     else:
1678         n.message (_ ("cannot find suitable event"))
1679
1680     if event:
1681         event.duration = musicxml_duration_to_lily (n)
1682
1683     return event
1684
1685
1686 ## TODO
1687 class NegativeSkip:
1688     def __init__ (self, here, dest):
1689         self.here = here
1690         self.dest = dest
1691
1692 class LilyPondVoiceBuilder:
1693     def __init__ (self):
1694         self.elements = []
1695         self.pending_dynamics = []
1696         self.end_moment = Rational (0)
1697         self.begin_moment = Rational (0)
1698         self.pending_multibar = Rational (0)
1699         self.ignore_skips = False
1700         self.has_relevant_elements = False
1701         self.measure_length = (4, 4)
1702
1703     def _insert_multibar (self):
1704         layout_information.set_context_item ('Score', 'skipBars = ##t')
1705         r = musicexp.MultiMeasureRest ()
1706         lenfrac = Rational (self.measure_length[0], self.measure_length[1])
1707         r.duration = rational_to_lily_duration (lenfrac)
1708         r.duration.factor *= self.pending_multibar / lenfrac
1709         self.elements.append (r)
1710         self.begin_moment = self.end_moment
1711         self.end_moment = self.begin_moment + self.pending_multibar
1712         self.pending_multibar = Rational (0)
1713
1714     def set_measure_length (self, mlen):
1715         if (mlen != self.measure_length) and self.pending_multibar:
1716             self._insert_multibar ()
1717         self.measure_length = mlen
1718
1719     def add_multibar_rest (self, duration):
1720         self.pending_multibar += duration
1721
1722     def set_duration (self, duration):
1723         self.end_moment = self.begin_moment + duration
1724     def current_duration (self):
1725         return self.end_moment - self.begin_moment
1726
1727     def add_music (self, music, duration):
1728         assert isinstance (music, musicexp.Music)
1729         if self.pending_multibar > Rational (0):
1730             self._insert_multibar ()
1731
1732         self.has_relevant_elements = True
1733         self.elements.append (music)
1734         self.begin_moment = self.end_moment
1735         self.set_duration (duration)
1736
1737         # Insert all pending dynamics right after the note/rest:
1738         if isinstance (music, musicexp.ChordEvent) and self.pending_dynamics:
1739             for d in self.pending_dynamics:
1740                 music.append (d)
1741             self.pending_dynamics = []
1742
1743     # Insert some music command that does not affect the position in the measure
1744     def add_command (self, command):
1745         assert isinstance (command, musicexp.Music)
1746         if self.pending_multibar > Rational (0):
1747             self._insert_multibar ()
1748         self.has_relevant_elements = True
1749         self.elements.append (command)
1750     def add_barline (self, barline):
1751         # TODO: Implement merging of default barline and custom bar line
1752         self.add_music (barline, Rational (0))
1753     def add_partial (self, command):
1754         self.ignore_skips = True
1755         self.add_command (command)
1756
1757     def add_dynamics (self, dynamic):
1758         # store the dynamic item(s) until we encounter the next note/rest:
1759         self.pending_dynamics.append (dynamic)
1760
1761     def add_bar_check (self, number):
1762         # re/store has_relevant_elements, so that a barline alone does not
1763         # trigger output for figured bass, chord names
1764         has_relevant = self.has_relevant_elements
1765         b = musicexp.BarLine ()
1766         b.bar_number = number
1767         self.add_barline (b)
1768         self.has_relevant_elements = has_relevant
1769
1770     def jumpto (self, moment):
1771         current_end = self.end_moment + self.pending_multibar
1772         diff = moment - current_end
1773
1774         if diff < Rational (0):
1775             error_message (_ ('Negative skip %s (from position %s to %s)') %
1776                              (diff, current_end, moment))
1777             diff = Rational (0)
1778
1779         if diff > Rational (0) and not (self.ignore_skips and moment == 0):
1780             skip = musicexp.SkipEvent()
1781             duration_factor = 1
1782             duration_log = {1: 0, 2: 1, 4:2, 8:3, 16:4, 32:5, 64:6, 128:7, 256:8, 512:9}.get (diff.denominator (), -1)
1783             duration_dots = 0
1784             # TODO: Use the time signature for skips, too. Problem: The skip
1785             #       might not start at a measure boundary!
1786             if duration_log > 0: # denominator is a power of 2...
1787                 if diff.numerator () == 3:
1788                     duration_log -= 1
1789                     duration_dots = 1
1790                 else:
1791                     duration_factor = Rational (diff.numerator ())
1792             else:
1793                 # for skips of a whole or more, simply use s1*factor
1794                 duration_log = 0
1795                 duration_factor = diff
1796             skip.duration.duration_log = duration_log
1797             skip.duration.factor = duration_factor
1798             skip.duration.dots = duration_dots
1799
1800             evc = musicexp.ChordEvent ()
1801             evc.elements.append (skip)
1802             self.add_music (evc, diff)
1803
1804         if diff > Rational (0) and moment == 0:
1805             self.ignore_skips = False
1806
1807     def last_event_chord (self, starting_at):
1808
1809         value = None
1810
1811         # if the position matches, find the last ChordEvent, do not cross a bar line!
1812         at = len( self.elements ) - 1
1813         while (at >= 0 and
1814                not isinstance (self.elements[at], musicexp.ChordEvent) and
1815                not isinstance (self.elements[at], musicexp.BarLine)):
1816             at -= 1
1817
1818         if (self.elements
1819             and at >= 0
1820             and isinstance (self.elements[at], musicexp.ChordEvent)
1821             and self.begin_moment == starting_at):
1822             value = self.elements[at]
1823         else:
1824             self.jumpto (starting_at)
1825             value = None
1826         return value
1827
1828     def correct_negative_skip (self, goto):
1829         self.end_moment = goto
1830         self.begin_moment = goto
1831         evc = musicexp.ChordEvent ()
1832         self.elements.append (evc)
1833
1834
1835 class VoiceData:
1836     def __init__ (self):
1837         self.voicename = None
1838         self.voicedata = None
1839         self.ly_voice = None
1840         self.figured_bass = None
1841         self.chordnames = None
1842         self.lyrics_dict = {}
1843         self.lyrics_order = []
1844
1845 def musicxml_step_to_lily (step):
1846     if step:
1847         return (ord (step) - ord ('A') + 7 - 2) % 7
1848     else:
1849         return None
1850
1851 def measure_length_from_attributes (attr, current_measure_length):
1852     mxl = attr.get_named_attribute ('time')
1853     if mxl:
1854         return attr.get_time_signature ()
1855     else:
1856         return current_measure_length
1857
1858 def musicxml_voice_to_lily_voice (voice):
1859     tuplet_events = []
1860     modes_found = {}
1861     lyrics = {}
1862     return_value = VoiceData ()
1863     return_value.voicedata = voice
1864
1865     # First pitch needed for relative mode (if selected in command-line options)
1866     first_pitch = None
1867
1868     # Needed for melismata detection (ignore lyrics on those notes!):
1869     inside_slur = False
1870     is_tied = False
1871     is_chord = False
1872     is_beamed = False
1873     ignore_lyrics = False
1874
1875     current_staff = None
1876
1877     pending_figured_bass = []
1878     pending_chordnames = []
1879
1880     # Make sure that the keys in the dict don't get reordered, since
1881     # we need the correct ordering of the lyrics stanzas! By default,
1882     # a dict will reorder its keys
1883     return_value.lyrics_order = voice.get_lyrics_numbers ()
1884     for k in return_value.lyrics_order:
1885         lyrics[k] = []
1886
1887     voice_builder = LilyPondVoiceBuilder ()
1888     figured_bass_builder = LilyPondVoiceBuilder ()
1889     chordnames_builder = LilyPondVoiceBuilder ()
1890     current_measure_length = (4, 4)
1891     voice_builder.set_measure_length (current_measure_length)
1892
1893     for n in voice._elements:
1894         if n.get_name () == 'forward':
1895             continue
1896         staff = n.get_maybe_exist_named_child ('staff')
1897         if staff:
1898             staff = staff.get_text ()
1899             if current_staff and staff <> current_staff and not n.get_maybe_exist_named_child ('chord'):
1900                 voice_builder.add_command (musicexp.StaffChange (staff))
1901             current_staff = staff
1902
1903         if isinstance (n, musicxml.Partial) and n.partial > 0:
1904             a = musicxml_partial_to_lily (n.partial)
1905             if a:
1906                 voice_builder.add_partial (a)
1907             continue
1908
1909         is_chord = n.get_maybe_exist_named_child ('chord')
1910         is_after_grace = (isinstance (n, musicxml.Note) and n.is_after_grace ());
1911         if not is_chord and not is_after_grace:
1912             try:
1913                 voice_builder.jumpto (n._when)
1914             except NegativeSkip, neg:
1915                 voice_builder.correct_negative_skip (n._when)
1916                 n.message (_ ("Negative skip found: from %s to %s, difference is %s") % (neg.here, neg.dest, neg.dest - neg.here))
1917
1918         if isinstance (n, musicxml.Barline):
1919             barlines = musicxml_barline_to_lily (n)
1920             for a in barlines:
1921                 if isinstance (a, musicexp.BarLine):
1922                     voice_builder.add_barline (a)
1923                 elif isinstance (a, RepeatMarker) or isinstance (a, EndingMarker):
1924                     voice_builder.add_command (a)
1925             continue
1926
1927         # Continue any multimeasure-rests before trying to add bar checks!
1928         # Don't handle new MM rests yet, because for them we want bar checks!
1929         rest = n.get_maybe_exist_typed_child (musicxml.Rest)
1930         if (rest and rest.is_whole_measure ()
1931                  and voice_builder.pending_multibar > Rational (0)):
1932             voice_builder.add_multibar_rest (n._duration)
1933             continue
1934
1935
1936         # print a bar check at the beginning of each measure!
1937         if n.is_first () and n._measure_position == Rational (0) and n != voice._elements[0]:
1938             try:
1939                 num = int (n.get_parent ().number)
1940             except ValueError:
1941                 num = 0
1942             if num > 0:
1943                 voice_builder.add_bar_check (num)
1944                 figured_bass_builder.add_bar_check (num)
1945                 chordnames_builder.add_bar_check (num)
1946
1947         # Start any new multimeasure rests
1948         if (rest and rest.is_whole_measure ()):
1949             voice_builder.add_multibar_rest (n._duration)
1950             continue
1951
1952
1953         if isinstance (n, musicxml.Direction):
1954             for a in musicxml_direction_to_lily (n):
1955                 if a.wait_for_note ():
1956                     voice_builder.add_dynamics (a)
1957                 else:
1958                     voice_builder.add_command (a)
1959             continue
1960
1961         if isinstance (n, musicxml.Harmony):
1962             for a in musicxml_harmony_to_lily (n):
1963                 if a.wait_for_note ():
1964                     voice_builder.add_dynamics (a)
1965                 else:
1966                     voice_builder.add_command (a)
1967             for a in musicxml_harmony_to_lily_chordname (n):
1968                 pending_chordnames.append (a)
1969             continue
1970
1971         if isinstance (n, musicxml.FiguredBass):
1972             a = musicxml_figured_bass_to_lily (n)
1973             if a:
1974                 pending_figured_bass.append (a)
1975             continue
1976
1977         if isinstance (n, musicxml.Attributes):
1978             for a in musicxml_attributes_to_lily (n):
1979                 voice_builder.add_command (a)
1980             measure_length = measure_length_from_attributes (n, current_measure_length)
1981             if current_measure_length != measure_length:
1982                 current_measure_length = measure_length
1983                 voice_builder.set_measure_length (current_measure_length)
1984             continue
1985
1986         if not n.__class__.__name__ == 'Note':
1987             n.message (_ ('unexpected %s; expected %s or %s or %s') % (n, 'Note', 'Attributes', 'Barline'))
1988             continue
1989
1990         main_event = musicxml_note_to_lily_main_event (n)
1991         if main_event and not first_pitch:
1992             first_pitch = main_event.pitch
1993         # ignore lyrics for notes inside a slur, tie, chord or beam
1994         ignore_lyrics = inside_slur or is_tied or is_chord or is_beamed
1995
1996         if main_event and hasattr (main_event, 'drum_type') and main_event.drum_type:
1997             modes_found['drummode'] = True
1998
1999         ev_chord = voice_builder.last_event_chord (n._when)
2000         if not ev_chord:
2001             ev_chord = musicexp.ChordEvent()
2002             voice_builder.add_music (ev_chord, n._duration)
2003
2004         # For grace notes:
2005         grace = n.get_maybe_exist_typed_child (musicxml.Grace)
2006         if n.is_grace ():
2007             is_after_grace = ev_chord.has_elements () or n.is_after_grace ();
2008             is_chord = n.get_maybe_exist_typed_child (musicxml.Chord)
2009
2010             grace_chord = None
2011
2012             # after-graces and other graces use different lists; Depending on
2013             # whether we have a chord or not, obtain either a new ChordEvent or
2014             # the previous one to create a chord
2015             if is_after_grace:
2016                 if ev_chord.after_grace_elements and n.get_maybe_exist_typed_child (musicxml.Chord):
2017                     grace_chord = ev_chord.after_grace_elements.get_last_event_chord ()
2018                 if not grace_chord:
2019                     grace_chord = musicexp.ChordEvent ()
2020                     ev_chord.append_after_grace (grace_chord)
2021             elif n.is_grace ():
2022                 if ev_chord.grace_elements and n.get_maybe_exist_typed_child (musicxml.Chord):
2023                     grace_chord = ev_chord.grace_elements.get_last_event_chord ()
2024                 if not grace_chord:
2025                     grace_chord = musicexp.ChordEvent ()
2026                     ev_chord.append_grace (grace_chord)
2027
2028             if hasattr (grace, 'slash') and not is_after_grace:
2029                 # TODO: use grace_type = "appoggiatura" for slurred grace notes
2030                 if grace.slash == "yes":
2031                     ev_chord.grace_type = "acciaccatura"
2032             # now that we have inserted the chord into the grace music, insert
2033             # everything into that chord instead of the ev_chord
2034             ev_chord = grace_chord
2035             ev_chord.append (main_event)
2036             ignore_lyrics = True
2037         else:
2038             ev_chord.append (main_event)
2039             # When a note/chord has grace notes (duration==0), the duration of the
2040             # event chord is not yet known, but the event chord was already added
2041             # with duration 0. The following correct this when we hit the real note!
2042             if voice_builder.current_duration () == 0 and n._duration > 0:
2043                 voice_builder.set_duration (n._duration)
2044
2045         # if we have a figured bass, set its voice builder to the correct position
2046         # and insert the pending figures
2047         if pending_figured_bass:
2048             try:
2049                 figured_bass_builder.jumpto (n._when)
2050             except NegativeSkip, neg:
2051                 pass
2052             for fb in pending_figured_bass:
2053                 # if a duration is given, use that, otherwise the one of the note
2054                 dur = fb.real_duration
2055                 if not dur:
2056                     dur = ev_chord.get_length ()
2057                 if not fb.duration:
2058                     fb.duration = ev_chord.get_duration ()
2059                 figured_bass_builder.add_music (fb, dur)
2060             pending_figured_bass = []
2061
2062         if pending_chordnames:
2063             try:
2064                 chordnames_builder.jumpto (n._when)
2065             except NegativeSkip, neg:
2066                 pass
2067             for cn in pending_chordnames:
2068                 # Assign the duration of the EventChord
2069                 cn.duration = ev_chord.get_duration ()
2070                 chordnames_builder.add_music (cn, ev_chord.get_length ())
2071             pending_chordnames = []
2072
2073         notations_children = n.get_typed_children (musicxml.Notations)
2074         tuplet_event = None
2075         span_events = []
2076
2077         # The <notation> element can have the following children (+ means implemented, ~ partially, - not):
2078         # +tied | +slur | +tuplet | glissando | slide |
2079         #    ornaments | technical | articulations | dynamics |
2080         #    +fermata | arpeggiate | non-arpeggiate |
2081         #    accidental-mark | other-notation
2082         for notations in notations_children:
2083             for tuplet_event in notations.get_tuplets():
2084                 time_mod = n.get_maybe_exist_typed_child (musicxml.Time_modification)
2085                 tuplet_events.append ((ev_chord, tuplet_event, time_mod))
2086
2087             # First, close all open slurs, only then start any new slur
2088             # TODO: Record the number of the open slur to dtermine the correct
2089             #       closing slur!
2090             endslurs = [s for s in notations.get_named_children ('slur')
2091                 if s.get_type () in ('stop')]
2092             if endslurs and not inside_slur:
2093                 endslurs[0].message (_ ('Encountered closing slur, but no slur is open'))
2094             elif endslurs:
2095                 if len (endslurs) > 1:
2096                     endslurs[0].message (_ ('Cannot have two simultaneous (closing) slurs'))
2097                 # record the slur status for the next note in the loop
2098                 if not grace:
2099                     inside_slur = False
2100                 lily_ev = musicxml_spanner_to_lily_event (endslurs[0])
2101                 ev_chord.append (lily_ev)
2102
2103             startslurs = [s for s in notations.get_named_children ('slur')
2104                 if s.get_type () in ('start')]
2105             if startslurs and inside_slur:
2106                 startslurs[0].message (_ ('Cannot have a slur inside another slur'))
2107             elif startslurs:
2108                 if len (startslurs) > 1:
2109                     startslurs[0].message (_ ('Cannot have two simultaneous slurs'))
2110                 # record the slur status for the next note in the loop
2111                 if not grace:
2112                     inside_slur = True
2113                 lily_ev = musicxml_spanner_to_lily_event (startslurs[0])
2114                 ev_chord.append (lily_ev)
2115
2116
2117             if not grace:
2118                 mxl_tie = notations.get_tie ()
2119                 if mxl_tie and mxl_tie.type == 'start':
2120                     ev_chord.append (musicexp.TieEvent ())
2121                     is_tied = True
2122                 else:
2123                     is_tied = False
2124
2125             fermatas = notations.get_named_children ('fermata')
2126             for a in fermatas:
2127                 ev = musicxml_fermata_to_lily_event (a)
2128                 if ev:
2129                     ev_chord.append (ev)
2130
2131             arpeggiate = notations.get_named_children ('arpeggiate')
2132             for a in arpeggiate:
2133                 ev = musicxml_arpeggiate_to_lily_event (a)
2134                 if ev:
2135                     ev_chord.append (ev)
2136
2137             arpeggiate = notations.get_named_children ('non-arpeggiate')
2138             for a in arpeggiate:
2139                 ev = musicxml_nonarpeggiate_to_lily_event (a)
2140                 if ev:
2141                     ev_chord.append (ev)
2142
2143             glissandos = notations.get_named_children ('glissando')
2144             glissandos += notations.get_named_children ('slide')
2145             for a in glissandos:
2146                 ev = musicxml_spanner_to_lily_event (a)
2147                 if ev:
2148                     ev_chord.append (ev)
2149
2150             # accidental-marks are direct children of <notation>!
2151             for a in notations.get_named_children ('accidental-mark'):
2152                 ev = musicxml_articulation_to_lily_event (a)
2153                 if ev:
2154                     ev_chord.append (ev)
2155
2156             # Articulations can contain the following child elements:
2157             #         accent | strong-accent | staccato | tenuto |
2158             #         detached-legato | staccatissimo | spiccato |
2159             #         scoop | plop | doit | falloff | breath-mark |
2160             #         caesura | stress | unstress
2161             # Technical can contain the following child elements:
2162             #         up-bow | down-bow | harmonic | open-string |
2163             #         thumb-position | fingering | pluck | double-tongue |
2164             #         triple-tongue | stopped | snap-pizzicato | fret |
2165             #         string | hammer-on | pull-off | bend | tap | heel |
2166             #         toe | fingernails | other-technical
2167             # Ornaments can contain the following child elements:
2168             #         trill-mark | turn | delayed-turn | inverted-turn |
2169             #         shake | wavy-line | mordent | inverted-mordent |
2170             #         schleifer | tremolo | other-ornament, accidental-mark
2171             ornaments = notations.get_named_children ('ornaments')
2172             ornaments += notations.get_named_children ('articulations')
2173             ornaments += notations.get_named_children ('technical')
2174
2175             for a in ornaments:
2176                 for ch in a.get_all_children ():
2177                     ev = musicxml_articulation_to_lily_event (ch)
2178                     if ev:
2179                         ev_chord.append (ev)
2180
2181             dynamics = notations.get_named_children ('dynamics')
2182             for a in dynamics:
2183                 for ch in a.get_all_children ():
2184                     ev = musicxml_dynamics_to_lily_event (ch)
2185                     if ev:
2186                         ev_chord.append (ev)
2187
2188
2189         mxl_beams = [b for b in n.get_named_children ('beam')
2190                      if (b.get_type () in ('begin', 'end')
2191                          and b.is_primary ())]
2192         if mxl_beams and not conversion_settings.ignore_beaming:
2193             beam_ev = musicxml_spanner_to_lily_event (mxl_beams[0])
2194             if beam_ev:
2195                 ev_chord.append (beam_ev)
2196                 if beam_ev.span_direction == -1: # beam and thus melisma starts here
2197                     is_beamed = True
2198                 elif beam_ev.span_direction == 1: # beam and thus melisma ends here
2199                     is_beamed = False
2200
2201         # Extract the lyrics
2202         if not rest and not ignore_lyrics:
2203             note_lyrics_processed = []
2204             note_lyrics_elements = n.get_typed_children (musicxml.Lyric)
2205             for l in note_lyrics_elements:
2206                 if l.get_number () < 0:
2207                     for k in lyrics.keys ():
2208                         lyrics[k].append (l.lyric_to_text ())
2209                         note_lyrics_processed.append (k)
2210                 else:
2211                     lyrics[l.number].append(l.lyric_to_text ())
2212                     note_lyrics_processed.append (l.number)
2213             for lnr in lyrics.keys ():
2214                 if not lnr in note_lyrics_processed:
2215                     lyrics[lnr].append ("\skip4")
2216
2217     ## force trailing mm rests to be written out.
2218     voice_builder.add_music (musicexp.ChordEvent (), Rational (0))
2219
2220     ly_voice = group_tuplets (voice_builder.elements, tuplet_events)
2221     ly_voice = group_repeats (ly_voice)
2222
2223     seq_music = musicexp.SequentialMusic ()
2224
2225     if 'drummode' in modes_found.keys ():
2226         ## \key <pitch> barfs in drummode.
2227         ly_voice = [e for e in ly_voice
2228                     if not isinstance(e, musicexp.KeySignatureChange)]
2229
2230     seq_music.elements = ly_voice
2231     for k in lyrics.keys ():
2232         return_value.lyrics_dict[k] = musicexp.Lyrics ()
2233         return_value.lyrics_dict[k].lyrics_syllables = lyrics[k]
2234
2235
2236     if len (modes_found) > 1:
2237        error_message (_ ('cannot simultaneously have more than one mode: %s') % modes_found.keys ())
2238
2239     if options.relative:
2240         v = musicexp.RelativeMusic ()
2241         v.element = seq_music
2242         v.basepitch = first_pitch
2243         seq_music = v
2244
2245     return_value.ly_voice = seq_music
2246     for mode in modes_found.keys ():
2247         v = musicexp.ModeChangingMusicWrapper()
2248         v.element = seq_music
2249         v.mode = mode
2250         return_value.ly_voice = v
2251
2252     # create \figuremode { figured bass elements }
2253     if figured_bass_builder.has_relevant_elements:
2254         fbass_music = musicexp.SequentialMusic ()
2255         fbass_music.elements = figured_bass_builder.elements
2256         v = musicexp.ModeChangingMusicWrapper()
2257         v.mode = 'figuremode'
2258         v.element = fbass_music
2259         return_value.figured_bass = v
2260
2261     # create \chordmode { chords }
2262     if chordnames_builder.has_relevant_elements:
2263         cname_music = musicexp.SequentialMusic ()
2264         cname_music.elements = chordnames_builder.elements
2265         v = musicexp.ModeChangingMusicWrapper()
2266         v.mode = 'chordmode'
2267         v.element = cname_music
2268         return_value.chordnames = v
2269
2270     return return_value
2271
2272 def musicxml_id_to_lily (id):
2273     digits = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five',
2274               'Six', 'Seven', 'Eight', 'Nine', 'Ten']
2275
2276     for digit in digits:
2277         d = digits.index (digit)
2278         id = re.sub ('%d' % d, digit, id)
2279
2280     id = re.sub  ('[^a-zA-Z]', 'X', id)
2281     return id
2282
2283 def musicxml_pitch_to_lily (mxl_pitch):
2284     p = musicexp.Pitch ()
2285     p.alteration = mxl_pitch.get_alteration ()
2286     p.step = musicxml_step_to_lily (mxl_pitch.get_step ())
2287     p.octave = mxl_pitch.get_octave () - 4
2288     return p
2289
2290 def musicxml_unpitched_to_lily (mxl_unpitched):
2291     p = None
2292     step = mxl_unpitched.get_step ()
2293     if step:
2294         p = musicexp.Pitch ()
2295         p.step = musicxml_step_to_lily (step)
2296     octave = mxl_unpitched.get_octave ()
2297     if octave and p:
2298         p.octave = octave - 4
2299     return p
2300
2301 def musicxml_restdisplay_to_lily (mxl_rest):
2302     p = None
2303     step = mxl_rest.get_step ()
2304     if step:
2305         p = musicexp.Pitch ()
2306         p.step = musicxml_step_to_lily (step)
2307     octave = mxl_rest.get_octave ()
2308     if octave and p:
2309         p.octave = octave - 4
2310     return p
2311
2312 def voices_in_part (part):
2313     """Return a Name -> Voice dictionary for PART"""
2314     part.interpret ()
2315     part.extract_voices ()
2316     voices = part.get_voices ()
2317     part_info = part.get_staff_attributes ()
2318
2319     return (voices, part_info)
2320
2321 def voices_in_part_in_parts (parts):
2322     """return a Part -> Name -> Voice dictionary"""
2323     return dict([(p.id, voices_in_part (p)) for p in parts])
2324
2325
2326 def get_all_voices (parts):
2327     all_voices = voices_in_part_in_parts (parts)
2328
2329     all_ly_voices = {}
2330     all_ly_staffinfo = {}
2331     for p, (name_voice, staff_info) in all_voices.items ():
2332
2333         part_ly_voices = {}
2334         for n, v in name_voice.items ():
2335             progress (_ ("Converting to LilyPond expressions..."))
2336             # musicxml_voice_to_lily_voice returns (lily_voice, {nr->lyrics, nr->lyrics})
2337             part_ly_voices[n] = musicxml_voice_to_lily_voice (v)
2338
2339         all_ly_voices[p] = part_ly_voices
2340         all_ly_staffinfo[p] = staff_info
2341
2342     return (all_ly_voices, all_ly_staffinfo)
2343
2344
2345 def option_parser ():
2346     p = ly.get_option_parser (usage = _ ("musicxml2ly [OPTION]... FILE.xml"),
2347                              description =
2348 _ ("""Convert MusicXML from FILE.xml to LilyPond input.
2349 If the given filename is -, musicxml2ly reads from the command line.
2350 """), add_help_option=False)
2351
2352     p.add_option("-h", "--help",
2353                  action="help",
2354                  help=_ ("show this help and exit"))
2355
2356     p.version = ('''%prog (LilyPond) @TOPLEVEL_VERSION@\n\n'''
2357 +
2358 _ ("""Copyright (c) 2005--2008 by
2359     Han-Wen Nienhuys <hanwen@xs4all.nl>,
2360     Jan Nieuwenhuizen <janneke@gnu.org> and
2361     Reinhold Kainhofer <reinhold@kainhofer.com>
2362 """
2363 +
2364 """
2365 This program is free software.  It is covered by the GNU General Public
2366 License and you are welcome to change it and/or distribute copies of it
2367 under certain conditions.  Invoke as `%s --warranty' for more
2368 information.""") % 'lilypond')
2369
2370     p.add_option("--version",
2371                  action="version",
2372                  help=_ ("show version number and exit"))
2373
2374     p.add_option ('-v', '--verbose',
2375                   action = "store_true",
2376                   dest = 'verbose',
2377                   help = _ ("be verbose"))
2378
2379     p.add_option ('', '--lxml',
2380                   action = "store_true",
2381                   default = False,
2382                   dest = "use_lxml",
2383                   help = _ ("use lxml.etree; uses less memory and cpu time"))
2384
2385     p.add_option ('-z', '--compressed',
2386                   action = "store_true",
2387                   dest = 'compressed',
2388                   default = False,
2389                   help = _ ("input file is a zip-compressed MusicXML file"))
2390
2391     p.add_option ('-r', '--relative',
2392                   action = "store_true",
2393                   default = True,
2394                   dest = "relative",
2395                   help = _ ("convert pitches in relative mode (default)"))
2396
2397     p.add_option ('-a', '--absolute',
2398                   action = "store_false",
2399                   dest = "relative",
2400                   help = _ ("convert pitches in absolute mode"))
2401
2402     p.add_option ('-l', '--language',
2403                   metavar = _ ("LANG"),
2404                   action = "store",
2405                   help = _ ("use a different language file 'LANG.ly' and corresponding pitch names, e.g. 'deutsch' for deutsch.ly"))
2406
2407     p.add_option ('--nd', '--no-articulation-directions',
2408                   action = "store_false",
2409                   default = True,
2410                   dest = "convert_directions",
2411                   help = _ ("do not convert directions (^, _ or -) for articulations, dynamics, etc."))
2412
2413     p.add_option ('--no-beaming',
2414                   action = "store_false",
2415                   default = True,
2416                   dest = "convert_beaming",
2417                   help = _ ("do not convert beaming information, use lilypond's automatic beaming instead"))
2418
2419     p.add_option ('-o', '--output',
2420                   metavar = _ ("FILE"),
2421                   action = "store",
2422                   default = None,
2423                   type = 'string',
2424                   dest = 'output_name',
2425                   help = _ ("set output filename to FILE, stdout if -"))
2426     p.add_option_group ('',
2427                         description = (_ ("Report bugs via")
2428                                      + ''' http://post.gmane.org/post.php'''
2429                                      '''?group=gmane.comp.gnu.lilypond.bugs\n'''))
2430     return p
2431
2432 def music_xml_voice_name_to_lily_name (part_id, name):
2433     str = "Part%sVoice%s" % (part_id, name)
2434     return musicxml_id_to_lily (str)
2435
2436 def music_xml_lyrics_name_to_lily_name (part_id, name, lyricsnr):
2437     str = "Part%sVoice%sLyrics%s" % (part_id, name, lyricsnr)
2438     return musicxml_id_to_lily (str)
2439
2440 def music_xml_figuredbass_name_to_lily_name (part_id, voicename):
2441     str = "Part%sVoice%sFiguredBass" % (part_id, voicename)
2442     return musicxml_id_to_lily (str)
2443
2444 def music_xml_chordnames_name_to_lily_name (part_id, voicename):
2445     str = "Part%sVoice%sChords" % (part_id, voicename)
2446     return musicxml_id_to_lily (str)
2447
2448 def print_voice_definitions (printer, part_list, voices):
2449     for part in part_list:
2450         part_id = part.id
2451         nv_dict = voices.get (part_id, {})
2452         for (name, voice) in nv_dict.items ():
2453             k = music_xml_voice_name_to_lily_name (part_id, name)
2454             printer.dump ('%s = ' % k)
2455             voice.ly_voice.print_ly (printer)
2456             printer.newline()
2457             if voice.chordnames:
2458                 cnname = music_xml_chordnames_name_to_lily_name (part_id, name)
2459                 printer.dump ('%s = ' % cnname )
2460                 voice.chordnames.print_ly (printer)
2461                 printer.newline()
2462             for l in voice.lyrics_order:
2463                 lname = music_xml_lyrics_name_to_lily_name (part_id, name, l)
2464                 printer.dump ('%s = ' % lname )
2465                 voice.lyrics_dict[l].print_ly (printer)
2466                 printer.newline()
2467             if voice.figured_bass:
2468                 fbname = music_xml_figuredbass_name_to_lily_name (part_id, name)
2469                 printer.dump ('%s = ' % fbname )
2470                 voice.figured_bass.print_ly (printer)
2471                 printer.newline()
2472
2473
2474 def uniq_list (l):
2475     return dict ([(elt,1) for elt in l]).keys ()
2476
2477 # format the information about the staff in the form
2478 #     [staffid,
2479 #         [
2480 #            [voiceid1, [lyricsid11, lyricsid12,...], figuredbassid1],
2481 #            [voiceid2, [lyricsid21, lyricsid22,...], figuredbassid2],
2482 #            ...
2483 #         ]
2484 #     ]
2485 # raw_voices is of the form [(voicename, lyricsids, havefiguredbass)*]
2486 def format_staff_info (part_id, staff_id, raw_voices):
2487     voices = []
2488     for (v, lyricsids, figured_bass, chordnames) in raw_voices:
2489         voice_name = music_xml_voice_name_to_lily_name (part_id, v)
2490         voice_lyrics = [music_xml_lyrics_name_to_lily_name (part_id, v, l)
2491                    for l in lyricsids]
2492         figured_bass_name = ''
2493         if figured_bass:
2494             figured_bass_name = music_xml_figuredbass_name_to_lily_name (part_id, v)
2495         chordnames_name = ''
2496         if chordnames:
2497             chordnames_name = music_xml_chordnames_name_to_lily_name (part_id, v)
2498         voices.append ([voice_name, voice_lyrics, figured_bass_name, chordnames_name])
2499     return [staff_id, voices]
2500
2501 def update_score_setup (score_structure, part_list, voices):
2502
2503     for part_definition in part_list:
2504         part_id = part_definition.id
2505         nv_dict = voices.get (part_id)
2506         if not nv_dict:
2507             error_message (_ ('unknown part in part-list: %s') % part_id)
2508             continue
2509
2510         staves = reduce (lambda x,y: x+ y,
2511                 [voice.voicedata._staves.keys ()
2512                  for voice in nv_dict.values ()],
2513                 [])
2514         staves_info = []
2515         if len (staves) > 1:
2516             staves_info = []
2517             staves = uniq_list (staves)
2518             staves.sort ()
2519             for s in staves:
2520                 thisstaff_raw_voices = [(voice_name, voice.lyrics_order, voice.figured_bass, voice.chordnames)
2521                     for (voice_name, voice) in nv_dict.items ()
2522                     if voice.voicedata._start_staff == s]
2523                 staves_info.append (format_staff_info (part_id, s, thisstaff_raw_voices))
2524         else:
2525             thisstaff_raw_voices = [(voice_name, voice.lyrics_order, voice.figured_bass, voice.chordnames)
2526                 for (voice_name, voice) in nv_dict.items ()]
2527             staves_info.append (format_staff_info (part_id, None, thisstaff_raw_voices))
2528         score_structure.set_part_information (part_id, staves_info)
2529
2530 # Set global values in the \layout block, like auto-beaming etc.
2531 def update_layout_information ():
2532     if not conversion_settings.ignore_beaming and layout_information:
2533         layout_information.set_context_item ('Score', 'autoBeaming = ##f')
2534
2535 def print_ly_preamble (printer, filename):
2536     printer.dump_version ()
2537     printer.print_verbatim ('%% automatically converted from %s\n' % filename)
2538
2539 def print_ly_additional_definitions (printer, filename):
2540     if needed_additional_definitions:
2541         printer.newline ()
2542         printer.print_verbatim ('%% additional definitions required by the score:')
2543         printer.newline ()
2544     for a in set(needed_additional_definitions):
2545         printer.print_verbatim (additional_definitions.get (a, ''))
2546         printer.newline ()
2547     printer.newline ()
2548
2549 # Read in the tree from the given I/O object (either file or string) and
2550 # demarshall it using the classes from the musicxml.py file
2551 def read_xml (io_object, use_lxml):
2552     if use_lxml:
2553         import lxml.etree
2554         tree = lxml.etree.parse (io_object)
2555         mxl_tree = musicxml.lxml_demarshal_node (tree.getroot ())
2556         return mxl_tree
2557     else:
2558         from xml.dom import minidom, Node
2559         doc = minidom.parse(io_object)
2560         node = doc.documentElement
2561         return musicxml.minidom_demarshal_node (node)
2562     return None
2563
2564
2565 def read_musicxml (filename, compressed, use_lxml):
2566     raw_string = None
2567     if compressed:
2568         if filename == "-":
2569              progress (_ ("Input is compressed, extracting raw MusicXML data from stdin") )
2570              z = zipfile.ZipFile (sys.stdin)
2571         else:
2572             progress (_ ("Input file %s is compressed, extracting raw MusicXML data") % filename)
2573             z = zipfile.ZipFile (filename, "r")
2574         container_xml = z.read ("META-INF/container.xml")
2575         if not container_xml:
2576             return None
2577         container = read_xml (StringIO.StringIO (container_xml), use_lxml)
2578         if not container:
2579             return None
2580         rootfiles = container.get_maybe_exist_named_child ('rootfiles')
2581         if not rootfiles:
2582             return None
2583         rootfile_list = rootfiles.get_named_children ('rootfile')
2584         mxml_file = None
2585         if len (rootfile_list) > 0:
2586             mxml_file = getattr (rootfile_list[0], 'full-path', None)
2587         if mxml_file:
2588             raw_string = z.read (mxml_file)
2589
2590     if raw_string:
2591         io_object = StringIO.StringIO (raw_string)
2592     elif filename == "-":
2593         io_object = sys.stdin
2594     else:
2595         io_object = filename
2596
2597     return read_xml (io_object, use_lxml)
2598
2599
2600 def convert (filename, options):
2601     if filename == "-":
2602         progress (_ ("Reading MusicXML from Standard input ...") )
2603     else:
2604         progress (_ ("Reading MusicXML from %s ...") % filename)
2605
2606     tree = read_musicxml (filename, options.compressed, options.use_lxml)
2607     score_information = extract_score_information (tree)
2608     paper_information = extract_paper_information (tree)
2609
2610     parts = tree.get_typed_children (musicxml.Part)
2611     (voices, staff_info) = get_all_voices (parts)
2612
2613     score = None
2614     mxl_pl = tree.get_maybe_exist_typed_child (musicxml.Part_list)
2615     if mxl_pl:
2616         score = extract_score_structure (mxl_pl, staff_info)
2617         part_list = mxl_pl.get_named_children ("score-part")
2618
2619     # score information is contained in the <work>, <identification> or <movement-title> tags
2620     update_score_setup (score, part_list, voices)
2621     # After the conversion, update the list of settings for the \layout block
2622     update_layout_information ()
2623
2624     if not options.output_name:
2625         options.output_name = os.path.basename (filename)
2626         options.output_name = os.path.splitext (options.output_name)[0]
2627     elif re.match (".*\.ly", options.output_name):
2628         options.output_name = os.path.splitext (options.output_name)[0]
2629
2630
2631     #defs_ly_name = options.output_name + '-defs.ly'
2632     if (options.output_name == "-"):
2633       output_ly_name = 'Standard output'
2634     else:
2635       output_ly_name = options.output_name + '.ly'
2636
2637     progress (_ ("Output to `%s'") % output_ly_name)
2638     printer = musicexp.Output_printer()
2639     #progress (_ ("Output to `%s'") % defs_ly_name)
2640     if (options.output_name == "-"):
2641       printer.set_file (codecs.getwriter ("utf-8")(sys.stdout))
2642     else:
2643       printer.set_file (codecs.open (output_ly_name, 'wb', encoding='utf-8'))
2644     print_ly_preamble (printer, filename)
2645     print_ly_additional_definitions (printer, filename)
2646     if score_information:
2647         score_information.print_ly (printer)
2648     if paper_information:
2649         paper_information.print_ly (printer)
2650     if layout_information:
2651         layout_information.print_ly (printer)
2652     print_voice_definitions (printer, part_list, voices)
2653
2654     printer.newline ()
2655     printer.dump ("% The score definition")
2656     printer.newline ()
2657     score.print_ly (printer)
2658     printer.newline ()
2659
2660     return voices
2661
2662 def get_existing_filename_with_extension (filename, ext):
2663     if os.path.exists (filename):
2664         return filename
2665     newfilename = filename + "." + ext
2666     if os.path.exists (newfilename):
2667         return newfilename;
2668     newfilename = filename + ext
2669     if os.path.exists (newfilename):
2670         return newfilename;
2671     return ''
2672
2673 def main ():
2674     opt_parser = option_parser()
2675
2676     global options
2677     (options, args) = opt_parser.parse_args ()
2678     if not args:
2679         opt_parser.print_usage()
2680         sys.exit (2)
2681
2682     if options.language:
2683         musicexp.set_pitch_language (options.language)
2684         needed_additional_definitions.append (options.language)
2685         additional_definitions[options.language] = "\\include \"%s.ly\"\n" % options.language
2686     conversion_settings.ignore_beaming = not options.convert_beaming
2687
2688     # Allow the user to leave out the .xml or xml on the filename
2689     basefilename = args[0].decode('utf-8')
2690     if basefilename == "-": # Read from stdin
2691         basefilename = "-"
2692     else:
2693         filename = get_existing_filename_with_extension (basefilename, "xml")
2694         if not filename:
2695             filename = get_existing_filename_with_extension (basefilename, "mxl")
2696             options.compressed = True
2697     if filename and filename.endswith ("mxl"):
2698         options.compressed = True
2699
2700     if filename and (filename == "-" or os.path.exists (filename)):
2701         voices = convert (filename, options)
2702     else:
2703         progress (_ ("Unable to find input file %s") % basefilename)
2704
2705 if __name__ == '__main__':
2706     main()