X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=scripts%2Fmusicxml2ly.py;h=6d7389fb5284eed6dc5537b7b7c8b7f05bdcacc4;hb=50544a7e764debe4a149220497c854ee0819d95c;hp=4441f5be682ef9fc24340ea9ced05f945293f0b5;hpb=7c61b155a19349e4b1140b0de5dfd0c318af365c;p=lilypond.git

diff --git a/scripts/musicxml2ly.py b/scripts/musicxml2ly.py
index 4441f5be68..6d7389fb52 100644
--- a/scripts/musicxml2ly.py
+++ b/scripts/musicxml2ly.py
@@ -6,6 +6,8 @@ import re
 import os
 import string
 import codecs
+import zipfile
+import StringIO
 from gettext import gettext as _
 
 """
@@ -19,15 +21,130 @@ import musicexp
 
 from rational import Rational
 
+# Store command-line options in a global variable, so we can access them everythwere
+options = None
 
 def progress (str):
-    sys.stderr.write (str + '\n')
+    ly.stderr_write (str + '\n')
     sys.stderr.flush ()
 
 def error_message (str):
-    sys.stderr.write (str + '\n')
+    ly.stderr_write (str + '\n')
     sys.stderr.flush ()
 
+needed_additional_definitions = []
+additional_definitions = {
+  "snappizzicato": """#(define-markup-command (snappizzicato layout props) ()
+  (interpret-markup layout props
+    (markup #:stencil
+      (ly:stencil-translate-axis
+        (ly:stencil-add
+          (make-circle-stencil 0.7 0.1 #f)
+          (ly:make-stencil
+            (list 'draw-line 0.1 0 0.1 0 1)
+            '(-0.1 . 0.1) '(0.1 . 1)
+          )
+        )
+        0.7 X
+      )
+    )
+  )
+)"""
+}
+
+def round_to_two_digits (val):
+    return round (val * 100) / 100
+
+def extract_layout_information (tree):
+    paper = musicexp.Paper ()
+    defaults = tree.get_maybe_exist_named_child ('defaults')
+    if not defaults:
+        return None
+    tenths = -1
+    scaling = defaults.get_maybe_exist_named_child ('scaling')
+    if scaling:
+        mm = scaling.get_named_child ('millimeters')
+        mm = string.atof (mm.get_text ())
+        tn = scaling.get_maybe_exist_named_child ('tenths')
+        tn = string.atof (tn.get_text ())
+        tenths = mm / tn
+        paper.global_staff_size = mm * 72.27 / 25.4
+    # We need the scaling (i.e. the size of staff tenths for everything!
+    if tenths < 0:
+        return None
+
+    def from_tenths (txt):
+        return round_to_two_digits (string.atof (txt) * tenths / 10)
+    def set_paper_variable (varname, parent, element_name):
+        el = parent.get_maybe_exist_named_child (element_name)
+        if el: # Convert to cm from tenths
+            setattr (paper, varname, from_tenths (el.get_text ()))
+
+    pagelayout = defaults.get_maybe_exist_named_child ('page-layout')
+    if pagelayout:
+        # TODO: How can one have different margins for even and odd pages???
+        set_paper_variable ("page_height", pagelayout, 'page-height')
+        set_paper_variable ("page_width", pagelayout, 'page-width')
+
+        pmargins = pagelayout.get_named_children ('page-margins')
+        for pm in pmargins:
+            set_paper_variable ("left_margin", pm, 'left-margin')
+            set_paper_variable ("right_margin", pm, 'right-margin')
+            set_paper_variable ("bottom_margin", pm, 'bottom-margin')
+            set_paper_variable ("top_margin", pm, 'top-margin')
+
+    systemlayout = defaults.get_maybe_exist_named_child ('system-layout')
+    if systemlayout:
+        sl = systemlayout.get_maybe_exist_named_child ('system-margins')
+        if sl:
+            set_paper_variable ("system_left_margin", sl, 'left-margin')
+            set_paper_variable ("system_right_margin", sl, 'right-margin')
+        set_paper_variable ("system_distance", systemlayout, 'system-distance')
+        set_paper_variable ("top_system_distance", systemlayout, 'top-system-distance')
+
+    stafflayout = defaults.get_named_children ('staff-layout')
+    for sl in stafflayout:
+        nr = getattr (sl, 'number', 1)
+        dist = sl.get_named_child ('staff-distance')
+        #TODO: the staff distance needs to be set in the Staff context!!!
+
+    # TODO: Finish appearance?, music-font?, word-font?, lyric-font*, lyric-language*
+    appearance = defaults.get_named_child ('appearance')
+    if appearance:
+        lws = appearance.get_named_children ('line-width')
+        for lw in lws:
+            # Possible types are: beam, bracket, dashes,
+            #    enclosure, ending, extend, heavy barline, leger,
+            #    light barline, octave shift, pedal, slur middle, slur tip,
+            #    staff, stem, tie middle, tie tip, tuplet bracket, and wedge
+            tp = lw.type
+            w = from_tenths (lw.get_text  ())
+            # TODO: Do something with these values!
+        nss = appearance.get_named_children ('note-size')
+        for ns in nss:
+            # Possible types are: cue, grace and large
+            tp = ns.type
+            sz = from_tenths (ns.get_text ())
+            # TODO: Do something with these values!
+        # <other-appearance> elements have no specified meaning
+
+    rawmusicfont = defaults.get_named_child ('music-font')
+    if rawmusicfont:
+        # TODO: Convert the font
+        pass
+    rawwordfont = defaults.get_named_child ('word-font')
+    if rawwordfont:
+        # TODO: Convert the font
+        pass
+    rawlyricsfonts = defaults.get_named_children ('lyric-font')
+    for lyricsfont in rawlyricsfonts:
+        # TODO: Convert the font
+        pass
+
+    return paper
+
+
+
 # score information is contained in the <work>, <identification> or <movement-title> tags
 # extract those into a hash, indexed by proper lilypond header attributes
 def extract_score_information (tree):
@@ -62,26 +179,111 @@ def extract_score_information (tree):
 
     return header
 
+class PartGroupInfo:
+    def __init__ (self):
+        self.start = {}
+        self.end = {}
+    def is_empty (self):
+        return len (self.start) + len (self.end) == 0
+    def add_start (self, g):
+        self.start[getattr (g, 'number', "1")] = g
+    def add_end (self, g):
+        self.end[getattr (g, 'number', "1")] = g
+    def print_ly (self, printer):
+        error_message ("Unprocessed PartGroupInfo %s encountered" % self)
+    def ly_expression (self):
+        error_message ("Unprocessed PartGroupInfo %s encountered" % self)
+        return ''
+
+def staff_attributes_to_string_tunings (mxl_attr):
+    details = mxl_attr.get_maybe_exist_named_child ('staff-details')
+    if not details:
+        return []
+    lines = 6
+    staff_lines = details.get_maybe_exist_named_child ('staff-lines')
+    if staff_lines:
+        lines = string.atoi (staff_lines.get_text ())
+
+    tunings = [0]*lines
+    staff_tunings = details.get_named_children ('staff-tuning')
+    for i in staff_tunings:
+        p = musicexp.Pitch()
+        line = 0
+        try:
+            line = string.atoi (i.line) - 1
+        except ValueError:
+            pass
+        tunings[line] = p
+
+        step = i.get_named_child (u'tuning-step')
+        step = step.get_text ().strip ()
+        p.step = musicxml_step_to_lily (step)
+
+        octave = i.get_named_child (u'tuning-octave')
+        octave = octave.get_text ().strip ()
+        p.octave = int (octave) - 4
+
+        alter = i.get_named_child (u'tuning-alter')
+        if alter:
+            p.alteration = int (alter.get_text ().strip ())
+    # lilypond seems to use the opposite ordering than MusicXML...
+    tunings.reverse ()
+
+    return tunings
+
+
+def staff_attributes_to_lily_staff (mxl_attr):
+    if not mxl_attr:
+        return musicexp.Staff ()
+
+    (staff_id, attributes) = mxl_attr.items ()[0]
+
+    # distinguish by clef:
+    # percussion (percussion and rhythmic), tab, and everything else
+    clef_sign = None
+    clef = attributes.get_maybe_exist_named_child ('clef')
+    if clef:
+        sign = clef.get_maybe_exist_named_child ('sign')
+        if sign:
+            clef_sign = {"percussion": "percussion", "TAB": "tab"}.get (sign.get_text (), None)
+
+    lines = 5
+    details = attributes.get_maybe_exist_named_child ('staff-details')
+    if details:
+        staff_lines = details.get_maybe_exist_named_child ('staff-lines')
+        if staff_lines:
+            lines = string.atoi (staff_lines.get_text ())
+
+    staff = None
+    if clef_sign == "percussion" and lines == 1:
+        staff = musicexp.RhythmicStaff ()
+    elif clef_sign == "percussion":
+        staff = musicexp.DrumStaff ()
+        # staff.drum_style_table = ???
+    elif clef_sign == "tab":
+        staff = musicexp.TabStaff ()
+        staff.string_tunings = staff_attributes_to_string_tunings (attributes)
+        # staff.tablature_format = ???
+    else:
+        # TODO: Handle case with lines <> 5!
+        staff = musicexp.Staff ()
+
+    return staff
+
 
-def extract_score_layout (part_list):
+def extract_score_layout (part_list, staffinfo):
     layout = musicexp.StaffGroup (None)
-    currentgroups_dict = {}
-    currentgroups = []
     if not part_list:
         return layout
 
-    def insert_into_layout (object):
-            if len (currentgroups) > 0:
-                group_to_insert = currentgroups_dict.get (currentgroups [-1], layout)
-            else:
-                group_to_insert = layout
-            group_to_insert.appendStaff (object)
-            return group_to_insert
-
     def read_score_part (el):
         if not isinstance (el, musicxml.Score_part):
             return
-        staff = musicexp.Staff ()
+        # Depending on the attributes of the first measure, we create different
+        # types of staves (Staff, RhythmicStaff, DrumStaff, TabStaff, etc.)
+        staff = staff_attributes_to_lily_staff (staffinfo.get (el.id, None))
+        if not staff:
+            return None
         staff.id = el.id
         partname = el.get_maybe_exist_named_child ('part-name')
         # Finale gives unnamed parts the name "MusicXML Part" automatically!
@@ -92,48 +294,112 @@ def extract_score_layout (part_list):
         # TODO: Read in the MIDI device / instrument
         return staff
 
+    def read_score_group (el):
+        if not isinstance (el, musicxml.Part_group):
+            return
+        group = musicexp.StaffGroup ()
+        if hasattr (el, 'number'):
+            id = el.number
+            group.id = id
+            #currentgroups_dict[id] = group
+            #currentgroups.append (id)
+        if el.get_maybe_exist_named_child ('group-name'):
+            group.instrument_name = el.get_maybe_exist_named_child ('group-name').get_text ()
+        if el.get_maybe_exist_named_child ('group-abbreviation'):
+            group.short_instrument_name = el.get_maybe_exist_named_child ('group-abbreviation').get_text ()
+        if el.get_maybe_exist_named_child ('group-symbol'):
+            group.symbol = el.get_maybe_exist_named_child ('group-symbol').get_text ()
+        if el.get_maybe_exist_named_child ('group-barline'):
+            group.spanbar = el.get_maybe_exist_named_child ('group-barline').get_text ()
+        return group
+
 
     parts_groups = part_list.get_all_children ()
-    # the start/end group tags are not necessarily ordered correctly, so
-    # we can't go through the children sequentially!
 
-    if len (parts_groups) == 1 and isinstance (parts_group[1], musicxml.Score_part):
-        return read_score_part (parts_group[1])
+    # the start/end group tags are not necessarily ordered correctly and groups
+    # might even overlap, so we can't go through the children sequentially!
 
+    # 1) Replace all Score_part objects by their corresponding Staff objects,
+    #    also collect all group start/stop points into one PartGroupInfo object
+    staves = []
+    group_info = PartGroupInfo ()
     for el in parts_groups:
         if isinstance (el, musicxml.Score_part):
+            if not group_info.is_empty ():
+                staves.append (group_info)
+                group_info = PartGroupInfo ()
             staff = read_score_part (el)
-            insert_into_layout (staff)
+            if staff:
+                staves.append (staff)
         elif isinstance (el, musicxml.Part_group):
             if el.type == "start":
-                group = musicexp.StaffGroup ()
-                staff_group = insert_into_layout (group)
-                # If we're inserting a nested staffgroup, we need to use InnerStaffGroup
-                if staff_group != layout:
-                    group.stafftype = "InnerStaffGroup"
-                if hasattr (el, 'number'):
-                    id = el.number
-                    group.id = id
-                    currentgroups_dict[id] = group
-                    currentgroups.append (id)
-                if el.get_maybe_exist_named_child ('group-name'):
-                    group.instrument_name = el.get_maybe_exist_named_child ('group-name').get_text ()
-                if el.get_maybe_exist_named_child ('group-abbreviation'):
-                    group.short_instrument_name = el.get_maybe_exist_named_child ('group-abbreviation').get_text ()
-                if el.get_maybe_exist_named_child ('group-symbol'):
-                    group.symbol = el.get_maybe_exist_named_child ('group-symbol').get_text ()
-                if el.get_maybe_exist_named_child ('group-barline'):
-                    group.spanbar = el.get_maybe_exist_named_child ('group-barline').get_text ()
-
+                group_info.add_start (el)
             elif el.type == "stop":
-                # end the part-group, i.e. simply remove it from the lists
-                if hasattr (el, 'number'):
-                    pid = el.number
-                elif len (currentgroups) > 0:
-                    pid = el[-1]
-                if pid:
-                    del currentgroups_dict[pid]
-                    currentgroups.remove (pid)
+                group_info.add_end (el)
+    if not group_info.is_empty ():
+        staves.append (group_info)
+
+    # 2) Now, detect the groups:
+    group_starts = []
+    pos = 0
+    while pos < len (staves):
+        el = staves[pos]
+        if isinstance (el, PartGroupInfo):
+            prev_start = 0
+            if len (group_starts) > 0:
+                prev_start = group_starts[-1]
+            elif len (el.end) > 0: # no group to end here
+                el.end = {}
+            if len (el.end) > 0: # closes an existing group
+                ends = el.end.keys ()
+                prev_started = staves[prev_start].start.keys ()
+                grpid = None
+                intersection = filter(lambda x:x in ends, prev_started)
+                if len (intersection) > 0:
+                    grpid = intersection[0]
+                else:
+                    # Close the last started group
+                    grpid = staves[prev_start].start.keys () [0]
+                    # Find the corresponding closing tag and remove it!
+                    j = pos + 1
+                    foundclosing = False
+                    while j < len (staves) and not foundclosing:
+                        if isinstance (staves[j], PartGroupInfo) and staves[j].end.has_key (grpid):
+                            foundclosing = True
+                            del staves[j].end[grpid]
+                            if staves[j].is_empty ():
+                                del staves[j]
+                        j += 1
+                grpobj = staves[prev_start].start[grpid]
+                group = read_score_group (grpobj)
+                # remove the id from both the start and end
+                if el.end.has_key (grpid):
+                    del el.end[grpid]
+                del staves[prev_start].start[grpid]
+                if el.is_empty ():
+                    del staves[pos]
+                # replace the staves with the whole group
+                for j in staves[(prev_start + 1):pos]:
+                    if j.is_group:
+                        j.stafftype = "InnerStaffGroup"
+                    group.append_staff (j)
+                del staves[(prev_start + 1):pos]
+                staves.insert (prev_start + 1, group)
+                # reset pos so that we continue at the correct position
+                pos = prev_start
+                # remove an empty start group
+                if staves[prev_start].is_empty ():
+                    del staves[prev_start]
+                    group_starts.remove (prev_start)
+                    pos -= 1
+            elif len (el.start) > 0: # starts new part groups
+                group_starts.append (pos)
+        pos += 1
+
+    if len (staves) == 1:
+        return staves[0]
+    for i in staves:
+        layout.append_staff (i)
     return layout
 
 
@@ -157,8 +423,8 @@ def rational_to_lily_duration (rational_len):
     d.duration_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)
     d.factor = Rational (rational_len.numerator ())
     if d.duration_log < 0:
-        error_message ("Encountered rational duration with denominator %s, "
-                       "unable to convert to lilypond duration" %
+        error_message (_ ("Encountered rational duration with denominator %s, "
+                       "unable to convert to lilypond duration") %
                        rational_len.denominator ())
         # TODO: Test the above error message
         return None
@@ -179,13 +445,13 @@ def musicxml_partial_to_lily (partial_len):
 def group_repeats (music_list):
     repeat_replaced = True
     music_start = 0
-    i=0
+    i = 0
     # Walk through the list of expressions, looking for repeat structure
     # (repeat start/end, corresponding endings). If we find one, try to find the
     # last event of the repeat, replace the whole structure and start over again.
     # For nested repeats, as soon as we encounter another starting repeat bar,
     # treat that one first, and start over for the outer repeat.
-    while repeat_replaced and i<10:
+    while repeat_replaced and i < 100:
         i += 1
         repeat_start = -1  # position of repeat start / end
         repeat_end = -1 # position of repeat start / end
@@ -220,6 +486,7 @@ def group_repeats (music_list):
                 if e.direction == -1:
                     if repeat_start < 0:
                         repeat_start = 0
+                    if repeat_end < 0:
                         repeat_end = pos
                     ending_start = pos
                 elif e.direction == 1:
@@ -377,7 +644,7 @@ class Marker (musicexp.Music):
         self.direction = 0
         self.event = None
     def print_ly (self, printer):
-        sys.stderr.write ("Encountered unprocessed marker %s\n" % self)
+        ly.stderr_write (_ ("Encountered unprocessed marker %s\n") % self)
         pass
     def ly_expression (self):
         return ""
@@ -417,18 +684,18 @@ def musicxml_barline_to_lily (barline):
                 repeat.times = 2
         repeat.event = barline
         if repeat.direction == -1:
-            retval[1] = repeat
-        else:
             retval[3] = repeat
+        else:
+            retval[1] = repeat
 
     if ending_element and hasattr (ending_element, 'type'):
         ending = EndingMarker ()
         ending.direction = {"start": -1, "stop": 1, "discontinue": 1}.get (ending_element.type, 0)
         ending.event = barline
         if ending.direction == -1:
-            retval[0] = ending
-        else:
             retval[4] = ending
+        else:
+            retval[0] = ending
 
     if bartype:
         b = musicexp.BarLine ()
@@ -438,12 +705,14 @@ def musicxml_barline_to_lily (barline):
     return retval.values ()
 
 spanner_event_dict = {
-    'slur' : musicexp.SlurEvent,
     'beam' : musicexp.BeamEvent,
+    'dashes' : musicexp.TextSpannerEvent,
+    'bracket' : musicexp.BracketSpannerEvent,
     'glissando' : musicexp.GlissandoEvent,
+    'octave-shift' : musicexp.OctaveShiftEvent,
     'pedal' : musicexp.PedalEvent,
+    'slur' : musicexp.SlurEvent,
     'wavy-line' : musicexp.TrillSpanEvent,
-    'octave-shift' : musicexp.OctaveShiftEvent,
     'wedge' : musicexp.HairpinEvent
 }
 spanner_type_dict = {
@@ -453,6 +722,7 @@ spanner_type_dict = {
     'decreschendo': -1,
     'diminuendo': -1,
     'continue': 0,
+    'change': 0,
     'up': -1,
     'down': -1,
     'stop': 1,
@@ -467,7 +737,7 @@ def musicxml_spanner_to_lily_event (mxl_event):
     if func:
         ev = func()
     else:
-        error_message ('unknown span event %s' % mxl_event)
+        error_message (_ ('unknown span event %s') % mxl_event)
 
 
     type = mxl_event.get_type ()
@@ -477,7 +747,7 @@ def musicxml_spanner_to_lily_event (mxl_event):
     if span_direction != None:
         ev.span_direction = span_direction
     else:
-        error_message ('unknown span type %s for %s' % (type, name))
+        error_message (_ ('unknown span type %s for %s') % (type, name))
 
     ev.set_span_type (type)
     ev.line_type = getattr (mxl_event, 'line-type', 'solid')
@@ -488,20 +758,41 @@ def musicxml_spanner_to_lily_event (mxl_event):
     return ev
 
 def musicxml_direction_to_indicator (direction):
-    return { "above": 1, "upright": 1, "below": -1, "downright": -1 }.get (direction, '')
+    return { "above": 1, "upright": 1, "up":1, "below": -1, "downright": -1, "down": -1, "inverted": -1 }.get (direction, 0)
 
 def musicxml_fermata_to_lily_event (mxl_event):
     ev = musicexp.ArticulationEvent ()
-    ev.type = "fermata"
+    txt = mxl_event.get_text ()
+    # The contents of the element defined the shape, possible are normal, angled and square
+    ev.type = { "angled": "shortfermata", "square": "longfermata" }.get (txt, "fermata")
     if hasattr (mxl_event, 'type'):
       dir = musicxml_direction_to_indicator (mxl_event.type)
-      if dir:
+      if dir and options.convert_directions:
         ev.force_direction = dir
     return ev
 
+def musicxml_arpeggiate_to_lily_event (mxl_event):
+    ev = musicexp.ArpeggioEvent ()
+    ev.direction = musicxml_direction_to_indicator (getattr (mxl_event, 'direction', None))
+    return ev
+
 def musicxml_tremolo_to_lily_event (mxl_event):
     ev = musicexp.TremoloEvent ()
-    ev.bars = mxl_event.get_text ()
+    txt = mxl_event.get_text ()
+    if txt:
+      ev.bars = txt
+    else:
+      ev.bars = "3"
+    return ev
+
+def musicxml_falloff_to_lily_event (mxl_event):
+    ev = musicexp.BendEvent ()
+    ev.alter = -4
+    return ev
+
+def musicxml_doit_to_lily_event (mxl_event):
+    ev = musicexp.BendEvent ()
+    ev.alter = 4
     return ev
 
 def musicxml_bend_to_lily_event (mxl_event):
@@ -509,12 +800,29 @@ def musicxml_bend_to_lily_event (mxl_event):
     ev.alter = mxl_event.bend_alter ()
     return ev
 
+def musicxml_caesura_to_lily_event (mxl_event):
+    ev = musicexp.MarkupEvent ()
+    # FIXME: default to straight or curved caesura?
+    ev.contents = "\\musicglyph #\"scripts.caesura.straight\""
+    ev.force_direction = 1
+    return ev
 
 def musicxml_fingering_event (mxl_event):
     ev = musicexp.ShortArticulationEvent ()
     ev.type = mxl_event.get_text ()
     return ev
 
+def musicxml_snappizzicato_event (mxl_event):
+    needed_additional_definitions.append ("snappizzicato")
+    ev = musicexp.MarkupEvent ()
+    ev.contents = "\\snappizzicato"
+    return ev
+
+def musicxml_string_event (mxl_event):
+    ev = musicexp.NoDirectionArticulationEvent ()
+    ev.type = mxl_event.get_text ()
+    return ev
+
 def musicxml_accidental_mark (mxl_event):
     ev = musicexp.MarkupEvent ()
     contents = { "sharp": "\\sharp",
@@ -544,17 +852,17 @@ def musicxml_accidental_mark (mxl_event):
 #   -) (class, name)  (like string, only that a different class than ArticulationEvent is used)
 # TODO: Some translations are missing!
 articulations_dict = {
-    "accent": (musicexp.ShortArticulationEvent, ">"),
+    "accent": (musicexp.ShortArticulationEvent, ">"), # or "accent"
     "accidental-mark": musicxml_accidental_mark,
     "bend": musicxml_bend_to_lily_event,
     "breath-mark": (musicexp.NoDirectionArticulationEvent, "breathe"),
-    #"caesura": "caesura",
+    "caesura": musicxml_caesura_to_lily_event,
     #"delayed-turn": "?",
-    #"detached-legato": "",
-    #"doit": "",
+    "detached-legato": (musicexp.ShortArticulationEvent, "_"), # or "portato"
+    "doit": musicxml_doit_to_lily_event,
     #"double-tongue": "",
     "down-bow": "downbow",
-    #"falloff": "",
+    "falloff": musicxml_falloff_to_lily_event,
     "fingering": musicxml_fingering_event,
     #"fingernails": "",
     #"fret": "",
@@ -564,25 +872,24 @@ articulations_dict = {
     "inverted-mordent": "prall",
     "inverted-turn": "reverseturn",
     "mordent": "mordent",
-    #"open-string": "",
+    "open-string": "open",
     #"plop": "",
     #"pluck": "",
-    #"portato": (musicexp.ShortArticulationEvent, "_"), # does not exist in MusicXML
     #"pull-off": "",
     #"schleifer": "?",
     #"scoop": "",
     #"shake": "?",
-    #"snap-pizzicato": "",
+    "snap-pizzicato": musicxml_snappizzicato_event,
     #"spiccato": "",
-    "staccatissimo": (musicexp.ShortArticulationEvent, "|"),
-    "staccato": (musicexp.ShortArticulationEvent, "."),
-    "stopped": (musicexp.ShortArticulationEvent, "+"),
+    "staccatissimo": (musicexp.ShortArticulationEvent, "|"), # or "staccatissimo"
+    "staccato": (musicexp.ShortArticulationEvent, "."), # or "staccato"
+    "stopped": (musicexp.ShortArticulationEvent, "+"), # or "stopped"
     #"stress": "",
-    #"string": "",
-    "strong-accent": (musicexp.ShortArticulationEvent, "^"),
+    "string": musicxml_string_event,
+    "strong-accent": (musicexp.ShortArticulationEvent, "^"), # or "marcato"
     #"tap": "",
-    "tenuto": (musicexp.ShortArticulationEvent, "-"),
-    #"thumb-position": "",
+    "tenuto": (musicexp.ShortArticulationEvent, "-"), # or "tenuto"
+    "thumb-position": "thumb",
     #"toe": "",
     "turn": "turn",
     "tremolo": musicxml_tremolo_to_lily_event,
@@ -614,22 +921,35 @@ def musicxml_articulation_to_lily_event (mxl_event):
 
     # Some articulations use the type attribute, other the placement...
     dir = None
-    if hasattr (mxl_event, 'type'):
+    if hasattr (mxl_event, 'type') and options.convert_directions:
         dir = musicxml_direction_to_indicator (mxl_event.type)
-    if hasattr (mxl_event, 'placement'):
+    if hasattr (mxl_event, 'placement') and options.convert_directions:
         dir = musicxml_direction_to_indicator (mxl_event.placement)
+    if dir:
+        ev.force_direction = dir
     return ev
 
 
+
 def musicxml_dynamics_to_lily_event (dynentry):
-    dynamics_available = ( "p", "pp", "ppp", "pppp", "ppppp", "pppppp",
-        "f", "ff", "fff", "ffff", "fffff", "ffffff",
-        "mp", "mf", "sf", "sfp", "sfpp", "fp",
-        "rf", "rfz", "sfz", "sffz", "fz" )
-    if not dynentry.get_name() in dynamics_available:
+    dynamics_available = (
+        "ppppp", "pppp", "ppp", "pp", "p", "mp", "mf", 
+        "f", "ff", "fff", "ffff", "fp", "sf", "sff", "sp", "spp", "sfz", "rfz" )
+    dynamicsname = dynentry.get_name ()
+    if dynamicsname == "other-dynamics":
+        dynamicsname = dynentry.get_text ()
+    if not dynamicsname or dynamicsname=="#text":
         return
+
+    if not dynamicsname in dynamics_available:
+        # Get rid of - in tag names (illegal in ly tags!)
+        dynamicstext = dynamicsname
+        dynamicsname = string.replace (dynamicsname, "-", "")
+        additional_definitions[dynamicsname] = dynamicsname + \
+              " = #(make-dynamic-script \"" + dynamicstext + "\")"
+        needed_additional_definitions.append (dynamicsname)
     event = musicexp.DynamicsEvent ()
-    event.type = dynentry.get_name ()
+    event.type = dynamicsname
     return event
 
 # Convert single-color two-byte strings to numbers 0.0 - 1.0
@@ -656,7 +976,7 @@ def musicxml_words_to_lily_event (words):
     text = re.sub (' *\n? *$', '', text)
     event.text = text
 
-    if hasattr (words, 'default-y'):
+    if hasattr (words, 'default-y') and options.convert_directions:
         offset = getattr (words, 'default-y')
         try:
             off = string.atoi (offset)
@@ -706,16 +1026,140 @@ def musicxml_words_to_lily_event (words):
     return event
 
 
-direction_spanners = [ 'octave-shift', 'pedal', 'wedge' ]
+# convert accordion-registration to lilypond.
+# Since lilypond does not have any built-in commands, we need to create
+# the markup commands manually and define our own variables.
+# Idea was taken from: http://lsr.dsi.unimi.it/LSR/Item?id=194
+def musicxml_accordion_to_markup (mxl_event):
+    commandname = "accReg"
+    command = ""
+
+    high = mxl_event.get_maybe_exist_named_child ('accordion-high')
+    if high:
+        commandname += "H"
+        command += """\\combine
+          \\raise #2.5 \\musicglyph #\"accordion.accDot\"
+          """
+    middle = mxl_event.get_maybe_exist_named_child ('accordion-middle')
+    if middle:
+        # By default, use one dot (when no or invalid content is given). The 
+        # MusicXML spec is quiet about this case...
+        txt = 1
+        try:
+          txt = string.atoi (middle.get_text ())
+        except ValueError:
+            pass
+        if txt == 3:
+            commandname += "MMM"
+            command += """\\combine
+          \\raise #1.5 \\musicglyph #\"accordion.accDot\"
+          \\combine
+          \\raise #1.5 \\translate #(cons 1 0) \\musicglyph #\"accordion.accDot\"
+          \\combine
+          \\raise #1.5 \\translate #(cons -1 0) \\musicglyph #\"accordion.accDot\"
+          """
+        elif txt == 2:
+            commandname += "MM"
+            command += """\\combine
+          \\raise #1.5 \\translate #(cons 0.5 0) \\musicglyph #\"accordion.accDot\"
+          \\combine
+          \\raise #1.5 \\translate #(cons -0.5 0) \\musicglyph #\"accordion.accDot\"
+          """
+        elif not txt <= 0:
+            commandname += "M"
+            command += """\\combine
+          \\raise #1.5 \\musicglyph #\"accordion.accDot\"
+          """
+    low = mxl_event.get_maybe_exist_named_child ('accordion-low')
+    if low:
+        commandname += "L"
+        command += """\\combine
+          \\raise #0.5 \musicglyph #\"accordion.accDot\"
+          """
+
+    command += "\musicglyph #\"accordion.accDiscant\""
+    command = "\\markup { \\normalsize %s }" % command
+    # Define the newly built command \accReg[H][MMM][L]
+    additional_definitions[commandname] = "%s = %s" % (commandname, command)
+    needed_additional_definitions.append (commandname)
+    return "\\%s" % commandname
+
+def musicxml_accordion_to_ly (mxl_event):
+    txt = musicxml_accordion_to_markup (mxl_event)
+    if txt:
+        ev = musicexp.MarkEvent (txt)
+        return ev
+    return
+
+
+def musicxml_rehearsal_to_ly_mark (mxl_event):
+    text = mxl_event.get_text ()
+    if not text:
+        return
+    # default is boxed rehearsal marks!
+    encl = "box"
+    if hasattr (mxl_event, 'enclosure'):
+        encl = {"none": None, "square": "box", "circle": "circle" }.get (mxl_event.enclosure, None)
+    if encl:
+        text = "\\%s { %s }" % (encl, text)
+    ev = musicexp.MarkEvent ("\\markup { %s }" % text)
+    return ev
+
+# translate directions into Events, possible values:
+#   -) string  (MarkEvent with that command)
+#   -) function (function(mxl_event) needs to return a full Event-derived object
+#   -) (class, name)  (like string, only that a different class than MarkEvent is used)
+directions_dict = {
+    'accordion-registration' : musicxml_accordion_to_ly,
+    'coda' : (musicexp.MusicGlyphMarkEvent, "coda"),
+#     'damp' : ???
+#     'damp-all' : ???
+#     'eyeglasses': ??????
+#     'harp-pedals' : 
+#     'image' : 
+#     'metronome' : 
+    'rehearsal' : musicxml_rehearsal_to_ly_mark,
+#     'scordatura' : 
+    'segno' : (musicexp.MusicGlyphMarkEvent, "segno"),
+    'words' : musicxml_words_to_lily_event,
+}
+directions_spanners = [ 'octave-shift', 'pedal', 'wedge', 'dashes', 'bracket' ]
 
 def musicxml_direction_to_lily (n):
     # TODO: Handle the <staff> element!
     res = []
+    # placement applies to all children!
+    dir = None
+    if hasattr (n, 'placement') and options.convert_directions:
+        dir = musicxml_direction_to_indicator (n.placement)
     dirtype_children = []
+    # TODO: The direction-type is used for grouping (e.g. dynamics with text), 
+    #       so we can't simply flatten them out!
     for dt in n.get_typed_children (musicxml.DirType):
         dirtype_children += dt.get_all_children ()
 
     for entry in dirtype_children:
+        # backets, dashes, octave shifts. pedal marks, hairpins etc. are spanners:
+        if entry.get_name() in directions_spanners:
+            event = musicxml_spanner_to_lily_event (entry)
+            if event:
+                res.append (event)
+            continue
+
+        # now treat all the "simple" ones, that can be translated using the dict
+        ev = None
+        tmp_tp = directions_dict.get (entry.get_name (), None)
+        if isinstance (tmp_tp, str): # string means MarkEvent
+            ev = musicexp.MarkEvent (tmp_tp)
+        elif isinstance (tmp_tp, tuple): # tuple means (EventClass, "text")
+            ev = tmp_tp[0] (tmp_tp[1])
+        elif tmp_tp:
+            ev = tmp_tp (entry)
+        if ev:
+            # TODO: set the correct direction! Unfortunately, \mark in ly does
+            #       not seem to support directions!
+            res.append (ev)
+            continue
 
         if entry.get_name () == "dynamics":
             for dynentry in entry.get_all_children ():
@@ -723,17 +1167,39 @@ def musicxml_direction_to_lily (n):
                 if ev:
                     res.append (ev)
 
-        if entry.get_name () == "words":
-            ev = musicxml_words_to_lily_event (entry)
-            if ev:
-                res.append (ev)
+    return res
 
-        # octave shifts. pedal marks, hairpins etc. are spanners:
-        if entry.get_name() in direction_spanners:
-            event = musicxml_spanner_to_lily_event (entry)
-            if event:
-                res.append (event)
+def musicxml_frame_to_lily_event (frame):
+    ev = musicexp.FretEvent ()
+    ev.strings = frame.get_strings ()
+    ev.frets = frame.get_frets ()
+    #offset = frame.get_first_fret () - 1
+    barre = []
+    for fn in frame.get_named_children ('frame-note'):
+        fret = fn.get_fret ()
+        if fret <= 0:
+            fret = "o"
+        el = [ fn.get_string (), fret ]
+        fingering = fn.get_fingering ()
+        if fingering >= 0:
+            el.append (fingering)
+        ev.elements.append (el)
+        b = fn.get_barre ()
+        if b == 'start':
+            barre[0] = el[0] # start string
+            barre[2] = el[1] # fret
+        elif b == 'stop':
+            barre[1] = el[0] # end string
+    if barre:
+        ev.barre = barre
+    return ev
 
+def musicxml_harmony_to_lily (n):
+    res = []
+    for f in n.get_named_children ('frame'):
+        ev = musicxml_frame_to_lily_event (f)
+        if ev:
+            res.append (ev)
 
     return res
 
@@ -749,26 +1215,34 @@ instrument_drumtype_dict = {
 def musicxml_note_to_lily_main_event (n):
     pitch  = None
     duration = None
-        
-    mxl_pitch = n.get_maybe_exist_typed_child (musicxml.Pitch)
     event = None
+
+    mxl_pitch = n.get_maybe_exist_typed_child (musicxml.Pitch)
     if mxl_pitch:
         pitch = musicxml_pitch_to_lily (mxl_pitch)
-        event = musicexp.NoteEvent()
+        event = musicexp.NoteEvent ()
         event.pitch = pitch
 
         acc = n.get_maybe_exist_named_child ('accidental')
         if acc:
             # let's not force accs everywhere. 
             event.cautionary = acc.editorial
+
+    elif n.get_maybe_exist_typed_child (musicxml.Unpitched):
+	# Unpitched elements have display-step and can also have
+	# display-octave.
+	unpitched = n.get_maybe_exist_typed_child (musicxml.Unpitched)
+	event = musicexp.NoteEvent ()
+	event.pitch = musicxml_unpitched_to_lily (unpitched)
         
     elif n.get_maybe_exist_typed_child (musicxml.Rest):
         # rests can have display-octave and display-step, which are
         # treated like an ordinary note pitch
         rest = n.get_maybe_exist_typed_child (musicxml.Rest)
-        event = musicexp.RestEvent()
+        event = musicexp.RestEvent ()
         pitch = musicxml_restdisplay_to_lily (rest)
         event.pitch = pitch
+
     elif n.instrument_name:
         event = musicexp.NoteEvent ()
         drum_type = instrument_drumtype_dict.get (n.instrument_name)
@@ -777,11 +1251,13 @@ def musicxml_note_to_lily_main_event (n):
         else:
             n.message ("drum %s type unknown, please add to instrument_drumtype_dict" % n.instrument_name)
             event.drum_type = 'acousticsnare'
-    
-    if not event:
+
+    else:
         n.message ("cannot find suitable event")
 
-    event.duration = musicxml_duration_to_lily (n)
+    if event:
+	event.duration = musicxml_duration_to_lily (n)
+
     return event
 
 
@@ -828,7 +1304,7 @@ class LilyPondVoiceBuilder:
         self.set_duration (duration)
         
         # Insert all pending dynamics right after the note/rest:
-        if isinstance (music, musicexp.EventChord) and self.pending_dynamics:
+        if isinstance (music, musicexp.ChordEvent) and self.pending_dynamics:
             for d in self.pending_dynamics:
                 music.append (d)
             self.pending_dynamics = []
@@ -863,12 +1339,25 @@ class LilyPondVoiceBuilder:
             error_message ('Negative skip %s' % diff)
             diff = Rational (0)
 
-        if diff > Rational (0) and not self.ignore_skips:
+        if diff > Rational (0) and not (self.ignore_skips and moment == 0):
             skip = musicexp.SkipEvent()
-            skip.duration.duration_log = 0
-            skip.duration.factor = diff
+            duration_factor = 1
+            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)
+            duration_dots = 0
+            if duration_log > 0: # denominator is a power of 2...
+                if diff.numerator () == 3:
+                    duration_log -= 1
+                    duration_dots = 1
+                else:
+                    duration_factor = Rational (diff.numerator ())
+            else:
+                duration_log = 0
+                duration_factor = diff
+            skip.duration.duration_log = duration_log
+            skip.duration.factor = duration_factor
+            skip.duration.dots = duration_dots
 
-            evc = musicexp.EventChord ()
+            evc = musicexp.ChordEvent ()
             evc.elements.append (skip)
             self.add_music (evc, diff)
 
@@ -879,16 +1368,16 @@ class LilyPondVoiceBuilder:
 
         value = None
 
-        # if the position matches, find the last EventChord, do not cross a bar line!
+        # if the position matches, find the last ChordEvent, do not cross a bar line!
         at = len( self.elements ) - 1
         while (at >= 0 and
-               not isinstance (self.elements[at], musicexp.EventChord) and
+               not isinstance (self.elements[at], musicexp.ChordEvent) and
                not isinstance (self.elements[at], musicexp.BarLine)):
             at -= 1
 
         if (self.elements
             and at >= 0
-            and isinstance (self.elements[at], musicexp.EventChord)
+            and isinstance (self.elements[at], musicexp.ChordEvent)
             and self.begin_moment == starting_at):
             value = self.elements[at]
         else:
@@ -899,13 +1388,32 @@ class LilyPondVoiceBuilder:
     def correct_negative_skip (self, goto):
         self.end_moment = goto
         self.begin_moment = goto
-        evc = musicexp.EventChord ()
+        evc = musicexp.ChordEvent ()
         self.elements.append (evc)
-        
+
+
+class VoiceData:
+    def __init__ (self):
+        self.voicedata = None
+        self.ly_voice = None
+        self.lyrics_dict = {}
+        self.lyrics_order = []
+
+def musicxml_step_to_lily (step):
+    if step:
+	return (ord (step) - ord ('A') + 7 - 2) % 7
+    else:
+	return None
+
 def musicxml_voice_to_lily_voice (voice):
     tuplet_events = []
     modes_found = {}
     lyrics = {}
+    return_value = VoiceData ()
+    return_value.voicedata = voice
+    
+    # First pitch needed for relative mode (if selected in command-line options)
+    first_pitch = None
 
     # Needed for melismata detection (ignore lyrics on those notes!):
     inside_slur = False
@@ -913,10 +1421,13 @@ def musicxml_voice_to_lily_voice (voice):
     is_chord = False
     ignore_lyrics = False
 
-    # TODO: Make sure that the keys in the dict don't get reordered, since
-    #       we need the correct ordering of the lyrics stanzas! By default,
-    #       a dict will reorder its keys
-    for k in voice.get_lyrics_numbers ():
+    current_staff = None
+
+    # Make sure that the keys in the dict don't get reordered, since
+    # we need the correct ordering of the lyrics stanzas! By default,
+    # a dict will reorder its keys
+    return_value.lyrics_order = voice.get_lyrics_numbers ()
+    for k in return_value.lyrics_order:
         lyrics[k] = []
 
     voice_builder = LilyPondVoiceBuilder()
@@ -924,6 +1435,12 @@ def musicxml_voice_to_lily_voice (voice):
     for n in voice._elements:
         if n.get_name () == 'forward':
             continue
+        staff = n.get_maybe_exist_named_child ('staff')
+        if staff:
+            staff = staff.get_text ()
+            if current_staff and staff <> current_staff and not n.get_maybe_exist_named_child ('chord'):
+                voice_builder.add_command (musicexp.StaffChange (staff))
+            current_staff = staff
 
         if isinstance (n, musicxml.Partial) and n.partial > 0:
             a = musicxml_partial_to_lily (n.partial)
@@ -938,7 +1455,15 @@ def musicxml_voice_to_lily_voice (voice):
                 else:
                     voice_builder.add_command (a)
             continue
-        
+
+        if isinstance (n, musicxml.Harmony):
+            for a in musicxml_harmony_to_lily (n):
+                if a.wait_for_note ():
+                    voice_builder.add_dynamics (a)
+                else:
+                    voice_builder.add_command (a)
+            continue
+
         is_chord = n.get_maybe_exist_named_child ('chord')
         if not is_chord:
             try:
@@ -970,7 +1495,7 @@ def musicxml_voice_to_lily_voice (voice):
             continue
 
         if not n.__class__.__name__ == 'Note':
-            error_message ('not a Note or Attributes? %s' % n)
+            error_message (_ ('unexpected %s; expected %s or %s or %s') % (n, 'Note', 'Attributes', 'Barline'))
             continue
 
         rest = n.get_maybe_exist_typed_child (musicxml.Rest)
@@ -989,15 +1514,16 @@ def musicxml_voice_to_lily_voice (voice):
                 voice_builder.add_bar_check (num)
 
         main_event = musicxml_note_to_lily_main_event (n)
+        if main_event and not first_pitch:
+            first_pitch = main_event.pitch
         ignore_lyrics = inside_slur or is_tied or is_chord
 
-        if hasattr (main_event, 'drum_type') and main_event.drum_type:
+        if main_event and hasattr (main_event, 'drum_type') and main_event.drum_type:
             modes_found['drummode'] = True
 
-
         ev_chord = voice_builder.last_event_chord (n._when)
         if not ev_chord: 
-            ev_chord = musicexp.EventChord()
+            ev_chord = musicexp.ChordEvent()
             voice_builder.add_music (ev_chord, n._duration)
 
         grace = n.get_maybe_exist_typed_child (musicxml.Grace)
@@ -1006,14 +1532,12 @@ def musicxml_voice_to_lily_voice (voice):
             if n.get_maybe_exist_typed_child (musicxml.Chord) and ev_chord.grace_elements:
                 grace_chord = ev_chord.grace_elements.get_last_event_chord ()
             if not grace_chord:
-                grace_chord = musicexp.EventChord ()
+                grace_chord = musicexp.ChordEvent ()
                 ev_chord.append_grace (grace_chord)
             if hasattr (grace, 'slash'):
                 # TODO: use grace_type = "appoggiatura" for slurred grace notes
                 if grace.slash == "yes":
                     ev_chord.grace_type = "acciaccatura"
-                elif grace.slash == "no":
-                    ev_chord.grace_type = "grace"
             # now that we have inserted the chord into the grace music, insert
             # everything into that chord instead of the ev_chord
             ev_chord = grace_chord
@@ -1027,7 +1551,7 @@ def musicxml_voice_to_lily_voice (voice):
             if voice_builder.current_duration () == 0 and n._duration > 0:
                 voice_builder.set_duration (n._duration)
         
-        notations = n.get_maybe_exist_typed_child (musicxml.Notations)
+        notations_children = n.get_typed_children (musicxml.Notations)
         tuplet_event = None
         span_events = []
 
@@ -1036,9 +1560,8 @@ def musicxml_voice_to_lily_voice (voice):
         #    ornaments | technical | articulations | dynamics |
         #    +fermata | arpeggiate | non-arpeggiate | 
         #    accidental-mark | other-notation
-        if notations:
-            if notations.get_tuplet():
-                tuplet_event = notations.get_tuplet()
+        for notations in notations_children:
+            for tuplet_event in notations.get_tuplets():
                 mod = n.get_maybe_exist_typed_child (musicxml.Time_modification)
                 frac = (1,1)
                 if mod:
@@ -1050,21 +1573,23 @@ def musicxml_voice_to_lily_voice (voice):
                 if s.get_type () in ('start','stop')]
             if slurs:
                 if len (slurs) > 1:
-                    error_message ('more than 1 slur?')
+                    error_message (_ ('cannot have two simultaneous slurs'))
                 # record the slur status for the next note in the loop
-                if slurs[0].get_type () == 'start':
-                    inside_slur = True
-                elif slurs[0].get_type () == 'stop':
-                    inside_slur = False
+                if not grace:
+                    if slurs[0].get_type () == 'start':
+                        inside_slur = True
+                    elif slurs[0].get_type () == 'stop':
+                        inside_slur = False
                 lily_ev = musicxml_spanner_to_lily_event (slurs[0])
                 ev_chord.append (lily_ev)
 
-            mxl_tie = notations.get_tie ()
-            if mxl_tie and mxl_tie.type == 'start':
-                ev_chord.append (musicexp.TieEvent ())
-                is_tied = True
-            else:
-                is_tied = False
+            if not grace:
+                mxl_tie = notations.get_tie ()
+                if mxl_tie and mxl_tie.type == 'start':
+                    ev_chord.append (musicexp.TieEvent ())
+                    is_tied = True
+                else:
+                    is_tied = False
 
             fermatas = notations.get_named_children ('fermata')
             for a in fermatas:
@@ -1074,7 +1599,9 @@ def musicxml_voice_to_lily_voice (voice):
 
             arpeggiate = notations.get_named_children ('arpeggiate')
             for a in arpeggiate:
-                ev_chord.append (musicexp.ArpeggioEvent ())
+                ev = musicxml_arpeggiate_to_lily_event (a)
+                if ev:
+                    ev_chord.append (ev)
 
             glissandos = notations.get_named_children ('glissando')
             for a in glissandos:
@@ -1098,12 +1625,6 @@ def musicxml_voice_to_lily_voice (voice):
             #         shake | wavy-line | mordent | inverted-mordent | 
             #         schleifer | tremolo | other-ornament, accidental-mark
             ornaments = notations.get_named_children ('ornaments')
-            for a in ornaments:
-                for ch in a.get_named_children ('tremolo'):
-                    ev = musicxml_tremolo_to_lily_event (ch)
-                    if ev: 
-                        ev_chord.append (ev)
-
             ornaments += notations.get_named_children ('articulations')
             ornaments += notations.get_named_children ('technical')
 
@@ -1154,7 +1675,7 @@ def musicxml_voice_to_lily_voice (voice):
             tuplet_events.append ((ev_chord, tuplet_event, frac))
 
     ## force trailing mm rests to be written out.   
-    voice_builder.add_music (musicexp.EventChord (), Rational (0))
+    voice_builder.add_music (musicexp.ChordEvent (), Rational (0))
     
     ly_voice = group_tuplets (voice_builder.elements, tuplet_events)
     ly_voice = group_repeats (ly_voice)
@@ -1167,24 +1688,28 @@ def musicxml_voice_to_lily_voice (voice):
                     if not isinstance(e, musicexp.KeySignatureChange)]
     
     seq_music.elements = ly_voice
-    lyrics_dict = {}
     for k in lyrics.keys ():
-        lyrics_dict[k] = musicexp.Lyrics ()
-        lyrics_dict[k].lyrics_syllables = lyrics[k]
+        return_value.lyrics_dict[k] = musicexp.Lyrics ()
+        return_value.lyrics_dict[k].lyrics_syllables = lyrics[k]
     
     
     if len (modes_found) > 1:
-       error_message ('Too many modes found %s' % modes_found.keys ())
-
-    return_value = seq_music
+       error_message (_ ('cannot simultaneously have more than one mode: %s') % modes_found.keys ())
+       
+    if options.relative:
+        v = musicexp.RelativeMusic ()
+        v.element = seq_music
+        v.basepitch = first_pitch
+        seq_music = v
+
+    return_value.ly_voice = seq_music
     for mode in modes_found.keys ():
         v = musicexp.ModeChangingMusicWrapper()
-        v.element = return_value
+        v.element = seq_music
         v.mode = mode
-        return_value = v
+        return_value.ly_voice = v
     
-    return (return_value, lyrics_dict)
-
+    return return_value
 
 def musicxml_id_to_lily (id):
     digits = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five',
@@ -1197,20 +1722,30 @@ def musicxml_id_to_lily (id):
     id = re.sub  ('[^a-zA-Z]', 'X', id)
     return id
 
-
 def musicxml_pitch_to_lily (mxl_pitch):
-    p = musicexp.Pitch()
+    p = musicexp.Pitch ()
     p.alteration = mxl_pitch.get_alteration ()
-    p.step = (ord (mxl_pitch.get_step ()) - ord ('A') + 7 - 2) % 7
+    p.step = musicxml_step_to_lily (mxl_pitch.get_step ())
     p.octave = mxl_pitch.get_octave () - 4
     return p
 
+def musicxml_unpitched_to_lily (mxl_unpitched):
+    p = None
+    step = mxl_unpitched.get_step ()
+    if step:
+	p = musicexp.Pitch ()
+	p.step = musicxml_step_to_lily (step)
+    octave = mxl_unpitched.get_octave ()
+    if octave and p:
+	p.octave = octave - 4
+    return p
+
 def musicxml_restdisplay_to_lily (mxl_rest):
     p = None
     step = mxl_rest.get_step ()
     if step:
-        p = musicexp.Pitch()
-        p.step = (ord (step) - ord ('A') + 7 - 2) % 7
+        p = musicexp.Pitch ()
+        p.step = musicxml_step_to_lily (step)
     octave = mxl_rest.get_octave ()
     if octave and p:
         p.octave = octave - 4
@@ -1220,34 +1755,37 @@ def voices_in_part (part):
     """Return a Name -> Voice dictionary for PART"""
     part.interpret ()
     part.extract_voices ()
-    voice_dict = part.get_voices ()
+    voices = part.get_voices ()
+    part_info = part.get_staff_attributes ()
 
-    return voice_dict
+    return (voices, part_info)
 
 def voices_in_part_in_parts (parts):
     """return a Part -> Name -> Voice dictionary"""
-    return dict([(p, voices_in_part (p)) for p in parts])
+    return dict([(p.id, voices_in_part (p)) for p in parts])
 
 
 def get_all_voices (parts):
     all_voices = voices_in_part_in_parts (parts)
 
     all_ly_voices = {}
-    for p, name_voice in all_voices.items ():
+    all_ly_staffinfo = {}
+    for p, (name_voice, staff_info) in all_voices.items ():
 
         part_ly_voices = {}
         for n, v in name_voice.items ():
-            progress ("Converting to LilyPond expressions...")
+            progress (_ ("Converting to LilyPond expressions..."))
             # musicxml_voice_to_lily_voice returns (lily_voice, {nr->lyrics, nr->lyrics})
-            part_ly_voices[n] = (musicxml_voice_to_lily_voice (v), v)
+            part_ly_voices[n] = musicxml_voice_to_lily_voice (v)
 
         all_ly_voices[p] = part_ly_voices
-        
-    return all_ly_voices
+        all_ly_staffinfo[p] = staff_info
+
+    return (all_ly_voices, all_ly_staffinfo)
 
 
 def option_parser ():
-    p = ly.get_option_parser(usage=_ ("musicxml2ly FILE.xml"),
+    p = ly.get_option_parser(usage=_ ("musicxml2ly [options] FILE.xml"),
                              version=('''%prog (LilyPond) @TOPLEVEL_VERSION@\n\n'''
                                       +
 _ ("""This program is free software.  It is covered by the GNU General Public
@@ -1255,9 +1793,10 @@ License and you are welcome to change it and/or distribute copies of it
 under certain conditions.  Invoke as `%s --warranty' for more
 information.""") % 'lilypond'
 + """
-Copyright (c) 2005--2007 by
-    Han-Wen Nienhuys <hanwen@xs4all.nl> and
-    Jan Nieuwenhuizen <janneke@gnu.org>
+Copyright (c) 2005--2008 by
+    Han-Wen Nienhuys <hanwen@xs4all.nl>,
+    Jan Nieuwenhuizen <janneke@gnu.org> and
+    Reinhold Kainhofer <reinhold@kainhofer.com>
 """),
                              description=_ ("Convert %s to LilyPond input.") % 'MusicXML' + "\n")
     p.add_option ('-v', '--verbose',
@@ -1270,7 +1809,34 @@ Copyright (c) 2005--2007 by
                   default=False,
                   dest="use_lxml",
                   help=_ ("Use lxml.etree; uses less memory and cpu time."))
-    
+
+    p.add_option ('-z', '--compressed',
+                  action = "store_true",
+                  dest = 'compressed',
+                  default = False,
+                  help = _ ("Input file is a zip-compressed MusicXML file."))
+
+    p.add_option ('-r', '--relative',
+                  action = "store_true",
+                  dest = "relative",
+                  help = _ ("Convert pitches in relative mode. (Default)"))
+
+    p.add_option ('-a', '--absolute',
+                  action = "store_false",
+                  dest = "relative",
+                  help = _ ("Convert pitches in absolute mode."))
+
+    p.add_option ('-l', '--language',
+                  metavar=_("LANG"),
+                  action = "store",
+                  help = _ ("Use a different language file 'LANG.ly' and corresponding pitch names, e.g. 'deutsch' for deutsch.ly."))
+
+    p.add_option ('--nd', '--no-articulation-directions', 
+                  action = "store_false",
+                  default = True,
+                  dest = "convert_directions",
+                  help = _ ("Do not convert directions (^, _ or -) for articulations, dynamics, etc."))
+
     p.add_option ('-o', '--output',
                   metavar=_ ("FILE"),
                   action="store",
@@ -1278,40 +1844,36 @@ Copyright (c) 2005--2007 by
                   type='string',
                   dest='output_name',
                   help=_ ("set output filename to FILE"))
-    p.add_option_group ('bugs',
+    p.add_option_group ( _('Bugs'),
                         description=(_ ("Report bugs via")
                                      + ''' http://post.gmane.org/post.php'''
                                      '''?group=gmane.comp.gnu.lilypond.bugs\n'''))
     return p
 
-def music_xml_voice_name_to_lily_name (part, name):
-    str = "Part%sVoice%s" % (part.id, name)
+def music_xml_voice_name_to_lily_name (part_id, name):
+    str = "Part%sVoice%s" % (part_id, name)
     return musicxml_id_to_lily (str) 
 
-def music_xml_lyrics_name_to_lily_name (part, name, lyricsnr):
-    str = "Part%sVoice%sLyrics%s" % (part.id, name, lyricsnr)
+def music_xml_lyrics_name_to_lily_name (part_id, name, lyricsnr):
+    str = "Part%sVoice%sLyrics%s" % (part_id, name, lyricsnr)
     return musicxml_id_to_lily (str) 
 
 def print_voice_definitions (printer, part_list, voices):
-    part_dict={}
-    for (part, nv_dict) in voices.items():
-        part_dict[part.id] = (part, nv_dict)
-
     for part in part_list:
-        (p, nv_dict) = part_dict.get (part.id, (None, {}))
-        for (name, ((voice, lyrics), mxlvoice)) in nv_dict.items ():
-            k = music_xml_voice_name_to_lily_name (p, name)
+        part_id = part.id
+        nv_dict = voices.get (part_id, {})
+        for (name, voice) in nv_dict.items ():
+            k = music_xml_voice_name_to_lily_name (part_id, name)
             printer.dump ('%s = ' % k)
-            voice.print_ly (printer)
+            voice.ly_voice.print_ly (printer)
             printer.newline()
-            
-            for l in lyrics.keys ():
-                lname = music_xml_lyrics_name_to_lily_name (p, name, l)
+            for l in voice.lyrics_order:
+                lname = music_xml_lyrics_name_to_lily_name (part_id, name, l)
                 printer.dump ('%s = ' %lname )
-                lyrics[l].print_ly (printer)
+                voice.lyrics_dict[l].print_ly (printer)
                 printer.newline()
 
-            
+
 def uniq_list (l):
     return dict ([(elt,1) for elt in l]).keys ()
 
@@ -1323,31 +1885,28 @@ def uniq_list (l):
 #            ...
 #         ]
 #     ]
-# raw_voices is of the form [(voicename, lyrics)*]
-def format_staff_info (part, staff_id, raw_voices):
+# raw_voices is of the form [(voicename, lyricsids)*]
+def format_staff_info (part_id, staff_id, raw_voices):
     voices = []
-    for (v, lyrics) in raw_voices:
-        voice_name = music_xml_voice_name_to_lily_name (part, v)
-        voice_lyrics = [music_xml_lyrics_name_to_lily_name (part, v, l)
-                   for l in lyrics.keys ()]
+    for (v, lyricsids) in raw_voices:
+        voice_name = music_xml_voice_name_to_lily_name (part_id, v)
+        voice_lyrics = [music_xml_lyrics_name_to_lily_name (part_id, v, l)
+                   for l in lyricsids]
         voices.append ([voice_name, voice_lyrics])
     return [staff_id, voices]
 
 def update_score_setup (score_structure, part_list, voices):
-    part_dict = dict ([(p.id, p) for p in voices.keys ()])
-    final_part_dict = {}
 
     for part_definition in part_list:
-        part_name = part_definition.id
-        part = part_dict.get (part_name)
-        if not part:
-            error_message ('unknown part in part-list: %s' % part_name)
+        part_id = part_definition.id
+        nv_dict = voices.get (part_id)
+        if not nv_dict:
+            error_message ('unknown part in part-list: %s' % part_id)
             continue
 
-        nv_dict = voices.get (part)
         staves = reduce (lambda x,y: x+ y,
-                [mxlvoice._staves.keys ()
-                 for (v, mxlvoice) in nv_dict.values ()],
+                [voice.voicedata._staves.keys ()
+                 for voice in nv_dict.values ()],
                 [])
         staves_info = []
         if len (staves) > 1:
@@ -1355,52 +1914,90 @@ def update_score_setup (score_structure, part_list, voices):
             staves = uniq_list (staves)
             staves.sort ()
             for s in staves:
-                thisstaff_raw_voices = [(voice_name, lyrics) 
-                    for (voice_name, ((music, lyrics), mxlvoice)) in nv_dict.items ()
-                    if mxlvoice._start_staff == s]
-                staves_info.append (format_staff_info (part, s, thisstaff_raw_voices))
+                thisstaff_raw_voices = [(voice_name, voice.lyrics_order) 
+                    for (voice_name, voice) in nv_dict.items ()
+                    if voice.voicedata._start_staff == s]
+                staves_info.append (format_staff_info (part_id, s, thisstaff_raw_voices))
         else:
-            thisstaff_raw_voices = [(voice_name, lyrics) 
-                for (voice_name, ((music, lyrics), mxlvoice)) in nv_dict.items ()]
-            staves_info.append (format_staff_info (part, None, thisstaff_raw_voices))
-        score_structure.setPartInformation (part_name, staves_info)
+            thisstaff_raw_voices = [(voice_name, voice.lyrics_order) 
+                for (voice_name, voice) in nv_dict.items ()]
+            staves_info.append (format_staff_info (part_id, None, thisstaff_raw_voices))
+        score_structure.set_part_information (part_id, staves_info)
 
 def print_ly_preamble (printer, filename):
     printer.dump_version ()
     printer.print_verbatim ('%% automatically converted from %s\n' % filename)
 
-def read_musicxml (filename, use_lxml):
+def print_ly_additional_definitions (printer, filename):
+    if needed_additional_definitions:
+        printer.newline ()
+        printer.print_verbatim ('%% additional definitions required by the score:')
+        printer.newline ()
+    for a in set(needed_additional_definitions):
+        printer.print_verbatim (additional_definitions.get (a, ''))
+        printer.newline ()
+    printer.newline ()
+
+# Read in the tree from the given I/O object (either file or string) and 
+# demarshall it using the classes from the musicxml.py file
+def read_xml (io_object, use_lxml):
     if use_lxml:
         import lxml.etree
-        
-        tree = lxml.etree.parse (filename)
+        tree = lxml.etree.parse (io_object)
         mxl_tree = musicxml.lxml_demarshal_node (tree.getroot ())
         return mxl_tree
     else:
         from xml.dom import minidom, Node
-        
-        doc = minidom.parse(filename)
+        doc = minidom.parse(io_object)
         node = doc.documentElement
         return musicxml.minidom_demarshal_node (node)
-
     return None
 
 
+def read_musicxml (filename, compressed, use_lxml):
+    raw_string = None
+    if compressed:
+        progress (_ ("Input file %s is compressed, extracting raw MusicXML data") % filename)
+        z = zipfile.ZipFile (filename, "r")
+        container_xml = z.read ("META-INF/container.xml")
+        if not container_xml:
+            return None
+        container = read_xml (StringIO.StringIO (container_xml), use_lxml)
+        if not container:
+            return None
+        rootfiles = container.get_maybe_exist_named_child ('rootfiles')
+        if not rootfiles:
+            return None
+        rootfile_list = rootfiles.get_named_children ('rootfile')
+        mxml_file = None
+        if len (rootfile_list) > 0:
+            mxml_file = getattr (rootfile_list[0], 'full-path', None)
+        if mxml_file:
+            raw_string = z.read (mxml_file)
+
+    io_object = filename
+    if raw_string:
+        io_object = StringIO.StringIO (raw_string)
+
+    return read_xml (io_object, use_lxml)
+
+
 def convert (filename, options):
-    progress ("Reading MusicXML from %s ..." % filename)
+    progress (_ ("Reading MusicXML from %s ...") % filename)
     
-    tree = read_musicxml (filename, options.use_lxml)
+    tree = read_musicxml (filename, options.compressed, options.use_lxml)
+    parts = tree.get_typed_children (musicxml.Part)
+    (voices, staff_info) = get_all_voices (parts)
 
     score_structure = None
     mxl_pl = tree.get_maybe_exist_typed_child (musicxml.Part_list)
     if mxl_pl:
-        score_structure = extract_score_layout (mxl_pl)
+        score_structure = extract_score_layout (mxl_pl, staff_info)
         part_list = mxl_pl.get_named_children ("score-part")
 
     # score information is contained in the <work>, <identification> or <movement-title> tags
     score_information = extract_score_information (tree)
-    parts = tree.get_typed_children (musicxml.Part)
-    voices = get_all_voices (parts)
+    layout_information = extract_layout_information (tree)
     update_score_setup (score_structure, part_list, voices)
 
     if not options.output_name:
@@ -1414,17 +2011,21 @@ def convert (filename, options):
     driver_ly_name = options.output_name + '.ly'
 
     printer = musicexp.Output_printer()
-    progress ("Output to `%s'" % defs_ly_name)
+    progress (_ ("Output to `%s'") % defs_ly_name)
     printer.set_file (codecs.open (defs_ly_name, 'wb', encoding='utf-8'))
 
     print_ly_preamble (printer, filename)
-    score_information.print_ly (printer)
+    print_ly_additional_definitions (printer, filename)
+    if score_information:
+        score_information.print_ly (printer)
+    if layout_information:
+        layout_information.print_ly (printer)
     print_voice_definitions (printer, part_list, voices)
     
     printer.close ()
     
     
-    progress ("Output to `%s'" % driver_ly_name)
+    progress (_ ("Output to `%s'") % driver_ly_name)
     printer = musicexp.Output_printer()
     printer.set_file (codecs.open (driver_ly_name, 'wb', encoding='utf-8'))
     print_ly_preamble (printer, filename)
@@ -1437,10 +2038,10 @@ def convert (filename, options):
 def get_existing_filename_with_extension (filename, ext):
     if os.path.exists (filename):
         return filename
-    newfilename = filename + ".xml"
+    newfilename = filename + "." + ext
     if os.path.exists (newfilename):
         return newfilename;
-    newfilename = filename + "xml"
+    newfilename = filename + ext
     if os.path.exists (newfilename):
         return newfilename;
     return ''
@@ -1448,17 +2049,26 @@ def get_existing_filename_with_extension (filename, ext):
 def main ():
     opt_parser = option_parser()
 
+    global options
     (options, args) = opt_parser.parse_args ()
     if not args:
         opt_parser.print_usage()
         sys.exit (2)
-    
+
+    if options.language:
+        musicexp.set_pitch_language (options.language)
+        needed_additional_definitions.append (options.language)
+        additional_definitions[options.language] = "\\include \"%s.ly\"\n" % options.language
+
     # Allow the user to leave out the .xml or xml on the filename
     filename = get_existing_filename_with_extension (args[0], "xml")
+    if not filename:
+        filename = get_existing_filename_with_extension (args[0], "mxl")
+        options.compressed = True
     if filename and os.path.exists (filename):
         voices = convert (filename, options)
     else:
-        progress ("Unable to find input file %s" % args[0])
+        progress (_ ("Unable to find input file %s") % args[0])
 
 if __name__ == '__main__':
     main()