# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_CanorusPython')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_CanorusPython')
    _CanorusPython = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_CanorusPython', [dirname(__file__)])
        except ImportError:
            import _CanorusPython
            return _CanorusPython
        try:
            _mod = imp.load_module('_CanorusPython', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _CanorusPython = swig_import_helper()
    del swig_import_helper
else:
    import _CanorusPython
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0


def markDelete(*args):
    return _CanorusPython.markDelete(*args)
markDelete = _CanorusPython.markDelete

def tr(*args):
    return _CanorusPython.tr(*args)
tr = _CanorusPython.tr

def hasGui(*args):
    return _CanorusPython.hasGui(*args)
hasGui = _CanorusPython.hasGui

def rebuildUi(*args):
    return _CanorusPython.rebuildUi(*args)
rebuildUi = _CanorusPython.rebuildUi

def repaintUi(*args):
    return _CanorusPython.repaintUi(*args)
repaintUi = _CanorusPython.repaintUi

def setSelection(*args):
    return _CanorusPython.setSelection(*args)
setSelection = _CanorusPython.setSelection
class QThread(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QThread, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QThread, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def isRunning(self, *args):
        return _CanorusPython.QThread_isRunning(self, *args)

    def wait(self, *args):
        return _CanorusPython.QThread_wait(self, *args)
    __swig_destroy__ = _CanorusPython.delete_QThread
    __del__ = lambda self: None
QThread_swigregister = _CanorusPython.QThread_swigregister
QThread_swigregister(QThread)

class QXmlDefaultHandler(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QXmlDefaultHandler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QXmlDefaultHandler, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_QXmlDefaultHandler(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_QXmlDefaultHandler
    __del__ = lambda self: None
QXmlDefaultHandler_swigregister = _CanorusPython.QXmlDefaultHandler_swigregister
QXmlDefaultHandler_swigregister(QXmlDefaultHandler)

class QObject(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QObject, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_QObject(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_QObject
    __del__ = lambda self: None
QObject_swigregister = _CanorusPython.QObject_swigregister
QObject_swigregister(QObject)

class QAction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QAction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QAction, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_QAction(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_QAction
    __del__ = lambda self: None
QAction_swigregister = _CanorusPython.QAction_swigregister
QAction_swigregister(QAction)

class QSettings(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, QSettings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, QSettings, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_QSettings(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_QSettings
    __del__ = lambda self: None
QSettings_swigregister = _CanorusPython.QSettings_swigregister
QSettings_swigregister(QSettings)

class CAResource(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAResource, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAResource, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CAResource_Undefined
    Image = _CanorusPython.CAResource_Image
    Sound = _CanorusPython.CAResource_Sound
    Movie = _CanorusPython.CAResource_Movie
    Document = _CanorusPython.CAResource_Document
    Other = _CanorusPython.CAResource_Other

    def __init__(self, *args):
        this = _CanorusPython.new_CAResource(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAResource
    __del__ = lambda self: None

    def setName(self, *args):
        return _CanorusPython.CAResource_setName(self, *args)

    def name(self, *args):
        return _CanorusPython.CAResource_name(self, *args)

    def setDescription(self, *args):
        return _CanorusPython.CAResource_setDescription(self, *args)

    def description(self, *args):
        return _CanorusPython.CAResource_description(self, *args)

    def setUrl(self, *args):
        return _CanorusPython.CAResource_setUrl(self, *args)

    def url(self, *args):
        return _CanorusPython.CAResource_url(self, *args)

    def setResourceType(self, *args):
        return _CanorusPython.CAResource_setResourceType(self, *args)

    def resourceType(self, *args):
        return _CanorusPython.CAResource_resourceType(self, *args)

    def setLinked(self, *args):
        return _CanorusPython.CAResource_setLinked(self, *args)

    def isLinked(self, *args):
        return _CanorusPython.CAResource_isLinked(self, *args)

    def setDocument(self, *args):
        return _CanorusPython.CAResource_setDocument(self, *args)

    def document(self, *args):
        return _CanorusPython.CAResource_document(self, *args)

    def copy(self, *args):
        return _CanorusPython.CAResource_copy(self, *args)
    if _newclass:
        resourceTypeToString = staticmethod(_CanorusPython.CAResource_resourceTypeToString)
    else:
        resourceTypeToString = _CanorusPython.CAResource_resourceTypeToString
    if _newclass:
        resourceTypeFromString = staticmethod(_CanorusPython.CAResource_resourceTypeFromString)
    else:
        resourceTypeFromString = _CanorusPython.CAResource_resourceTypeFromString
CAResource_swigregister = _CanorusPython.CAResource_swigregister
CAResource_swigregister(CAResource)

def CAResource_resourceTypeToString(*args):
    return _CanorusPython.CAResource_resourceTypeToString(*args)
CAResource_resourceTypeToString = _CanorusPython.CAResource_resourceTypeToString

def CAResource_resourceTypeFromString(*args):
    return _CanorusPython.CAResource_resourceTypeFromString(*args)
CAResource_resourceTypeFromString = _CanorusPython.CAResource_resourceTypeFromString

class CAResourceCtl(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAResourceCtl, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAResourceCtl, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAResourceCtl(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAResourceCtl
    __del__ = lambda self: None
    if _newclass:
        importResource = staticmethod(_CanorusPython.CAResourceCtl_importResource)
    else:
        importResource = _CanorusPython.CAResourceCtl_importResource
    if _newclass:
        createEmptyResource = staticmethod(_CanorusPython.CAResourceCtl_createEmptyResource)
    else:
        createEmptyResource = _CanorusPython.CAResourceCtl_createEmptyResource
    if _newclass:
        deleteResource = staticmethod(_CanorusPython.CAResourceCtl_deleteResource)
    else:
        deleteResource = _CanorusPython.CAResourceCtl_deleteResource
CAResourceCtl_swigregister = _CanorusPython.CAResourceCtl_swigregister
CAResourceCtl_swigregister(CAResourceCtl)

def CAResourceCtl_importResource(*args):
    return _CanorusPython.CAResourceCtl_importResource(*args)
CAResourceCtl_importResource = _CanorusPython.CAResourceCtl_importResource

def CAResourceCtl_createEmptyResource(*args):
    return _CanorusPython.CAResourceCtl_createEmptyResource(*args)
CAResourceCtl_createEmptyResource = _CanorusPython.CAResourceCtl_createEmptyResource

def CAResourceCtl_deleteResource(*args):
    return _CanorusPython.CAResourceCtl_deleteResource(*args)
CAResourceCtl_deleteResource = _CanorusPython.CAResourceCtl_deleteResource

class CADocument(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CADocument, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CADocument, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CADocument(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CADocument
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CADocument_clone(self, *args)

    def clear(self, *args):
        return _CanorusPython.CADocument_clear(self, *args)

    def sheetList(self, *args):
        return _CanorusPython.CADocument_sheetList(self, *args)

    def addSheetByName(self, *args):
        return _CanorusPython.CADocument_addSheetByName(self, *args)

    def addSheet(self, *args):
        return _CanorusPython.CADocument_addSheet(self, *args)

    def removeSheet(self, *args):
        return _CanorusPython.CADocument_removeSheet(self, *args)

    def findSheet(self, *args):
        return _CanorusPython.CADocument_findSheet(self, *args)

    def resourceList(self, *args):
        return _CanorusPython.CADocument_resourceList(self, *args)

    def addResource(self, *args):
        return _CanorusPython.CADocument_addResource(self, *args)

    def removeResource(self, *args):
        return _CanorusPython.CADocument_removeResource(self, *args)

    def title(self, *args):
        return _CanorusPython.CADocument_title(self, *args)

    def subtitle(self, *args):
        return _CanorusPython.CADocument_subtitle(self, *args)

    def composer(self, *args):
        return _CanorusPython.CADocument_composer(self, *args)

    def arranger(self, *args):
        return _CanorusPython.CADocument_arranger(self, *args)

    def poet(self, *args):
        return _CanorusPython.CADocument_poet(self, *args)

    def textTranslator(self, *args):
        return _CanorusPython.CADocument_textTranslator(self, *args)

    def dedication(self, *args):
        return _CanorusPython.CADocument_dedication(self, *args)

    def copyright(self, *args):
        return _CanorusPython.CADocument_copyright(self, *args)

    def dateCreated(self, *args):
        return _CanorusPython.CADocument_dateCreated(self, *args)

    def dateLastModified(self, *args):
        return _CanorusPython.CADocument_dateLastModified(self, *args)

    def timeEdited(self, *args):
        return _CanorusPython.CADocument_timeEdited(self, *args)

    def comments(self, *args):
        return _CanorusPython.CADocument_comments(self, *args)

    def setTitle(self, *args):
        return _CanorusPython.CADocument_setTitle(self, *args)

    def setSubtitle(self, *args):
        return _CanorusPython.CADocument_setSubtitle(self, *args)

    def setComposer(self, *args):
        return _CanorusPython.CADocument_setComposer(self, *args)

    def setArranger(self, *args):
        return _CanorusPython.CADocument_setArranger(self, *args)

    def setPoet(self, *args):
        return _CanorusPython.CADocument_setPoet(self, *args)

    def setTextTranslator(self, *args):
        return _CanorusPython.CADocument_setTextTranslator(self, *args)

    def setDedication(self, *args):
        return _CanorusPython.CADocument_setDedication(self, *args)

    def setCopyright(self, *args):
        return _CanorusPython.CADocument_setCopyright(self, *args)

    def setDateCreated(self, *args):
        return _CanorusPython.CADocument_setDateCreated(self, *args)

    def setDateLastModified(self, *args):
        return _CanorusPython.CADocument_setDateLastModified(self, *args)

    def setTimeEdited(self, *args):
        return _CanorusPython.CADocument_setTimeEdited(self, *args)

    def setComments(self, *args):
        return _CanorusPython.CADocument_setComments(self, *args)

    def fileName(self, *args):
        return _CanorusPython.CADocument_fileName(self, *args)

    def isModified(self, *args):
        return _CanorusPython.CADocument_isModified(self, *args)

    def archive(self, *args):
        return _CanorusPython.CADocument_archive(self, *args)

    def setFileName(self, *args):
        return _CanorusPython.CADocument_setFileName(self, *args)

    def setModified(self, *args):
        return _CanorusPython.CADocument_setModified(self, *args)

    def setArchive(self, *args):
        return _CanorusPython.CADocument_setArchive(self, *args)
CADocument_swigregister = _CanorusPython.CADocument_swigregister
CADocument_swigregister(CADocument)

class CASheet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CASheet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CASheet, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CASheet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CASheet
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CASheet_clone(self, *args)

    def contextList(self, *args):
        return _CanorusPython.CASheet_contextList(self, *args)

    def findContext(self, *args):
        return _CanorusPython.CASheet_findContext(self, *args)

    def insertContext(self, *args):
        return _CanorusPython.CASheet_insertContext(self, *args)

    def insertContextAfter(self, *args):
        return _CanorusPython.CASheet_insertContextAfter(self, *args)

    def addContext(self, *args):
        return _CanorusPython.CASheet_addContext(self, *args)

    def removeContext(self, *args):
        return _CanorusPython.CASheet_removeContext(self, *args)

    def addStaff(self, *args):
        return _CanorusPython.CASheet_addStaff(self, *args)

    def staffList(self, *args):
        return _CanorusPython.CASheet_staffList(self, *args)

    def voiceList(self, *args):
        return _CanorusPython.CASheet_voiceList(self, *args)

    def getChord(self, *args):
        return _CanorusPython.CASheet_getChord(self, *args)

    def getTempo(self, *args):
        return _CanorusPython.CASheet_getTempo(self, *args)

    def document(self, *args):
        return _CanorusPython.CASheet_document(self, *args)

    def setDocument(self, *args):
        return _CanorusPython.CASheet_setDocument(self, *args)

    def name(self, *args):
        return _CanorusPython.CASheet_name(self, *args)

    def setName(self, *args):
        return _CanorusPython.CASheet_setName(self, *args)

    def addNoteCheckerError(self, *args):
        return _CanorusPython.CASheet_addNoteCheckerError(self, *args)

    def clearNoteCheckerErrors(self, *args):
        return _CanorusPython.CASheet_clearNoteCheckerErrors(self, *args)

    def noteCheckerErrorList(self, *args):
        return _CanorusPython.CASheet_noteCheckerErrorList(self, *args)

    def clear(self, *args):
        return _CanorusPython.CASheet_clear(self, *args)
CASheet_swigregister = _CanorusPython.CASheet_swigregister
CASheet_swigregister(CASheet)

class CAContext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAContext, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CanorusPython.delete_CAContext
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAContext_clone(self, *args)
    Staff = _CanorusPython.CAContext_Staff
    LyricsContext = _CanorusPython.CAContext_LyricsContext
    FunctionMarkContext = _CanorusPython.CAContext_FunctionMarkContext
    FiguredBassContext = _CanorusPython.CAContext_FiguredBassContext

    def name(self, *args):
        return _CanorusPython.CAContext_name(self, *args)

    def setName(self, *args):
        return _CanorusPython.CAContext_setName(self, *args)

    def contextType(self, *args):
        return _CanorusPython.CAContext_contextType(self, *args)

    def sheet(self, *args):
        return _CanorusPython.CAContext_sheet(self, *args)

    def setSheet(self, *args):
        return _CanorusPython.CAContext_setSheet(self, *args)

    def clear(self, *args):
        return _CanorusPython.CAContext_clear(self, *args)

    def next(self, *args):
        return _CanorusPython.CAContext_next(self, *args)

    def previous(self, *args):
        return _CanorusPython.CAContext_previous(self, *args)

    def remove(self, *args):
        return _CanorusPython.CAContext_remove(self, *args)
CAContext_swigregister = _CanorusPython.CAContext_swigregister
CAContext_swigregister(CAContext)

class CAStaff(CAContext):
    __swig_setmethods__ = {}
    for _s in [CAContext]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAStaff, name, value)
    __swig_getmethods__ = {}
    for _s in [CAContext]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAStaff, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAStaff(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAStaff
    __del__ = lambda self: None

    def numberOfLines(self, *args):
        return _CanorusPython.CAStaff_numberOfLines(self, *args)

    def setNumberOfLines(self, *args):
        return _CanorusPython.CAStaff_setNumberOfLines(self, *args)

    def clear(self, *args):
        return _CanorusPython.CAStaff_clear(self, *args)

    def clone(self, *args):
        return _CanorusPython.CAStaff_clone(self, *args)

    def voiceList(self, *args):
        return _CanorusPython.CAStaff_voiceList(self, *args)

    def insertVoice(self, *args):
        return _CanorusPython.CAStaff_insertVoice(self, *args)

    def addVoice(self, *args):
        return _CanorusPython.CAStaff_addVoice(self, *args)

    def removeVoice(self, *args):
        return _CanorusPython.CAStaff_removeVoice(self, *args)

    def findVoice(self, *args):
        return _CanorusPython.CAStaff_findVoice(self, *args)

    def next(self, *args):
        return _CanorusPython.CAStaff_next(self, *args)

    def previous(self, *args):
        return _CanorusPython.CAStaff_previous(self, *args)

    def remove(self, *args):
        return _CanorusPython.CAStaff_remove(self, *args)

    def lastTimeEnd(self, *args):
        return _CanorusPython.CAStaff_lastTimeEnd(self, *args)

    def getEltByType(self, *args):
        return _CanorusPython.CAStaff_getEltByType(self, *args)

    def getOneEltByType(self, *args):
        return _CanorusPython.CAStaff_getOneEltByType(self, *args)

    def getChord(self, *args):
        return _CanorusPython.CAStaff_getChord(self, *args)

    def getTempo(self, *args):
        return _CanorusPython.CAStaff_getTempo(self, *args)

    def synchronizeVoices(self, *args):
        return _CanorusPython.CAStaff_synchronizeVoices(self, *args)
    if _newclass:
        placeAutoBar = staticmethod(_CanorusPython.CAStaff_placeAutoBar)
    else:
        placeAutoBar = _CanorusPython.CAStaff_placeAutoBar

    def clefRefs(self, *args):
        return _CanorusPython.CAStaff_clefRefs(self, *args)

    def keySignatureRefs(self, *args):
        return _CanorusPython.CAStaff_keySignatureRefs(self, *args)

    def timeSignatureRefs(self, *args):
        return _CanorusPython.CAStaff_timeSignatureRefs(self, *args)

    def barlineRefs(self, *args):
        return _CanorusPython.CAStaff_barlineRefs(self, *args)
CAStaff_swigregister = _CanorusPython.CAStaff_swigregister
CAStaff_swigregister(CAStaff)

def CAStaff_placeAutoBar(*args):
    return _CanorusPython.CAStaff_placeAutoBar(*args)
CAStaff_placeAutoBar = _CanorusPython.CAStaff_placeAutoBar

class CAVoice(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAVoice, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAVoice, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAVoice(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAVoice
    __del__ = lambda self: None

    def staff(self, *args):
        return _CanorusPython.CAVoice_staff(self, *args)

    def setStaff(self, *args):
        return _CanorusPython.CAVoice_setStaff(self, *args)

    def clear(self, *args):
        return _CanorusPython.CAVoice_clear(self, *args)

    def clone(self, *args):
        return _CanorusPython.CAVoice_clone(self, *args)

    def cloneVoiceProperties(self, *args):
        return _CanorusPython.CAVoice_cloneVoiceProperties(self, *args)

    def append(self, *args):
        return _CanorusPython.CAVoice_append(self, *args)

    def insert(self, *args):
        return _CanorusPython.CAVoice_insert(self, *args)

    def remove(self, *args):
        return _CanorusPython.CAVoice_remove(self, *args)

    def insertInTupletAndVoiceAt(self, *args):
        return _CanorusPython.CAVoice_insertInTupletAndVoiceAt(self, *args)

    def synchronizeMusElements(self, *args):
        return _CanorusPython.CAVoice_synchronizeMusElements(self, *args)

    def musElementList(self, *args):
        return _CanorusPython.CAVoice_musElementList(self, *args)

    def getSignList(self, *args):
        return _CanorusPython.CAVoice_getSignList(self, *args)

    def getNoteList(self, *args):
        return _CanorusPython.CAVoice_getNoteList(self, *args)

    def containsPitch(self, *args):
        return _CanorusPython.CAVoice_containsPitch(self, *args)

    def next(self, *args):
        return _CanorusPython.CAVoice_next(self, *args)

    def previous(self, *args):
        return _CanorusPython.CAVoice_previous(self, *args)

    def nextByType(self, *args):
        return _CanorusPython.CAVoice_nextByType(self, *args)

    def previousByType(self, *args):
        return _CanorusPython.CAVoice_previousByType(self, *args)

    def nextNote(self, *args):
        return _CanorusPython.CAVoice_nextNote(self, *args)

    def previousNote(self, *args):
        return _CanorusPython.CAVoice_previousNote(self, *args)

    def nextRest(self, *args):
        return _CanorusPython.CAVoice_nextRest(self, *args)

    def previousRest(self, *args):
        return _CanorusPython.CAVoice_previousRest(self, *args)

    def nextPlayable(self, *args):
        return _CanorusPython.CAVoice_nextPlayable(self, *args)

    def previousPlayable(self, *args):
        return _CanorusPython.CAVoice_previousPlayable(self, *args)

    def binarySearch_startTime(self, *args):
        return _CanorusPython.CAVoice_binarySearch_startTime(self, *args)

    def getOneEltByType(self, *args):
        return _CanorusPython.CAVoice_getOneEltByType(self, *args)

    def getEltByType(self, *args):
        return _CanorusPython.CAVoice_getEltByType(self, *args)

    def getOnePreviousByType(self, *args):
        return _CanorusPython.CAVoice_getOnePreviousByType(self, *args)

    def getPreviousByType(self, *args):
        return _CanorusPython.CAVoice_getPreviousByType(self, *args)

    def lastTimeEnd(self, *args):
        return _CanorusPython.CAVoice_lastTimeEnd(self, *args)

    def lastTimeStart(self, *args):
        return _CanorusPython.CAVoice_lastTimeStart(self, *args)

    def lastMusElement(self, *args):
        return _CanorusPython.CAVoice_lastMusElement(self, *args)

    def lastNotePitch(self, *args):
        return _CanorusPython.CAVoice_lastNotePitch(self, *args)

    def lastPlayableElt(self, *args):
        return _CanorusPython.CAVoice_lastPlayableElt(self, *args)

    def lastNote(self, *args):
        return _CanorusPython.CAVoice_lastNote(self, *args)

    def getTimeSig(self, *args):
        return _CanorusPython.CAVoice_getTimeSig(self, *args)

    def getKeySig(self, *args):
        return _CanorusPython.CAVoice_getKeySig(self, *args)

    def getChord(self, *args):
        return _CanorusPython.CAVoice_getChord(self, *args)

    def getBar(self, *args):
        return _CanorusPython.CAVoice_getBar(self, *args)

    def getTempo(self, *args):
        return _CanorusPython.CAVoice_getTempo(self, *args)

    def getKeySignature(self, *args):
        return _CanorusPython.CAVoice_getKeySignature(self, *args)

    def getTimeSignature(self, *args):
        return _CanorusPython.CAVoice_getTimeSignature(self, *args)

    def getClef(self, *args):
        return _CanorusPython.CAVoice_getClef(self, *args)

    def getPreviousKeySignature(self, *args):
        return _CanorusPython.CAVoice_getPreviousKeySignature(self, *args)

    def getPreviousTimeSignature(self, *args):
        return _CanorusPython.CAVoice_getPreviousTimeSignature(self, *args)

    def getPreviousClef(self, *args):
        return _CanorusPython.CAVoice_getPreviousClef(self, *args)

    def voiceNumber(self, *args):
        return _CanorusPython.CAVoice_voiceNumber(self, *args)

    def isFirstVoice(self, *args):
        return _CanorusPython.CAVoice_isFirstVoice(self, *args)

    def stemDirection(self, *args):
        return _CanorusPython.CAVoice_stemDirection(self, *args)

    def setStemDirection(self, *args):
        return _CanorusPython.CAVoice_setStemDirection(self, *args)

    def name(self, *args):
        return _CanorusPython.CAVoice_name(self, *args)

    def setName(self, *args):
        return _CanorusPython.CAVoice_setName(self, *args)

    def midiChannel(self, *args):
        return _CanorusPython.CAVoice_midiChannel(self, *args)

    def setMidiChannel(self, *args):
        return _CanorusPython.CAVoice_setMidiChannel(self, *args)

    def midiProgram(self, *args):
        return _CanorusPython.CAVoice_midiProgram(self, *args)

    def setMidiProgram(self, *args):
        return _CanorusPython.CAVoice_setMidiProgram(self, *args)

    def midiPitchOffset(self, *args):
        return _CanorusPython.CAVoice_midiPitchOffset(self, *args)

    def setMidiPitchOffset(self, *args):
        return _CanorusPython.CAVoice_setMidiPitchOffset(self, *args)

    def lyricsContextList(self, *args):
        return _CanorusPython.CAVoice_lyricsContextList(self, *args)

    def addLyricsContext(self, *args):
        return _CanorusPython.CAVoice_addLyricsContext(self, *args)

    def setLyricsContexts(self, *args):
        return _CanorusPython.CAVoice_setLyricsContexts(self, *args)

    def addLyricsContexts(self, *args):
        return _CanorusPython.CAVoice_addLyricsContexts(self, *args)

    def removeLyricsContext(self, *args):
        return _CanorusPython.CAVoice_removeLyricsContext(self, *args)
CAVoice_swigregister = _CanorusPython.CAVoice_swigregister
CAVoice_swigregister(CAVoice)

class CAFunctionMarkContext(CAContext):
    __swig_setmethods__ = {}
    for _s in [CAContext]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAFunctionMarkContext, name, value)
    __swig_getmethods__ = {}
    for _s in [CAContext]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAFunctionMarkContext, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAFunctionMarkContext(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAFunctionMarkContext
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAFunctionMarkContext_clone(self, *args)

    def functionMarkList(self, *args):
        return _CanorusPython.CAFunctionMarkContext_functionMarkList(self, *args)

    def functionMarkAt(self, *args):
        return _CanorusPython.CAFunctionMarkContext_functionMarkAt(self, *args)

    def addFunctionMark(self, *args):
        return _CanorusPython.CAFunctionMarkContext_addFunctionMark(self, *args)

    def addEmptyFunction(self, *args):
        return _CanorusPython.CAFunctionMarkContext_addEmptyFunction(self, *args)

    def repositFunctions(self, *args):
        return _CanorusPython.CAFunctionMarkContext_repositFunctions(self, *args)

    def clear(self, *args):
        return _CanorusPython.CAFunctionMarkContext_clear(self, *args)

    def next(self, *args):
        return _CanorusPython.CAFunctionMarkContext_next(self, *args)

    def previous(self, *args):
        return _CanorusPython.CAFunctionMarkContext_previous(self, *args)

    def remove(self, *args):
        return _CanorusPython.CAFunctionMarkContext_remove(self, *args)
CAFunctionMarkContext_swigregister = _CanorusPython.CAFunctionMarkContext_swigregister
CAFunctionMarkContext_swigregister(CAFunctionMarkContext)

class CAFiguredBassContext(CAContext):
    __swig_setmethods__ = {}
    for _s in [CAContext]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAFiguredBassContext, name, value)
    __swig_getmethods__ = {}
    for _s in [CAContext]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAFiguredBassContext, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAFiguredBassContext(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAFiguredBassContext
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAFiguredBassContext_clone(self, *args)

    def clear(self, *args):
        return _CanorusPython.CAFiguredBassContext_clear(self, *args)

    def next(self, *args):
        return _CanorusPython.CAFiguredBassContext_next(self, *args)

    def previous(self, *args):
        return _CanorusPython.CAFiguredBassContext_previous(self, *args)

    def remove(self, *args):
        return _CanorusPython.CAFiguredBassContext_remove(self, *args)

    def figuredBassMarkList(self, *args):
        return _CanorusPython.CAFiguredBassContext_figuredBassMarkList(self, *args)

    def figuredBassMarkAtTimeStart(self, *args):
        return _CanorusPython.CAFiguredBassContext_figuredBassMarkAtTimeStart(self, *args)

    def repositFiguredBassMarks(self, *args):
        return _CanorusPython.CAFiguredBassContext_repositFiguredBassMarks(self, *args)

    def addFiguredBassMark(self, *args):
        return _CanorusPython.CAFiguredBassContext_addFiguredBassMark(self, *args)

    def addEmptyFiguredBassMark(self, *args):
        return _CanorusPython.CAFiguredBassContext_addEmptyFiguredBassMark(self, *args)
CAFiguredBassContext_swigregister = _CanorusPython.CAFiguredBassContext_swigregister
CAFiguredBassContext_swigregister(CAFiguredBassContext)

class CALyricsContext(CAContext):
    __swig_setmethods__ = {}
    for _s in [CAContext]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CALyricsContext, name, value)
    __swig_getmethods__ = {}
    for _s in [CAContext]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CALyricsContext, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CALyricsContext(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CALyricsContext
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CALyricsContext_clone(self, *args)

    def cloneLyricsContextProperties(self, *args):
        return _CanorusPython.CALyricsContext_cloneLyricsContextProperties(self, *args)

    def repositSyllables(self, *args):
        return _CanorusPython.CALyricsContext_repositSyllables(self, *args)

    def next(self, *args):
        return _CanorusPython.CALyricsContext_next(self, *args)

    def previous(self, *args):
        return _CanorusPython.CALyricsContext_previous(self, *args)

    def remove(self, *args):
        return _CanorusPython.CALyricsContext_remove(self, *args)

    def clear(self, *args):
        return _CanorusPython.CALyricsContext_clear(self, *args)

    def syllableList(self, *args):
        return _CanorusPython.CALyricsContext_syllableList(self, *args)

    def addSyllable(self, *args):
        return _CanorusPython.CALyricsContext_addSyllable(self, *args)

    def addEmptySyllable(self, *args):
        return _CanorusPython.CALyricsContext_addEmptySyllable(self, *args)

    def removeSyllableAtTimeStart(self, *args):
        return _CanorusPython.CALyricsContext_removeSyllableAtTimeStart(self, *args)

    def syllableAtTimeStart(self, *args):
        return _CanorusPython.CALyricsContext_syllableAtTimeStart(self, *args)

    def associatedVoice(self, *args):
        return _CanorusPython.CALyricsContext_associatedVoice(self, *args)

    def setAssociatedVoice(self, *args):
        return _CanorusPython.CALyricsContext_setAssociatedVoice(self, *args)

    def stanzaNumber(self, *args):
        return _CanorusPython.CALyricsContext_stanzaNumber(self, *args)

    def setStanzaNumber(self, *args):
        return _CanorusPython.CALyricsContext_setStanzaNumber(self, *args)

    def customStanzaName(self, *args):
        return _CanorusPython.CALyricsContext_customStanzaName(self, *args)

    def setCustomStanzaName(self, *args):
        return _CanorusPython.CALyricsContext_setCustomStanzaName(self, *args)
CALyricsContext_swigregister = _CanorusPython.CALyricsContext_swigregister
CALyricsContext_swigregister(CALyricsContext)

class CAPlayableLength(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAPlayableLength, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAPlayableLength, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CAPlayableLength_Undefined
    Breve = _CanorusPython.CAPlayableLength_Breve
    Whole = _CanorusPython.CAPlayableLength_Whole
    Half = _CanorusPython.CAPlayableLength_Half
    Quarter = _CanorusPython.CAPlayableLength_Quarter
    Eighth = _CanorusPython.CAPlayableLength_Eighth
    Sixteenth = _CanorusPython.CAPlayableLength_Sixteenth
    ThirtySecond = _CanorusPython.CAPlayableLength_ThirtySecond
    SixtyFourth = _CanorusPython.CAPlayableLength_SixtyFourth
    HundredTwentyEighth = _CanorusPython.CAPlayableLength_HundredTwentyEighth

    def __init__(self, *args):
        this = _CanorusPython.new_CAPlayableLength(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def musicLength(self, *args):
        return _CanorusPython.CAPlayableLength_musicLength(self, *args)

    def dotted(self, *args):
        return _CanorusPython.CAPlayableLength_dotted(self, *args)

    def setMusicLength(self, *args):
        return _CanorusPython.CAPlayableLength_setMusicLength(self, *args)

    def setDotted(self, *args):
        return _CanorusPython.CAPlayableLength_setDotted(self, *args)

    def __eq__(self, *args):
        return _CanorusPython.CAPlayableLength___eq__(self, *args)

    def __ne__(self, *args):
        return _CanorusPython.CAPlayableLength___ne__(self, *args)
    if _newclass:
        musicLengthToString = staticmethod(_CanorusPython.CAPlayableLength_musicLengthToString)
    else:
        musicLengthToString = _CanorusPython.CAPlayableLength_musicLengthToString
    if _newclass:
        musicLengthFromString = staticmethod(_CanorusPython.CAPlayableLength_musicLengthFromString)
    else:
        musicLengthFromString = _CanorusPython.CAPlayableLength_musicLengthFromString
    if _newclass:
        playableLengthToTimeLength = staticmethod(_CanorusPython.CAPlayableLength_playableLengthToTimeLength)
    else:
        playableLengthToTimeLength = _CanorusPython.CAPlayableLength_playableLengthToTimeLength
    if _newclass:
        musicLengthToTimeLength = staticmethod(_CanorusPython.CAPlayableLength_musicLengthToTimeLength)
    else:
        musicLengthToTimeLength = _CanorusPython.CAPlayableLength_musicLengthToTimeLength
    if _newclass:
        timeLengthToPlayableLengthList = staticmethod(_CanorusPython.CAPlayableLength_timeLengthToPlayableLengthList)
    else:
        timeLengthToPlayableLengthList = _CanorusPython.CAPlayableLength_timeLengthToPlayableLengthList
    if _newclass:
        matchToBars = staticmethod(_CanorusPython.CAPlayableLength_matchToBars)
    else:
        matchToBars = _CanorusPython.CAPlayableLength_matchToBars
    __swig_destroy__ = _CanorusPython.delete_CAPlayableLength
    __del__ = lambda self: None
CAPlayableLength_swigregister = _CanorusPython.CAPlayableLength_swigregister
CAPlayableLength_swigregister(CAPlayableLength)

def CAPlayableLength_musicLengthToString(*args):
    return _CanorusPython.CAPlayableLength_musicLengthToString(*args)
CAPlayableLength_musicLengthToString = _CanorusPython.CAPlayableLength_musicLengthToString

def CAPlayableLength_musicLengthFromString(*args):
    return _CanorusPython.CAPlayableLength_musicLengthFromString(*args)
CAPlayableLength_musicLengthFromString = _CanorusPython.CAPlayableLength_musicLengthFromString

def CAPlayableLength_playableLengthToTimeLength(*args):
    return _CanorusPython.CAPlayableLength_playableLengthToTimeLength(*args)
CAPlayableLength_playableLengthToTimeLength = _CanorusPython.CAPlayableLength_playableLengthToTimeLength

def CAPlayableLength_musicLengthToTimeLength(*args):
    return _CanorusPython.CAPlayableLength_musicLengthToTimeLength(*args)
CAPlayableLength_musicLengthToTimeLength = _CanorusPython.CAPlayableLength_musicLengthToTimeLength

def CAPlayableLength_timeLengthToPlayableLengthList(*args):
    return _CanorusPython.CAPlayableLength_timeLengthToPlayableLengthList(*args)
CAPlayableLength_timeLengthToPlayableLengthList = _CanorusPython.CAPlayableLength_timeLengthToPlayableLengthList

def CAPlayableLength_matchToBars(*args):
    return _CanorusPython.CAPlayableLength_matchToBars(*args)
CAPlayableLength_matchToBars = _CanorusPython.CAPlayableLength_matchToBars

class CADiatonicPitch(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CADiatonicPitch, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CADiatonicPitch, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CADiatonicPitch_Undefined
    C = _CanorusPython.CADiatonicPitch_C
    D = _CanorusPython.CADiatonicPitch_D
    E = _CanorusPython.CADiatonicPitch_E
    F = _CanorusPython.CADiatonicPitch_F
    G = _CanorusPython.CADiatonicPitch_G
    A = _CanorusPython.CADiatonicPitch_A
    B = _CanorusPython.CADiatonicPitch_B
    PreferAuto = _CanorusPython.CADiatonicPitch_PreferAuto
    PreferSharps = _CanorusPython.CADiatonicPitch_PreferSharps
    PreferFlats = _CanorusPython.CADiatonicPitch_PreferFlats

    def __init__(self, *args):
        this = _CanorusPython.new_CADiatonicPitch(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, *args):
        return _CanorusPython.CADiatonicPitch___eq__(self, *args)

    def __ne__(self, *args):
        return _CanorusPython.CADiatonicPitch___ne__(self, *args)

    def __add__(self, *args):
        return _CanorusPython.CADiatonicPitch___add__(self, *args)

    def __sub__(self, *args):
        return _CanorusPython.CADiatonicPitch___sub__(self, *args)

    def noteName(self, *args):
        return _CanorusPython.CADiatonicPitch_noteName(self, *args)

    def accs(self, *args):
        return _CanorusPython.CADiatonicPitch_accs(self, *args)

    def setNoteName(self, *args):
        return _CanorusPython.CADiatonicPitch_setNoteName(self, *args)

    def setAccs(self, *args):
        return _CanorusPython.CADiatonicPitch_setAccs(self, *args)

    def midiPitch(self, *args):
        return _CanorusPython.CADiatonicPitch_midiPitch(self, *args)
    if _newclass:
        diatonicPitchToString = staticmethod(_CanorusPython.CADiatonicPitch_diatonicPitchToString)
    else:
        diatonicPitchToString = _CanorusPython.CADiatonicPitch_diatonicPitchToString
    if _newclass:
        diatonicPitchFromString = staticmethod(_CanorusPython.CADiatonicPitch_diatonicPitchFromString)
    else:
        diatonicPitchFromString = _CanorusPython.CADiatonicPitch_diatonicPitchFromString
    if _newclass:
        diatonicPitchFromMidiPitch = staticmethod(_CanorusPython.CADiatonicPitch_diatonicPitchFromMidiPitch)
    else:
        diatonicPitchFromMidiPitch = _CanorusPython.CADiatonicPitch_diatonicPitchFromMidiPitch
    if _newclass:
        diatonicPitchFromMidiPitchKey = staticmethod(_CanorusPython.CADiatonicPitch_diatonicPitchFromMidiPitchKey)
    else:
        diatonicPitchFromMidiPitchKey = _CanorusPython.CADiatonicPitch_diatonicPitchFromMidiPitchKey
    if _newclass:
        diatonicPitchToMidiPitch = staticmethod(_CanorusPython.CADiatonicPitch_diatonicPitchToMidiPitch)
    else:
        diatonicPitchToMidiPitch = _CanorusPython.CADiatonicPitch_diatonicPitchToMidiPitch
    __swig_destroy__ = _CanorusPython.delete_CADiatonicPitch
    __del__ = lambda self: None
CADiatonicPitch_swigregister = _CanorusPython.CADiatonicPitch_swigregister
CADiatonicPitch_swigregister(CADiatonicPitch)

def CADiatonicPitch_diatonicPitchToString(*args):
    return _CanorusPython.CADiatonicPitch_diatonicPitchToString(*args)
CADiatonicPitch_diatonicPitchToString = _CanorusPython.CADiatonicPitch_diatonicPitchToString

def CADiatonicPitch_diatonicPitchFromString(*args):
    return _CanorusPython.CADiatonicPitch_diatonicPitchFromString(*args)
CADiatonicPitch_diatonicPitchFromString = _CanorusPython.CADiatonicPitch_diatonicPitchFromString

def CADiatonicPitch_diatonicPitchFromMidiPitch(*args):
    return _CanorusPython.CADiatonicPitch_diatonicPitchFromMidiPitch(*args)
CADiatonicPitch_diatonicPitchFromMidiPitch = _CanorusPython.CADiatonicPitch_diatonicPitchFromMidiPitch

def CADiatonicPitch_diatonicPitchFromMidiPitchKey(*args):
    return _CanorusPython.CADiatonicPitch_diatonicPitchFromMidiPitchKey(*args)
CADiatonicPitch_diatonicPitchFromMidiPitchKey = _CanorusPython.CADiatonicPitch_diatonicPitchFromMidiPitchKey

def CADiatonicPitch_diatonicPitchToMidiPitch(*args):
    return _CanorusPython.CADiatonicPitch_diatonicPitchToMidiPitch(*args)
CADiatonicPitch_diatonicPitchToMidiPitch = _CanorusPython.CADiatonicPitch_diatonicPitchToMidiPitch

class CAInterval(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAInterval, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAInterval, name)
    __repr__ = _swig_repr
    Major = _CanorusPython.CAInterval_Major
    Minor = _CanorusPython.CAInterval_Minor
    Perfect = _CanorusPython.CAInterval_Perfect
    Augmented = _CanorusPython.CAInterval_Augmented
    Diminished = _CanorusPython.CAInterval_Diminished
    Undefined = _CanorusPython.CAInterval_Undefined
    Prime = _CanorusPython.CAInterval_Prime
    Second = _CanorusPython.CAInterval_Second
    Third = _CanorusPython.CAInterval_Third
    Fourth = _CanorusPython.CAInterval_Fourth
    Fifth = _CanorusPython.CAInterval_Fifth
    Sixth = _CanorusPython.CAInterval_Sixth
    Seventh = _CanorusPython.CAInterval_Seventh
    Octave = _CanorusPython.CAInterval_Octave

    def __init__(self, *args):
        this = _CanorusPython.new_CAInterval(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __invert__(self, *args):
        return _CanorusPython.CAInterval___invert__(self, *args)

    def __add__(self, *args):
        return _CanorusPython.CAInterval___add__(self, *args)

    def __sub__(self, *args):
        return _CanorusPython.CAInterval___sub__(self, *args)

    def __mul__(self, *args):
        return _CanorusPython.CAInterval___mul__(self, *args)

    def __eq__(self, *args):
        return _CanorusPython.CAInterval___eq__(self, *args)

    def __ne__(self, *args):
        return _CanorusPython.CAInterval___ne__(self, *args)

    def quality(self, *args):
        return _CanorusPython.CAInterval_quality(self, *args)

    def quantity(self, *args):
        return _CanorusPython.CAInterval_quantity(self, *args)

    def setQuality(self, *args):
        return _CanorusPython.CAInterval_setQuality(self, *args)

    def setQuantity(self, *args):
        return _CanorusPython.CAInterval_setQuantity(self, *args)

    def semitones(self, *args):
        return _CanorusPython.CAInterval_semitones(self, *args)
    if _newclass:
        fromSemitones = staticmethod(_CanorusPython.CAInterval_fromSemitones)
    else:
        fromSemitones = _CanorusPython.CAInterval_fromSemitones
    if _newclass:
        qualityToReadable = staticmethod(_CanorusPython.CAInterval_qualityToReadable)
    else:
        qualityToReadable = _CanorusPython.CAInterval_qualityToReadable
    if _newclass:
        quantityToReadable = staticmethod(_CanorusPython.CAInterval_quantityToReadable)
    else:
        quantityToReadable = _CanorusPython.CAInterval_quantityToReadable
    __swig_destroy__ = _CanorusPython.delete_CAInterval
    __del__ = lambda self: None
CAInterval_swigregister = _CanorusPython.CAInterval_swigregister
CAInterval_swigregister(CAInterval)

def CAInterval_fromSemitones(*args):
    return _CanorusPython.CAInterval_fromSemitones(*args)
CAInterval_fromSemitones = _CanorusPython.CAInterval_fromSemitones

def CAInterval_qualityToReadable(*args):
    return _CanorusPython.CAInterval_qualityToReadable(*args)
CAInterval_qualityToReadable = _CanorusPython.CAInterval_qualityToReadable

def CAInterval_quantityToReadable(*args):
    return _CanorusPython.CAInterval_quantityToReadable(*args)
CAInterval_quantityToReadable = _CanorusPython.CAInterval_quantityToReadable

class CADiatonicKey(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CADiatonicKey, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CADiatonicKey, name)
    __repr__ = _swig_repr
    Major = _CanorusPython.CADiatonicKey_Major
    Minor = _CanorusPython.CADiatonicKey_Minor
    Natural = _CanorusPython.CADiatonicKey_Natural
    Harmonic = _CanorusPython.CADiatonicKey_Harmonic
    Melodic = _CanorusPython.CADiatonicKey_Melodic

    def __init__(self, *args):
        this = _CanorusPython.new_CADiatonicKey(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __eq__(self, *args):
        return _CanorusPython.CADiatonicKey___eq__(self, *args)

    def __ne__(self, *args):
        return _CanorusPython.CADiatonicKey___ne__(self, *args)

    def __add__(self, *args):
        return _CanorusPython.CADiatonicKey___add__(self, *args)

    def diatonicPitch(self, *args):
        return _CanorusPython.CADiatonicKey_diatonicPitch(self, *args)

    def gender(self, *args):
        return _CanorusPython.CADiatonicKey_gender(self, *args)

    def shape(self, *args):
        return _CanorusPython.CADiatonicKey_shape(self, *args)

    def setDiatonicPitch(self, *args):
        return _CanorusPython.CADiatonicKey_setDiatonicPitch(self, *args)

    def setGender(self, *args):
        return _CanorusPython.CADiatonicKey_setGender(self, *args)

    def setShape(self, *args):
        return _CanorusPython.CADiatonicKey_setShape(self, *args)
    if _newclass:
        shapeToString = staticmethod(_CanorusPython.CADiatonicKey_shapeToString)
    else:
        shapeToString = _CanorusPython.CADiatonicKey_shapeToString
    if _newclass:
        shapeFromString = staticmethod(_CanorusPython.CADiatonicKey_shapeFromString)
    else:
        shapeFromString = _CanorusPython.CADiatonicKey_shapeFromString
    if _newclass:
        genderToString = staticmethod(_CanorusPython.CADiatonicKey_genderToString)
    else:
        genderToString = _CanorusPython.CADiatonicKey_genderToString
    if _newclass:
        genderFromString = staticmethod(_CanorusPython.CADiatonicKey_genderFromString)
    else:
        genderFromString = _CanorusPython.CADiatonicKey_genderFromString
    if _newclass:
        diatonicKeyToString = staticmethod(_CanorusPython.CADiatonicKey_diatonicKeyToString)
    else:
        diatonicKeyToString = _CanorusPython.CADiatonicKey_diatonicKeyToString
    if _newclass:
        diatonicKeyFromString = staticmethod(_CanorusPython.CADiatonicKey_diatonicKeyFromString)
    else:
        diatonicKeyFromString = _CanorusPython.CADiatonicKey_diatonicKeyFromString

    def numberOfAccs(self, *args):
        return _CanorusPython.CADiatonicKey_numberOfAccs(self, *args)

    def accsMatrix(self, *args):
        return _CanorusPython.CADiatonicKey_accsMatrix(self, *args)

    def noteAccs(self, *args):
        return _CanorusPython.CADiatonicKey_noteAccs(self, *args)

    def containsPitch(self, *args):
        return _CanorusPython.CADiatonicKey_containsPitch(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CADiatonicKey
    __del__ = lambda self: None
CADiatonicKey_swigregister = _CanorusPython.CADiatonicKey_swigregister
CADiatonicKey_swigregister(CADiatonicKey)

def CADiatonicKey_shapeToString(*args):
    return _CanorusPython.CADiatonicKey_shapeToString(*args)
CADiatonicKey_shapeToString = _CanorusPython.CADiatonicKey_shapeToString

def CADiatonicKey_shapeFromString(*args):
    return _CanorusPython.CADiatonicKey_shapeFromString(*args)
CADiatonicKey_shapeFromString = _CanorusPython.CADiatonicKey_shapeFromString

def CADiatonicKey_genderToString(*args):
    return _CanorusPython.CADiatonicKey_genderToString(*args)
CADiatonicKey_genderToString = _CanorusPython.CADiatonicKey_genderToString

def CADiatonicKey_genderFromString(*args):
    return _CanorusPython.CADiatonicKey_genderFromString(*args)
CADiatonicKey_genderFromString = _CanorusPython.CADiatonicKey_genderFromString

def CADiatonicKey_diatonicKeyToString(*args):
    return _CanorusPython.CADiatonicKey_diatonicKeyToString(*args)
CADiatonicKey_diatonicKeyToString = _CanorusPython.CADiatonicKey_diatonicKeyToString

def CADiatonicKey_diatonicKeyFromString(*args):
    return _CanorusPython.CADiatonicKey_diatonicKeyFromString(*args)
CADiatonicKey_diatonicKeyFromString = _CanorusPython.CADiatonicKey_diatonicKeyFromString

class CATranspose(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CATranspose, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CATranspose, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CATranspose(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CATranspose
    __del__ = lambda self: None

    def transposeBySemitones(self, *args):
        return _CanorusPython.CATranspose_transposeBySemitones(self, *args)

    def transposeByInterval(self, *args):
        return _CanorusPython.CATranspose_transposeByInterval(self, *args)

    def transposeByKeySig(self, *args):
        return _CanorusPython.CATranspose_transposeByKeySig(self, *args)

    def reinterpretAccidentals(self, *args):
        return _CanorusPython.CATranspose_reinterpretAccidentals(self, *args)

    def addSheet(self, *args):
        return _CanorusPython.CATranspose_addSheet(self, *args)

    def addContext(self, *args):
        return _CanorusPython.CATranspose_addContext(self, *args)

    def addMusElement(self, *args):
        return _CanorusPython.CATranspose_addMusElement(self, *args)
CATranspose_swigregister = _CanorusPython.CATranspose_swigregister
CATranspose_swigregister(CATranspose)

class CAMusElement(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMusElement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAMusElement, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CAMusElement_Undefined
    Note = _CanorusPython.CAMusElement_Note
    Rest = _CanorusPython.CAMusElement_Rest
    MidiNote = _CanorusPython.CAMusElement_MidiNote
    Barline = _CanorusPython.CAMusElement_Barline
    Clef = _CanorusPython.CAMusElement_Clef
    TimeSignature = _CanorusPython.CAMusElement_TimeSignature
    KeySignature = _CanorusPython.CAMusElement_KeySignature
    Slur = _CanorusPython.CAMusElement_Slur
    Tuplet = _CanorusPython.CAMusElement_Tuplet
    Syllable = _CanorusPython.CAMusElement_Syllable
    FunctionMark = _CanorusPython.CAMusElement_FunctionMark
    FiguredBassMark = _CanorusPython.CAMusElement_FiguredBassMark
    Mark = _CanorusPython.CAMusElement_Mark
    __swig_destroy__ = _CanorusPython.delete_CAMusElement
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAMusElement_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAMusElement_compare(self, *args)

    def musElementType(self, *args):
        return _CanorusPython.CAMusElement_musElementType(self, *args)

    def context(self, *args):
        return _CanorusPython.CAMusElement_context(self, *args)

    def setContext(self, *args):
        return _CanorusPython.CAMusElement_setContext(self, *args)

    def timeStart(self, *args):
        return _CanorusPython.CAMusElement_timeStart(self, *args)

    def setTimeStart(self, *args):
        return _CanorusPython.CAMusElement_setTimeStart(self, *args)

    def timeLength(self, *args):
        return _CanorusPython.CAMusElement_timeLength(self, *args)

    def setTimeLength(self, *args):
        return _CanorusPython.CAMusElement_setTimeLength(self, *args)

    def timeEnd(self, *args):
        return _CanorusPython.CAMusElement_timeEnd(self, *args)

    def realTimeStart(self, *args):
        return _CanorusPython.CAMusElement_realTimeStart(self, *args)

    def realTimeLength(self, *args):
        return _CanorusPython.CAMusElement_realTimeLength(self, *args)

    def realTimeEnd(self, *args):
        return _CanorusPython.CAMusElement_realTimeEnd(self, *args)

    def name(self, *args):
        return _CanorusPython.CAMusElement_name(self, *args)

    def setName(self, *args):
        return _CanorusPython.CAMusElement_setName(self, *args)

    def isVisible(self, *args):
        return _CanorusPython.CAMusElement_isVisible(self, *args)

    def setVisible(self, *args):
        return _CanorusPython.CAMusElement_setVisible(self, *args)

    def color(self, *args):
        return _CanorusPython.CAMusElement_color(self, *args)

    def setColor(self, *args):
        return _CanorusPython.CAMusElement_setColor(self, *args)

    def markList(self, *args):
        return _CanorusPython.CAMusElement_markList(self, *args)

    def addMark(self, *args):
        return _CanorusPython.CAMusElement_addMark(self, *args)

    def addMarks(self, *args):
        return _CanorusPython.CAMusElement_addMarks(self, *args)

    def removeMark(self, *args):
        return _CanorusPython.CAMusElement_removeMark(self, *args)

    def noteCheckerErrorList(self, *args):
        return _CanorusPython.CAMusElement_noteCheckerErrorList(self, *args)

    def addNoteCheckerError(self, *args):
        return _CanorusPython.CAMusElement_addNoteCheckerError(self, *args)

    def removeNoteCheckerError(self, *args):
        return _CanorusPython.CAMusElement_removeNoteCheckerError(self, *args)

    def isPlayable(self, *args):
        return _CanorusPython.CAMusElement_isPlayable(self, *args)
    if _newclass:
        musElementTypeToString = staticmethod(_CanorusPython.CAMusElement_musElementTypeToString)
    else:
        musElementTypeToString = _CanorusPython.CAMusElement_musElementTypeToString
    if _newclass:
        musElementTypeFromString = staticmethod(_CanorusPython.CAMusElement_musElementTypeFromString)
    else:
        musElementTypeFromString = _CanorusPython.CAMusElement_musElementTypeFromString
CAMusElement_swigregister = _CanorusPython.CAMusElement_swigregister
CAMusElement_swigregister(CAMusElement)

def CAMusElement_musElementTypeToString(*args):
    return _CanorusPython.CAMusElement_musElementTypeToString(*args)
CAMusElement_musElementTypeToString = _CanorusPython.CAMusElement_musElementTypeToString

def CAMusElement_musElementTypeFromString(*args):
    return _CanorusPython.CAMusElement_musElementTypeFromString(*args)
CAMusElement_musElementTypeFromString = _CanorusPython.CAMusElement_musElementTypeFromString

class CAPlayable(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAPlayable, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAPlayable, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CanorusPython.delete_CAPlayable
    __del__ = lambda self: None

    def playableLength(self, *args):
        return _CanorusPython.CAPlayable_playableLength(self, *args)

    def setPlayableLength(self, *args):
        return _CanorusPython.CAPlayable_setPlayableLength(self, *args)

    def clone(self, *args):
        return _CanorusPython.CAPlayable_clone(self, *args)

    def tuplet(self, *args):
        return _CanorusPython.CAPlayable_tuplet(self, *args)

    def setTuplet(self, *args):
        return _CanorusPython.CAPlayable_setTuplet(self, *args)

    def voice(self, *args):
        return _CanorusPython.CAPlayable_voice(self, *args)

    def setVoice(self, *args):
        return _CanorusPython.CAPlayable_setVoice(self, *args)

    def staff(self, *args):
        return _CanorusPython.CAPlayable_staff(self, *args)

    def isFirstInTuplet(self, *args):
        return _CanorusPython.CAPlayable_isFirstInTuplet(self, *args)

    def isLastInTuplet(self, *args):
        return _CanorusPython.CAPlayable_isLastInTuplet(self, *args)

    def resetTime(self, *args):
        return _CanorusPython.CAPlayable_resetTime(self, *args)

    def calculateTimeLength(self, *args):
        return _CanorusPython.CAPlayable_calculateTimeLength(self, *args)
CAPlayable_swigregister = _CanorusPython.CAPlayable_swigregister
CAPlayable_swigregister(CAPlayable)

class CABarline(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CABarline, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CABarline, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CABarline_Undefined
    Single = _CanorusPython.CABarline_Single
    Double = _CanorusPython.CABarline_Double
    End = _CanorusPython.CABarline_End
    RepeatOpen = _CanorusPython.CABarline_RepeatOpen
    RepeatClose = _CanorusPython.CABarline_RepeatClose
    RepeatCloseOpen = _CanorusPython.CABarline_RepeatCloseOpen
    Dotted = _CanorusPython.CABarline_Dotted

    def __init__(self, *args):
        this = _CanorusPython.new_CABarline(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CABarline
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CABarline_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CABarline_compare(self, *args)

    def barlineType(self, *args):
        return _CanorusPython.CABarline_barlineType(self, *args)

    def setBarlineType(self, *args):
        return _CanorusPython.CABarline_setBarlineType(self, *args)
    if _newclass:
        barlineTypeToString = staticmethod(_CanorusPython.CABarline_barlineTypeToString)
    else:
        barlineTypeToString = _CanorusPython.CABarline_barlineTypeToString
    if _newclass:
        barlineTypeFromString = staticmethod(_CanorusPython.CABarline_barlineTypeFromString)
    else:
        barlineTypeFromString = _CanorusPython.CABarline_barlineTypeFromString
CABarline_swigregister = _CanorusPython.CABarline_swigregister
CABarline_swigregister(CABarline)

def CABarline_barlineTypeToString(*args):
    return _CanorusPython.CABarline_barlineTypeToString(*args)
CABarline_barlineTypeToString = _CanorusPython.CABarline_barlineTypeToString

def CABarline_barlineTypeFromString(*args):
    return _CanorusPython.CABarline_barlineTypeFromString(*args)
CABarline_barlineTypeFromString = _CanorusPython.CABarline_barlineTypeFromString

class CAClef(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAClef, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAClef, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CAClef_Undefined
    Treble = _CanorusPython.CAClef_Treble
    Bass = _CanorusPython.CAClef_Bass
    French = _CanorusPython.CAClef_French
    Soprano = _CanorusPython.CAClef_Soprano
    Mezzosoprano = _CanorusPython.CAClef_Mezzosoprano
    Alto = _CanorusPython.CAClef_Alto
    Tenor = _CanorusPython.CAClef_Tenor
    Baritone = _CanorusPython.CAClef_Baritone
    Varbaritone = _CanorusPython.CAClef_Varbaritone
    Subbass = _CanorusPython.CAClef_Subbass
    Percussion = _CanorusPython.CAClef_Percussion
    Tablature = _CanorusPython.CAClef_Tablature
    F = _CanorusPython.CAClef_F
    G = _CanorusPython.CAClef_G
    C = _CanorusPython.CAClef_C
    PercussionHigh = _CanorusPython.CAClef_PercussionHigh
    PercussionLow = _CanorusPython.CAClef_PercussionLow
    Tab = _CanorusPython.CAClef_Tab

    def __init__(self, *args):
        this = _CanorusPython.new_CAClef(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self, *args):
        return _CanorusPython.CAClef_clone(self, *args)

    def staff(self, *args):
        return _CanorusPython.CAClef_staff(self, *args)

    def setPredefinedType(self, *args):
        return _CanorusPython.CAClef_setPredefinedType(self, *args)

    def clefType(self, *args):
        return _CanorusPython.CAClef_clefType(self, *args)

    def c1(self, *args):
        return _CanorusPython.CAClef_c1(self, *args)

    def centerPitch(self, *args):
        return _CanorusPython.CAClef_centerPitch(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAClef_compare(self, *args)

    def setClefType(self, *args):
        return _CanorusPython.CAClef_setClefType(self, *args)

    def setOffset(self, *args):
        return _CanorusPython.CAClef_setOffset(self, *args)

    def offset(self, *args):
        return _CanorusPython.CAClef_offset(self, *args)
    if _newclass:
        clefTypeToString = staticmethod(_CanorusPython.CAClef_clefTypeToString)
    else:
        clefTypeToString = _CanorusPython.CAClef_clefTypeToString
    if _newclass:
        clefTypeFromString = staticmethod(_CanorusPython.CAClef_clefTypeFromString)
    else:
        clefTypeFromString = _CanorusPython.CAClef_clefTypeFromString
    if _newclass:
        offsetFromReadable = staticmethod(_CanorusPython.CAClef_offsetFromReadable)
    else:
        offsetFromReadable = _CanorusPython.CAClef_offsetFromReadable
    if _newclass:
        offsetToReadable = staticmethod(_CanorusPython.CAClef_offsetToReadable)
    else:
        offsetToReadable = _CanorusPython.CAClef_offsetToReadable
    __swig_destroy__ = _CanorusPython.delete_CAClef
    __del__ = lambda self: None
CAClef_swigregister = _CanorusPython.CAClef_swigregister
CAClef_swigregister(CAClef)

def CAClef_clefTypeToString(*args):
    return _CanorusPython.CAClef_clefTypeToString(*args)
CAClef_clefTypeToString = _CanorusPython.CAClef_clefTypeToString

def CAClef_clefTypeFromString(*args):
    return _CanorusPython.CAClef_clefTypeFromString(*args)
CAClef_clefTypeFromString = _CanorusPython.CAClef_clefTypeFromString

def CAClef_offsetFromReadable(*args):
    return _CanorusPython.CAClef_offsetFromReadable(*args)
CAClef_offsetFromReadable = _CanorusPython.CAClef_offsetFromReadable

def CAClef_offsetToReadable(*args):
    return _CanorusPython.CAClef_offsetToReadable(*args)
CAClef_offsetToReadable = _CanorusPython.CAClef_offsetToReadable

class CAFiguredBassMark(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAFiguredBassMark, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAFiguredBassMark, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAFiguredBassMark(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAFiguredBassMark
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAFiguredBassMark_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAFiguredBassMark_compare(self, *args)

    def addNumber(self, *args):
        return _CanorusPython.CAFiguredBassMark_addNumber(self, *args)

    def removeNumber(self, *args):
        return _CanorusPython.CAFiguredBassMark_removeNumber(self, *args)

    def numbers(self, *args):
        return _CanorusPython.CAFiguredBassMark_numbers(self, *args)

    def accs(self, *args):
        return _CanorusPython.CAFiguredBassMark_accs(self, *args)
CAFiguredBassMark_swigregister = _CanorusPython.CAFiguredBassMark_swigregister
CAFiguredBassMark_swigregister(CAFiguredBassMark)

class CAFunctionMark(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAFunctionMark, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAFunctionMark, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CAFunctionMark_Undefined
    I = _CanorusPython.CAFunctionMark_I
    II = _CanorusPython.CAFunctionMark_II
    III = _CanorusPython.CAFunctionMark_III
    IV = _CanorusPython.CAFunctionMark_IV
    V = _CanorusPython.CAFunctionMark_V
    VI = _CanorusPython.CAFunctionMark_VI
    VII = _CanorusPython.CAFunctionMark_VII
    T = _CanorusPython.CAFunctionMark_T
    S = _CanorusPython.CAFunctionMark_S
    D = _CanorusPython.CAFunctionMark_D
    F = _CanorusPython.CAFunctionMark_F
    N = _CanorusPython.CAFunctionMark_N
    L = _CanorusPython.CAFunctionMark_L
    K = _CanorusPython.CAFunctionMark_K

    def __init__(self, *args):
        this = _CanorusPython.new_CAFunctionMark(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self, *args):
        return _CanorusPython.CAFunctionMark_clone(self, *args)

    def clear(self, *args):
        return _CanorusPython.CAFunctionMark_clear(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CAFunctionMark
    __del__ = lambda self: None

    def fmContext(self, *args):
        return _CanorusPython.CAFunctionMark_fmContext(self, *args)

    def function(self, *args):
        return _CanorusPython.CAFunctionMark_function(self, *args)

    def key(self, *args):
        return _CanorusPython.CAFunctionMark_key(self, *args)

    def chordArea(self, *args):
        return _CanorusPython.CAFunctionMark_chordArea(self, *args)

    def tonicDegree(self, *args):
        return _CanorusPython.CAFunctionMark_tonicDegree(self, *args)

    def alteredDegrees(self, *args):
        return _CanorusPython.CAFunctionMark_alteredDegrees(self, *args)

    def addedDegrees(self, *args):
        return _CanorusPython.CAFunctionMark_addedDegrees(self, *args)

    def setFunction(self, *args):
        return _CanorusPython.CAFunctionMark_setFunction(self, *args)

    def setKey(self, *args):
        return _CanorusPython.CAFunctionMark_setKey(self, *args)

    def setChordArea(self, *args):
        return _CanorusPython.CAFunctionMark_setChordArea(self, *args)

    def setChordAreaMinor(self, *args):
        return _CanorusPython.CAFunctionMark_setChordAreaMinor(self, *args)

    def setTonicDegree(self, *args):
        return _CanorusPython.CAFunctionMark_setTonicDegree(self, *args)

    def setTonicDegreeMinor(self, *args):
        return _CanorusPython.CAFunctionMark_setTonicDegreeMinor(self, *args)

    def setAlteredDegrees(self, *args):
        return _CanorusPython.CAFunctionMark_setAlteredDegrees(self, *args)

    def setAddedDegrees(self, *args):
        return _CanorusPython.CAFunctionMark_setAddedDegrees(self, *args)

    def setMinor(self, *args):
        return _CanorusPython.CAFunctionMark_setMinor(self, *args)

    def setEllipse(self, *args):
        return _CanorusPython.CAFunctionMark_setEllipse(self, *args)

    def setAlterations(self, *args):
        return _CanorusPython.CAFunctionMark_setAlterations(self, *args)

    def isEmpty(self, *args):
        return _CanorusPython.CAFunctionMark_isEmpty(self, *args)

    def isSideDegree(self, *args):
        return _CanorusPython.CAFunctionMark_isSideDegree(self, *args)

    def isMinor(self, *args):
        return _CanorusPython.CAFunctionMark_isMinor(self, *args)

    def isChordAreaMinor(self, *args):
        return _CanorusPython.CAFunctionMark_isChordAreaMinor(self, *args)

    def isTonicDegreeMinor(self, *args):
        return _CanorusPython.CAFunctionMark_isTonicDegreeMinor(self, *args)

    def isPartOfEllipse(self, *args):
        return _CanorusPython.CAFunctionMark_isPartOfEllipse(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAFunctionMark_compare(self, *args)
    if _newclass:
        functionTypeToString = staticmethod(_CanorusPython.CAFunctionMark_functionTypeToString)
    else:
        functionTypeToString = _CanorusPython.CAFunctionMark_functionTypeToString
    if _newclass:
        functionTypeFromString = staticmethod(_CanorusPython.CAFunctionMark_functionTypeFromString)
    else:
        functionTypeFromString = _CanorusPython.CAFunctionMark_functionTypeFromString
CAFunctionMark_swigregister = _CanorusPython.CAFunctionMark_swigregister
CAFunctionMark_swigregister(CAFunctionMark)

def CAFunctionMark_functionTypeToString(*args):
    return _CanorusPython.CAFunctionMark_functionTypeToString(*args)
CAFunctionMark_functionTypeToString = _CanorusPython.CAFunctionMark_functionTypeToString

def CAFunctionMark_functionTypeFromString(*args):
    return _CanorusPython.CAFunctionMark_functionTypeFromString(*args)
CAFunctionMark_functionTypeFromString = _CanorusPython.CAFunctionMark_functionTypeFromString

class CAKeySignature(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAKeySignature, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAKeySignature, name)
    __repr__ = _swig_repr
    MajorMinor = _CanorusPython.CAKeySignature_MajorMinor
    Modus = _CanorusPython.CAKeySignature_Modus
    Custom = _CanorusPython.CAKeySignature_Custom
    Ionian = _CanorusPython.CAKeySignature_Ionian
    Dorian = _CanorusPython.CAKeySignature_Dorian
    Phrygian = _CanorusPython.CAKeySignature_Phrygian
    Lydian = _CanorusPython.CAKeySignature_Lydian
    Mixolydian = _CanorusPython.CAKeySignature_Mixolydian
    Aeolian = _CanorusPython.CAKeySignature_Aeolian
    Locrian = _CanorusPython.CAKeySignature_Locrian
    Hypodorian = _CanorusPython.CAKeySignature_Hypodorian
    Hypolydian = _CanorusPython.CAKeySignature_Hypolydian
    Hypomixolydian = _CanorusPython.CAKeySignature_Hypomixolydian
    Hypophrygian = _CanorusPython.CAKeySignature_Hypophrygian

    def __init__(self, *args):
        this = _CanorusPython.new_CAKeySignature(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAKeySignature
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAKeySignature_clone(self, *args)

    def staff(self, *args):
        return _CanorusPython.CAKeySignature_staff(self, *args)

    def keySignatureType(self, *args):
        return _CanorusPython.CAKeySignature_keySignatureType(self, *args)

    def setKeySignatureType(self, *args):
        return _CanorusPython.CAKeySignature_setKeySignatureType(self, *args)

    def diatonicKey(self, *args):
        return _CanorusPython.CAKeySignature_diatonicKey(self, *args)

    def modus(self, *args):
        return _CanorusPython.CAKeySignature_modus(self, *args)

    def setDiatonicKey(self, *args):
        return _CanorusPython.CAKeySignature_setDiatonicKey(self, *args)

    def setModus(self, *args):
        return _CanorusPython.CAKeySignature_setModus(self, *args)

    def accidentals(self, *args):
        return _CanorusPython.CAKeySignature_accidentals(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAKeySignature_compare(self, *args)
    if _newclass:
        keySignatureTypeToString = staticmethod(_CanorusPython.CAKeySignature_keySignatureTypeToString)
    else:
        keySignatureTypeToString = _CanorusPython.CAKeySignature_keySignatureTypeToString
    if _newclass:
        keySignatureTypeFromString = staticmethod(_CanorusPython.CAKeySignature_keySignatureTypeFromString)
    else:
        keySignatureTypeFromString = _CanorusPython.CAKeySignature_keySignatureTypeFromString
    if _newclass:
        modusToString = staticmethod(_CanorusPython.CAKeySignature_modusToString)
    else:
        modusToString = _CanorusPython.CAKeySignature_modusToString
    if _newclass:
        modusFromString = staticmethod(_CanorusPython.CAKeySignature_modusFromString)
    else:
        modusFromString = _CanorusPython.CAKeySignature_modusFromString
CAKeySignature_swigregister = _CanorusPython.CAKeySignature_swigregister
CAKeySignature_swigregister(CAKeySignature)

def CAKeySignature_keySignatureTypeToString(*args):
    return _CanorusPython.CAKeySignature_keySignatureTypeToString(*args)
CAKeySignature_keySignatureTypeToString = _CanorusPython.CAKeySignature_keySignatureTypeToString

def CAKeySignature_keySignatureTypeFromString(*args):
    return _CanorusPython.CAKeySignature_keySignatureTypeFromString(*args)
CAKeySignature_keySignatureTypeFromString = _CanorusPython.CAKeySignature_keySignatureTypeFromString

def CAKeySignature_modusToString(*args):
    return _CanorusPython.CAKeySignature_modusToString(*args)
CAKeySignature_modusToString = _CanorusPython.CAKeySignature_modusToString

def CAKeySignature_modusFromString(*args):
    return _CanorusPython.CAKeySignature_modusFromString(*args)
CAKeySignature_modusFromString = _CanorusPython.CAKeySignature_modusFromString

class CASlur(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CASlur, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CASlur, name)
    __repr__ = _swig_repr
    SlurUp = _CanorusPython.CASlur_SlurUp
    SlurDown = _CanorusPython.CASlur_SlurDown
    SlurNeutral = _CanorusPython.CASlur_SlurNeutral
    SlurPreferred = _CanorusPython.CASlur_SlurPreferred
    Undefined = _CanorusPython.CASlur_Undefined
    SlurSolid = _CanorusPython.CASlur_SlurSolid
    SlurDotted = _CanorusPython.CASlur_SlurDotted
    TieType = _CanorusPython.CASlur_TieType
    SlurType = _CanorusPython.CASlur_SlurType
    PhrasingSlurType = _CanorusPython.CASlur_PhrasingSlurType

    def __init__(self, *args):
        this = _CanorusPython.new_CASlur(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CASlur
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CASlur_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CASlur_compare(self, *args)

    def slurDirection(self, *args):
        return _CanorusPython.CASlur_slurDirection(self, *args)

    def setSlurDirection(self, *args):
        return _CanorusPython.CASlur_setSlurDirection(self, *args)

    def slurType(self, *args):
        return _CanorusPython.CASlur_slurType(self, *args)

    def noteStart(self, *args):
        return _CanorusPython.CASlur_noteStart(self, *args)

    def noteEnd(self, *args):
        return _CanorusPython.CASlur_noteEnd(self, *args)

    def slurStyle(self, *args):
        return _CanorusPython.CASlur_slurStyle(self, *args)

    def setNoteStart(self, *args):
        return _CanorusPython.CASlur_setNoteStart(self, *args)

    def setNoteEnd(self, *args):
        return _CanorusPython.CASlur_setNoteEnd(self, *args)

    def setSlurStyle(self, *args):
        return _CanorusPython.CASlur_setSlurStyle(self, *args)
    if _newclass:
        slurStyleToString = staticmethod(_CanorusPython.CASlur_slurStyleToString)
    else:
        slurStyleToString = _CanorusPython.CASlur_slurStyleToString
    if _newclass:
        slurStyleFromString = staticmethod(_CanorusPython.CASlur_slurStyleFromString)
    else:
        slurStyleFromString = _CanorusPython.CASlur_slurStyleFromString
    if _newclass:
        slurDirectionToString = staticmethod(_CanorusPython.CASlur_slurDirectionToString)
    else:
        slurDirectionToString = _CanorusPython.CASlur_slurDirectionToString
    if _newclass:
        slurDirectionFromString = staticmethod(_CanorusPython.CASlur_slurDirectionFromString)
    else:
        slurDirectionFromString = _CanorusPython.CASlur_slurDirectionFromString
CASlur_swigregister = _CanorusPython.CASlur_swigregister
CASlur_swigregister(CASlur)

def CASlur_slurStyleToString(*args):
    return _CanorusPython.CASlur_slurStyleToString(*args)
CASlur_slurStyleToString = _CanorusPython.CASlur_slurStyleToString

def CASlur_slurStyleFromString(*args):
    return _CanorusPython.CASlur_slurStyleFromString(*args)
CASlur_slurStyleFromString = _CanorusPython.CASlur_slurStyleFromString

def CASlur_slurDirectionToString(*args):
    return _CanorusPython.CASlur_slurDirectionToString(*args)
CASlur_slurDirectionToString = _CanorusPython.CASlur_slurDirectionToString

def CASlur_slurDirectionFromString(*args):
    return _CanorusPython.CASlur_slurDirectionFromString(*args)
CASlur_slurDirectionFromString = _CanorusPython.CASlur_slurDirectionFromString

class CATuplet(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CATuplet, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CATuplet, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CATuplet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CATuplet
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CATuplet_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CATuplet_compare(self, *args)

    def number(self, *args):
        return _CanorusPython.CATuplet_number(self, *args)

    def setNumber(self, *args):
        return _CanorusPython.CATuplet_setNumber(self, *args)

    def actualNumber(self, *args):
        return _CanorusPython.CATuplet_actualNumber(self, *args)

    def setActualNumber(self, *args):
        return _CanorusPython.CATuplet_setActualNumber(self, *args)

    def noteList(self, *args):
        return _CanorusPython.CATuplet_noteList(self, *args)

    def addNote(self, *args):
        return _CanorusPython.CATuplet_addNote(self, *args)

    def addNotes(self, *args):
        return _CanorusPython.CATuplet_addNotes(self, *args)

    def removeNote(self, *args):
        return _CanorusPython.CATuplet_removeNote(self, *args)

    def firstNote(self, *args):
        return _CanorusPython.CATuplet_firstNote(self, *args)

    def lastNote(self, *args):
        return _CanorusPython.CATuplet_lastNote(self, *args)

    def containsNote(self, *args):
        return _CanorusPython.CATuplet_containsNote(self, *args)

    def nextTimed(self, *args):
        return _CanorusPython.CATuplet_nextTimed(self, *args)

    def timeLength(self, *args):
        return _CanorusPython.CATuplet_timeLength(self, *args)

    def timeStart(self, *args):
        return _CanorusPython.CATuplet_timeStart(self, *args)

    def assignTimes(self, *args):
        return _CanorusPython.CATuplet_assignTimes(self, *args)
CATuplet_swigregister = _CanorusPython.CATuplet_swigregister
CATuplet_swigregister(CATuplet)

class CASyllable(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CASyllable, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CASyllable, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CASyllable(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CASyllable
    __del__ = lambda self: None

    def clear(self, *args):
        return _CanorusPython.CASyllable_clear(self, *args)

    def hyphenStart(self, *args):
        return _CanorusPython.CASyllable_hyphenStart(self, *args)

    def setHyphenStart(self, *args):
        return _CanorusPython.CASyllable_setHyphenStart(self, *args)

    def melismaStart(self, *args):
        return _CanorusPython.CASyllable_melismaStart(self, *args)

    def setMelismaStart(self, *args):
        return _CanorusPython.CASyllable_setMelismaStart(self, *args)

    def text(self, *args):
        return _CanorusPython.CASyllable_text(self, *args)

    def setText(self, *args):
        return _CanorusPython.CASyllable_setText(self, *args)

    def associatedVoice(self, *args):
        return _CanorusPython.CASyllable_associatedVoice(self, *args)

    def setAssociatedVoice(self, *args):
        return _CanorusPython.CASyllable_setAssociatedVoice(self, *args)

    def lyricsContext(self, *args):
        return _CanorusPython.CASyllable_lyricsContext(self, *args)

    def clone(self, *args):
        return _CanorusPython.CASyllable_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CASyllable_compare(self, *args)
CASyllable_swigregister = _CanorusPython.CASyllable_swigregister
CASyllable_swigregister(CASyllable)

class CATimeSignature(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CATimeSignature, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CATimeSignature, name)
    __repr__ = _swig_repr
    Classical = _CanorusPython.CATimeSignature_Classical
    Number = _CanorusPython.CATimeSignature_Number
    Mensural = _CanorusPython.CATimeSignature_Mensural
    Neomensural = _CanorusPython.CATimeSignature_Neomensural
    Baroque = _CanorusPython.CATimeSignature_Baroque

    def __init__(self, *args):
        this = _CanorusPython.new_CATimeSignature(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self, *args):
        return _CanorusPython.CATimeSignature_clone(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CATimeSignature
    __del__ = lambda self: None

    def staff(self, *args):
        return _CanorusPython.CATimeSignature_staff(self, *args)

    def beats(self, *args):
        return _CanorusPython.CATimeSignature_beats(self, *args)

    def setBeats(self, *args):
        return _CanorusPython.CATimeSignature_setBeats(self, *args)

    def beat(self, *args):
        return _CanorusPython.CATimeSignature_beat(self, *args)

    def setBeat(self, *args):
        return _CanorusPython.CATimeSignature_setBeat(self, *args)

    def barDuration(self, *args):
        return _CanorusPython.CATimeSignature_barDuration(self, *args)

    def timeSignatureType(self, *args):
        return _CanorusPython.CATimeSignature_timeSignatureType(self, *args)

    def timeSignatureML(self, *args):
        return _CanorusPython.CATimeSignature_timeSignatureML(self, *args)

    def timeSignatureTypeML(self, *args):
        return _CanorusPython.CATimeSignature_timeSignatureTypeML(self, *args)
    if _newclass:
        timeSignatureTypeToString = staticmethod(_CanorusPython.CATimeSignature_timeSignatureTypeToString)
    else:
        timeSignatureTypeToString = _CanorusPython.CATimeSignature_timeSignatureTypeToString
    if _newclass:
        timeSignatureTypeFromString = staticmethod(_CanorusPython.CATimeSignature_timeSignatureTypeFromString)
    else:
        timeSignatureTypeFromString = _CanorusPython.CATimeSignature_timeSignatureTypeFromString

    def compare(self, *args):
        return _CanorusPython.CATimeSignature_compare(self, *args)
CATimeSignature_swigregister = _CanorusPython.CATimeSignature_swigregister
CATimeSignature_swigregister(CATimeSignature)

def CATimeSignature_timeSignatureTypeToString(*args):
    return _CanorusPython.CATimeSignature_timeSignatureTypeToString(*args)
CATimeSignature_timeSignatureTypeToString = _CanorusPython.CATimeSignature_timeSignatureTypeToString

def CATimeSignature_timeSignatureTypeFromString(*args):
    return _CanorusPython.CATimeSignature_timeSignatureTypeFromString(*args)
CATimeSignature_timeSignatureTypeFromString = _CanorusPython.CATimeSignature_timeSignatureTypeFromString

class CANote(CAPlayable):
    __swig_setmethods__ = {}
    for _s in [CAPlayable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CANote, name, value)
    __swig_getmethods__ = {}
    for _s in [CAPlayable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CANote, name)
    __repr__ = _swig_repr
    StemUndefined = _CanorusPython.CANote_StemUndefined
    StemNeutral = _CanorusPython.CANote_StemNeutral
    StemUp = _CanorusPython.CANote_StemUp
    StemDown = _CanorusPython.CANote_StemDown
    StemPreferred = _CanorusPython.CANote_StemPreferred

    def __init__(self, *args):
        this = _CanorusPython.new_CANote(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone(self, *args):
        return _CanorusPython.CANote_clone(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CANote
    __del__ = lambda self: None

    def noteLength(self, *args):
        return _CanorusPython.CANote_noteLength(self, *args)

    def diatonicPitch(self, *args):
        return _CanorusPython.CANote_diatonicPitch(self, *args)

    def setDiatonicPitch(self, *args):
        return _CanorusPython.CANote_setDiatonicPitch(self, *args)

    def midiPitch(self, *args):
        return _CanorusPython.CANote_midiPitch(self, *args)

    def stemDirection(self, *args):
        return _CanorusPython.CANote_stemDirection(self, *args)

    def setStemDirection(self, *args):
        return _CanorusPython.CANote_setStemDirection(self, *args)

    def notePosition(self, *args):
        return _CanorusPython.CANote_notePosition(self, *args)

    def tieStart(self, *args):
        return _CanorusPython.CANote_tieStart(self, *args)

    def tieEnd(self, *args):
        return _CanorusPython.CANote_tieEnd(self, *args)

    def slurStart(self, *args):
        return _CanorusPython.CANote_slurStart(self, *args)

    def slurEnd(self, *args):
        return _CanorusPython.CANote_slurEnd(self, *args)

    def phrasingSlurStart(self, *args):
        return _CanorusPython.CANote_phrasingSlurStart(self, *args)

    def phrasingSlurEnd(self, *args):
        return _CanorusPython.CANote_phrasingSlurEnd(self, *args)

    def actualStemDirection(self, *args):
        return _CanorusPython.CANote_actualStemDirection(self, *args)

    def actualSlurDirection(self, *args):
        return _CanorusPython.CANote_actualSlurDirection(self, *args)

    def setTieStart(self, *args):
        return _CanorusPython.CANote_setTieStart(self, *args)

    def setTieEnd(self, *args):
        return _CanorusPython.CANote_setTieEnd(self, *args)

    def setSlurStart(self, *args):
        return _CanorusPython.CANote_setSlurStart(self, *args)

    def setSlurEnd(self, *args):
        return _CanorusPython.CANote_setSlurEnd(self, *args)

    def setPhrasingSlurStart(self, *args):
        return _CanorusPython.CANote_setPhrasingSlurStart(self, *args)

    def setPhrasingSlurEnd(self, *args):
        return _CanorusPython.CANote_setPhrasingSlurEnd(self, *args)

    def updateTies(self, *args):
        return _CanorusPython.CANote_updateTies(self, *args)

    def isPartOfChord(self, *args):
        return _CanorusPython.CANote_isPartOfChord(self, *args)

    def isLastInChord(self, *args):
        return _CanorusPython.CANote_isLastInChord(self, *args)

    def isFirstInChord(self, *args):
        return _CanorusPython.CANote_isFirstInChord(self, *args)

    def getChord(self, *args):
        return _CanorusPython.CANote_getChord(self, *args)

    def forceAccidentals(self, *args):
        return _CanorusPython.CANote_forceAccidentals(self, *args)

    def setForceAccidentals(self, *args):
        return _CanorusPython.CANote_setForceAccidentals(self, *args)
    if _newclass:
        generateNoteName = staticmethod(_CanorusPython.CANote_generateNoteName)
    else:
        generateNoteName = _CanorusPython.CANote_generateNoteName
    if _newclass:
        stemDirectionToString = staticmethod(_CanorusPython.CANote_stemDirectionToString)
    else:
        stemDirectionToString = _CanorusPython.CANote_stemDirectionToString
    if _newclass:
        stemDirectionFromString = staticmethod(_CanorusPython.CANote_stemDirectionFromString)
    else:
        stemDirectionFromString = _CanorusPython.CANote_stemDirectionFromString

    def compare(self, *args):
        return _CanorusPython.CANote_compare(self, *args)
CANote_swigregister = _CanorusPython.CANote_swigregister
CANote_swigregister(CANote)

def CANote_generateNoteName(*args):
    return _CanorusPython.CANote_generateNoteName(*args)
CANote_generateNoteName = _CanorusPython.CANote_generateNoteName

def CANote_stemDirectionToString(*args):
    return _CanorusPython.CANote_stemDirectionToString(*args)
CANote_stemDirectionToString = _CanorusPython.CANote_stemDirectionToString

def CANote_stemDirectionFromString(*args):
    return _CanorusPython.CANote_stemDirectionFromString(*args)
CANote_stemDirectionFromString = _CanorusPython.CANote_stemDirectionFromString

class CARest(CAPlayable):
    __swig_setmethods__ = {}
    for _s in [CAPlayable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CARest, name, value)
    __swig_getmethods__ = {}
    for _s in [CAPlayable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CARest, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CARest_Undefined
    Normal = _CanorusPython.CARest_Normal
    Hidden = _CanorusPython.CARest_Hidden

    def __init__(self, *args):
        this = _CanorusPython.new_CARest(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CARest
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CARest_clone(self, *args)

    def restType(self, *args):
        return _CanorusPython.CARest_restType(self, *args)

    def setRestType(self, *args):
        return _CanorusPython.CARest_setRestType(self, *args)

    def compare(self, *args):
        return _CanorusPython.CARest_compare(self, *args)
    if _newclass:
        restTypeToString = staticmethod(_CanorusPython.CARest_restTypeToString)
    else:
        restTypeToString = _CanorusPython.CARest_restTypeToString
    if _newclass:
        restTypeFromString = staticmethod(_CanorusPython.CARest_restTypeFromString)
    else:
        restTypeFromString = _CanorusPython.CARest_restTypeFromString
    if _newclass:
        composeRests = staticmethod(_CanorusPython.CARest_composeRests)
    else:
        composeRests = _CanorusPython.CARest_composeRests
CARest_swigregister = _CanorusPython.CARest_swigregister
CARest_swigregister(CARest)

def CARest_restTypeToString(*args):
    return _CanorusPython.CARest_restTypeToString(*args)
CARest_restTypeToString = _CanorusPython.CARest_restTypeToString

def CARest_restTypeFromString(*args):
    return _CanorusPython.CARest_restTypeFromString(*args)
CARest_restTypeFromString = _CanorusPython.CARest_restTypeFromString

def CARest_composeRests(*args):
    return _CanorusPython.CARest_composeRests(*args)
CARest_composeRests = _CanorusPython.CARest_composeRests

class CAMidiNote(CAPlayable):
    __swig_setmethods__ = {}
    for _s in [CAPlayable]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMidiNote, name, value)
    __swig_getmethods__ = {}
    for _s in [CAPlayable]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAMidiNote, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAMidiNote(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAMidiNote
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAMidiNote_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAMidiNote_compare(self, *args)

    def midiPitch(self, *args):
        return _CanorusPython.CAMidiNote_midiPitch(self, *args)

    def setMidiPitch(self, *args):
        return _CanorusPython.CAMidiNote_setMidiPitch(self, *args)
CAMidiNote_swigregister = _CanorusPython.CAMidiNote_swigregister
CAMidiNote_swigregister(CAMidiNote)

class CAMark(CAMusElement):
    __swig_setmethods__ = {}
    for _s in [CAMusElement]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMark, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMusElement]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAMark, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CAMark_Undefined
    Text = _CanorusPython.CAMark_Text
    Tempo = _CanorusPython.CAMark_Tempo
    Ritardando = _CanorusPython.CAMark_Ritardando
    Dynamic = _CanorusPython.CAMark_Dynamic
    Crescendo = _CanorusPython.CAMark_Crescendo
    Pedal = _CanorusPython.CAMark_Pedal
    InstrumentChange = _CanorusPython.CAMark_InstrumentChange
    BookMark = _CanorusPython.CAMark_BookMark
    RehersalMark = _CanorusPython.CAMark_RehersalMark
    Fermata = _CanorusPython.CAMark_Fermata
    RepeatMark = _CanorusPython.CAMark_RepeatMark
    Articulation = _CanorusPython.CAMark_Articulation
    Fingering = _CanorusPython.CAMark_Fingering

    def __init__(self, *args):
        this = _CanorusPython.new_CAMark(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAMark
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAMark_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAMark_compare(self, *args)

    def associatedElement(self, *args):
        return _CanorusPython.CAMark_associatedElement(self, *args)

    def setAssociatedElement(self, *args):
        return _CanorusPython.CAMark_setAssociatedElement(self, *args)

    def markType(self, *args):
        return _CanorusPython.CAMark_markType(self, *args)

    def setMarkType(self, *args):
        return _CanorusPython.CAMark_setMarkType(self, *args)

    def isCommon(self, *args):
        return _CanorusPython.CAMark_isCommon(self, *args)
    if _newclass:
        markTypeToString = staticmethod(_CanorusPython.CAMark_markTypeToString)
    else:
        markTypeToString = _CanorusPython.CAMark_markTypeToString
    if _newclass:
        markTypeFromString = staticmethod(_CanorusPython.CAMark_markTypeFromString)
    else:
        markTypeFromString = _CanorusPython.CAMark_markTypeFromString
CAMark_swigregister = _CanorusPython.CAMark_swigregister
CAMark_swigregister(CAMark)

def CAMark_markTypeToString(*args):
    return _CanorusPython.CAMark_markTypeToString(*args)
CAMark_markTypeToString = _CanorusPython.CAMark_markTypeToString

def CAMark_markTypeFromString(*args):
    return _CanorusPython.CAMark_markTypeFromString(*args)
CAMark_markTypeFromString = _CanorusPython.CAMark_markTypeFromString

class CAText(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAText, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAText, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAText(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAText
    __del__ = lambda self: None

    def text(self, *args):
        return _CanorusPython.CAText_text(self, *args)

    def setText(self, *args):
        return _CanorusPython.CAText_setText(self, *args)

    def clone(self, *args):
        return _CanorusPython.CAText_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAText_compare(self, *args)
CAText_swigregister = _CanorusPython.CAText_swigregister
CAText_swigregister(CAText)

class CATempo(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CATempo, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CATempo, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CATempo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CATempo
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CATempo_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CATempo_compare(self, *args)

    def bpm(self, *args):
        return _CanorusPython.CATempo_bpm(self, *args)

    def setBpm(self, *args):
        return _CanorusPython.CATempo_setBpm(self, *args)

    def beat(self, *args):
        return _CanorusPython.CATempo_beat(self, *args)

    def setBeat(self, *args):
        return _CanorusPython.CATempo_setBeat(self, *args)
CATempo_swigregister = _CanorusPython.CATempo_swigregister
CATempo_swigregister(CATempo)

class CARitardando(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CARitardando, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CARitardando, name)
    __repr__ = _swig_repr
    Ritardando = _CanorusPython.CARitardando_Ritardando
    Accellerando = _CanorusPython.CARitardando_Accellerando

    def __init__(self, *args):
        this = _CanorusPython.new_CARitardando(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CARitardando
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CARitardando_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CARitardando_compare(self, *args)

    def finalTempo(self, *args):
        return _CanorusPython.CARitardando_finalTempo(self, *args)

    def setFinalTempo(self, *args):
        return _CanorusPython.CARitardando_setFinalTempo(self, *args)

    def ritardandoType(self, *args):
        return _CanorusPython.CARitardando_ritardandoType(self, *args)

    def setRitardandoType(self, *args):
        return _CanorusPython.CARitardando_setRitardandoType(self, *args)
    if _newclass:
        ritardandoTypeToString = staticmethod(_CanorusPython.CARitardando_ritardandoTypeToString)
    else:
        ritardandoTypeToString = _CanorusPython.CARitardando_ritardandoTypeToString
    if _newclass:
        ritardandoTypeFromString = staticmethod(_CanorusPython.CARitardando_ritardandoTypeFromString)
    else:
        ritardandoTypeFromString = _CanorusPython.CARitardando_ritardandoTypeFromString
CARitardando_swigregister = _CanorusPython.CARitardando_swigregister
CARitardando_swigregister(CARitardando)

def CARitardando_ritardandoTypeToString(*args):
    return _CanorusPython.CARitardando_ritardandoTypeToString(*args)
CARitardando_ritardandoTypeToString = _CanorusPython.CARitardando_ritardandoTypeToString

def CARitardando_ritardandoTypeFromString(*args):
    return _CanorusPython.CARitardando_ritardandoTypeFromString(*args)
CARitardando_ritardandoTypeFromString = _CanorusPython.CARitardando_ritardandoTypeFromString

class CADynamic(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CADynamic, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CADynamic, name)
    __repr__ = _swig_repr
    ppppp = _CanorusPython.CADynamic_ppppp
    pppp = _CanorusPython.CADynamic_pppp
    ppp = _CanorusPython.CADynamic_ppp
    pp = _CanorusPython.CADynamic_pp
    p = _CanorusPython.CADynamic_p
    fffff = _CanorusPython.CADynamic_fffff
    ffff = _CanorusPython.CADynamic_ffff
    fff = _CanorusPython.CADynamic_fff
    ff = _CanorusPython.CADynamic_ff
    f = _CanorusPython.CADynamic_f
    fp = _CanorusPython.CADynamic_fp
    mf = _CanorusPython.CADynamic_mf
    mp = _CanorusPython.CADynamic_mp
    rfz = _CanorusPython.CADynamic_rfz
    sff = _CanorusPython.CADynamic_sff
    sf = _CanorusPython.CADynamic_sf
    sfz = _CanorusPython.CADynamic_sfz
    spp = _CanorusPython.CADynamic_spp
    sp = _CanorusPython.CADynamic_sp
    Custom = _CanorusPython.CADynamic_Custom

    def __init__(self, *args):
        this = _CanorusPython.new_CADynamic(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CADynamic
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CADynamic_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CADynamic_compare(self, *args)

    def text(self, *args):
        return _CanorusPython.CADynamic_text(self, *args)

    def setText(self, *args):
        return _CanorusPython.CADynamic_setText(self, *args)

    def volume(self, *args):
        return _CanorusPython.CADynamic_volume(self, *args)

    def setVolume(self, *args):
        return _CanorusPython.CADynamic_setVolume(self, *args)
    if _newclass:
        dynamicTextToString = staticmethod(_CanorusPython.CADynamic_dynamicTextToString)
    else:
        dynamicTextToString = _CanorusPython.CADynamic_dynamicTextToString
    if _newclass:
        dynamicTextFromString = staticmethod(_CanorusPython.CADynamic_dynamicTextFromString)
    else:
        dynamicTextFromString = _CanorusPython.CADynamic_dynamicTextFromString
CADynamic_swigregister = _CanorusPython.CADynamic_swigregister
CADynamic_swigregister(CADynamic)

def CADynamic_dynamicTextToString(*args):
    return _CanorusPython.CADynamic_dynamicTextToString(*args)
CADynamic_dynamicTextToString = _CanorusPython.CADynamic_dynamicTextToString

def CADynamic_dynamicTextFromString(*args):
    return _CanorusPython.CADynamic_dynamicTextFromString(*args)
CADynamic_dynamicTextFromString = _CanorusPython.CADynamic_dynamicTextFromString

class CACrescendo(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CACrescendo, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CACrescendo, name)
    __repr__ = _swig_repr
    Crescendo = _CanorusPython.CACrescendo_Crescendo
    Decrescendo = _CanorusPython.CACrescendo_Decrescendo

    def __init__(self, *args):
        this = _CanorusPython.new_CACrescendo(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CACrescendo
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CACrescendo_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CACrescendo_compare(self, *args)

    def finalVolume(self, *args):
        return _CanorusPython.CACrescendo_finalVolume(self, *args)

    def setFinalVolume(self, *args):
        return _CanorusPython.CACrescendo_setFinalVolume(self, *args)

    def crescendoType(self, *args):
        return _CanorusPython.CACrescendo_crescendoType(self, *args)

    def setCrescendoType(self, *args):
        return _CanorusPython.CACrescendo_setCrescendoType(self, *args)
    if _newclass:
        crescendoTypeToString = staticmethod(_CanorusPython.CACrescendo_crescendoTypeToString)
    else:
        crescendoTypeToString = _CanorusPython.CACrescendo_crescendoTypeToString
    if _newclass:
        crescendoTypeFromString = staticmethod(_CanorusPython.CACrescendo_crescendoTypeFromString)
    else:
        crescendoTypeFromString = _CanorusPython.CACrescendo_crescendoTypeFromString
CACrescendo_swigregister = _CanorusPython.CACrescendo_swigregister
CACrescendo_swigregister(CACrescendo)

def CACrescendo_crescendoTypeToString(*args):
    return _CanorusPython.CACrescendo_crescendoTypeToString(*args)
CACrescendo_crescendoTypeToString = _CanorusPython.CACrescendo_crescendoTypeToString

def CACrescendo_crescendoTypeFromString(*args):
    return _CanorusPython.CACrescendo_crescendoTypeFromString(*args)
CACrescendo_crescendoTypeFromString = _CanorusPython.CACrescendo_crescendoTypeFromString

class CAInstrumentChange(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAInstrumentChange, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAInstrumentChange, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAInstrumentChange(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAInstrumentChange
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAInstrumentChange_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAInstrumentChange_compare(self, *args)

    def instrument(self, *args):
        return _CanorusPython.CAInstrumentChange_instrument(self, *args)

    def setInstrument(self, *args):
        return _CanorusPython.CAInstrumentChange_setInstrument(self, *args)
CAInstrumentChange_swigregister = _CanorusPython.CAInstrumentChange_swigregister
CAInstrumentChange_swigregister(CAInstrumentChange)

class CABookMark(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CABookMark, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CABookMark, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CABookMark(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CABookMark
    __del__ = lambda self: None

    def text(self, *args):
        return _CanorusPython.CABookMark_text(self, *args)

    def setText(self, *args):
        return _CanorusPython.CABookMark_setText(self, *args)

    def clone(self, *args):
        return _CanorusPython.CABookMark_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CABookMark_compare(self, *args)
CABookMark_swigregister = _CanorusPython.CABookMark_swigregister
CABookMark_swigregister(CABookMark)

class CAFermata(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAFermata, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAFermata, name)
    __repr__ = _swig_repr
    NormalFermata = _CanorusPython.CAFermata_NormalFermata
    ShortFermata = _CanorusPython.CAFermata_ShortFermata
    LongFermata = _CanorusPython.CAFermata_LongFermata
    VeryLongFermata = _CanorusPython.CAFermata_VeryLongFermata

    def __init__(self, *args):
        this = _CanorusPython.new_CAFermata(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAFermata
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAFermata_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAFermata_compare(self, *args)

    def fermataType(self, *args):
        return _CanorusPython.CAFermata_fermataType(self, *args)

    def setFermataType(self, *args):
        return _CanorusPython.CAFermata_setFermataType(self, *args)
    if _newclass:
        fermataTypeToString = staticmethod(_CanorusPython.CAFermata_fermataTypeToString)
    else:
        fermataTypeToString = _CanorusPython.CAFermata_fermataTypeToString
    if _newclass:
        fermataTypeFromString = staticmethod(_CanorusPython.CAFermata_fermataTypeFromString)
    else:
        fermataTypeFromString = _CanorusPython.CAFermata_fermataTypeFromString
CAFermata_swigregister = _CanorusPython.CAFermata_swigregister
CAFermata_swigregister(CAFermata)

def CAFermata_fermataTypeToString(*args):
    return _CanorusPython.CAFermata_fermataTypeToString(*args)
CAFermata_fermataTypeToString = _CanorusPython.CAFermata_fermataTypeToString

def CAFermata_fermataTypeFromString(*args):
    return _CanorusPython.CAFermata_fermataTypeFromString(*args)
CAFermata_fermataTypeFromString = _CanorusPython.CAFermata_fermataTypeFromString

class CARepeatMark(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CARepeatMark, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CARepeatMark, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CARepeatMark_Undefined
    Volta = _CanorusPython.CARepeatMark_Volta
    Segno = _CanorusPython.CARepeatMark_Segno
    Coda = _CanorusPython.CARepeatMark_Coda
    VarCoda = _CanorusPython.CARepeatMark_VarCoda
    DalSegno = _CanorusPython.CARepeatMark_DalSegno
    DalCoda = _CanorusPython.CARepeatMark_DalCoda
    DalVarCoda = _CanorusPython.CARepeatMark_DalVarCoda

    def __init__(self, *args):
        this = _CanorusPython.new_CARepeatMark(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CARepeatMark
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CARepeatMark_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CARepeatMark_compare(self, *args)

    def repeatMarkType(self, *args):
        return _CanorusPython.CARepeatMark_repeatMarkType(self, *args)

    def setRepeatMarkType(self, *args):
        return _CanorusPython.CARepeatMark_setRepeatMarkType(self, *args)

    def voltaNumber(self, *args):
        return _CanorusPython.CARepeatMark_voltaNumber(self, *args)

    def setVoltaNumber(self, *args):
        return _CanorusPython.CARepeatMark_setVoltaNumber(self, *args)
    if _newclass:
        repeatMarkTypeToString = staticmethod(_CanorusPython.CARepeatMark_repeatMarkTypeToString)
    else:
        repeatMarkTypeToString = _CanorusPython.CARepeatMark_repeatMarkTypeToString
    if _newclass:
        repeatMarkTypeFromString = staticmethod(_CanorusPython.CARepeatMark_repeatMarkTypeFromString)
    else:
        repeatMarkTypeFromString = _CanorusPython.CARepeatMark_repeatMarkTypeFromString
CARepeatMark_swigregister = _CanorusPython.CARepeatMark_swigregister
CARepeatMark_swigregister(CARepeatMark)

def CARepeatMark_repeatMarkTypeToString(*args):
    return _CanorusPython.CARepeatMark_repeatMarkTypeToString(*args)
CARepeatMark_repeatMarkTypeToString = _CanorusPython.CARepeatMark_repeatMarkTypeToString

def CARepeatMark_repeatMarkTypeFromString(*args):
    return _CanorusPython.CARepeatMark_repeatMarkTypeFromString(*args)
CARepeatMark_repeatMarkTypeFromString = _CanorusPython.CARepeatMark_repeatMarkTypeFromString

class CAArticulation(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAArticulation, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAArticulation, name)
    __repr__ = _swig_repr
    Undefined = _CanorusPython.CAArticulation_Undefined
    Accent = _CanorusPython.CAArticulation_Accent
    Marcato = _CanorusPython.CAArticulation_Marcato
    Staccatissimo = _CanorusPython.CAArticulation_Staccatissimo
    Espressivo = _CanorusPython.CAArticulation_Espressivo
    Staccato = _CanorusPython.CAArticulation_Staccato
    Tenuto = _CanorusPython.CAArticulation_Tenuto
    Portato = _CanorusPython.CAArticulation_Portato
    UpBow = _CanorusPython.CAArticulation_UpBow
    DownBow = _CanorusPython.CAArticulation_DownBow
    Flageolet = _CanorusPython.CAArticulation_Flageolet
    Open = _CanorusPython.CAArticulation_Open
    Stopped = _CanorusPython.CAArticulation_Stopped
    Turn = _CanorusPython.CAArticulation_Turn
    ReverseTurn = _CanorusPython.CAArticulation_ReverseTurn
    Trill = _CanorusPython.CAArticulation_Trill
    Prall = _CanorusPython.CAArticulation_Prall
    Mordent = _CanorusPython.CAArticulation_Mordent
    PrallPrall = _CanorusPython.CAArticulation_PrallPrall
    PrallMordent = _CanorusPython.CAArticulation_PrallMordent
    UpPrall = _CanorusPython.CAArticulation_UpPrall
    DownPrall = _CanorusPython.CAArticulation_DownPrall
    UpMordent = _CanorusPython.CAArticulation_UpMordent
    DownMordent = _CanorusPython.CAArticulation_DownMordent
    PrallDown = _CanorusPython.CAArticulation_PrallDown
    PrallUp = _CanorusPython.CAArticulation_PrallUp
    LinePrall = _CanorusPython.CAArticulation_LinePrall

    def __init__(self, *args):
        this = _CanorusPython.new_CAArticulation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAArticulation
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAArticulation_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAArticulation_compare(self, *args)

    def associatedNote(self, *args):
        return _CanorusPython.CAArticulation_associatedNote(self, *args)

    def setAssociatedNote(self, *args):
        return _CanorusPython.CAArticulation_setAssociatedNote(self, *args)

    def articulationType(self, *args):
        return _CanorusPython.CAArticulation_articulationType(self, *args)

    def setArticulationType(self, *args):
        return _CanorusPython.CAArticulation_setArticulationType(self, *args)
    if _newclass:
        articulationTypeToString = staticmethod(_CanorusPython.CAArticulation_articulationTypeToString)
    else:
        articulationTypeToString = _CanorusPython.CAArticulation_articulationTypeToString
    if _newclass:
        articulationTypeFromString = staticmethod(_CanorusPython.CAArticulation_articulationTypeFromString)
    else:
        articulationTypeFromString = _CanorusPython.CAArticulation_articulationTypeFromString
CAArticulation_swigregister = _CanorusPython.CAArticulation_swigregister
CAArticulation_swigregister(CAArticulation)

def CAArticulation_articulationTypeToString(*args):
    return _CanorusPython.CAArticulation_articulationTypeToString(*args)
CAArticulation_articulationTypeToString = _CanorusPython.CAArticulation_articulationTypeToString

def CAArticulation_articulationTypeFromString(*args):
    return _CanorusPython.CAArticulation_articulationTypeFromString(*args)
CAArticulation_articulationTypeFromString = _CanorusPython.CAArticulation_articulationTypeFromString

class CAFingering(CAMark):
    __swig_setmethods__ = {}
    for _s in [CAMark]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAFingering, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMark]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAFingering, name)
    __repr__ = _swig_repr
    First = _CanorusPython.CAFingering_First
    Second = _CanorusPython.CAFingering_Second
    Third = _CanorusPython.CAFingering_Third
    Fourth = _CanorusPython.CAFingering_Fourth
    Fifth = _CanorusPython.CAFingering_Fifth
    Thumb = _CanorusPython.CAFingering_Thumb
    LHeel = _CanorusPython.CAFingering_LHeel
    RHeel = _CanorusPython.CAFingering_RHeel
    LToe = _CanorusPython.CAFingering_LToe
    RToe = _CanorusPython.CAFingering_RToe
    Undefined = _CanorusPython.CAFingering_Undefined

    def __init__(self, *args):
        this = _CanorusPython.new_CAFingering(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAFingering
    __del__ = lambda self: None

    def clone(self, *args):
        return _CanorusPython.CAFingering_clone(self, *args)

    def compare(self, *args):
        return _CanorusPython.CAFingering_compare(self, *args)

    def finger(self, *args):
        return _CanorusPython.CAFingering_finger(self, *args)

    def setFinger(self, *args):
        return _CanorusPython.CAFingering_setFinger(self, *args)

    def fingerList(self, *args):
        return _CanorusPython.CAFingering_fingerList(self, *args)

    def addFinger(self, *args):
        return _CanorusPython.CAFingering_addFinger(self, *args)

    def removeFinger(self, *args):
        return _CanorusPython.CAFingering_removeFinger(self, *args)

    def isOriginal(self, *args):
        return _CanorusPython.CAFingering_isOriginal(self, *args)

    def setOriginal(self, *args):
        return _CanorusPython.CAFingering_setOriginal(self, *args)
    if _newclass:
        fingerNumberToString = staticmethod(_CanorusPython.CAFingering_fingerNumberToString)
    else:
        fingerNumberToString = _CanorusPython.CAFingering_fingerNumberToString
    if _newclass:
        fingerNumberFromString = staticmethod(_CanorusPython.CAFingering_fingerNumberFromString)
    else:
        fingerNumberFromString = _CanorusPython.CAFingering_fingerNumberFromString
CAFingering_swigregister = _CanorusPython.CAFingering_swigregister
CAFingering_swigregister(CAFingering)

def CAFingering_fingerNumberToString(*args):
    return _CanorusPython.CAFingering_fingerNumberToString(*args)
CAFingering_fingerNumberToString = _CanorusPython.CAFingering_fingerNumberToString

def CAFingering_fingerNumberFromString(*args):
    return _CanorusPython.CAFingering_fingerNumberFromString(*args)
CAFingering_fingerNumberFromString = _CanorusPython.CAFingering_fingerNumberFromString

class CAPlayback(QThread):
    __swig_setmethods__ = {}
    for _s in [QThread]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAPlayback, name, value)
    __swig_getmethods__ = {}
    for _s in [QThread]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAPlayback, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAPlayback(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAPlayback
    __del__ = lambda self: None

    def run(self, *args):
        return _CanorusPython.CAPlayback_run(self, *args)

    def stop(self, *args):
        return _CanorusPython.CAPlayback_stop(self, *args)

    def playImmediately(self, *args):
        return _CanorusPython.CAPlayback_playImmediately(self, *args)

    def getInitTimeStart(self, *args):
        return _CanorusPython.CAPlayback_getInitTimeStart(self, *args)

    def setInitTimeStart(self, *args):
        return _CanorusPython.CAPlayback_setInitTimeStart(self, *args)

    def midiDevice(self, *args):
        return _CanorusPython.CAPlayback_midiDevice(self, *args)

    def sheet(self, *args):
        return _CanorusPython.CAPlayback_sheet(self, *args)

    def setSheet(self, *args):
        return _CanorusPython.CAPlayback_setSheet(self, *args)

    def curPlaying(self, *args):
        return _CanorusPython.CAPlayback_curPlaying(self, *args)

    def stopNow(self, *args):
        return _CanorusPython.CAPlayback_stopNow(self, *args)
CAPlayback_swigregister = _CanorusPython.CAPlayback_swigregister
CAPlayback_swigregister(CAPlayback)

class CAMidiRecorder(QObject):
    __swig_setmethods__ = {}
    for _s in [QObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMidiRecorder, name, value)
    __swig_getmethods__ = {}
    for _s in [QObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAMidiRecorder, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAMidiRecorder(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAMidiRecorder
    __del__ = lambda self: None

    def startRecording(self, *args):
        return _CanorusPython.CAMidiRecorder_startRecording(self, *args)

    def pauseRecording(self, *args):
        return _CanorusPython.CAMidiRecorder_pauseRecording(self, *args)

    def stopRecording(self, *args):
        return _CanorusPython.CAMidiRecorder_stopRecording(self, *args)

    def curTime(self, *args):
        return _CanorusPython.CAMidiRecorder_curTime(self, *args)
CAMidiRecorder_swigregister = _CanorusPython.CAMidiRecorder_swigregister
CAMidiRecorder_swigregister(CAMidiRecorder)

class CAMidiDevice(QObject):
    __swig_setmethods__ = {}
    for _s in [QObject]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMidiDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [QObject]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAMidiDevice, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    RtMidiDevice = _CanorusPython.CAMidiDevice_RtMidiDevice
    MidiExportDevice = _CanorusPython.CAMidiDevice_MidiExportDevice
    Meta_Text = _CanorusPython.CAMidiDevice_Meta_Text
    Meta_Copyright = _CanorusPython.CAMidiDevice_Meta_Copyright
    Meta_SeqTrkName = _CanorusPython.CAMidiDevice_Meta_SeqTrkName
    Meta_InstrName = _CanorusPython.CAMidiDevice_Meta_InstrName
    Meta_Lyric = _CanorusPython.CAMidiDevice_Meta_Lyric
    Meta_Marker = _CanorusPython.CAMidiDevice_Meta_Marker
    Meta_CuePoint = _CanorusPython.CAMidiDevice_Meta_CuePoint
    Meta_Tempo = _CanorusPython.CAMidiDevice_Meta_Tempo
    Meta_SMPTEOffs = _CanorusPython.CAMidiDevice_Meta_SMPTEOffs
    Meta_Timesig = _CanorusPython.CAMidiDevice_Meta_Timesig
    Meta_Keysig = _CanorusPython.CAMidiDevice_Meta_Keysig
    Meta_Track_End = _CanorusPython.CAMidiDevice_Meta_Track_End
    Midi_Ctl_Reverb = _CanorusPython.CAMidiDevice_Midi_Ctl_Reverb
    Midi_Ctl_Chorus = _CanorusPython.CAMidiDevice_Midi_Ctl_Chorus
    Midi_Ctl_Pan = _CanorusPython.CAMidiDevice_Midi_Ctl_Pan
    Midi_Ctl_Volume = _CanorusPython.CAMidiDevice_Midi_Ctl_Volume
    Midi_Ctl_Sustain = _CanorusPython.CAMidiDevice_Midi_Ctl_Sustain
    Midi_Ctl_Event = _CanorusPython.CAMidiDevice_Midi_Ctl_Event
    Midi_Note_Off = _CanorusPython.CAMidiDevice_Midi_Note_Off
    Midi_Note_On = _CanorusPython.CAMidiDevice_Midi_Note_On
    Midi_Prog_Change = _CanorusPython.CAMidiDevice_Midi_Prog_Change
    Midi_Control_Chg = _CanorusPython.CAMidiDevice_Midi_Control_Chg
    if _newclass:
        gmInstrumentList = staticmethod(_CanorusPython.CAMidiDevice_gmInstrumentList)
    else:
        gmInstrumentList = _CanorusPython.CAMidiDevice_gmInstrumentList
    if _newclass:
        instrumentName = staticmethod(_CanorusPython.CAMidiDevice_instrumentName)
    else:
        instrumentName = _CanorusPython.CAMidiDevice_instrumentName
    if _newclass:
        instrumentNames = staticmethod(_CanorusPython.CAMidiDevice_instrumentNames)
    else:
        instrumentNames = _CanorusPython.CAMidiDevice_instrumentNames
    if _newclass:
        freeMidiChannel = staticmethod(_CanorusPython.CAMidiDevice_freeMidiChannel)
    else:
        freeMidiChannel = _CanorusPython.CAMidiDevice_freeMidiChannel
    __swig_destroy__ = _CanorusPython.delete_CAMidiDevice
    __del__ = lambda self: None

    def midiDeviceType(self, *args):
        return _CanorusPython.CAMidiDevice_midiDeviceType(self, *args)

    def isRealTime(self, *args):
        return _CanorusPython.CAMidiDevice_isRealTime(self, *args)

    def getOutputPorts(self, *args):
        return _CanorusPython.CAMidiDevice_getOutputPorts(self, *args)

    def getInputPorts(self, *args):
        return _CanorusPython.CAMidiDevice_getInputPorts(self, *args)

    def openOutputPort(self, *args):
        return _CanorusPython.CAMidiDevice_openOutputPort(self, *args)

    def openInputPort(self, *args):
        return _CanorusPython.CAMidiDevice_openInputPort(self, *args)

    def closeOutputPort(self, *args):
        return _CanorusPython.CAMidiDevice_closeOutputPort(self, *args)

    def closeInputPort(self, *args):
        return _CanorusPython.CAMidiDevice_closeInputPort(self, *args)

    def send(self, *args):
        return _CanorusPython.CAMidiDevice_send(self, *args)

    def sendMetaEvent(self, *args):
        return _CanorusPython.CAMidiDevice_sendMetaEvent(self, *args)
CAMidiDevice_swigregister = _CanorusPython.CAMidiDevice_swigregister
CAMidiDevice_swigregister(CAMidiDevice)

def rtMidiInCallback(*args):
    return _CanorusPython.rtMidiInCallback(*args)
rtMidiInCallback = _CanorusPython.rtMidiInCallback

def CAMidiDevice_gmInstrumentList(*args):
    return _CanorusPython.CAMidiDevice_gmInstrumentList(*args)
CAMidiDevice_gmInstrumentList = _CanorusPython.CAMidiDevice_gmInstrumentList

def CAMidiDevice_instrumentName(*args):
    return _CanorusPython.CAMidiDevice_instrumentName(*args)
CAMidiDevice_instrumentName = _CanorusPython.CAMidiDevice_instrumentName

def CAMidiDevice_instrumentNames(*args):
    return _CanorusPython.CAMidiDevice_instrumentNames(*args)
CAMidiDevice_instrumentNames = _CanorusPython.CAMidiDevice_instrumentNames

def CAMidiDevice_freeMidiChannel(*args):
    return _CanorusPython.CAMidiDevice_freeMidiChannel(*args)
CAMidiDevice_freeMidiChannel = _CanorusPython.CAMidiDevice_freeMidiChannel

class CARtMidiDevice(CAMidiDevice):
    __swig_setmethods__ = {}
    for _s in [CAMidiDevice]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CARtMidiDevice, name, value)
    __swig_getmethods__ = {}
    for _s in [CAMidiDevice]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CARtMidiDevice, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CARtMidiDevice(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CARtMidiDevice
    __del__ = lambda self: None

    def getOutputPorts(self, *args):
        return _CanorusPython.CARtMidiDevice_getOutputPorts(self, *args)

    def getInputPorts(self, *args):
        return _CanorusPython.CARtMidiDevice_getInputPorts(self, *args)

    def openOutputPort(self, *args):
        return _CanorusPython.CARtMidiDevice_openOutputPort(self, *args)

    def openInputPort(self, *args):
        return _CanorusPython.CARtMidiDevice_openInputPort(self, *args)

    def closeOutputPort(self, *args):
        return _CanorusPython.CARtMidiDevice_closeOutputPort(self, *args)

    def closeInputPort(self, *args):
        return _CanorusPython.CARtMidiDevice_closeInputPort(self, *args)

    def send(self, *args):
        return _CanorusPython.CARtMidiDevice_send(self, *args)

    def sendMetaEvent(self, *args):
        return _CanorusPython.CARtMidiDevice_sendMetaEvent(self, *args)
CARtMidiDevice_swigregister = _CanorusPython.CARtMidiDevice_swigregister
CARtMidiDevice_swigregister(CARtMidiDevice)

class CASettings(QSettings):
    __swig_setmethods__ = {}
    for _s in [QSettings]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CASettings, name, value)
    __swig_getmethods__ = {}
    for _s in [QSettings]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CASettings, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CASettings(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def initSettings(self, *args):
        return _CanorusPython.CASettings_initSettings(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CASettings
    __del__ = lambda self: None

    def readSettings(self, *args):
        return _CanorusPython.CASettings_readSettings(self, *args)

    def writeSettings(self, *args):
        return _CanorusPython.CASettings_writeSettings(self, *args)
    if _newclass:
        defaultSettingsPath = staticmethod(_CanorusPython.CASettings_defaultSettingsPath)
    else:
        defaultSettingsPath = _CanorusPython.CASettings_defaultSettingsPath

    def finaleLyricsBehaviour(self, *args):
        return _CanorusPython.CASettings_finaleLyricsBehaviour(self, *args)

    def setFinaleLyricsBehaviour(self, *args):
        return _CanorusPython.CASettings_setFinaleLyricsBehaviour(self, *args)

    def shadowNotesInOtherStaffs(self, *args):
        return _CanorusPython.CASettings_shadowNotesInOtherStaffs(self, *args)

    def setShadowNotesInOtherStaffs(self, *args):
        return _CanorusPython.CASettings_setShadowNotesInOtherStaffs(self, *args)

    def playInsertedNotes(self, *args):
        return _CanorusPython.CASettings_playInsertedNotes(self, *args)

    def setPlayInsertedNotes(self, *args):
        return _CanorusPython.CASettings_setPlayInsertedNotes(self, *args)

    def autoBar(self, *args):
        return _CanorusPython.CASettings_autoBar(self, *args)

    def setAutoBar(self, *args):
        return _CanorusPython.CASettings_setAutoBar(self, *args)

    def useNoteChecker(self, *args):
        return _CanorusPython.CASettings_useNoteChecker(self, *args)

    def setUseNoteChecker(self, *args):
        return _CanorusPython.CASettings_setUseNoteChecker(self, *args)

    def documentsDirectory(self, *args):
        return _CanorusPython.CASettings_documentsDirectory(self, *args)

    def setDocumentsDirectory(self, *args):
        return _CanorusPython.CASettings_setDocumentsDirectory(self, *args)

    def defaultSaveFormat(self, *args):
        return _CanorusPython.CASettings_defaultSaveFormat(self, *args)

    def setDefaultSaveFormat(self, *args):
        return _CanorusPython.CASettings_setDefaultSaveFormat(self, *args)

    def autoRecoveryInterval(self, *args):
        return _CanorusPython.CASettings_autoRecoveryInterval(self, *args)

    def setAutoRecoveryInterval(self, *args):
        return _CanorusPython.CASettings_setAutoRecoveryInterval(self, *args)

    def maxRecentDocuments(self, *args):
        return _CanorusPython.CASettings_maxRecentDocuments(self, *args)

    def setMaxRecentDocuments(self, *args):
        return _CanorusPython.CASettings_setMaxRecentDocuments(self, *args)

    def midiInPort(self, *args):
        return _CanorusPython.CASettings_midiInPort(self, *args)

    def setMidiInPort(self, *args):
        return _CanorusPython.CASettings_setMidiInPort(self, *args)

    def midiOutPort(self, *args):
        return _CanorusPython.CASettings_midiOutPort(self, *args)

    def setMidiOutPort(self, *args):
        return _CanorusPython.CASettings_setMidiOutPort(self, *args)

    def typesetter(self, *args):
        return _CanorusPython.CASettings_typesetter(self, *args)

    def setTypesetter(self, *args):
        return _CanorusPython.CASettings_setTypesetter(self, *args)

    def typesetterLocation(self, *args):
        return _CanorusPython.CASettings_typesetterLocation(self, *args)

    def setTypesetterLocation(self, *args):
        return _CanorusPython.CASettings_setTypesetterLocation(self, *args)

    def useSystemDefaultTypesetter(self, *args):
        return _CanorusPython.CASettings_useSystemDefaultTypesetter(self, *args)

    def setUseSystemDefaultTypesetter(self, *args):
        return _CanorusPython.CASettings_setUseSystemDefaultTypesetter(self, *args)

    def pdfViewerLocation(self, *args):
        return _CanorusPython.CASettings_pdfViewerLocation(self, *args)

    def setPdfViewerLocation(self, *args):
        return _CanorusPython.CASettings_setPdfViewerLocation(self, *args)

    def useSystemDefaultPdfViewer(self, *args):
        return _CanorusPython.CASettings_useSystemDefaultPdfViewer(self, *args)

    def setUseSystemDefaultPdfViewer(self, *args):
        return _CanorusPython.CASettings_setUseSystemDefaultPdfViewer(self, *args)

    def latestShortcutsDirectory(self, *args):
        return _CanorusPython.CASettings_latestShortcutsDirectory(self, *args)

    def setLatestShortcutsDirectory(self, *args):
        return _CanorusPython.CASettings_setLatestShortcutsDirectory(self, *args)
CASettings_swigregister = _CanorusPython.CASettings_swigregister
CASettings_swigregister(CASettings)

def CASettings_defaultSettingsPath(*args):
    return _CanorusPython.CASettings_defaultSettingsPath(*args)
CASettings_defaultSettingsPath = _CanorusPython.CASettings_defaultSettingsPath
cvar = _CanorusPython.cvar
CASettings.DEFAULT_FINALE_LYRICS_BEHAVIOUR = _CanorusPython.cvar.CASettings_DEFAULT_FINALE_LYRICS_BEHAVIOUR
CASettings.DEFAULT_SHADOW_NOTES_IN_OTHER_STAFFS = _CanorusPython.cvar.CASettings_DEFAULT_SHADOW_NOTES_IN_OTHER_STAFFS
CASettings.DEFAULT_PLAY_INSERTED_NOTES = _CanorusPython.cvar.CASettings_DEFAULT_PLAY_INSERTED_NOTES
CASettings.DEFAULT_AUTO_BAR = _CanorusPython.cvar.CASettings_DEFAULT_AUTO_BAR
CASettings.DEFAULT_USE_NOTE_CHECKER = _CanorusPython.cvar.CASettings_DEFAULT_USE_NOTE_CHECKER
CASettings.DEFAULT_DOCUMENTS_DIRECTORY = _CanorusPython.cvar.CASettings_DEFAULT_DOCUMENTS_DIRECTORY
CASettings.DEFAULT_SAVE_FORMAT = _CanorusPython.cvar.CASettings_DEFAULT_SAVE_FORMAT
CASettings.DEFAULT_AUTO_RECOVERY_INTERVAL = _CanorusPython.cvar.CASettings_DEFAULT_AUTO_RECOVERY_INTERVAL
CASettings.DEFAULT_MAX_RECENT_DOCUMENTS = _CanorusPython.cvar.CASettings_DEFAULT_MAX_RECENT_DOCUMENTS
CASettings.DEFAULT_MIDI_IN_PORT = _CanorusPython.cvar.CASettings_DEFAULT_MIDI_IN_PORT
CASettings.DEFAULT_MIDI_OUT_PORT = _CanorusPython.cvar.CASettings_DEFAULT_MIDI_OUT_PORT
CASettings.DEFAULT_TYPESETTER = _CanorusPython.cvar.CASettings_DEFAULT_TYPESETTER
CASettings.DEFAULT_TYPESETTER_LOCATION = _CanorusPython.cvar.CASettings_DEFAULT_TYPESETTER_LOCATION
CASettings.DEFAULT_USE_SYSTEM_TYPESETTER = _CanorusPython.cvar.CASettings_DEFAULT_USE_SYSTEM_TYPESETTER
CASettings.DEFAULT_PDF_VIEWER_LOCATION = _CanorusPython.cvar.CASettings_DEFAULT_PDF_VIEWER_LOCATION
CASettings.DEFAULT_USE_SYSTEM_PDF_VIEWER = _CanorusPython.cvar.CASettings_DEFAULT_USE_SYSTEM_PDF_VIEWER
CASettings.DEFAULT_SHORTCUTS_DIRECTORY = _CanorusPython.cvar.CASettings_DEFAULT_SHORTCUTS_DIRECTORY

class CATypesetter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CATypesetter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CATypesetter, name)
    __repr__ = _swig_repr
    LilyPond = _CanorusPython.CATypesetter_LilyPond

    def __init__(self, *args):
        this = _CanorusPython.new_CATypesetter(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CATypesetter
    __del__ = lambda self: None
CATypesetter_swigregister = _CanorusPython.CATypesetter_swigregister
CATypesetter_swigregister(CATypesetter)

class CAFile(QThread):
    __swig_setmethods__ = {}
    for _s in [QThread]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAFile, name, value)
    __swig_getmethods__ = {}
    for _s in [QThread]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAFile, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CanorusPython.delete_CAFile
    __del__ = lambda self: None

    def status(self, *args):
        return _CanorusPython.CAFile_status(self, *args)

    def progress(self, *args):
        return _CanorusPython.CAFile_progress(self, *args)

    def readableStatus(self, *args):
        return _CanorusPython.CAFile_readableStatus(self, *args)

    def setStreamFromFile(self, *args):
        return _CanorusPython.CAFile_setStreamFromFile(self, *args)

    def setStreamToFile(self, *args):
        return _CanorusPython.CAFile_setStreamToFile(self, *args)

    def setStreamFromDevice(self, *args):
        return _CanorusPython.CAFile_setStreamFromDevice(self, *args)

    def setStreamToDevice(self, *args):
        return _CanorusPython.CAFile_setStreamToDevice(self, *args)

    def setStreamToString(self, *args):
        return _CanorusPython.CAFile_setStreamToString(self, *args)

    def getStreamAsString(self, *args):
        return _CanorusPython.CAFile_getStreamAsString(self, *args)
CAFile_swigregister = _CanorusPython.CAFile_swigregister
CAFile_swigregister(CAFile)

class CAImport(CAFile):
    __swig_setmethods__ = {}
    for _s in [CAFile]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAImport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAFile]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAImport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAImport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAImport
    __del__ = lambda self: None

    def setStreamFromFile(self, *args):
        return _CanorusPython.CAImport_setStreamFromFile(self, *args)

    def fileName(self, *args):
        return _CanorusPython.CAImport_fileName(self, *args)

    def readableStatus(self, *args):
        return _CanorusPython.CAImport_readableStatus(self, *args)

    def importDocument(self, *args):
        return _CanorusPython.CAImport_importDocument(self, *args)

    def importSheet(self, *args):
        return _CanorusPython.CAImport_importSheet(self, *args)

    def importStaff(self, *args):
        return _CanorusPython.CAImport_importStaff(self, *args)

    def importVoice(self, *args):
        return _CanorusPython.CAImport_importVoice(self, *args)

    def importLyricsContext(self, *args):
        return _CanorusPython.CAImport_importLyricsContext(self, *args)

    def importFunctionMarkContext(self, *args):
        return _CanorusPython.CAImport_importFunctionMarkContext(self, *args)

    def importedDocument(self, *args):
        return _CanorusPython.CAImport_importedDocument(self, *args)

    def importedSheet(self, *args):
        return _CanorusPython.CAImport_importedSheet(self, *args)

    def importedStaff(self, *args):
        return _CanorusPython.CAImport_importedStaff(self, *args)

    def importedVoice(self, *args):
        return _CanorusPython.CAImport_importedVoice(self, *args)

    def importedLyricsContext(self, *args):
        return _CanorusPython.CAImport_importedLyricsContext(self, *args)

    def importedFunctionMarkContext(self, *args):
        return _CanorusPython.CAImport_importedFunctionMarkContext(self, *args)
CAImport_swigregister = _CanorusPython.CAImport_swigregister
CAImport_swigregister(CAImport)

class CACanorusMLImport(CAImport, QXmlDefaultHandler):
    __swig_setmethods__ = {}
    for _s in [CAImport, QXmlDefaultHandler]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CACanorusMLImport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAImport, QXmlDefaultHandler]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CACanorusMLImport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CACanorusMLImport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CACanorusMLImport
    __del__ = lambda self: None

    def initCanorusMLImport(self, *args):
        return _CanorusPython.CACanorusMLImport_initCanorusMLImport(self, *args)

    def importDocumentImpl(self, *args):
        return _CanorusPython.CACanorusMLImport_importDocumentImpl(self, *args)

    def startElement(self, *args):
        return _CanorusPython.CACanorusMLImport_startElement(self, *args)

    def endElement(self, *args):
        return _CanorusPython.CACanorusMLImport_endElement(self, *args)

    def fatalError(self, *args):
        return _CanorusPython.CACanorusMLImport_fatalError(self, *args)

    def characters(self, *args):
        return _CanorusPython.CACanorusMLImport_characters(self, *args)
CACanorusMLImport_swigregister = _CanorusPython.CACanorusMLImport_swigregister
CACanorusMLImport_swigregister(CACanorusMLImport)

class CACanImport(CAImport):
    __swig_setmethods__ = {}
    for _s in [CAImport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CACanImport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAImport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CACanImport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CACanImport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CACanImport
    __del__ = lambda self: None

    def archive(self, *args):
        return _CanorusPython.CACanImport_archive(self, *args)

    def setArchive(self, *args):
        return _CanorusPython.CACanImport_setArchive(self, *args)
CACanImport_swigregister = _CanorusPython.CACanImport_swigregister
CACanImport_swigregister(CACanImport)

class CALilyPondImport(CAImport):
    __swig_setmethods__ = {}
    for _s in [CAImport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CALilyPondImport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAImport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CALilyPondImport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CALilyPondImport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def setTemplateVoice(self, *args):
        return _CanorusPython.CALilyPondImport_setTemplateVoice(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CALilyPondImport
    __del__ = lambda self: None

    def readableStatus(self, *args):
        return _CanorusPython.CALilyPondImport_readableStatus(self, *args)

    def importSheetImpl(self, *args):
        return _CanorusPython.CALilyPondImport_importSheetImpl(self, *args)
CALilyPondImport_swigregister = _CanorusPython.CALilyPondImport_swigregister
CALilyPondImport_swigregister(CALilyPondImport)

class CAMidiImport(CAImport):
    __swig_setmethods__ = {}
    for _s in [CAImport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMidiImport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAImport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAMidiImport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAMidiImport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAMidiImport
    __del__ = lambda self: None

    def closeFile(self, *args):
        return _CanorusPython.CAMidiImport_closeFile(self, *args)

    def importDocumentImpl(self, *args):
        return _CanorusPython.CAMidiImport_importDocumentImpl(self, *args)

    def importSheetImpl(self, *args):
        return _CanorusPython.CAMidiImport_importSheetImpl(self, *args)

    def importMidiNotes(self, *args):
        return _CanorusPython.CAMidiImport_importMidiNotes(self, *args)

    def readableStatus(self, *args):
        return _CanorusPython.CAMidiImport_readableStatus(self, *args)

    def midiProgramList(self, *args):
        return _CanorusPython.CAMidiImport_midiProgramList(self, *args)
CAMidiImport_swigregister = _CanorusPython.CAMidiImport_swigregister
CAMidiImport_swigregister(CAMidiImport)

class CAMusicXmlImport(CAImport):
    __swig_setmethods__ = {}
    for _s in [CAImport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMusicXmlImport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAImport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAMusicXmlImport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAMusicXmlImport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAMusicXmlImport
    __del__ = lambda self: None

    def readableStatus(self, *args):
        return _CanorusPython.CAMusicXmlImport_readableStatus(self, *args)
CAMusicXmlImport_swigregister = _CanorusPython.CAMusicXmlImport_swigregister
CAMusicXmlImport_swigregister(CAMusicXmlImport)

class CAExport(CAFile):
    __swig_setmethods__ = {}
    for _s in [CAFile]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAExport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAFile]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAExport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAExport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAExport
    __del__ = lambda self: None

    def readableStatus(self, *args):
        return _CanorusPython.CAExport_readableStatus(self, *args)

    def exportDocument(self, *args):
        return _CanorusPython.CAExport_exportDocument(self, *args)

    def exportSheet(self, *args):
        return _CanorusPython.CAExport_exportSheet(self, *args)

    def exportStaff(self, *args):
        return _CanorusPython.CAExport_exportStaff(self, *args)

    def exportVoice(self, *args):
        return _CanorusPython.CAExport_exportVoice(self, *args)

    def exportLyricsContext(self, *args):
        return _CanorusPython.CAExport_exportLyricsContext(self, *args)

    def exportFunctionMarkContext(self, *args):
        return _CanorusPython.CAExport_exportFunctionMarkContext(self, *args)

    def exportedDocument(self, *args):
        return _CanorusPython.CAExport_exportedDocument(self, *args)

    def exportedSheet(self, *args):
        return _CanorusPython.CAExport_exportedSheet(self, *args)

    def exportedStaff(self, *args):
        return _CanorusPython.CAExport_exportedStaff(self, *args)

    def exportedVoice(self, *args):
        return _CanorusPython.CAExport_exportedVoice(self, *args)

    def exportedLyricsContext(self, *args):
        return _CanorusPython.CAExport_exportedLyricsContext(self, *args)

    def exportedFunctionMarkContext(self, *args):
        return _CanorusPython.CAExport_exportedFunctionMarkContext(self, *args)

    def setStreamToFile(self, *args):
        return _CanorusPython.CAExport_setStreamToFile(self, *args)

    def wait(self, *args):
        return _CanorusPython.CAExport_wait(self, *args)
CAExport_swigregister = _CanorusPython.CAExport_swigregister
CAExport_swigregister(CAExport)

class CACanorusMLExport(CAExport):
    __swig_setmethods__ = {}
    for _s in [CAExport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CACanorusMLExport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAExport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CACanorusMLExport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CACanorusMLExport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CACanorusMLExport
    __del__ = lambda self: None

    def exportDocumentImpl(self, *args):
        return _CanorusPython.CACanorusMLExport_exportDocumentImpl(self, *args)
CACanorusMLExport_swigregister = _CanorusPython.CACanorusMLExport_swigregister
CACanorusMLExport_swigregister(CACanorusMLExport)

class CACanExport(CAExport):
    __swig_setmethods__ = {}
    for _s in [CAExport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CACanExport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAExport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CACanExport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CACanExport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CACanExport
    __del__ = lambda self: None

    def archive(self, *args):
        return _CanorusPython.CACanExport_archive(self, *args)

    def setArchive(self, *args):
        return _CanorusPython.CACanExport_setArchive(self, *args)
CACanExport_swigregister = _CanorusPython.CACanExport_swigregister
CACanExport_swigregister(CACanExport)

class CALilyPondExport(CAExport):
    __swig_setmethods__ = {}
    for _s in [CAExport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CALilyPondExport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAExport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CALilyPondExport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CALilyPondExport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def curVoice(self, *args):
        return _CanorusPython.CALilyPondExport_curVoice(self, *args)

    def curSheet(self, *args):
        return _CanorusPython.CALilyPondExport_curSheet(self, *args)

    def curDocument(self, *args):
        return _CanorusPython.CALilyPondExport_curDocument(self, *args)

    def curContext(self, *args):
        return _CanorusPython.CALilyPondExport_curContext(self, *args)

    def curContextIndex(self, *args):
        return _CanorusPython.CALilyPondExport_curContextIndex(self, *args)

    def curIndentLevel(self, *args):
        return _CanorusPython.CALilyPondExport_curIndentLevel(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CALilyPondExport
    __del__ = lambda self: None
CALilyPondExport_swigregister = _CanorusPython.CALilyPondExport_swigregister
CALilyPondExport_swigregister(CALilyPondExport)

class CAMusicXmlExport(CAExport):
    __swig_setmethods__ = {}
    for _s in [CAExport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMusicXmlExport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAExport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAMusicXmlExport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAMusicXmlExport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAMusicXmlExport
    __del__ = lambda self: None

    def curVoice(self, *args):
        return _CanorusPython.CAMusicXmlExport_curVoice(self, *args)

    def curSheet(self, *args):
        return _CanorusPython.CAMusicXmlExport_curSheet(self, *args)

    def curDocument(self, *args):
        return _CanorusPython.CAMusicXmlExport_curDocument(self, *args)

    def curContext(self, *args):
        return _CanorusPython.CAMusicXmlExport_curContext(self, *args)

    def curContextIndex(self, *args):
        return _CanorusPython.CAMusicXmlExport_curContextIndex(self, *args)
CAMusicXmlExport_swigregister = _CanorusPython.CAMusicXmlExport_swigregister
CAMusicXmlExport_swigregister(CAMusicXmlExport)

class CAMidiExport(CAExport, CAMidiDevice):
    __swig_setmethods__ = {}
    for _s in [CAExport, CAMidiDevice]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAMidiExport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAExport, CAMidiDevice]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAMidiExport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAMidiExport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def getOutputPorts(self, *args):
        return _CanorusPython.CAMidiExport_getOutputPorts(self, *args)

    def getInputPorts(self, *args):
        return _CanorusPython.CAMidiExport_getInputPorts(self, *args)

    def openOutputPort(self, *args):
        return _CanorusPython.CAMidiExport_openOutputPort(self, *args)

    def openInputPort(self, *args):
        return _CanorusPython.CAMidiExport_openInputPort(self, *args)

    def closeOutputPort(self, *args):
        return _CanorusPython.CAMidiExport_closeOutputPort(self, *args)

    def closeInputPort(self, *args):
        return _CanorusPython.CAMidiExport_closeInputPort(self, *args)

    def send(self, *args):
        return _CanorusPython.CAMidiExport_send(self, *args)

    def sendMetaEvent(self, *args):
        return _CanorusPython.CAMidiExport_sendMetaEvent(self, *args)

    def writeFile(self, *args):
        return _CanorusPython.CAMidiExport_writeFile(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CAMidiExport
    __del__ = lambda self: None
CAMidiExport_swigregister = _CanorusPython.CAMidiExport_swigregister
CAMidiExport_swigregister(CAMidiExport)

class CAPDFExport(CAExport):
    __swig_setmethods__ = {}
    for _s in [CAExport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAPDFExport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAExport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAPDFExport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAPDFExport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAPDFExport
    __del__ = lambda self: None

    def getTempFilePath(self, *args):
        return _CanorusPython.CAPDFExport_getTempFilePath(self, *args)
CAPDFExport_swigregister = _CanorusPython.CAPDFExport_swigregister
CAPDFExport_swigregister(CAPDFExport)

class CASVGExport(CAExport):
    __swig_setmethods__ = {}
    for _s in [CAExport]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CASVGExport, name, value)
    __swig_getmethods__ = {}
    for _s in [CAExport]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CASVGExport, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CASVGExport(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CASVGExport
    __del__ = lambda self: None

    def getTempFilePath(self, *args):
        return _CanorusPython.CASVGExport_getTempFilePath(self, *args)
CASVGExport_swigregister = _CanorusPython.CASVGExport_swigregister
CASVGExport_swigregister(CASVGExport)

class CAPyConsoleInterface(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAPyConsoleInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAPyConsoleInterface, name)
    __repr__ = _swig_repr

    def bufferedInput(self, *args):
        return _CanorusPython.CAPyConsoleInterface_bufferedInput(self, *args)

    def bufferedOutput(self, *args):
        return _CanorusPython.CAPyConsoleInterface_bufferedOutput(self, *args)

    def __init__(self, *args):
        this = _CanorusPython.new_CAPyConsoleInterface(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def pluginInit(self, *args):
        return _CanorusPython.CAPyConsoleInterface_pluginInit(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CAPyConsoleInterface
    __del__ = lambda self: None
CAPyConsoleInterface_swigregister = _CanorusPython.CAPyConsoleInterface_swigregister
CAPyConsoleInterface_swigregister(CAPyConsoleInterface)

class CAPlugin(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAPlugin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CAPlugin, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAPlugin(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAPlugin
    __del__ = lambda self: None

    def action(self, *args):
        return _CanorusPython.CAPlugin_action(self, *args)

    def callAction(self, *args):
        return _CanorusPython.CAPlugin_callAction(self, *args)

    def addAction(self, *args):
        return _CanorusPython.CAPlugin_addAction(self, *args)

    def addMenu(self, *args):
        return _CanorusPython.CAPlugin_addMenu(self, *args)

    def setEnabled(self, *args):
        return _CanorusPython.CAPlugin_setEnabled(self, *args)

    def isEnabled(self, *args):
        return _CanorusPython.CAPlugin_isEnabled(self, *args)

    def name(self, *args):
        return _CanorusPython.CAPlugin_name(self, *args)

    def author(self, *args):
        return _CanorusPython.CAPlugin_author(self, *args)

    def version(self, *args):
        return _CanorusPython.CAPlugin_version(self, *args)

    def date(self, *args):
        return _CanorusPython.CAPlugin_date(self, *args)

    def dirName(self, *args):
        return _CanorusPython.CAPlugin_dirName(self, *args)

    def homeUrl(self, *args):
        return _CanorusPython.CAPlugin_homeUrl(self, *args)

    def updateUrl(self, *args):
        return _CanorusPython.CAPlugin_updateUrl(self, *args)

    def description(self, *args):
        return _CanorusPython.CAPlugin_description(self, *args)

    def localDescription(self, *args):
        return _CanorusPython.CAPlugin_localDescription(self, *args)

    def menu(self, *args):
        return _CanorusPython.CAPlugin_menu(self, *args)

    def setName(self, *args):
        return _CanorusPython.CAPlugin_setName(self, *args)

    def setDescription(self, *args):
        return _CanorusPython.CAPlugin_setDescription(self, *args)

    def setAuthor(self, *args):
        return _CanorusPython.CAPlugin_setAuthor(self, *args)

    def setVersion(self, *args):
        return _CanorusPython.CAPlugin_setVersion(self, *args)

    def setDate(self, *args):
        return _CanorusPython.CAPlugin_setDate(self, *args)

    def setDirName(self, *args):
        return _CanorusPython.CAPlugin_setDirName(self, *args)

    def setHomeUrl(self, *args):
        return _CanorusPython.CAPlugin_setHomeUrl(self, *args)

    def setUpdateUrl(self, *args):
        return _CanorusPython.CAPlugin_setUpdateUrl(self, *args)

    def actionList(self, *args):
        return _CanorusPython.CAPlugin_actionList(self, *args)
CAPlugin_swigregister = _CanorusPython.CAPlugin_swigregister
CAPlugin_swigregister(CAPlugin)

class CAPluginManager(QXmlDefaultHandler):
    __swig_setmethods__ = {}
    for _s in [QXmlDefaultHandler]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAPluginManager, name, value)
    __swig_getmethods__ = {}
    for _s in [QXmlDefaultHandler]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAPluginManager, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAPluginManager(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _CanorusPython.delete_CAPluginManager
    __del__ = lambda self: None
    if _newclass:
        readPlugins = staticmethod(_CanorusPython.CAPluginManager_readPlugins)
    else:
        readPlugins = _CanorusPython.CAPluginManager_readPlugins
    if _newclass:
        enablePlugin = staticmethod(_CanorusPython.CAPluginManager_enablePlugin)
    else:
        enablePlugin = _CanorusPython.CAPluginManager_enablePlugin
    if _newclass:
        enablePlugins = staticmethod(_CanorusPython.CAPluginManager_enablePlugins)
    else:
        enablePlugins = _CanorusPython.CAPluginManager_enablePlugins
    if _newclass:
        disablePlugin = staticmethod(_CanorusPython.CAPluginManager_disablePlugin)
    else:
        disablePlugin = _CanorusPython.CAPluginManager_disablePlugin
    if _newclass:
        disablePlugins = staticmethod(_CanorusPython.CAPluginManager_disablePlugins)
    else:
        disablePlugins = _CanorusPython.CAPluginManager_disablePlugins
    if _newclass:
        action = staticmethod(_CanorusPython.CAPluginManager_action)
    else:
        action = _CanorusPython.CAPluginManager_action
    if _newclass:
        exportFilterExists = staticmethod(_CanorusPython.CAPluginManager_exportFilterExists)
    else:
        exportFilterExists = _CanorusPython.CAPluginManager_exportFilterExists
    if _newclass:
        exportAction = staticmethod(_CanorusPython.CAPluginManager_exportAction)
    else:
        exportAction = _CanorusPython.CAPluginManager_exportAction
    if _newclass:
        importFilterExists = staticmethod(_CanorusPython.CAPluginManager_importFilterExists)
    else:
        importFilterExists = _CanorusPython.CAPluginManager_importFilterExists
    if _newclass:
        importAction = staticmethod(_CanorusPython.CAPluginManager_importAction)
    else:
        importAction = _CanorusPython.CAPluginManager_importAction
    if _newclass:
        installPlugin = staticmethod(_CanorusPython.CAPluginManager_installPlugin)
    else:
        installPlugin = _CanorusPython.CAPluginManager_installPlugin
    if _newclass:
        removePlugin = staticmethod(_CanorusPython.CAPluginManager_removePlugin)
    else:
        removePlugin = _CanorusPython.CAPluginManager_removePlugin
    if _newclass:
        pluginList = staticmethod(_CanorusPython.CAPluginManager_pluginList)
    else:
        pluginList = _CanorusPython.CAPluginManager_pluginList

    def startElement(self, *args):
        return _CanorusPython.CAPluginManager_startElement(self, *args)

    def endElement(self, *args):
        return _CanorusPython.CAPluginManager_endElement(self, *args)

    def fatalError(self, *args):
        return _CanorusPython.CAPluginManager_fatalError(self, *args)

    def characters(self, *args):
        return _CanorusPython.CAPluginManager_characters(self, *args)
CAPluginManager_swigregister = _CanorusPython.CAPluginManager_swigregister
CAPluginManager_swigregister(CAPluginManager)

def CAPluginManager_readPlugins(*args):
    return _CanorusPython.CAPluginManager_readPlugins(*args)
CAPluginManager_readPlugins = _CanorusPython.CAPluginManager_readPlugins

def CAPluginManager_enablePlugin(*args):
    return _CanorusPython.CAPluginManager_enablePlugin(*args)
CAPluginManager_enablePlugin = _CanorusPython.CAPluginManager_enablePlugin

def CAPluginManager_enablePlugins(*args):
    return _CanorusPython.CAPluginManager_enablePlugins(*args)
CAPluginManager_enablePlugins = _CanorusPython.CAPluginManager_enablePlugins

def CAPluginManager_disablePlugin(*args):
    return _CanorusPython.CAPluginManager_disablePlugin(*args)
CAPluginManager_disablePlugin = _CanorusPython.CAPluginManager_disablePlugin

def CAPluginManager_disablePlugins(*args):
    return _CanorusPython.CAPluginManager_disablePlugins(*args)
CAPluginManager_disablePlugins = _CanorusPython.CAPluginManager_disablePlugins

def CAPluginManager_action(*args):
    return _CanorusPython.CAPluginManager_action(*args)
CAPluginManager_action = _CanorusPython.CAPluginManager_action

def CAPluginManager_exportFilterExists(*args):
    return _CanorusPython.CAPluginManager_exportFilterExists(*args)
CAPluginManager_exportFilterExists = _CanorusPython.CAPluginManager_exportFilterExists

def CAPluginManager_exportAction(*args):
    return _CanorusPython.CAPluginManager_exportAction(*args)
CAPluginManager_exportAction = _CanorusPython.CAPluginManager_exportAction

def CAPluginManager_importFilterExists(*args):
    return _CanorusPython.CAPluginManager_importFilterExists(*args)
CAPluginManager_importFilterExists = _CanorusPython.CAPluginManager_importFilterExists

def CAPluginManager_importAction(*args):
    return _CanorusPython.CAPluginManager_importAction(*args)
CAPluginManager_importAction = _CanorusPython.CAPluginManager_importAction

def CAPluginManager_installPlugin(*args):
    return _CanorusPython.CAPluginManager_installPlugin(*args)
CAPluginManager_installPlugin = _CanorusPython.CAPluginManager_installPlugin

def CAPluginManager_removePlugin(*args):
    return _CanorusPython.CAPluginManager_removePlugin(*args)
CAPluginManager_removePlugin = _CanorusPython.CAPluginManager_removePlugin

def CAPluginManager_pluginList(*args):
    return _CanorusPython.CAPluginManager_pluginList(*args)
CAPluginManager_pluginList = _CanorusPython.CAPluginManager_pluginList

class CAPluginAction(QAction):
    __swig_setmethods__ = {}
    for _s in [QAction]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CAPluginAction, name, value)
    __swig_getmethods__ = {}
    for _s in [QAction]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CAPluginAction, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CanorusPython.new_CAPluginAction(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def plugin(self, *args):
        return _CanorusPython.CAPluginAction_plugin(self, *args)

    def name(self, *args):
        return _CanorusPython.CAPluginAction_name(self, *args)

    def lang(self, *args):
        return _CanorusPython.CAPluginAction_lang(self, *args)

    def function(self, *args):
        return _CanorusPython.CAPluginAction_function(self, *args)

    def args(self, *args):
        return _CanorusPython.CAPluginAction_args(self, *args)

    def filename(self, *args):
        return _CanorusPython.CAPluginAction_filename(self, *args)

    def onAction(self, *args):
        return _CanorusPython.CAPluginAction_onAction(self, *args)

    def exportFilter(self, *args):
        return _CanorusPython.CAPluginAction_exportFilter(self, *args)

    def localExportFilter(self, *args):
        return _CanorusPython.CAPluginAction_localExportFilter(self, *args)

    def importFilter(self, *args):
        return _CanorusPython.CAPluginAction_importFilter(self, *args)

    def localImportFilter(self, *args):
        return _CanorusPython.CAPluginAction_localImportFilter(self, *args)

    def localeText(self, *args):
        return _CanorusPython.CAPluginAction_localeText(self, *args)

    def localText(self, *args):
        return _CanorusPython.CAPluginAction_localText(self, *args)

    def refresh(self, *args):
        return _CanorusPython.CAPluginAction_refresh(self, *args)

    def setPlugin(self, *args):
        return _CanorusPython.CAPluginAction_setPlugin(self, *args)

    def setName(self, *args):
        return _CanorusPython.CAPluginAction_setName(self, *args)

    def setLang(self, *args):
        return _CanorusPython.CAPluginAction_setLang(self, *args)

    def setFunction(self, *args):
        return _CanorusPython.CAPluginAction_setFunction(self, *args)

    def addArgument(self, *args):
        return _CanorusPython.CAPluginAction_addArgument(self, *args)

    def removeArgument(self, *args):
        return _CanorusPython.CAPluginAction_removeArgument(self, *args)

    def setFilename(self, *args):
        return _CanorusPython.CAPluginAction_setFilename(self, *args)

    def setOnAction(self, *args):
        return _CanorusPython.CAPluginAction_setOnAction(self, *args)

    def setExportFilter(self, *args):
        return _CanorusPython.CAPluginAction_setExportFilter(self, *args)

    def setExportFilters(self, *args):
        return _CanorusPython.CAPluginAction_setExportFilters(self, *args)

    def setImportFilter(self, *args):
        return _CanorusPython.CAPluginAction_setImportFilter(self, *args)

    def setImportFilters(self, *args):
        return _CanorusPython.CAPluginAction_setImportFilters(self, *args)

    def setLocaleText(self, *args):
        return _CanorusPython.CAPluginAction_setLocaleText(self, *args)

    def setTexts(self, *args):
        return _CanorusPython.CAPluginAction_setTexts(self, *args)

    def setRefresh(self, *args):
        return _CanorusPython.CAPluginAction_setRefresh(self, *args)
    __swig_destroy__ = _CanorusPython.delete_CAPluginAction
    __del__ = lambda self: None
CAPluginAction_swigregister = _CanorusPython.CAPluginAction_swigregister
CAPluginAction_swigregister(CAPluginAction)

# This file is compatible with both classic and new-style classes.


